/*

 * Copyright (c) 2006, 2016, Oracle and/or its affiliates. All rights reserved.

 */

/*

 * drmP.h -- Private header for Direct Rendering Manager -*- linux-c -*-

 * Created: Mon Jan  4 10:05:05 1999 by [email protected]

 */

/*

 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.

 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.

 * Copyright (c) 2009, 2013, Intel Corporation.

 * All rights reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice (including the next

 * paragraph) shall be included in all copies or substantial portions of the

 * Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR

 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 *

 * Authors:

 *    Rickard E. (Rik) Faith <[email protected]>

 *    Gareth Hughes <[email protected]>

 *

 */

#ifndef	_DRMP_H

#define	_DRMP_H

#include <sys/types.h>

#include <sys/conf.h>

#include <sys/modctl.h>

#include <sys/stat.h>

#include <sys/file.h>

#include <sys/cmn_err.h>

#include <sys/varargs.h>

#include <sys/pci.h>

#include <sys/ddi.h>

#include <sys/sunddi.h>

#include <sys/sunldi.h>

#include <sys/agpgart.h>

#include <sys/time.h>

#include <sys/gfx_private.h>

#include <sys/ddifm.h>

#include <sys/fm/protocol.h>

#include <sys/fm/util.h>

#include <sys/fm/io/ddi.h>

#include <drm/drm.h>

#include <drm/drm_os_solaris.h>

#include "drm_atomic.h"

#include <sys/queue.h>

#include "drm_linux.h"

#include "drm_linux_list.h"

#include "drm_mm.h"

#include "drm_mode.h"

#include "drm_sun_idr.h"

#include "drm_sun_timer.h"

#include "drm_sun_workqueue.h"

#include "drm_sun_pci.h"

#ifndef __inline__

#define	__inline__	inline

#endif

#if !defined(__FUNCTION__)

#if defined(_STDC_C99) || defined(__C99FEATURES__)

#define	__FUNCTION__ __func__

#else

#define	__FUNCTION__ " "

#endif

#endif

#define KB(x)	((x) * 1024)

#define MB(x)	(KB (KB (x)))

#define GB(x)	(MB (KB (x)))

#define	DRM_MINOR_NBITS      (9)

#define DRM_MINOR_SHIFT      (0)

#define DRM_MINOR_MAX        ((1 << DRM_MINOR_NBITS) - 1)

#define DRM_DEV2MINOR(dev)   ((getminor(dev) >> DRM_MINOR_SHIFT) & DRM_MINOR_MAX)

#define DRM_CLONEID_NBITS    (NBITSMINOR - DRM_MINOR_NBITS)

#define DRM_CLONEID_SHIFT    (DRM_MINOR_NBITS)

#define DRM_CLONEID_MAX      ((1 << DRM_CLONEID_NBITS) - 1)

#define DRM_DEV2CLONEID(dev) ((getminor(dev) >> DRM_CLONEID_SHIFT) & DRM_CLONEID_MAX)

#define DRM_MAKEDEV(major_id, minor_id, clone_id)  \

    makedevice(major_id, (minor_id << DRM_MINOR_SHIFT) | (clone_id << DRM_CLONEID_SHIFT))

/* driver capabilities and requirements mask */

#define DRIVER_USE_AGP     0x1

#define DRIVER_REQUIRE_AGP 0x2

#define DRIVER_USE_MTRR    0x4

#define DRIVER_PCI_DMA     0x8

#define DRIVER_SG          0x10

#define DRIVER_HAVE_DMA    0x20

#define DRIVER_HAVE_IRQ    0x40

#define DRIVER_IRQ_SHARED  0x80

#define DRIVER_IRQ_VBL     0x100

#define DRIVER_DMA_QUEUE   0x200

#define DRIVER_FB_DMA      0x400

#define DRIVER_IRQ_VBL2    0x800

#define DRIVER_GEM         0x1000

#define DRIVER_MODESET     0x2000

#define DRIVER_PRIME       0x4000

#define	DRIVER_USE_PLATFORM_DEVICE	0x8000

/* DRM space units */

#define	DRM_PAGE_SHIFT			PAGESHIFT

#define	DRM_PAGE_SIZE			(1 << DRM_PAGE_SHIFT)

#define	DRM_PAGE_OFFSET			(DRM_PAGE_SIZE - 1)

