drmP.h 55 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710
  1. /**
  2. * \file drmP.h
  3. * Private header for Direct Rendering Manager
  4. *
  5. * \author Rickard E. (Rik) Faith <faith@valinux.com>
  6. * \author Gareth Hughes <gareth@valinux.com>
  7. */
  8. /*
  9. * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
  10. * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
  11. * Copyright (c) 2009-2010, Code Aurora Forum.
  12. * All rights reserved.
  13. *
  14. * Permission is hereby granted, free of charge, to any person obtaining a
  15. * copy of this software and associated documentation files (the "Software"),
  16. * to deal in the Software without restriction, including without limitation
  17. * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  18. * and/or sell copies of the Software, and to permit persons to whom the
  19. * Software is furnished to do so, subject to the following conditions:
  20. *
  21. * The above copyright notice and this permission notice (including the next
  22. * paragraph) shall be included in all copies or substantial portions of the
  23. * Software.
  24. *
  25. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  26. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  27. * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  28. * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  29. * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  30. * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  31. * OTHER DEALINGS IN THE SOFTWARE.
  32. */
  33. #ifndef _DRM_P_H_
  34. #define _DRM_P_H_
  35. #ifdef __KERNEL__
  36. #ifdef __alpha__
  37. /* add include of current.h so that "current" is defined
  38. * before static inline funcs in wait.h. Doing this so we
  39. * can build the DRM (part of PI DRI). 4/21/2000 S + B */
  40. #include <asm/current.h>
  41. #endif /* __alpha__ */
  42. #include <linux/kernel.h>
  43. #include <linux/miscdevice.h>
  44. #include <linux/fs.h>
  45. #include <linux/proc_fs.h>
  46. #include <linux/init.h>
  47. #include <linux/file.h>
  48. #include <linux/platform_device.h>
  49. #include <linux/pci.h>
  50. #include <linux/jiffies.h>
  51. #include <linux/dma-mapping.h>
  52. #include <linux/mm.h>
  53. #include <linux/cdev.h>
  54. #include <linux/mutex.h>
  55. #include <linux/io.h>
  56. #include <linux/slab.h>
  57. #if defined(__alpha__) || defined(__powerpc__)
  58. #include <asm/pgtable.h> /* For pte_wrprotect */
  59. #endif
  60. #include <asm/mman.h>
  61. #include <asm/uaccess.h>
  62. #include <linux/types.h>
  63. #include <linux/agp_backend.h>
  64. #include <linux/workqueue.h>
  65. #include <linux/poll.h>
  66. #include <asm/pgalloc.h>
  67. #include <drm/drm.h>
  68. #include <drm/drm_sarea.h>
  69. #include <drm/drm_vma_manager.h>
  70. #include <linux/idr.h>
  71. #define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE)))
  72. #define __OS_HAS_MTRR (defined(CONFIG_MTRR))
  73. struct module;
  74. struct drm_file;
  75. struct drm_device;
  76. struct device_node;
  77. struct videomode;
  78. #include <drm/drm_os_linux.h>
  79. #include <drm/drm_hashtab.h>
  80. #include <drm/drm_mm.h>
  81. #define DRM_UT_CORE 0x01
  82. #define DRM_UT_DRIVER 0x02
  83. #define DRM_UT_KMS 0x04
  84. #define DRM_UT_PRIME 0x08
  85. /*
  86. * Three debug levels are defined.
  87. * drm_core, drm_driver, drm_kms
  88. * drm_core level can be used in the generic drm code. For example:
  89. * drm_ioctl, drm_mm, drm_memory
  90. * The macro definition of DRM_DEBUG is used.
  91. * DRM_DEBUG(fmt, args...)
  92. * The debug info by using the DRM_DEBUG can be obtained by adding
  93. * the boot option of "drm.debug=1".
  94. *
  95. * drm_driver level can be used in the specific drm driver. It is used
  96. * to add the debug info related with the drm driver. For example:
  97. * i915_drv, i915_dma, i915_gem, radeon_drv,
  98. * The macro definition of DRM_DEBUG_DRIVER can be used.
  99. * DRM_DEBUG_DRIVER(fmt, args...)
  100. * The debug info by using the DRM_DEBUG_DRIVER can be obtained by
  101. * adding the boot option of "drm.debug=0x02"
  102. *
  103. * drm_kms level can be used in the KMS code related with specific drm driver.
  104. * It is used to add the debug info related with KMS mode. For example:
  105. * the connector/crtc ,
  106. * The macro definition of DRM_DEBUG_KMS can be used.
  107. * DRM_DEBUG_KMS(fmt, args...)
  108. * The debug info by using the DRM_DEBUG_KMS can be obtained by
  109. * adding the boot option of "drm.debug=0x04"
  110. *
  111. * If we add the boot option of "drm.debug=0x06", we can get the debug info by
  112. * using the DRM_DEBUG_KMS and DRM_DEBUG_DRIVER.
  113. * If we add the boot option of "drm.debug=0x05", we can get the debug info by
  114. * using the DRM_DEBUG_KMS and DRM_DEBUG.
  115. */
  116. extern __printf(4, 5)
  117. void drm_ut_debug_printk(unsigned int request_level,
  118. const char *prefix,
  119. const char *function_name,
  120. const char *format, ...);
  121. extern __printf(2, 3)
  122. int drm_err(const char *func, const char *format, ...);
  123. /***********************************************************************/
  124. /** \name DRM template customization defaults */
  125. /*@{*/
  126. /* driver capabilities and requirements mask */
  127. #define DRIVER_USE_AGP 0x1
  128. #define DRIVER_REQUIRE_AGP 0x2
  129. #define DRIVER_USE_MTRR 0x4
  130. #define DRIVER_PCI_DMA 0x8
  131. #define DRIVER_SG 0x10
  132. #define DRIVER_HAVE_DMA 0x20
  133. #define DRIVER_HAVE_IRQ 0x40
  134. #define DRIVER_IRQ_SHARED 0x80
  135. #define DRIVER_IRQ_VBL 0x100
  136. #define DRIVER_DMA_QUEUE 0x200
  137. #define DRIVER_IRQ_VBL2 0x800
  138. #define DRIVER_GEM 0x1000
  139. #define DRIVER_MODESET 0x2000
  140. #define DRIVER_PRIME 0x4000
  141. #define DRIVER_BUS_PCI 0x1
  142. #define DRIVER_BUS_PLATFORM 0x2
  143. #define DRIVER_BUS_USB 0x3
  144. /***********************************************************************/
  145. /** \name Begin the DRM... */
  146. /*@{*/
  147. #define DRM_DEBUG_CODE 2 /**< Include debugging code if > 1, then
  148. also include looping detection. */
  149. #define DRM_MAGIC_HASH_ORDER 4 /**< Size of key hash table. Must be power of 2. */
  150. #define DRM_KERNEL_CONTEXT 0 /**< Change drm_resctx if changed */
  151. #define DRM_RESERVED_CONTEXTS 1 /**< Change drm_resctx if changed */
  152. #define DRM_LOOPING_LIMIT 5000000
  153. #define DRM_TIME_SLICE (HZ/20) /**< Time slice for GLXContexts */
  154. #define DRM_LOCK_SLICE 1 /**< Time slice for lock, in jiffies */
  155. #define DRM_FLAG_DEBUG 0x01
  156. #define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)
  157. #define DRM_MAP_HASH_OFFSET 0x10000000
  158. /*@}*/
  159. /***********************************************************************/
  160. /** \name Macros to make printk easier */
  161. /*@{*/
  162. /**
  163. * Error output.
  164. *
  165. * \param fmt printf() like format string.
  166. * \param arg arguments
  167. */
  168. #define DRM_ERROR(fmt, ...) \
  169. drm_err(__func__, fmt, ##__VA_ARGS__)
  170. #define DRM_INFO(fmt, ...) \
  171. printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__)
  172. /**
  173. * Debug output.
  174. *
  175. * \param fmt printf() like format string.
  176. * \param arg arguments
  177. */
  178. #if DRM_DEBUG_CODE
  179. #define DRM_DEBUG(fmt, args...) \
  180. do { \
  181. drm_ut_debug_printk(DRM_UT_CORE, DRM_NAME, \
  182. __func__, fmt, ##args); \
  183. } while (0)
  184. #define DRM_DEBUG_DRIVER(fmt, args...) \
  185. do { \
  186. drm_ut_debug_printk(DRM_UT_DRIVER, DRM_NAME, \
  187. __func__, fmt, ##args); \
  188. } while (0)
  189. #define DRM_DEBUG_KMS(fmt, args...) \
  190. do { \
  191. drm_ut_debug_printk(DRM_UT_KMS, DRM_NAME, \
  192. __func__, fmt, ##args); \
  193. } while (0)
  194. #define DRM_DEBUG_PRIME(fmt, args...) \
  195. do { \
  196. drm_ut_debug_printk(DRM_UT_PRIME, DRM_NAME, \
  197. __func__, fmt, ##args); \
  198. } while (0)
  199. #define DRM_LOG(fmt, args...) \
  200. do { \
  201. drm_ut_debug_printk(DRM_UT_CORE, NULL, \
  202. NULL, fmt, ##args); \
  203. } while (0)
  204. #define DRM_LOG_KMS(fmt, args...) \
  205. do { \
  206. drm_ut_debug_printk(DRM_UT_KMS, NULL, \
  207. NULL, fmt, ##args); \
  208. } while (0)
  209. #define DRM_LOG_MODE(fmt, args...) \
  210. do { \
  211. drm_ut_debug_printk(DRM_UT_MODE, NULL, \
  212. NULL, fmt, ##args); \
  213. } while (0)
  214. #define DRM_LOG_DRIVER(fmt, args...) \
  215. do { \
  216. drm_ut_debug_printk(DRM_UT_DRIVER, NULL, \
  217. NULL, fmt, ##args); \
  218. } while (0)
  219. #else
  220. #define DRM_DEBUG_DRIVER(fmt, args...) do { } while (0)
  221. #define DRM_DEBUG_KMS(fmt, args...) do { } while (0)
  222. #define DRM_DEBUG_PRIME(fmt, args...) do { } while (0)
  223. #define DRM_DEBUG(fmt, arg...) do { } while (0)
  224. #define DRM_LOG(fmt, arg...) do { } while (0)
  225. #define DRM_LOG_KMS(fmt, args...) do { } while (0)
  226. #define DRM_LOG_MODE(fmt, arg...) do { } while (0)
  227. #define DRM_LOG_DRIVER(fmt, arg...) do { } while (0)
  228. #endif
  229. /*@}*/
  230. /***********************************************************************/
  231. /** \name Internal types and structures */
  232. /*@{*/
  233. #define DRM_ARRAY_SIZE(x) ARRAY_SIZE(x)
  234. #define DRM_LEFTCOUNT(x) (((x)->rp + (x)->count - (x)->wp) % ((x)->count + 1))
  235. #define DRM_BUFCOUNT(x) ((x)->count - DRM_LEFTCOUNT(x))
  236. #define DRM_IF_VERSION(maj, min) (maj << 16 | min)
  237. /**
  238. * Test that the hardware lock is held by the caller, returning otherwise.
  239. *
  240. * \param dev DRM device.
  241. * \param filp file pointer of the caller.
  242. */
  243. #define LOCK_TEST_WITH_RETURN( dev, _file_priv ) \
  244. do { \
  245. if (!_DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock) || \
  246. _file_priv->master->lock.file_priv != _file_priv) { \
  247. DRM_ERROR( "%s called without lock held, held %d owner %p %p\n",\
  248. __func__, _DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock),\
  249. _file_priv->master->lock.file_priv, _file_priv); \
  250. return -EINVAL; \
  251. } \
  252. } while (0)
  253. /**
  254. * Ioctl function type.
  255. *
  256. * \param inode device inode.
  257. * \param file_priv DRM file private pointer.
  258. * \param cmd command.
  259. * \param arg argument.
  260. */
  261. typedef int drm_ioctl_t(struct drm_device *dev, void *data,
  262. struct drm_file *file_priv);
  263. typedef int drm_ioctl_compat_t(struct file *filp, unsigned int cmd,
  264. unsigned long arg);
  265. #define DRM_IOCTL_NR(n) _IOC_NR(n)
  266. #define DRM_MAJOR 226
  267. #define DRM_AUTH 0x1
  268. #define DRM_MASTER 0x2
  269. #define DRM_ROOT_ONLY 0x4
  270. #define DRM_CONTROL_ALLOW 0x8
  271. #define DRM_UNLOCKED 0x10
  272. struct drm_ioctl_desc {
  273. unsigned int cmd;
  274. int flags;
  275. drm_ioctl_t *func;
  276. unsigned int cmd_drv;
  277. const char *name;
  278. };
  279. /**
  280. * Creates a driver or general drm_ioctl_desc array entry for the given
  281. * ioctl, for use by drm_ioctl().
  282. */
  283. #define DRM_IOCTL_DEF_DRV(ioctl, _func, _flags) \
  284. [DRM_IOCTL_NR(DRM_##ioctl)] = {.cmd = DRM_##ioctl, .func = _func, .flags = _flags, .cmd_drv = DRM_IOCTL_##ioctl, .name = #ioctl}
  285. struct drm_magic_entry {
  286. struct list_head head;
  287. struct drm_hash_item hash_item;
  288. struct drm_file *priv;
  289. };
  290. struct drm_vma_entry {
  291. struct list_head head;
  292. struct vm_area_struct *vma;
  293. pid_t pid;
  294. };
  295. /**
  296. * DMA buffer.
  297. */
  298. struct drm_buf {
  299. int idx; /**< Index into master buflist */
  300. int total; /**< Buffer size */
  301. int order; /**< log-base-2(total) */
  302. int used; /**< Amount of buffer in use (for DMA) */
  303. unsigned long offset; /**< Byte offset (used internally) */
  304. void *address; /**< Address of buffer */
  305. unsigned long bus_address; /**< Bus address of buffer */
  306. struct drm_buf *next; /**< Kernel-only: used for free list */
  307. __volatile__ int waiting; /**< On kernel DMA queue */
  308. __volatile__ int pending; /**< On hardware DMA queue */
  309. struct drm_file *file_priv; /**< Private of holding file descr */
  310. int context; /**< Kernel queue for this buffer */
  311. int while_locked; /**< Dispatch this buffer while locked */
  312. enum {
  313. DRM_LIST_NONE = 0,
  314. DRM_LIST_FREE = 1,
  315. DRM_LIST_WAIT = 2,
  316. DRM_LIST_PEND = 3,
  317. DRM_LIST_PRIO = 4,
  318. DRM_LIST_RECLAIM = 5
  319. } list; /**< Which list we're on */
  320. int dev_priv_size; /**< Size of buffer private storage */
  321. void *dev_private; /**< Per-buffer private storage */
  322. };
  323. /** bufs is one longer than it has to be */
  324. struct drm_waitlist {
  325. int count; /**< Number of possible buffers */
  326. struct drm_buf **bufs; /**< List of pointers to buffers */
  327. struct drm_buf **rp; /**< Read pointer */
  328. struct drm_buf **wp; /**< Write pointer */
  329. struct drm_buf **end; /**< End pointer */
  330. spinlock_t read_lock;
  331. spinlock_t write_lock;
  332. };
  333. struct drm_freelist {
  334. int initialized; /**< Freelist in use */
  335. atomic_t count; /**< Number of free buffers */
  336. struct drm_buf *next; /**< End pointer */
  337. wait_queue_head_t waiting; /**< Processes waiting on free bufs */
  338. int low_mark; /**< Low water mark */
  339. int high_mark; /**< High water mark */
  340. atomic_t wfh; /**< If waiting for high mark */
  341. spinlock_t lock;
  342. };
  343. typedef struct drm_dma_handle {
  344. dma_addr_t busaddr;
  345. void *vaddr;
  346. size_t size;
  347. } drm_dma_handle_t;
  348. /**
  349. * Buffer entry. There is one of this for each buffer size order.
  350. */
  351. struct drm_buf_entry {
  352. int buf_size; /**< size */
  353. int buf_count; /**< number of buffers */
  354. struct drm_buf *buflist; /**< buffer list */
  355. int seg_count;
  356. int page_order;
  357. struct drm_dma_handle **seglist;
  358. struct drm_freelist freelist;
  359. };
  360. /* Event queued up for userspace to read */
  361. struct drm_pending_event {
  362. struct drm_event *event;
  363. struct list_head link;
  364. struct drm_file *file_priv;
  365. pid_t pid; /* pid of requester, no guarantee it's valid by the time
  366. we deliver the event, for tracing only */
  367. void (*destroy)(struct drm_pending_event *event);
  368. };
  369. /* initial implementaton using a linked list - todo hashtab */
  370. struct drm_prime_file_private {
  371. struct list_head head;
  372. struct mutex lock;
  373. };
  374. /** File private data */
  375. struct drm_file {
  376. int authenticated;
  377. struct pid *pid;
  378. kuid_t uid;
  379. drm_magic_t magic;
  380. unsigned long ioctl_count;
  381. struct list_head lhead;
  382. struct drm_minor *minor;
  383. unsigned long lock_count;
  384. /** Mapping of mm object handles to object pointers. */
  385. struct idr object_idr;
  386. /** Lock for synchronization of access to object_idr. */
  387. spinlock_t table_lock;
  388. struct file *filp;
  389. void *driver_priv;
  390. int is_master; /* this file private is a master for a minor */
  391. struct drm_master *master; /* master this node is currently associated with
  392. N.B. not always minor->master */
  393. /**
  394. * fbs - List of framebuffers associated with this file.
  395. *
  396. * Protected by fbs_lock. Note that the fbs list holds a reference on
  397. * the fb object to prevent it from untimely disappearing.
  398. */
  399. struct list_head fbs;
  400. struct mutex fbs_lock;
  401. wait_queue_head_t event_wait;
  402. struct list_head event_list;
  403. int event_space;
  404. struct drm_prime_file_private prime;
  405. };
  406. /** Wait queue */
  407. struct drm_queue {
  408. atomic_t use_count; /**< Outstanding uses (+1) */
  409. atomic_t finalization; /**< Finalization in progress */
  410. atomic_t block_count; /**< Count of processes waiting */
  411. atomic_t block_read; /**< Queue blocked for reads */
  412. wait_queue_head_t read_queue; /**< Processes waiting on block_read */
  413. atomic_t block_write; /**< Queue blocked for writes */
  414. wait_queue_head_t write_queue; /**< Processes waiting on block_write */
  415. atomic_t total_queued; /**< Total queued statistic */
  416. atomic_t total_flushed; /**< Total flushes statistic */
  417. atomic_t total_locks; /**< Total locks statistics */
  418. enum drm_ctx_flags flags; /**< Context preserving and 2D-only */
  419. struct drm_waitlist waitlist; /**< Pending buffers */
  420. wait_queue_head_t flush_queue; /**< Processes waiting until flush */
  421. };
  422. /**
  423. * Lock data.
  424. */
  425. struct drm_lock_data {
  426. struct drm_hw_lock *hw_lock; /**< Hardware lock */
  427. /** Private of lock holder's file (NULL=kernel) */
  428. struct drm_file *file_priv;
  429. wait_queue_head_t lock_queue; /**< Queue of blocked processes */
  430. unsigned long lock_time; /**< Time of last lock in jiffies */
  431. spinlock_t spinlock;
  432. uint32_t kernel_waiters;
  433. uint32_t user_waiters;
  434. int idle_has_lock;
  435. };
  436. /**
  437. * DMA data.
  438. */
  439. struct drm_device_dma {
  440. struct drm_buf_entry bufs[DRM_MAX_ORDER + 1]; /**< buffers, grouped by their size order */
  441. int buf_count; /**< total number of buffers */
  442. struct drm_buf **buflist; /**< Vector of pointers into drm_device_dma::bufs */
  443. int seg_count;
  444. int page_count; /**< number of pages */
  445. unsigned long *pagelist; /**< page list */
  446. unsigned long byte_count;
  447. enum {
  448. _DRM_DMA_USE_AGP = 0x01,
  449. _DRM_DMA_USE_SG = 0x02,
  450. _DRM_DMA_USE_FB = 0x04,
  451. _DRM_DMA_USE_PCI_RO = 0x08
  452. } flags;
  453. };
  454. /**
  455. * AGP memory entry. Stored as a doubly linked list.
  456. */
  457. struct drm_agp_mem {
  458. unsigned long handle; /**< handle */
  459. DRM_AGP_MEM *memory;
  460. unsigned long bound; /**< address */
  461. int pages;
  462. struct list_head head;
  463. };
  464. /**
  465. * AGP data.
  466. *
  467. * \sa drm_agp_init() and drm_device::agp.
  468. */
  469. struct drm_agp_head {
  470. DRM_AGP_KERN agp_info; /**< AGP device information */
  471. struct list_head memory;
  472. unsigned long mode; /**< AGP mode */
  473. struct agp_bridge_data *bridge;
  474. int enabled; /**< whether the AGP bus as been enabled */
  475. int acquired; /**< whether the AGP device has been acquired */
  476. unsigned long base;
  477. int agp_mtrr;
  478. int cant_use_aperture;
  479. unsigned long page_mask;
  480. };
  481. /**
  482. * Scatter-gather memory.
  483. */
  484. struct drm_sg_mem {
  485. unsigned long handle;
  486. void *virtual;
  487. int pages;
  488. struct page **pagelist;
  489. dma_addr_t *busaddr;
  490. };
  491. struct drm_sigdata {
  492. int context;
  493. struct drm_hw_lock *lock;
  494. };
  495. /**
  496. * Kernel side of a mapping
  497. */
  498. struct drm_local_map {
  499. resource_size_t offset; /**< Requested physical address (0 for SAREA)*/
  500. unsigned long size; /**< Requested physical size (bytes) */
  501. enum drm_map_type type; /**< Type of memory to map */
  502. enum drm_map_flags flags; /**< Flags */
  503. void *handle; /**< User-space: "Handle" to pass to mmap() */
  504. /**< Kernel-space: kernel-virtual address */
  505. int mtrr; /**< MTRR slot used */
  506. };
  507. typedef struct drm_local_map drm_local_map_t;
  508. /**
  509. * Mappings list
  510. */
  511. struct drm_map_list {
  512. struct list_head head; /**< list head */
  513. struct drm_hash_item hash;
  514. struct drm_local_map *map; /**< mapping */
  515. uint64_t user_token;
  516. struct drm_master *master;
  517. };
  518. /**
  519. * Context handle list
  520. */
  521. struct drm_ctx_list {
  522. struct list_head head; /**< list head */
  523. drm_context_t handle; /**< context handle */
  524. struct drm_file *tag; /**< associated fd private data */
  525. };
  526. /* location of GART table */
  527. #define DRM_ATI_GART_MAIN 1
  528. #define DRM_ATI_GART_FB 2
  529. #define DRM_ATI_GART_PCI 1
  530. #define DRM_ATI_GART_PCIE 2
  531. #define DRM_ATI_GART_IGP 3
  532. struct drm_ati_pcigart_info {
  533. int gart_table_location;
  534. int gart_reg_if;
  535. void *addr;
  536. dma_addr_t bus_addr;
  537. dma_addr_t table_mask;
  538. struct drm_dma_handle *table_handle;
  539. struct drm_local_map mapping;
  540. int table_size;
  541. };
  542. /**
  543. * GEM specific mm private for tracking GEM objects
  544. */
  545. struct drm_gem_mm {
  546. struct drm_vma_offset_manager vma_manager;
  547. };
  548. /**
  549. * This structure defines the drm_mm memory object, which will be used by the
  550. * DRM for its buffer objects.
  551. */
  552. struct drm_gem_object {
  553. /** Reference count of this object */
  554. struct kref refcount;
  555. /** Handle count of this object. Each handle also holds a reference */
  556. atomic_t handle_count; /* number of handles on this object */
  557. /** Related drm device */
  558. struct drm_device *dev;
  559. /** File representing the shmem storage */
  560. struct file *filp;
  561. /* Mapping info for this object */
  562. struct drm_vma_offset_node vma_node;
  563. /**
  564. * Size of the object, in bytes. Immutable over the object's
  565. * lifetime.
  566. */
  567. size_t size;
  568. /**
  569. * Global name for this object, starts at 1. 0 means unnamed.
  570. * Access is covered by the object_name_lock in the related drm_device
  571. */
  572. int name;
  573. /**
  574. * Memory domains. These monitor which caches contain read/write data
  575. * related to the object. When transitioning from one set of domains
  576. * to another, the driver is called to ensure that caches are suitably
  577. * flushed and invalidated
  578. */
  579. uint32_t read_domains;
  580. uint32_t write_domain;
  581. /**
  582. * While validating an exec operation, the
  583. * new read/write domain values are computed here.
  584. * They will be transferred to the above values
  585. * at the point that any cache flushing occurs
  586. */
  587. uint32_t pending_read_domains;
  588. uint32_t pending_write_domain;
  589. void *driver_private;
  590. /* dma buf exported from this GEM object */
  591. struct dma_buf *export_dma_buf;
  592. /* dma buf attachment backing this object */
  593. struct dma_buf_attachment *import_attach;
  594. };
  595. #include <drm/drm_crtc.h>
  596. /* per-master structure */
  597. struct drm_master {
  598. struct kref refcount; /* refcount for this master */
  599. struct list_head head; /**< each minor contains a list of masters */
  600. struct drm_minor *minor; /**< link back to minor we are a master for */
  601. char *unique; /**< Unique identifier: e.g., busid */
  602. int unique_len; /**< Length of unique field */
  603. int unique_size; /**< amount allocated */
  604. int blocked; /**< Blocked due to VC switch? */
  605. /** \name Authentication */
  606. /*@{ */
  607. struct drm_open_hash magiclist;
  608. struct list_head magicfree;
  609. /*@} */
  610. struct drm_lock_data lock; /**< Information on hardware lock */
  611. void *driver_priv; /**< Private structure for driver to use */
  612. };
  613. /* Size of ringbuffer for vblank timestamps. Just double-buffer
  614. * in initial implementation.
  615. */
  616. #define DRM_VBLANKTIME_RBSIZE 2
  617. /* Flags and return codes for get_vblank_timestamp() driver function. */
  618. #define DRM_CALLED_FROM_VBLIRQ 1
  619. #define DRM_VBLANKTIME_SCANOUTPOS_METHOD (1 << 0)
  620. #define DRM_VBLANKTIME_INVBL (1 << 1)
  621. /* get_scanout_position() return flags */
  622. #define DRM_SCANOUTPOS_VALID (1 << 0)
  623. #define DRM_SCANOUTPOS_INVBL (1 << 1)
  624. #define DRM_SCANOUTPOS_ACCURATE (1 << 2)
  625. struct drm_bus {
  626. int bus_type;
  627. int (*get_irq)(struct drm_device *dev);
  628. const char *(*get_name)(struct drm_device *dev);
  629. int (*set_busid)(struct drm_device *dev, struct drm_master *master);
  630. int (*set_unique)(struct drm_device *dev, struct drm_master *master,
  631. struct drm_unique *unique);
  632. int (*irq_by_busid)(struct drm_device *dev, struct drm_irq_busid *p);
  633. /* hooks that are for PCI */
  634. int (*agp_init)(struct drm_device *dev);
  635. void (*agp_destroy)(struct drm_device *dev);
  636. };
  637. /**
  638. * DRM driver structure. This structure represent the common code for
  639. * a family of cards. There will one drm_device for each card present
  640. * in this family
  641. */
  642. struct drm_driver {
  643. int (*load) (struct drm_device *, unsigned long flags);
  644. int (*firstopen) (struct drm_device *);
  645. int (*open) (struct drm_device *, struct drm_file *);
  646. void (*preclose) (struct drm_device *, struct drm_file *file_priv);
  647. void (*postclose) (struct drm_device *, struct drm_file *);
  648. void (*lastclose) (struct drm_device *);
  649. int (*unload) (struct drm_device *);
  650. int (*suspend) (struct drm_device *, pm_message_t state);
  651. int (*resume) (struct drm_device *);
  652. int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
  653. int (*dma_quiescent) (struct drm_device *);
  654. int (*context_dtor) (struct drm_device *dev, int context);
  655. /**
  656. * get_vblank_counter - get raw hardware vblank counter
  657. * @dev: DRM device
  658. * @crtc: counter to fetch
  659. *
  660. * Driver callback for fetching a raw hardware vblank counter for @crtc.
  661. * If a device doesn't have a hardware counter, the driver can simply
  662. * return the value of drm_vblank_count. The DRM core will account for
  663. * missed vblank events while interrupts where disabled based on system
  664. * timestamps.
  665. *
  666. * Wraparound handling and loss of events due to modesetting is dealt
  667. * with in the DRM core code.
  668. *
  669. * RETURNS
  670. * Raw vblank counter value.
  671. */
  672. u32 (*get_vblank_counter) (struct drm_device *dev, int crtc);
  673. /**
  674. * enable_vblank - enable vblank interrupt events
  675. * @dev: DRM device
  676. * @crtc: which irq to enable
  677. *
  678. * Enable vblank interrupts for @crtc. If the device doesn't have
  679. * a hardware vblank counter, this routine should be a no-op, since
  680. * interrupts will have to stay on to keep the count accurate.
  681. *
  682. * RETURNS
  683. * Zero on success, appropriate errno if the given @crtc's vblank
  684. * interrupt cannot be enabled.
  685. */
  686. int (*enable_vblank) (struct drm_device *dev, int crtc);
  687. /**
  688. * disable_vblank - disable vblank interrupt events
  689. * @dev: DRM device
  690. * @crtc: which irq to enable
  691. *
  692. * Disable vblank interrupts for @crtc. If the device doesn't have
  693. * a hardware vblank counter, this routine should be a no-op, since
  694. * interrupts will have to stay on to keep the count accurate.
  695. */
  696. void (*disable_vblank) (struct drm_device *dev, int crtc);
  697. /**
  698. * Called by \c drm_device_is_agp. Typically used to determine if a
  699. * card is really attached to AGP or not.
  700. *
  701. * \param dev DRM device handle
  702. *
  703. * \returns
  704. * One of three values is returned depending on whether or not the
  705. * card is absolutely \b not AGP (return of 0), absolutely \b is AGP
  706. * (return of 1), or may or may not be AGP (return of 2).
  707. */
  708. int (*device_is_agp) (struct drm_device *dev);
  709. /**
  710. * Called by vblank timestamping code.
  711. *
  712. * Return the current display scanout position from a crtc.
  713. *
  714. * \param dev DRM device.
  715. * \param crtc Id of the crtc to query.
  716. * \param *vpos Target location for current vertical scanout position.
  717. * \param *hpos Target location for current horizontal scanout position.
  718. *
  719. * Returns vpos as a positive number while in active scanout area.
  720. * Returns vpos as a negative number inside vblank, counting the number
  721. * of scanlines to go until end of vblank, e.g., -1 means "one scanline
  722. * until start of active scanout / end of vblank."
  723. *
  724. * \return Flags, or'ed together as follows:
  725. *
  726. * DRM_SCANOUTPOS_VALID = Query successful.
  727. * DRM_SCANOUTPOS_INVBL = Inside vblank.
  728. * DRM_SCANOUTPOS_ACCURATE = Returned position is accurate. A lack of
  729. * this flag means that returned position may be offset by a constant
  730. * but unknown small number of scanlines wrt. real scanout position.
  731. *
  732. */
  733. int (*get_scanout_position) (struct drm_device *dev, int crtc,
  734. int *vpos, int *hpos);
  735. /**
  736. * Called by \c drm_get_last_vbltimestamp. Should return a precise
  737. * timestamp when the most recent VBLANK interval ended or will end.
  738. *
  739. * Specifically, the timestamp in @vblank_time should correspond as
  740. * closely as possible to the time when the first video scanline of
  741. * the video frame after the end of VBLANK will start scanning out,
  742. * the time immediately after end of the VBLANK interval. If the
  743. * @crtc is currently inside VBLANK, this will be a time in the future.
  744. * If the @crtc is currently scanning out a frame, this will be the
  745. * past start time of the current scanout. This is meant to adhere
  746. * to the OpenML OML_sync_control extension specification.
  747. *
  748. * \param dev dev DRM device handle.
  749. * \param crtc crtc for which timestamp should be returned.
  750. * \param *max_error Maximum allowable timestamp error in nanoseconds.
  751. * Implementation should strive to provide timestamp
  752. * with an error of at most *max_error nanoseconds.
  753. * Returns true upper bound on error for timestamp.
  754. * \param *vblank_time Target location for returned vblank timestamp.
  755. * \param flags 0 = Defaults, no special treatment needed.
  756. * \param DRM_CALLED_FROM_VBLIRQ = Function is called from vblank
  757. * irq handler. Some drivers need to apply some workarounds
  758. * for gpu-specific vblank irq quirks if flag is set.
  759. *
  760. * \returns
  761. * Zero if timestamping isn't supported in current display mode or a
  762. * negative number on failure. A positive status code on success,
  763. * which describes how the vblank_time timestamp was computed.
  764. */
  765. int (*get_vblank_timestamp) (struct drm_device *dev, int crtc,
  766. int *max_error,
  767. struct timeval *vblank_time,
  768. unsigned flags);
  769. /* these have to be filled in */
  770. irqreturn_t(*irq_handler) (DRM_IRQ_ARGS);
  771. void (*irq_preinstall) (struct drm_device *dev);
  772. int (*irq_postinstall) (struct drm_device *dev);
  773. void (*irq_uninstall) (struct drm_device *dev);
  774. /* Master routines */
  775. int (*master_create)(struct drm_device *dev, struct drm_master *master);
  776. void (*master_destroy)(struct drm_device *dev, struct drm_master *master);
  777. /**
  778. * master_set is called whenever the minor master is set.
  779. * master_drop is called whenever the minor master is dropped.
  780. */
  781. int (*master_set)(struct drm_device *dev, struct drm_file *file_priv,
  782. bool from_open);
  783. void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv,
  784. bool from_release);
  785. int (*debugfs_init)(struct drm_minor *minor);
  786. void (*debugfs_cleanup)(struct drm_minor *minor);
  787. /**
  788. * Driver-specific constructor for drm_gem_objects, to set up
  789. * obj->driver_private.
  790. *
  791. * Returns 0 on success.
  792. */
  793. int (*gem_init_object) (struct drm_gem_object *obj);
  794. void (*gem_free_object) (struct drm_gem_object *obj);
  795. int (*gem_open_object) (struct drm_gem_object *, struct drm_file *);
  796. void (*gem_close_object) (struct drm_gem_object *, struct drm_file *);
  797. /* prime: */
  798. /* export handle -> fd (see drm_gem_prime_handle_to_fd() helper) */
  799. int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv,
  800. uint32_t handle, uint32_t flags, int *prime_fd);
  801. /* import fd -> handle (see drm_gem_prime_fd_to_handle() helper) */
  802. int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv,
  803. int prime_fd, uint32_t *handle);
  804. /* export GEM -> dmabuf */
  805. struct dma_buf * (*gem_prime_export)(struct drm_device *dev,
  806. struct drm_gem_object *obj, int flags);
  807. /* import dmabuf -> GEM */
  808. struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev,
  809. struct dma_buf *dma_buf);
  810. /* low-level interface used by drm_gem_prime_{import,export} */
  811. int (*gem_prime_pin)(struct drm_gem_object *obj);
  812. void (*gem_prime_unpin)(struct drm_gem_object *obj);
  813. struct sg_table *(*gem_prime_get_sg_table)(struct drm_gem_object *obj);
  814. struct drm_gem_object *(*gem_prime_import_sg_table)(
  815. struct drm_device *dev, size_t size,
  816. struct sg_table *sgt);
  817. void *(*gem_prime_vmap)(struct drm_gem_object *obj);
  818. void (*gem_prime_vunmap)(struct drm_gem_object *obj, void *vaddr);
  819. int (*gem_prime_mmap)(struct drm_gem_object *obj,
  820. struct vm_area_struct *vma);
  821. /* vga arb irq handler */
  822. void (*vgaarb_irq)(struct drm_device *dev, bool state);
  823. /* dumb alloc support */
  824. int (*dumb_create)(struct drm_file *file_priv,
  825. struct drm_device *dev,
  826. struct drm_mode_create_dumb *args);
  827. int (*dumb_map_offset)(struct drm_file *file_priv,
  828. struct drm_device *dev, uint32_t handle,
  829. uint64_t *offset);
  830. int (*dumb_destroy)(struct drm_file *file_priv,
  831. struct drm_device *dev,
  832. uint32_t handle);
  833. /* Driver private ops for this object */
  834. const struct vm_operations_struct *gem_vm_ops;
  835. int major;
  836. int minor;
  837. int patchlevel;
  838. char *name;
  839. char *desc;
  840. char *date;
  841. u32 driver_features;
  842. int dev_priv_size;
  843. const struct drm_ioctl_desc *ioctls;
  844. int num_ioctls;
  845. const struct file_operations *fops;
  846. union {
  847. struct pci_driver *pci;
  848. struct platform_device *platform_device;
  849. struct usb_driver *usb;
  850. } kdriver;
  851. struct drm_bus *bus;
  852. /* List of devices hanging off this driver */
  853. struct list_head device_list;
  854. };
  855. #define DRM_MINOR_UNASSIGNED 0
  856. #define DRM_MINOR_LEGACY 1
  857. #define DRM_MINOR_CONTROL 2
  858. #define DRM_MINOR_RENDER 3
  859. /**
  860. * debugfs node list. This structure represents a debugfs file to
  861. * be created by the drm core
  862. */
  863. struct drm_debugfs_list {
  864. const char *name; /** file name */
  865. int (*show)(struct seq_file*, void*); /** show callback */
  866. u32 driver_features; /**< Required driver features for this entry */
  867. };
  868. /**
  869. * debugfs node structure. This structure represents a debugfs file.
  870. */
  871. struct drm_debugfs_node {
  872. struct list_head list;
  873. struct drm_minor *minor;
  874. struct drm_debugfs_list *debugfs_ent;
  875. struct dentry *dent;
  876. };
  877. /**
  878. * Info file list entry. This structure represents a debugfs or proc file to
  879. * be created by the drm core
  880. */
  881. struct drm_info_list {
  882. const char *name; /** file name */
  883. int (*show)(struct seq_file*, void*); /** show callback */
  884. u32 driver_features; /**< Required driver features for this entry */
  885. void *data;
  886. };
  887. /**
  888. * debugfs node structure. This structure represents a debugfs file.
  889. */
  890. struct drm_info_node {
  891. struct list_head list;
  892. struct drm_minor *minor;
  893. const struct drm_info_list *info_ent;
  894. struct dentry *dent;
  895. };
  896. /**
  897. * DRM minor structure. This structure represents a drm minor number.
  898. */
  899. struct drm_minor {
  900. int index; /**< Minor device number */
  901. int type; /**< Control or render */
  902. dev_t device; /**< Device number for mknod */
  903. struct device kdev; /**< Linux device */
  904. struct drm_device *dev;
  905. struct proc_dir_entry *proc_root; /**< proc directory entry */
  906. struct drm_info_node proc_nodes;
  907. struct dentry *debugfs_root;
  908. struct list_head debugfs_list;
  909. struct mutex debugfs_lock; /* Protects debugfs_list. */
  910. struct drm_master *master; /* currently active master for this node */
  911. struct list_head master_list;
  912. struct drm_mode_group mode_group;
  913. };
  914. /* mode specified on the command line */
  915. struct drm_cmdline_mode {
  916. bool specified;
  917. bool refresh_specified;
  918. bool bpp_specified;
  919. int xres, yres;
  920. int bpp;
  921. int refresh;
  922. bool rb;
  923. bool interlace;
  924. bool cvt;
  925. bool margins;
  926. enum drm_connector_force force;
  927. };
  928. struct drm_pending_vblank_event {
  929. struct drm_pending_event base;
  930. int pipe;
  931. struct drm_event_vblank event;
  932. };
  933. /**
  934. * DRM device structure. This structure represent a complete card that
  935. * may contain multiple heads.
  936. */
  937. struct drm_device {
  938. struct list_head driver_item; /**< list of devices per driver */
  939. char *devname; /**< For /proc/interrupts */
  940. int if_version; /**< Highest interface version set */
  941. /** \name Locks */
  942. /*@{ */
  943. spinlock_t count_lock; /**< For inuse, drm_device::open_count, drm_device::buf_use */
  944. struct mutex struct_mutex; /**< For others */
  945. /*@} */
  946. /** \name Usage Counters */
  947. /*@{ */
  948. int open_count; /**< Outstanding files open */
  949. atomic_t ioctl_count; /**< Outstanding IOCTLs pending */
  950. atomic_t vma_count; /**< Outstanding vma areas open */
  951. int buf_use; /**< Buffers in use -- cannot alloc */
  952. atomic_t buf_alloc; /**< Buffer allocation in progress */
  953. /*@} */
  954. /** \name Performance counters */
  955. /*@{ */
  956. unsigned long counters;
  957. enum drm_stat_type types[15];
  958. atomic_t counts[15];
  959. /*@} */
  960. struct list_head filelist;
  961. /** \name Memory management */
  962. /*@{ */
  963. struct list_head maplist; /**< Linked list of regions */
  964. int map_count; /**< Number of mappable regions */
  965. struct drm_open_hash map_hash; /**< User token hash table for maps */
  966. /** \name Context handle management */
  967. /*@{ */
  968. struct list_head ctxlist; /**< Linked list of context handles */
  969. int ctx_count; /**< Number of context handles */
  970. struct mutex ctxlist_mutex; /**< For ctxlist */
  971. struct idr ctx_idr;
  972. struct list_head vmalist; /**< List of vmas (for debugging) */
  973. /*@} */
  974. /** \name DMA support */
  975. /*@{ */
  976. struct drm_device_dma *dma; /**< Optional pointer for DMA support */
  977. /*@} */
  978. /** \name Context support */
  979. /*@{ */
  980. int irq_enabled; /**< True if irq handler is enabled */
  981. __volatile__ long context_flag; /**< Context swapping flag */
  982. int last_context; /**< Last current context */
  983. /*@} */
  984. struct work_struct work;
  985. /** \name VBLANK IRQ support */
  986. /*@{ */
  987. /*
  988. * At load time, disabling the vblank interrupt won't be allowed since
  989. * old clients may not call the modeset ioctl and therefore misbehave.
  990. * Once the modeset ioctl *has* been called though, we can safely
  991. * disable them when unused.
  992. */
  993. int vblank_disable_allowed;
  994. wait_queue_head_t *vbl_queue; /**< VBLANK wait queue */
  995. atomic_t *_vblank_count; /**< number of VBLANK interrupts (driver must alloc the right number of counters) */
  996. struct timeval *_vblank_time; /**< timestamp of current vblank_count (drivers must alloc right number of fields) */
  997. spinlock_t vblank_time_lock; /**< Protects vblank count and time updates during vblank enable/disable */
  998. spinlock_t vbl_lock;
  999. atomic_t *vblank_refcount; /* number of users of vblank interruptsper crtc */
  1000. u32 *last_vblank; /* protected by dev->vbl_lock, used */
  1001. /* for wraparound handling */
  1002. int *vblank_enabled; /* so we don't call enable more than
  1003. once per disable */
  1004. int *vblank_inmodeset; /* Display driver is setting mode */
  1005. u32 *last_vblank_wait; /* Last vblank seqno waited per CRTC */
  1006. struct timer_list vblank_disable_timer;
  1007. u32 max_vblank_count; /**< size of vblank counter register */
  1008. /**
  1009. * List of events
  1010. */
  1011. struct list_head vblank_event_list;
  1012. spinlock_t event_lock;
  1013. /*@} */
  1014. struct drm_agp_head *agp; /**< AGP data */
  1015. struct device *dev; /**< Device structure */
  1016. struct pci_dev *pdev; /**< PCI device structure */
  1017. int pci_vendor; /**< PCI vendor id */
  1018. int pci_device; /**< PCI device id */
  1019. #ifdef __alpha__
  1020. struct pci_controller *hose;
  1021. #endif
  1022. struct platform_device *platformdev; /**< Platform device struture */
  1023. struct usb_device *usbdev;
  1024. struct drm_sg_mem *sg; /**< Scatter gather memory */
  1025. unsigned int num_crtcs; /**< Number of CRTCs on this device */
  1026. void *dev_private; /**< device private data */
  1027. void *mm_private;
  1028. struct address_space *dev_mapping;
  1029. struct drm_sigdata sigdata; /**< For block_all_signals */
  1030. sigset_t sigmask;
  1031. struct drm_driver *driver;
  1032. struct drm_local_map *agp_buffer_map;
  1033. unsigned int agp_buffer_token;
  1034. struct drm_minor *control; /**< Control node for card */
  1035. struct drm_minor *primary; /**< render type primary screen head */
  1036. struct drm_mode_config mode_config; /**< Current mode config */
  1037. /** \name GEM information */
  1038. /*@{ */
  1039. spinlock_t object_name_lock;
  1040. struct idr object_name_idr;
  1041. /*@} */
  1042. int switch_power_state;
  1043. atomic_t unplugged; /* device has been unplugged or gone away */
  1044. };
  1045. #define DRM_SWITCH_POWER_ON 0
  1046. #define DRM_SWITCH_POWER_OFF 1
  1047. #define DRM_SWITCH_POWER_CHANGING 2
  1048. static __inline__ int drm_core_check_feature(struct drm_device *dev,
  1049. int feature)
  1050. {
  1051. return ((dev->driver->driver_features & feature) ? 1 : 0);
  1052. }
  1053. static inline int drm_dev_to_irq(struct drm_device *dev)
  1054. {
  1055. return dev->driver->bus->get_irq(dev);
  1056. }
  1057. #if __OS_HAS_MTRR
  1058. static inline int drm_core_has_MTRR(struct drm_device *dev)
  1059. {
  1060. return drm_core_check_feature(dev, DRIVER_USE_MTRR);
  1061. }
  1062. #else
  1063. #define drm_core_has_MTRR(dev) (0)
  1064. #endif
  1065. static inline void drm_device_set_unplugged(struct drm_device *dev)
  1066. {
  1067. smp_wmb();
  1068. atomic_set(&dev->unplugged, 1);
  1069. }
  1070. static inline int drm_device_is_unplugged(struct drm_device *dev)
  1071. {
  1072. int ret = atomic_read(&dev->unplugged);
  1073. smp_rmb();
  1074. return ret;
  1075. }
  1076. static inline bool drm_modeset_is_locked(struct drm_device *dev)
  1077. {
  1078. return mutex_is_locked(&dev->mode_config.mutex);
  1079. }
  1080. /******************************************************************/
  1081. /** \name Internal function definitions */
  1082. /*@{*/
  1083. /* Driver support (drm_drv.h) */
  1084. extern long drm_ioctl(struct file *filp,
  1085. unsigned int cmd, unsigned long arg);
  1086. extern long drm_compat_ioctl(struct file *filp,
  1087. unsigned int cmd, unsigned long arg);
  1088. extern int drm_lastclose(struct drm_device *dev);
  1089. /* Device support (drm_fops.h) */
  1090. extern struct mutex drm_global_mutex;
  1091. extern int drm_open(struct inode *inode, struct file *filp);
  1092. extern int drm_stub_open(struct inode *inode, struct file *filp);
  1093. extern ssize_t drm_read(struct file *filp, char __user *buffer,
  1094. size_t count, loff_t *offset);
  1095. extern int drm_release(struct inode *inode, struct file *filp);
  1096. /* Mapping support (drm_vm.h) */
  1097. extern int drm_mmap(struct file *filp, struct vm_area_struct *vma);
  1098. extern int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma);
  1099. extern void drm_vm_open_locked(struct drm_device *dev, struct vm_area_struct *vma);
  1100. extern void drm_vm_close_locked(struct drm_device *dev, struct vm_area_struct *vma);
  1101. extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait);
  1102. /* Memory management support (drm_memory.h) */
  1103. #include <drm/drm_memory.h>
  1104. /* Misc. IOCTL support (drm_ioctl.h) */
  1105. extern int drm_irq_by_busid(struct drm_device *dev, void *data,
  1106. struct drm_file *file_priv);
  1107. extern int drm_getunique(struct drm_device *dev, void *data,
  1108. struct drm_file *file_priv);
  1109. extern int drm_setunique(struct drm_device *dev, void *data,
  1110. struct drm_file *file_priv);
  1111. extern int drm_getmap(struct drm_device *dev, void *data,
  1112. struct drm_file *file_priv);
  1113. extern int drm_getclient(struct drm_device *dev, void *data,
  1114. struct drm_file *file_priv);
  1115. extern int drm_getstats(struct drm_device *dev, void *data,
  1116. struct drm_file *file_priv);
  1117. extern int drm_getcap(struct drm_device *dev, void *data,
  1118. struct drm_file *file_priv);
  1119. extern int drm_setversion(struct drm_device *dev, void *data,
  1120. struct drm_file *file_priv);
  1121. extern int drm_noop(struct drm_device *dev, void *data,
  1122. struct drm_file *file_priv);
  1123. /* Context IOCTL support (drm_context.h) */
  1124. extern int drm_resctx(struct drm_device *dev, void *data,
  1125. struct drm_file *file_priv);
  1126. extern int drm_addctx(struct drm_device *dev, void *data,
  1127. struct drm_file *file_priv);
  1128. extern int drm_getctx(struct drm_device *dev, void *data,
  1129. struct drm_file *file_priv);
  1130. extern int drm_switchctx(struct drm_device *dev, void *data,
  1131. struct drm_file *file_priv);
  1132. extern int drm_newctx(struct drm_device *dev, void *data,
  1133. struct drm_file *file_priv);
  1134. extern int drm_rmctx(struct drm_device *dev, void *data,
  1135. struct drm_file *file_priv);
  1136. extern void drm_legacy_ctxbitmap_init(struct drm_device *dev);
  1137. extern void drm_legacy_ctxbitmap_cleanup(struct drm_device *dev);
  1138. extern void drm_legacy_ctxbitmap_release(struct drm_device *dev,
  1139. struct drm_file *file_priv);
  1140. extern int drm_setsareactx(struct drm_device *dev, void *data,
  1141. struct drm_file *file_priv);
  1142. extern int drm_getsareactx(struct drm_device *dev, void *data,
  1143. struct drm_file *file_priv);
  1144. /* Authentication IOCTL support (drm_auth.h) */
  1145. extern int drm_getmagic(struct drm_device *dev, void *data,
  1146. struct drm_file *file_priv);
  1147. extern int drm_authmagic(struct drm_device *dev, void *data,
  1148. struct drm_file *file_priv);
  1149. extern int drm_remove_magic(struct drm_master *master, drm_magic_t magic);
  1150. /* Cache management (drm_cache.c) */
  1151. void drm_clflush_pages(struct page *pages[], unsigned long num_pages);
  1152. void drm_clflush_sg(struct sg_table *st);
  1153. void drm_clflush_virt_range(char *addr, unsigned long length);
  1154. /* Locking IOCTL support (drm_lock.h) */
  1155. extern int drm_lock(struct drm_device *dev, void *data,
  1156. struct drm_file *file_priv);
  1157. extern int drm_unlock(struct drm_device *dev, void *data,
  1158. struct drm_file *file_priv);
  1159. extern int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context);
  1160. extern void drm_idlelock_take(struct drm_lock_data *lock_data);
  1161. extern void drm_idlelock_release(struct drm_lock_data *lock_data);
  1162. /*
  1163. * These are exported to drivers so that they can implement fencing using
  1164. * DMA quiscent + idle. DMA quiescent usually requires the hardware lock.
  1165. */
  1166. extern int drm_i_have_hw_lock(struct drm_device *dev, struct drm_file *file_priv);
  1167. /* Buffer management support (drm_bufs.h) */
  1168. extern int drm_addbufs_agp(struct drm_device *dev, struct drm_buf_desc * request);
  1169. extern int drm_addbufs_pci(struct drm_device *dev, struct drm_buf_desc * request);
  1170. extern int drm_addmap(struct drm_device *dev, resource_size_t offset,
  1171. unsigned int size, enum drm_map_type type,
  1172. enum drm_map_flags flags, struct drm_local_map **map_ptr);
  1173. extern int drm_addmap_ioctl(struct drm_device *dev, void *data,
  1174. struct drm_file *file_priv);
  1175. extern int drm_rmmap(struct drm_device *dev, struct drm_local_map *map);
  1176. extern int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map);
  1177. extern int drm_rmmap_ioctl(struct drm_device *dev, void *data,
  1178. struct drm_file *file_priv);
  1179. extern int drm_addbufs(struct drm_device *dev, void *data,
  1180. struct drm_file *file_priv);
  1181. extern int drm_infobufs(struct drm_device *dev, void *data,
  1182. struct drm_file *file_priv);
  1183. extern int drm_markbufs(struct drm_device *dev, void *data,
  1184. struct drm_file *file_priv);
  1185. extern int drm_freebufs(struct drm_device *dev, void *data,
  1186. struct drm_file *file_priv);
  1187. extern int drm_mapbufs(struct drm_device *dev, void *data,
  1188. struct drm_file *file_priv);
  1189. /* DMA support (drm_dma.h) */
  1190. extern int drm_legacy_dma_setup(struct drm_device *dev);
  1191. extern void drm_legacy_dma_takedown(struct drm_device *dev);
  1192. extern void drm_free_buffer(struct drm_device *dev, struct drm_buf * buf);
  1193. extern void drm_core_reclaim_buffers(struct drm_device *dev,
  1194. struct drm_file *filp);
  1195. /* IRQ support (drm_irq.h) */
  1196. extern int drm_control(struct drm_device *dev, void *data,
  1197. struct drm_file *file_priv);
  1198. extern int drm_irq_install(struct drm_device *dev);
  1199. extern int drm_irq_uninstall(struct drm_device *dev);
  1200. extern int drm_vblank_init(struct drm_device *dev, int num_crtcs);
  1201. extern int drm_wait_vblank(struct drm_device *dev, void *data,
  1202. struct drm_file *filp);
  1203. extern int drm_vblank_wait(struct drm_device *dev, unsigned int *vbl_seq);
  1204. extern u32 drm_vblank_count(struct drm_device *dev, int crtc);
  1205. extern u32 drm_vblank_count_and_time(struct drm_device *dev, int crtc,
  1206. struct timeval *vblanktime);
  1207. extern void drm_send_vblank_event(struct drm_device *dev, int crtc,
  1208. struct drm_pending_vblank_event *e);
  1209. extern bool drm_handle_vblank(struct drm_device *dev, int crtc);
  1210. extern int drm_vblank_get(struct drm_device *dev, int crtc);
  1211. extern void drm_vblank_put(struct drm_device *dev, int crtc);
  1212. extern void drm_vblank_off(struct drm_device *dev, int crtc);
  1213. extern void drm_vblank_cleanup(struct drm_device *dev);
  1214. extern u32 drm_get_last_vbltimestamp(struct drm_device *dev, int crtc,
  1215. struct timeval *tvblank, unsigned flags);
  1216. extern int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev,
  1217. int crtc, int *max_error,
  1218. struct timeval *vblank_time,
  1219. unsigned flags,
  1220. struct drm_crtc *refcrtc);
  1221. extern void drm_calc_timestamping_constants(struct drm_crtc *crtc);
  1222. extern bool
  1223. drm_mode_parse_command_line_for_connector(const char *mode_option,
  1224. struct drm_connector *connector,
  1225. struct drm_cmdline_mode *mode);
  1226. extern struct drm_display_mode *
  1227. drm_mode_create_from_cmdline_mode(struct drm_device *dev,
  1228. struct drm_cmdline_mode *cmd);
  1229. extern int drm_display_mode_from_videomode(const struct videomode *vm,
  1230. struct drm_display_mode *dmode);
  1231. extern int of_get_drm_display_mode(struct device_node *np,
  1232. struct drm_display_mode *dmode,
  1233. int index);
  1234. /* Modesetting support */
  1235. extern void drm_vblank_pre_modeset(struct drm_device *dev, int crtc);
  1236. extern void drm_vblank_post_modeset(struct drm_device *dev, int crtc);
  1237. extern int drm_modeset_ctl(struct drm_device *dev, void *data,
  1238. struct drm_file *file_priv);
  1239. /* AGP/GART support (drm_agpsupport.h) */
  1240. #include <drm/drm_agpsupport.h>
  1241. /* Stub support (drm_stub.h) */
  1242. extern int drm_setmaster_ioctl(struct drm_device *dev, void *data,
  1243. struct drm_file *file_priv);
  1244. extern int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
  1245. struct drm_file *file_priv);
  1246. struct drm_master *drm_master_create(struct drm_minor *minor);
  1247. extern struct drm_master *drm_master_get(struct drm_master *master);
  1248. extern void drm_master_put(struct drm_master **master);
  1249. extern void drm_put_dev(struct drm_device *dev);
  1250. extern int drm_put_minor(struct drm_minor **minor);
  1251. extern void drm_unplug_dev(struct drm_device *dev);
  1252. extern unsigned int drm_debug;
  1253. extern unsigned int drm_vblank_offdelay;
  1254. extern unsigned int drm_timestamp_precision;
  1255. extern unsigned int drm_timestamp_monotonic;
  1256. extern struct class *drm_class;
  1257. extern struct proc_dir_entry *drm_proc_root;
  1258. extern struct dentry *drm_debugfs_root;
  1259. extern struct idr drm_minors_idr;
  1260. extern struct drm_local_map *drm_getsarea(struct drm_device *dev);
  1261. /* Proc support (drm_proc.h) */
  1262. extern int drm_proc_init(struct drm_minor *minor, struct proc_dir_entry *root);
  1263. extern int drm_proc_cleanup(struct drm_minor *minor, struct proc_dir_entry *root);
  1264. /* Debugfs support */
  1265. #if defined(CONFIG_DEBUG_FS)
  1266. extern int drm_debugfs_init(struct drm_minor *minor, int minor_id,
  1267. struct dentry *root);
  1268. extern int drm_debugfs_create_files(struct drm_info_list *files, int count,
  1269. struct dentry *root, struct drm_minor *minor);
  1270. extern int drm_debugfs_remove_files(struct drm_info_list *files, int count,
  1271. struct drm_minor *minor);
  1272. extern int drm_debugfs_cleanup(struct drm_minor *minor);
  1273. #endif
  1274. /* Info file support */
  1275. extern int drm_name_info(struct seq_file *m, void *data);
  1276. extern int drm_vm_info(struct seq_file *m, void *data);
  1277. extern int drm_bufs_info(struct seq_file *m, void *data);
  1278. extern int drm_vblank_info(struct seq_file *m, void *data);
  1279. extern int drm_clients_info(struct seq_file *m, void* data);
  1280. extern int drm_gem_name_info(struct seq_file *m, void *data);
  1281. extern struct dma_buf *drm_gem_prime_export(struct drm_device *dev,
  1282. struct drm_gem_object *obj, int flags);
  1283. extern int drm_gem_prime_handle_to_fd(struct drm_device *dev,
  1284. struct drm_file *file_priv, uint32_t handle, uint32_t flags,
  1285. int *prime_fd);
  1286. extern struct drm_gem_object *drm_gem_prime_import(struct drm_device *dev,
  1287. struct dma_buf *dma_buf);
  1288. extern int drm_gem_prime_fd_to_handle(struct drm_device *dev,
  1289. struct drm_file *file_priv, int prime_fd, uint32_t *handle);
  1290. extern int drm_prime_handle_to_fd_ioctl(struct drm_device *dev, void *data,
  1291. struct drm_file *file_priv);
  1292. extern int drm_prime_fd_to_handle_ioctl(struct drm_device *dev, void *data,
  1293. struct drm_file *file_priv);
  1294. extern int drm_prime_sg_to_page_addr_arrays(struct sg_table *sgt, struct page **pages,
  1295. dma_addr_t *addrs, int max_pages);
  1296. extern struct sg_table *drm_prime_pages_to_sg(struct page **pages, int nr_pages);
  1297. extern void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg);
  1298. int drm_gem_dumb_destroy(struct drm_file *file,
  1299. struct drm_device *dev,
  1300. uint32_t handle);
  1301. void drm_prime_init_file_private(struct drm_prime_file_private *prime_fpriv);
  1302. void drm_prime_destroy_file_private(struct drm_prime_file_private *prime_fpriv);
  1303. int drm_prime_lookup_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf, uint32_t *handle);
  1304. void drm_prime_remove_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf);
  1305. int drm_prime_add_dma_buf(struct drm_device *dev, struct drm_gem_object *obj);
  1306. int drm_prime_lookup_obj(struct drm_device *dev, struct dma_buf *buf,
  1307. struct drm_gem_object **obj);
  1308. #if DRM_DEBUG_CODE
  1309. extern int drm_vma_info(struct seq_file *m, void *data);
  1310. #endif
  1311. /* Scatter Gather Support (drm_scatter.h) */
  1312. extern void drm_legacy_sg_cleanup(struct drm_device *dev);
  1313. extern int drm_sg_alloc(struct drm_device *dev, void *data,
  1314. struct drm_file *file_priv);
  1315. extern int drm_sg_free(struct drm_device *dev, void *data,
  1316. struct drm_file *file_priv);
  1317. /* ATI PCIGART support (ati_pcigart.h) */
  1318. extern int drm_ati_pcigart_init(struct drm_device *dev,
  1319. struct drm_ati_pcigart_info * gart_info);
  1320. extern int drm_ati_pcigart_cleanup(struct drm_device *dev,
  1321. struct drm_ati_pcigart_info * gart_info);
  1322. extern drm_dma_handle_t *drm_pci_alloc(struct drm_device *dev, size_t size,
  1323. size_t align);
  1324. extern void __drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
  1325. extern void drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
  1326. /* sysfs support (drm_sysfs.c) */
  1327. struct drm_sysfs_class;
  1328. extern struct class *drm_sysfs_create(struct module *owner, char *name);
  1329. extern void drm_sysfs_destroy(void);
  1330. extern int drm_sysfs_device_add(struct drm_minor *minor);
  1331. extern void drm_sysfs_hotplug_event(struct drm_device *dev);
  1332. extern void drm_sysfs_device_remove(struct drm_minor *minor);
  1333. extern int drm_sysfs_connector_add(struct drm_connector *connector);
  1334. extern void drm_sysfs_connector_remove(struct drm_connector *connector);
  1335. /* Graphics Execution Manager library functions (drm_gem.c) */
  1336. int drm_gem_init(struct drm_device *dev);
  1337. void drm_gem_destroy(struct drm_device *dev);
  1338. void drm_gem_object_release(struct drm_gem_object *obj);
  1339. void drm_gem_object_free(struct kref *kref);
  1340. struct drm_gem_object *drm_gem_object_alloc(struct drm_device *dev,
  1341. size_t size);
  1342. int drm_gem_object_init(struct drm_device *dev,
  1343. struct drm_gem_object *obj, size_t size);
  1344. void drm_gem_private_object_init(struct drm_device *dev,
  1345. struct drm_gem_object *obj, size_t size);
  1346. void drm_gem_object_handle_free(struct drm_gem_object *obj);
  1347. void drm_gem_vm_open(struct vm_area_struct *vma);
  1348. void drm_gem_vm_close(struct vm_area_struct *vma);
  1349. int drm_gem_mmap_obj(struct drm_gem_object *obj, unsigned long obj_size,
  1350. struct vm_area_struct *vma);
  1351. int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma);
  1352. #include <drm/drm_global.h>
  1353. static inline void
  1354. drm_gem_object_reference(struct drm_gem_object *obj)
  1355. {
  1356. kref_get(&obj->refcount);
  1357. }
  1358. static inline void
  1359. drm_gem_object_unreference(struct drm_gem_object *obj)
  1360. {
  1361. if (obj != NULL)
  1362. kref_put(&obj->refcount, drm_gem_object_free);
  1363. }
  1364. static inline void
  1365. drm_gem_object_unreference_unlocked(struct drm_gem_object *obj)
  1366. {
  1367. if (obj && !atomic_add_unless(&obj->refcount.refcount, -1, 1)) {
  1368. struct drm_device *dev = obj->dev;
  1369. mutex_lock(&dev->struct_mutex);
  1370. if (likely(atomic_dec_and_test(&obj->refcount.refcount)))
  1371. drm_gem_object_free(&obj->refcount);
  1372. mutex_unlock(&dev->struct_mutex);
  1373. }
  1374. }
  1375. int drm_gem_handle_create(struct drm_file *file_priv,
  1376. struct drm_gem_object *obj,
  1377. u32 *handlep);
  1378. int drm_gem_handle_delete(struct drm_file *filp, u32 handle);
  1379. static inline void
  1380. drm_gem_object_handle_reference(struct drm_gem_object *obj)
  1381. {
  1382. drm_gem_object_reference(obj);
  1383. atomic_inc(&obj->handle_count);
  1384. }
  1385. static inline void
  1386. drm_gem_object_handle_unreference_unlocked(struct drm_gem_object *obj)
  1387. {
  1388. if (obj == NULL)
  1389. return;
  1390. if (atomic_read(&obj->handle_count) == 0)
  1391. return;
  1392. /*
  1393. * Must bump handle count first as this may be the last
  1394. * ref, in which case the object would disappear before we
  1395. * checked for a name
  1396. */
  1397. if (atomic_dec_and_test(&obj->handle_count))
  1398. drm_gem_object_handle_free(obj);
  1399. drm_gem_object_unreference_unlocked(obj);
  1400. }
  1401. void drm_gem_free_mmap_offset(struct drm_gem_object *obj);
  1402. int drm_gem_create_mmap_offset(struct drm_gem_object *obj);
  1403. struct drm_gem_object *drm_gem_object_lookup(struct drm_device *dev,
  1404. struct drm_file *filp,
  1405. u32 handle);
  1406. int drm_gem_close_ioctl(struct drm_device *dev, void *data,
  1407. struct drm_file *file_priv);
  1408. int drm_gem_flink_ioctl(struct drm_device *dev, void *data,
  1409. struct drm_file *file_priv);
  1410. int drm_gem_open_ioctl(struct drm_device *dev, void *data,
  1411. struct drm_file *file_priv);
  1412. void drm_gem_open(struct drm_device *dev, struct drm_file *file_private);
  1413. void drm_gem_release(struct drm_device *dev, struct drm_file *file_private);
  1414. extern void drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev);
  1415. extern void drm_core_ioremap_wc(struct drm_local_map *map, struct drm_device *dev);
  1416. extern void drm_core_ioremapfree(struct drm_local_map *map, struct drm_device *dev);
  1417. static __inline__ struct drm_local_map *drm_core_findmap(struct drm_device *dev,
  1418. unsigned int token)
  1419. {
  1420. struct drm_map_list *_entry;
  1421. list_for_each_entry(_entry, &dev->maplist, head)
  1422. if (_entry->user_token == token)
  1423. return _entry->map;
  1424. return NULL;
  1425. }
  1426. static __inline__ void drm_core_dropmap(struct drm_local_map *map)
  1427. {
  1428. }
  1429. #include <drm/drm_mem_util.h>
  1430. extern int drm_fill_in_dev(struct drm_device *dev,
  1431. const struct pci_device_id *ent,
  1432. struct drm_driver *driver);
  1433. int drm_get_minor(struct drm_device *dev, struct drm_minor **minor, int type);
  1434. /*@}*/
  1435. /* PCI section */
  1436. static __inline__ int drm_pci_device_is_agp(struct drm_device *dev)
  1437. {
  1438. if (dev->driver->device_is_agp != NULL) {
  1439. int err = (*dev->driver->device_is_agp) (dev);
  1440. if (err != 2) {
  1441. return err;
  1442. }
  1443. }
  1444. return pci_find_capability(dev->pdev, PCI_CAP_ID_AGP);
  1445. }
  1446. extern int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver);
  1447. extern void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver);
  1448. extern int drm_get_pci_dev(struct pci_dev *pdev,
  1449. const struct pci_device_id *ent,
  1450. struct drm_driver *driver);
  1451. #define DRM_PCIE_SPEED_25 1
  1452. #define DRM_PCIE_SPEED_50 2
  1453. #define DRM_PCIE_SPEED_80 4
  1454. extern int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *speed_mask);
  1455. /* platform section */
  1456. extern int drm_platform_init(struct drm_driver *driver, struct platform_device *platform_device);
  1457. extern void drm_platform_exit(struct drm_driver *driver, struct platform_device *platform_device);
  1458. extern int drm_get_platform_dev(struct platform_device *pdev,
  1459. struct drm_driver *driver);
  1460. /* returns true if currently okay to sleep */
  1461. static __inline__ bool drm_can_sleep(void)
  1462. {
  1463. if (in_atomic() || in_dbg_master() || irqs_disabled())
  1464. return false;
  1465. return true;
  1466. }
  1467. #endif /* __KERNEL__ */
  1468. #endif