WebSVN – Kolibri OS – Diff – /drivers/include/drm/drmP.h

 #ifndef _DRM_P_H_
 #define _DRM_P_H_
+#ifdef __KERNEL__
+#ifdef __alpha__
+/* add include of current.h so that "current" is defined
+ * before static inline funcs in wait.h. Doing this so we
+ * can build the DRM (part of PI DRI). 4/21/2000 S + B */
 #include
-#ifdef __KERNEL__
 #endif				/* __alpha__ */
 #include
 #include
 #include
+#include
 #include
 #include
 #include
 #include
 #include
 #define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE)))
-#define __OS_HAS_MTRR (defined(CONFIG_MTRR))
+#define __OS_HAS_MTRR (defined(CONFIG_MTRR))
-#include
 #include
 struct module;
 struct drm_file;
 struct drm_device;
-//#include "drm_os_linux.h"
-#include "drm_hashtab.h"
-#include "drm_mm.h"
 #define DRM_UT_CORE 		0x01
-#define DRM_UT_DRIVER		0x02
+//#include
-#define DRM_UT_KMS          0x04
+#include
-#define DRM_UT_MODE         0x08
+#include
+#define KHZ2PICOS(a) (1000000000UL/(a))
+/* get_scanout_position() return flags */
+#define DRM_SCANOUTPOS_VALID        (1 << 0)
+#define DRM_SCANOUTPOS_INVBL        (1 << 1)
+#define DRM_SCANOUTPOS_ACCURATE     (1 << 2)
+#define DRM_UT_CORE 		0x01
+#define DRM_UT_DRIVER		0x02
+#define DRM_UT_KMS          0x04
+#define DRM_UT_PRIME		0x08
+/*
+ * Three debug levels are defined.
+ * drm_core, drm_driver, drm_kms
+ * drm_core level can be used in the generic drm code. For example:
+ * 	drm_ioctl, drm_mm, drm_memory
+ * The macro definition of DRM_DEBUG is used.
+ * 	DRM_DEBUG(fmt, args...)
+ * 	The debug info by using the DRM_DEBUG can be obtained by adding
+ * 	the boot option of "drm.debug=1".
+ *
+ * drm_driver level can be used in the specific drm driver. It is used
+ * to add the debug info related with the drm driver. For example:
+ * i915_drv, i915_dma, i915_gem, radeon_drv,
+ * 	The macro definition of DRM_DEBUG_DRIVER can be used.
+ * 	DRM_DEBUG_DRIVER(fmt, args...)
+ * 	The debug info by using the DRM_DEBUG_DRIVER can be obtained by
+ * 	adding the boot option of "drm.debug=0x02"
+ *
+ * drm_kms level can be used in the KMS code related with specific drm driver.
+ * It is used to add the debug info related with KMS mode. For example:
+ * the connector/crtc ,
+ * 	The macro definition of DRM_DEBUG_KMS can be used.
+ * 	DRM_DEBUG_KMS(fmt, args...)
+ * 	The debug info by using the DRM_DEBUG_KMS can be obtained by
+ * 	adding the boot option of "drm.debug=0x04"
-#define KHZ2PICOS(a) (1000000000UL/(a))
+ *
  * If we add the boot option of "drm.debug=0x06", we can get the debug info by
-/* get_scanout_position() return flags */
+ * using the DRM_DEBUG_KMS and DRM_DEBUG_DRIVER.
-#define DRM_SCANOUTPOS_VALID        (1 << 0)
+ * If we add the boot option of "drm.debug=0x05", we can get the debug info by
-#define DRM_SCANOUTPOS_INVBL        (1 << 1)
-#define DRM_SCANOUTPOS_ACCURATE     (1 << 2)
-extern void drm_ut_debug_printk(unsigned int request_level,
-				const char *prefix,
+ * using the DRM_DEBUG_KMS and DRM_DEBUG.
-				const char *function_name,
-				const char *format, ...);
-#define DRM_DEBUG_MODE(prefix, fmt, args...)    \
-    do {                                        \
-        dbgprintf("drm debug: %s" fmt,          \
-                     __func__, ##args);         \
-    } while (0)
-#define DRM_DEBUG(fmt, args...)                                 \
-    do {                                                        \
-        printk("[" DRM_NAME ":%s] " fmt , __func__ , ##args);   \
-    } while(0)
-#define DRM_DEBUG_KMS(fmt, args...)                             \
-    do {                                                        \
-        printk("[" DRM_NAME ":%s] " fmt , __func__ , ##args);   \
-    } while(0)
-#define DRM_DEBUG_DRIVER(fmt, args...)                          \
-    do {                                                        \
-        printk("[" DRM_NAME ":%s] " fmt , __func__ , ##args);   \
+ */
-    } while (0)
-#define DRM_LOG_KMS(fmt, args...)      \
-    do {                               \
-        printk("[" DRM_NAME "]" fmt, ##args);     \
-    } while (0)
-static inline int drm_sysfs_connector_add(struct drm_connector *connector)
+extern __printf(4, 5)
-{ return 0; };
+void drm_ut_debug_printk(unsigned int request_level,
 #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_BUS_PCI 0x1
 #define DRIVER_BUS_PLATFORM 0x2
  * Error output.
+ *
  * \param fmt printf() like format string.
  * \param arg arguments
  */
-#define DRM_ERROR(fmt, arg...) \
+#define DRM_ERROR(fmt, ...)				\
-	printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* " fmt , __func__ , ##arg)
+	drm_err(__func__, fmt, ##__VA_ARGS__)
-/**
- * Memory error output.
- *
- * \param area memory area where the error occurred.
- * \param fmt printf() like format string.
- * \param arg arguments
- */
-#define DRM_MEM_ERROR(area, fmt, arg...) \
+#define DRM_INFO(fmt, ...)				\
-	printk(KERN_ERR "[" DRM_NAME ":%s:%s] *ERROR* " fmt , __func__, \
-	       drm_mem_stats[area].name , ##arg)
-#define DRM_INFO(fmt, arg...)  printk(KERN_INFO "[" DRM_NAME "] " fmt , ##arg)
+	printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__)
 /**
  * Debug output.
+ *
  * \param fmt printf() like format string.
  * \param arg arguments
  */
 #if DRM_DEBUG_CODE
-#define DRM_DEBUG(fmt, args...)						\
+#define DRM_DEBUG(fmt, ...)                                 \
-	do {								\
-		drm_ut_debug_printk(DRM_UT_CORE, DRM_NAME, 		\
+    do {                                                    \
+    printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__);  \
+	} while (0)
+#define DRM_DEBUG_DRIVER(fmt, ...)                          \
-					__func__, fmt, ##args);		\
+    do {                                                    \
-	} while (0)
+    printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__);  \
+	} while (0)
-#define DRM_DEBUG_DRIVER(fmt, args...)					\
-	do {								\
+#define DRM_DEBUG_KMS(fmt, ...)              \
-		drm_ut_debug_printk(DRM_UT_DRIVER, DRM_NAME,		\
+	do {								\
-					__func__, fmt, ##args);		\
+    printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__);  \
 	} while (0)
-#define DRM_DEBUG_KMS(fmt, args...)				\
-	do {								\
+#define DRM_DEBUG_PRIME(fmt, ...)                    \
-		drm_ut_debug_printk(DRM_UT_KMS, DRM_NAME, 		\
+	do {								\
-					 __func__, fmt, ##args);	\
+    printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__);  \
 	} while (0)
-#define DRM_LOG(fmt, args...)						\
-	do {								\
+#define DRM_LOG(fmt, ...)                        \
-		drm_ut_debug_printk(DRM_UT_CORE, NULL,			\
+	do {								\
-					NULL, fmt, ##args);		\
+    printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__);  \
 	} while (0)
-#define DRM_LOG_KMS(fmt, args...)					\
-	do {								\
+#define DRM_LOG_KMS(fmt, ...)                    \
-		drm_ut_debug_printk(DRM_UT_KMS, NULL,			\
+	do {								\
-					NULL, fmt, ##args);		\
+    printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__);  \
 	} while (0)
-#define DRM_LOG_MODE(fmt, args...)					\
-	do {								\
+#define DRM_LOG_MODE(fmt, ...)                   \
-		drm_ut_debug_printk(DRM_UT_MODE, NULL,			\
+	do {								\
-					NULL, fmt, ##args);		\
+    printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__);  \
 	} while (0)
-#define DRM_LOG_DRIVER(fmt, args...)					\
-	do {								\
+#define DRM_LOG_DRIVER(fmt, ...)                 \
-		drm_ut_debug_printk(DRM_UT_DRIVER, NULL,		\
+	do {								\
-					NULL, fmt, ##args);		\
+    printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__);  \
 	} while (0)
+#else
-#else
+#define DRM_DEBUG_DRIVER(fmt, args...) do { } while (0)
-#define DRM_DEBUG_DRIVER(fmt, args...) do { } while (0)
+#define DRM_DEBUG_KMS(fmt, args...)	do { } while (0)
-#define DRM_DEBUG_KMS(fmt, args...)	do { } while (0)
+#define DRM_DEBUG_PRIME(fmt, args...)	do { } while (0)
 #define DRM_DEBUG(fmt, arg...)		 do { } while (0)
 #define DRM_LOG(fmt, arg...)		do { } while (0)
 			   _file_priv->master->lock.file_priv, _file_priv);	\
 		return -EINVAL;							\
 	}									\
 } while (0)
 #if 0
 /**
  * Ioctl function type.
+ *
  * \param inode device inode.
 	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 waiting;      /**< On kernel DMA queue */
 	__volatile__ int pending;      /**< On hardware DMA queue */
-	wait_queue_head_t dma_wait;    /**< Processes waiting */
 	struct drm_file *file_priv;    /**< Private of holding file descr */
 	int context;		       /**< Kernel queue for this buffer */
 	int while_locked;	       /**< Dispatch this buffer while locked */
 	enum {
 		DRM_LIST_NONE = 0,
 	pid_t pid; /* pid of requester, no guarantee it's valid by the time
 		      we deliver the event, for tracing only */
 	void (*destroy)(struct drm_pending_event *event);
 };
+/* initial implementaton using a linked list - todo hashtab */
+struct drm_prime_file_private {
+	struct list_head head;
+	struct mutex lock;
+};
 /** File private data */
 struct drm_file {
 	int authenticated;
-	pid_t pid;
+	struct pid *pid;
-	uid_t uid;
+	kuid_t uid;
 	drm_magic_t magic;
 	unsigned long ioctl_count;
 	struct list_head lhead;
 	struct drm_minor *minor;
 	struct list_head fbs;
 	wait_queue_head_t event_wait;
 	struct list_head event_list;
+	int event_space;
-	int event_space;
+	struct drm_prime_file_private prime;
 };
 /** Wait queue */
 	uint32_t pending_write_domain;
 	void *driver_private;
 };
-#include "drm_crtc.h"
+#include
 	/**
 	 * get_vblank_counter - get raw hardware vblank counter
 	 * @dev: DRM device
 	 * @crtc: counter to fetch
+	 *
-	 * Driver callback for fetching a raw hardware vblank counter
+	 * Driver callback for fetching a raw hardware vblank counter for @crtc.
-	 * for @crtc.  If a device doesn't have a hardware counter, the
+	 * If a device doesn't have a hardware counter, the driver can simply
-	 * driver can simply return the value of drm_vblank_count and
+	 * return the value of drm_vblank_count. The DRM core will account for
-	 * make the enable_vblank() and disable_vblank() hooks into no-ops,
+	 * missed vblank events while interrupts where disabled based on system
-	 * leaving interrupts enabled at all times.
+	 * timestamps.
+	 *
 	 * Wraparound handling and loss of events due to modesetting is dealt
 	 * with in the DRM core code.
+	 *
 	 * RETURNS
 	irqreturn_t(*irq_handler) (DRM_IRQ_ARGS);
 	void (*irq_preinstall) (struct drm_device *dev);
 	int (*irq_postinstall) (struct drm_device *dev);
-	void (*irq_uninstall) (struct drm_device *dev);
-	void (*reclaim_buffers) (struct drm_device *dev,
-				 struct drm_file * file_priv);
-	void (*reclaim_buffers_locked) (struct drm_device *dev,
-					struct drm_file *file_priv);
-	void (*reclaim_buffers_idlelocked) (struct drm_device *dev,
-					    struct drm_file *file_priv);
+	void (*irq_uninstall) (struct drm_device *dev);
 	void (*set_version) (struct drm_device *dev,
 			     struct drm_set_version *sv);
 	int (*gem_init_object) (struct drm_gem_object *obj);
 	void (*gem_free_object) (struct drm_gem_object *obj);
 	int (*gem_open_object) (struct drm_gem_object *, struct drm_file *);
 	void (*gem_close_object) (struct drm_gem_object *, struct drm_file *);
+	/* prime: */
+	/* export handle -> fd (see drm_gem_prime_handle_to_fd() helper) */
+	int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv,
+				uint32_t handle, uint32_t flags, int *prime_fd);
+	/* import fd -> handle (see drm_gem_prime_fd_to_handle() helper) */
+	int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv,
+				int prime_fd, uint32_t *handle);
+	/* export GEM -> dmabuf */
+	struct dma_buf * (*gem_prime_export)(struct drm_device *dev,
+				struct drm_gem_object *obj, int flags);
+	/* import dmabuf -> GEM */
+	struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev,
+				struct dma_buf *dma_buf);
 	/* vga arb irq handler */
 	void (*vgaarb_irq)(struct drm_device *dev, bool state);
 	int (*dumb_destroy)(struct drm_file *file_priv,
 			    struct drm_device *dev,
 			    uint32_t handle);
 	/* Driver private ops for this object */
-	struct vm_operations_struct *gem_vm_ops;
+	const struct vm_operations_struct *gem_vm_ops;
 	int major;
 	int minor;
 	struct list_head vmalist;	/**< List of vmas (for debugging) */
 	/*@} */
-	/** \name DMA queues (contexts) */
-	/*@{ */
-	int queue_count;		/**< Number of active DMA queues */
 	int queue_reserved;		  /**< Number of reserved DMA queues */
-	int queue_slots;		/**< Actual length of queuelist */
+	/** \name DMA support */
-//   struct drm_queue **queuelist;   /**< Vector of pointers to DMA queues */
+	/*@{ */
 //   struct drm_device_dma *dma;     /**< Optional pointer for DMA support */
 	/*@{ */
    spinlock_t object_name_lock;
 	struct idr object_name_idr;
 	/*@} */
 	int switch_power_state;
+	atomic_t unplugged; /* device has been unplugged or gone away */
 };
 #define DRM_SWITCH_POWER_ON 0
 #define DRM_SWITCH_POWER_OFF 1
 extern int drm_release(struct inode *inode, struct file *filp);
 				/* Mapping support (drm_vm.h) */
 extern int drm_mmap(struct file *filp, struct vm_area_struct *vma);
 extern int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma);
-extern void drm_vm_open_locked(struct vm_area_struct *vma);
+extern void drm_vm_open_locked(struct drm_device *dev, struct vm_area_struct *vma);
-extern void drm_vm_close_locked(struct vm_area_struct *vma);
+extern void drm_vm_close_locked(struct drm_device *dev, struct vm_area_struct *vma);
 extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait);
-				/* Memory management support (drm_memory.h) */
-#include "drm_memory.h"
-extern void drm_mem_init(void);
-extern int drm_mem_info(char *buf, char **start, off_t offset,
-			int request, int *eof, void *data);
-extern void *drm_realloc(void *oldpt, size_t oldsize, size_t size, int area);
+				/* Memory management support (drm_memory.h) */
 #include
 extern void drm_free_agp(DRM_AGP_MEM * handle, int pages);
 extern int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start);
 extern DRM_AGP_MEM *drm_agp_bind_pages(struct drm_device *dev,
 			 struct drm_file *file_priv);
 extern int drm_remove_magic(struct drm_master *master, drm_magic_t magic);
 /* Cache management (drm_cache.c) */
+void drm_clflush_pages(struct page *pages[], unsigned long num_pages);
+void drm_clflush_sg(struct sg_table *st);
-void drm_clflush_pages(struct page *pages[], unsigned long num_pages);
+void drm_clflush_virt_range(char *addr, unsigned long length);
 				/* Locking IOCTL support (drm_lock.h) */
 extern int drm_lock(struct drm_device *dev, void *data,
 				     struct drm_file *filp);
 				/* IRQ support (drm_irq.h) */
 extern int drm_control(struct drm_device *dev, void *data,
-		       struct drm_file *file_priv);
-extern irqreturn_t drm_irq_handler(DRM_IRQ_ARGS);
+		       struct drm_file *file_priv);
 extern int drm_irq_install(struct drm_device *dev);