#define	DRM_PAGE_MASK			~(DRM_PAGE_SIZE - 1)

#define	DRM_MB2PAGES(x)			((x) << 8)

#define	DRM_PAGES2BYTES(x)		((x) << DRM_PAGE_SHIFT)

#define	DRM_BYTES2PAGES(x)		((x) >> DRM_PAGE_SHIFT)

#define	DRM_PAGES2KB(x)			((x) << 2)

#define	DRM_ALIGNED(offset)		(((offset) & DRM_PAGE_OFFSET) == 0)

#define	PAGE_SHIFT			DRM_PAGE_SHIFT

#define	PAGE_SIZE			DRM_PAGE_SIZE

#define	DRM_MAX_INSTANCES	8

#define	DRM_DEVNODE		"drm"

#define	DRM_UNOPENED		0

#define	DRM_OPENED		1

#define	DRM_HASH_SIZE		16 /* Size of key hash table */

#define	DRM_KERNEL_CONTEXT	0  /* Change drm_resctx if changed */

#define	DRM_RESERVED_CONTEXTS	1  /* Change drm_resctx if changed */

#define	DRM_MEM_DMA	   0

#define	DRM_MEM_SAREA	   1

#define	DRM_MEM_DRIVER	   2

#define	DRM_MEM_MAGIC	   3

#define	DRM_MEM_IOCTLS	   4

#define	DRM_MEM_MAPS	   5

#define	DRM_MEM_BUFS	   6

#define	DRM_MEM_SEGS	   7

#define	DRM_MEM_PAGES	   8

#define	DRM_MEM_FILES	  9

#define	DRM_MEM_QUEUES	  10

#define	DRM_MEM_CMDS	  11

#define	DRM_MEM_MAPPINGS  12

#define	DRM_MEM_BUFLISTS  13

#define	DRM_MEM_DRMLISTS  14

#define	DRM_MEM_TOTALDRM  15

#define	DRM_MEM_BOUNDDRM  16

#define	DRM_MEM_CTXBITMAP 17

#define	DRM_MEM_STUB	  18

#define	DRM_MEM_SGLISTS	  19

#define	DRM_MEM_AGPLISTS  20

#define	DRM_MEM_CTXLIST   21

#define	DRM_MEM_MM		22

#define	DRM_MEM_HASHTAB		23

#define	DRM_MEM_OBJECTS		24

#define	DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)

#define	DRM_MAP_HASH_OFFSET 0x10000000

#define	DRM_MAP_HASH_ORDER 12

#define	DRM_OBJECT_HASH_ORDER 12

#define	DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFFUL >> PAGE_SHIFT) + 1)

#define	DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFFUL >> PAGE_SHIFT) * 16)

#define	DRM_MM_INIT_MAX_PAGES 256

/* Internal types and structures */

#define	DRM_ARRAY_SIZE(x) (sizeof (x) / sizeof (x[0]))

#define	DRM_MIN(a, b) ((a) < (b) ? (a) : (b))

#define	DRM_MAX(a, b) ((a) > (b) ? (a) : (b))

#define	DRM_IF_VERSION(maj, min) (maj << 16 | min)

#define	__OS_HAS_AGP	1

#define	DRM_DEV_MOD	(S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)

#define	DRM_DEV_UID	0

#define	DRM_DEV_GID	0

#define	DRM_CURRENTPID		ddi_get_pid()

#define	DRM_SPINLOCK(l)		mutex_enter(l)

#define	DRM_SPINUNLOCK(u)	mutex_exit(u)

#define	DRM_UDELAY(d)		udelay(d)

#define	DRM_MEMORYBARRIER()

#define DRM_MINOR_UNASSIGNED 0

#define DRM_MINOR_LEGACY 1

#define DRM_MINOR_CONTROL 2

#define DRM_MINOR_RENDER 3

#define DRM_MINOR_VGATEXT 4

#define DRM_MINOR_AGPMASTER 5

#define DRM_MINOR_ID_BASE_LEGACY     0

#define DRM_MINOR_ID_BASE_CONTROL    64

#define DRM_MINOR_ID_BASE_RENDER     128

#define DRM_MINOR_ID_BASE_VGATEXT    384

#define DRM_MINOR_ID_BASE_AGPMASTER  448

#define DRM_MINOR_ID_LIMIT_LEGACY     63

#define DRM_MINOR_ID_LIMIT_CONTROL    127

#define DRM_MINOR_ID_LIMIT_RENDER     383

#define DRM_MINOR_ID_LIMIT_VGATEXT    447

#define DRM_MINOR_ID_LIMIT_AGPMASTER  511

#define DRM_MINOR_IS_LEGACY(minor_id)  \

    (minor_id >= DRM_MINOR_ID_BASE_LEGACY && minor_id < DRM_MINOR_ID_LIMIT_LEGACY)

#define DRM_MINOR_IS_CONTROL(minor_id)  \

    (minor_id >= DRM_MINOR_ID_BASE_CONTROL && minor_id < DRM_MINOR_ID_LIMIT_CONTROL)

#define DRM_MINOR_IS_RENDER(minor_id)  \

    (minor_id >= DRM_MINOR_ID_BASE_RENDER && minor_id < DRM_MINOR_ID_LIMIT_RENDER)

#define DRM_MINOR_IS_VGATEXT(minor_id)  \

    (minor_id >= DRM_MINOR_ID_BASE_VGATEXT && minor_id < DRM_MINOR_ID_LIMIT_VGATEXT)

#define DRM_MINOR_IS_AGPMASTER(minor_id)  \

    (minor_id >= DRM_MINOR_ID_BASE_AGPMASTER && minor_id < DRM_MINOR_ID_LIMIT_AGPMASTER)

/* Legacy VGA regions */

#define VGA_RSRC_NONE	       0x00

#define VGA_RSRC_LEGACY_IO     0x01

#define VGA_RSRC_LEGACY_MEM    0x02

#define VGA_RSRC_LEGACY_MASK   (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM)

/* Non-legacy access */

#define VGA_RSRC_NORMAL_IO     0x04

#define VGA_RSRC_NORMAL_MEM    0x08

#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))

typedef	struct drm_file		drm_file_t;

typedef struct drm_device	drm_device_t;

typedef struct drm_driver	drm_driver_t;

#define	DRM_COPYFROM_WITH_RETURN(dest, src, size)     \

	if (ddi_copyin((src), (dest), (size), 0)) {   \

		DRM_ERROR("copy from user failed");   \

		return (-EFAULT);                     \

	}

#define	DRM_COPYTO_WITH_RETURN(dest, src, size)       \

	if (ddi_copyout((src), (dest), (size), 0)) {  \

		DRM_ERROR("copy to user failed");     \

		return (-EFAULT);                     \

	}

#define	DRM_COPY_FROM_USER(dest, src, size) \

	ddi_copyin((src), (dest), (size), 0) /* flag for src */

#define	DRM_COPY_TO_USER(dest, src, size) \

	ddi_copyout((src), (dest), (size), 0) /* flags for dest */

#define	DRM_COPY_FROM_USER_UNCHECKED(arg1, arg2, arg3)  \

	ddi_copyin((arg2), (arg1), (arg3), 0)

#define	DRM_COPY_TO_USER_UNCHECKED(arg1, arg2, arg3)        \

	ddi_copyout((arg2), arg1, arg3, 0)

#define	DRM_READ8(map, offset) \

	*(volatile uint8_t *)((uintptr_t)((map)->handle) + (offset))

#define	DRM_READ16(map, offset) \

	*(volatile uint16_t *)((uintptr_t)((map)->handle) + (offset))

#define	DRM_READ32(map, offset) \

	*(volatile uint32_t *)((uintptr_t)((map)->handle) + (offset))

#define	DRM_READ64(map, offset) \

	*(volatile uint64_t *)((uintptr_t)((map)->handle) + (offset))

#define	DRM_WRITE8(map, offset, val) \

	*(volatile uint8_t *)((uintptr_t)((map)->handle) + (offset)) = (val)

#define	DRM_WRITE16(map, offset, val) \

	*(volatile uint16_t *)((uintptr_t)((map)->handle) + (offset)) = (val)

#define	DRM_WRITE32(map, offset, val) \

	*(volatile uint32_t *)((uintptr_t)((map)->handle) + (offset)) = (val)

#define	DRM_WRITE64(map, offset, val) \

	*(volatile uint64_t *)((uintptr_t)((map)->handle) + (offset)) = (val)