-extern int drm_irq_uninstall(struct drm_device *dev);
-extern void drm_driver_irq_preinstall(struct drm_device *dev);
-extern void drm_driver_irq_postinstall(struct drm_device *dev);
-extern void drm_driver_irq_uninstall(struct drm_device *dev);
+extern int drm_irq_uninstall(struct drm_device *dev);
 extern int drm_vblank_init(struct drm_device *dev, int num_crtcs);
 extern int drm_wait_vblank(struct drm_device *dev, void *data,
 extern struct drm_master *drm_master_get(struct drm_master *master);
 extern void drm_master_put(struct drm_master **master);
 extern void drm_put_dev(struct drm_device *dev);
+extern int drm_put_minor(struct drm_minor **minor);
+extern void drm_unplug_dev(struct drm_device *dev);
+#endif
 extern int drm_put_minor(struct drm_minor **minor);
+extern unsigned int drm_debug;
 extern unsigned int drm_debug;
 #if 0
 extern unsigned int drm_vblank_offdelay;
 extern unsigned int drm_timestamp_precision;
 #endif
 				/* Info file support */
 extern int drm_name_info(struct seq_file *m, void *data);
-extern int drm_vm_info(struct seq_file *m, void *data);
-extern int drm_queues_info(struct seq_file *m, void *data);
+extern int drm_vm_info(struct seq_file *m, void *data);
 extern int drm_bufs_info(struct seq_file *m, void *data);
 extern int drm_vblank_info(struct seq_file *m, void *data);
 extern int drm_clients_info(struct seq_file *m, void* data);
 			       /* ATI PCIGART support (ati_pcigart.h) */
 extern int drm_ati_pcigart_init(struct drm_device *dev,
 				struct drm_ati_pcigart_info * gart_info);
 extern int drm_ati_pcigart_cleanup(struct drm_device *dev,
 				   struct drm_ati_pcigart_info * gart_info);
+#endif
 extern drm_dma_handle_t *drm_pci_alloc(struct drm_device *dev, size_t size,
 				       size_t align);
 extern void __drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
+extern void drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
 extern void drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
 #if 0
 			       /* sysfs support (drm_sysfs.c) */
 struct drm_sysfs_class;
 extern struct class *drm_sysfs_create(struct module *owner, char *name);
 static __inline__ void drm_core_dropmap(struct drm_local_map *map)
+{
+}
 static __inline__ void *drm_calloc_large(size_t nmemb, size_t size)
+{
 	vfree(ptr);
+}
+#endif
+#define DRM_PCIE_SPEED_25 1
+#define DRM_PCIE_SPEED_50 2
+#define DRM_PCIE_SPEED_80 4
 #endif
 extern int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *speed_mask);
 static __inline__ int drm_device_is_agp(struct drm_device *dev)
 static __inline__ int drm_device_is_pcie(struct drm_device *dev)
+{
     return pci_find_capability(dev->pdev, PCI_CAP_ID_EXP);
+}
 #endif				/* __KERNEL__ */
+#define drm_sysfs_connector_add(connector)
+#define drm_sysfs_connector_remove(connector)
 #endif

Subversion Repositories Kolibri OS

(root)/drivers/include/drm/drmP.h – Rev 2967 → 3031