typedef struct drm_wait_queue {

	kcondvar_t	cv;

	kmutex_t	lock;

}wait_queue_head_t;

#define	DRM_INIT_WAITQUEUE(q, pri)	\

{ \

	mutex_init(&(q)->lock, NULL, MUTEX_DRIVER, pri); \

	cv_init(&(q)->cv, NULL, CV_DRIVER, NULL);	\

}

#define	DRM_FINI_WAITQUEUE(q)	\

{ \

	mutex_destroy(&(q)->lock);	\

	cv_destroy(&(q)->cv);	\

}

#define	DRM_WAKEUP(q)	\

{ \

	mutex_enter(&(q)->lock); \

	cv_broadcast(&(q)->cv);	\

	mutex_exit(&(q)->lock);	\

}

#define	DRM_WAIT_ON(ret, q, timeout, condition)  			\

	mutex_enter(&(q)->lock);					\

	while (!(condition)) {						\

		ret = cv_reltimedwait_sig(&(q)->cv, &(q)->lock, timeout,\

		    TR_CLOCK_TICK);					\

		if (ret == -1) {					\

			ret = EBUSY;					\

			break;						\

		} else if (ret == 0) {					\

			ret = EINTR;  					\

			break; 						\

		} else { 						\

			ret = 0; 					\

		} 							\

	} 								\

	mutex_exit(&(q)->lock);

#define	DRM_WAIT(ret, q, condition)  \

mutex_enter(&(q)->lock);	\

if (!(condition)) {	\

	(void) cv_timedwait_sig(&(q)->cv, &(q)->lock, jiffies + 3 * DRM_HZ); \

	ret = 0;					\

	if (!(condition)) {				\

		/* make sure we got what we want */	\

		if (wait_for(condition, 3000))		\

			ret = EBUSY;			\

	}						\

} \

mutex_exit(&(q)->lock);

/*

#define	DRM_GETSAREA()  					\

{                                				\

	drm_local_map_t *map;					\

	TAILQ_FOREACH(map, &dev->maplist, link) {		\

		if (map->type == _DRM_SHM &&			\

			map->flags & _DRM_CONTAINS_LOCK) {	\

			dev_priv->sarea = map;			\

			break;					\

		}						\

	}							\

}

*/

#define wake_up_all DRM_WAKEUP

/**

 * Test that the hardware lock is held by the caller, returning otherwise.

 *

 * \param dev DRM device.

 * \param filp file pointer of the caller.

 */

#define LOCK_TEST_WITH_RETURN( dev, _file_priv )				\

do {										\

	if (!_DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock) ||	\

	    _file_priv->master->lock.file_priv != _file_priv)	{		\

		DRM_ERROR( "%s called without lock held, held  %d owner %p %p\n",\

			   __func__, _DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock),\

			   (void *)_file_priv->master->lock.file_priv, (void *)_file_priv); \

		return -EINVAL;							\

	}									\

} while (*"\0")

/**

 * Copy and IOCTL return string to user space

 */

#define	DRM_COPY(name, value)                            \

	len = strlen(value);                             \

	if (len > name##_len) len = name##_len;          \

		name##_len = strlen(value);              \

	if (len && name) {                               \

		if (DRM_COPY_TO_USER(name, value, len))  \

			return (EFAULT);                 \

	}

#define	DRM_IRQ_ARGS	caddr_t	arg

#define	IRQ_HANDLED		DDI_INTR_CLAIMED

#define	IRQ_NONE		DDI_INTR_UNCLAIMED

enum {

	DRM_IS_NOT_AGP,

	DRM_IS_AGP,

	DRM_MIGHT_BE_AGP

};

/* Capabilities taken from src/sys/dev/pci/pcireg.h. */

#ifndef PCIY_AGP

#define	PCIY_AGP		0x02

#endif

#ifndef PCIY_EXPRESS

#define	PCIY_EXPRESS		0x10

#endif

#define	PAGE_ALIGN(addr)	(((addr) + DRM_PAGE_SIZE - 1) & DRM_PAGE_MASK)

#define	DRM_SUSER(p)		(crgetsgid(p) == 0 || crgetsuid(p) == 0)

/*

 * wait for 400 milliseconds

 */

//#define	DRM_HZ			drv_usectohz(400000)

#define	DRM_HZ			drv_usectohz(1000000)

#define	DRM_SUPPORT	1

#define	DRM_UNSUPPORT	0

#define	__OS_HAS_AGP	1

#ifndef offsetof

#define	__offsetof(type, field) ((size_t)(&((type *)0)->field))

#define	offsetof(type, field)   __offsetof(type, field)

#endif

typedef struct drm_pci_id_list {

	int vendor;

	int device;

	unsigned long driver_data;

} drm_pci_id_list_t;

#define	DRM_DEVICE	drm_device_t *dev = dev1

#define	DRM_IOCTL_ARGS	\

	dev_t dev_id, struct drm_device *dev, void *data, struct drm_file *file, int ioctl_mode, cred_t *credp

typedef int drm_ioctl_t(DRM_IOCTL_ARGS);

#define	DRM_AUTH	0x1

#define	DRM_MASTER	0x2

#define	DRM_ROOT_ONLY	0x4

#define DRM_CONTROL_ALLOW 0x8

#define DRM_UNLOCKED	0x10

typedef struct drm_ioctl_desc {

	drm_ioctl_t *func;

	int flags;

	int cmd;

	unsigned int cmd_drv;

	const char *name;

	int (*copyin32)(void *dest, void *src);

	int (*copyout32)(void *dest, void *src);

} drm_ioctl_desc_t;

/**

 * Creates a driver or general drm_ioctl_desc array entry for the given

 * ioctl, for use by drm_ioctl().

 */

#ifdef _MULTI_DATAMODEL

#define DRM_IOCTL_DEF(ioctl, _func, _flags, _copyin32, _copyout32) \

	[DRM_IOCTL_NR(ioctl)] = {.cmd = ioctl, .flags = _flags, .func = _func, .copyin32 = _copyin32, .copyout32 = _copyout32}

#else

#define DRM_IOCTL_DEF(ioctl, _func, _flags, _copyin32, _copyout32) \

#endif

typedef struct drm_magic_entry {

	drm_magic_t		magic;

	struct drm_file		*priv;

	struct drm_magic_entry	*next;

} drm_magic_entry_t;

typedef struct drm_magic_head {

	struct drm_magic_entry *head;

	struct drm_magic_entry *tail;

} drm_magic_head_t;

typedef struct drm_buf {

	int		idx;		/* Index into master buflist */

	int		total;		/* Buffer size */

	int		order;		/* log-base-2(total) */

	int		used;		/* Amount of buffer in use (for DMA) */

	unsigned long	offset;		/* Byte offset (used internally) */

	void		*address;	/* Address of buffer */

	unsigned long	bus_address;	/* Bus address of buffer */

	struct drm_buf	*next;		/* Kernel-only: used for free list */

	volatile int	pending;	/* On hardware DMA queue */

	struct drm_file	*file_priv;

				/* Uniq. identifier of holding process */

	int		context;	/* Kernel queue for this buffer */

	enum {

		DRM_LIST_NONE	 = 0,

		DRM_LIST_FREE	 = 1,

		DRM_LIST_WAIT	 = 2,

		DRM_LIST_PEND	 = 3,

		DRM_LIST_PRIO	 = 4,

		DRM_LIST_RECLAIM = 5

	}		list;		/* Which list we're on */

	int		dev_priv_size;	/* Size of buffer private storage */

	void		*dev_private;	/* Per-buffer private storage */

} drm_buf_t;

typedef struct drm_freelist {

	int		  initialized;	/* Freelist in use		*/

	uint32_t	  count;	/* Number of free buffers	*/

	drm_buf_t	  *next;	/* End pointer			*/

	int		  low_mark;	/* Low water mark		*/

	int		  high_mark;	/* High water mark		*/

} drm_freelist_t;

typedef struct drm_buf_entry {

	int		  buf_size;

	int		  buf_count;

	drm_buf_t	  *buflist;

	int		  seg_count;

	int		  page_order;

	uint32_t	  *seglist;

	unsigned long	  *seglist_bus;

	drm_freelist_t	  freelist;

} drm_buf_entry_t;

/* Event queued up for userspace to read */

struct drm_pending_event {

	struct drm_event *event;

	struct list_head link;

	struct drm_file *file_priv;

	pid_t pid; /* pid of requester, no guarantee it's valid by the time