1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32#ifndef _DRM_P_H_
33#define _DRM_P_H_
34
35#include <linux/agp_backend.h>
36#include <linux/cdev.h>
37#include <linux/dma-mapping.h>
38#include <linux/file.h>
39#include <linux/fs.h>
40#include <linux/highmem.h>
41#include <linux/idr.h>
42#include <linux/init.h>
43#include <linux/io.h>
44#include <linux/jiffies.h>
45#include <linux/kernel.h>
46#include <linux/kref.h>
47#include <linux/miscdevice.h>
48#include <linux/mm.h>
49#include <linux/mutex.h>
50#include <linux/pci.h>
51#include <linux/platform_device.h>
52#include <linux/poll.h>
53#include <linux/ratelimit.h>
54#include <linux/sched.h>
55#include <linux/slab.h>
56#include <linux/types.h>
57#include <linux/vmalloc.h>
58#include <linux/workqueue.h>
59
60#include <asm/mman.h>
61#include <asm/pgalloc.h>
62#include <asm/uaccess.h>
63
64#include <uapi/drm/drm.h>
65#include <uapi/drm/drm_mode.h>
66
67#include <drm/drm_agpsupport.h>
68#include <drm/drm_crtc.h>
69#include <drm/drm_global.h>
70#include <drm/drm_hashtab.h>
71#include <drm/drm_mem_util.h>
72#include <drm/drm_mm.h>
73#include <drm/drm_os_linux.h>
74#include <drm/drm_sarea.h>
75#include <drm/drm_vma_manager.h>
76
77struct module;
78
79struct drm_file;
80struct drm_device;
81struct drm_agp_head;
82struct drm_local_map;
83struct drm_device_dma;
84struct drm_dma_handle;
85struct drm_gem_object;
86
87struct device_node;
88struct videomode;
89struct reservation_object;
90struct dma_buf_attachment;
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126#define DRM_UT_CORE 0x01
127#define DRM_UT_DRIVER 0x02
128#define DRM_UT_KMS 0x04
129#define DRM_UT_PRIME 0x08
130#define DRM_UT_ATOMIC 0x10
131#define DRM_UT_VBL 0x20
132
133extern __printf(2, 3)
134void drm_ut_debug_printk(const char *function_name,
135 const char *format, ...);
136extern __printf(1, 2)
137void drm_err(const char *format, ...);
138
139
140
141
142
143
144#define DRIVER_USE_AGP 0x1
145#define DRIVER_PCI_DMA 0x8
146#define DRIVER_SG 0x10
147#define DRIVER_HAVE_DMA 0x20
148#define DRIVER_HAVE_IRQ 0x40
149#define DRIVER_IRQ_SHARED 0x80
150#define DRIVER_GEM 0x1000
151#define DRIVER_MODESET 0x2000
152#define DRIVER_PRIME 0x4000
153#define DRIVER_RENDER 0x8000
154#define DRIVER_ATOMIC 0x10000
155#define DRIVER_KMS_LEGACY_CONTEXT 0x20000
156
157
158
159
160
161
162
163
164
165
166
167#define DRM_ERROR(fmt, ...) \
168 drm_err(fmt, ##__VA_ARGS__)
169
170
171
172
173
174
175
176#define DRM_ERROR_RATELIMITED(fmt, ...) \
177({ \
178 static DEFINE_RATELIMIT_STATE(_rs, \
179 DEFAULT_RATELIMIT_INTERVAL, \
180 DEFAULT_RATELIMIT_BURST); \
181 \
182 if (__ratelimit(&_rs)) \
183 drm_err(fmt, ##__VA_ARGS__); \
184})
185
186#define DRM_INFO(fmt, ...) \
187 printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__)
188
189#define DRM_INFO_ONCE(fmt, ...) \
190 printk_once(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__)
191
192
193
194
195
196
197
198#define DRM_DEBUG(fmt, args...) \
199 do { \
200 if (unlikely(drm_debug & DRM_UT_CORE)) \
201 drm_ut_debug_printk(__func__, fmt, ##args); \
202 } while (0)
203
204#define DRM_DEBUG_DRIVER(fmt, args...) \
205 do { \
206 if (unlikely(drm_debug & DRM_UT_DRIVER)) \
207 drm_ut_debug_printk(__func__, fmt, ##args); \
208 } while (0)
209#define DRM_DEBUG_KMS(fmt, args...) \
210 do { \
211 if (unlikely(drm_debug & DRM_UT_KMS)) \
212 drm_ut_debug_printk(__func__, fmt, ##args); \
213 } while (0)
214#define DRM_DEBUG_PRIME(fmt, args...) \
215 do { \
216 if (unlikely(drm_debug & DRM_UT_PRIME)) \
217 drm_ut_debug_printk(__func__, fmt, ##args); \
218 } while (0)
219#define DRM_DEBUG_ATOMIC(fmt, args...) \
220 do { \
221 if (unlikely(drm_debug & DRM_UT_ATOMIC)) \
222 drm_ut_debug_printk(__func__, fmt, ##args); \
223 } while (0)
224#define DRM_DEBUG_VBL(fmt, args...) \
225 do { \
226 if (unlikely(drm_debug & DRM_UT_VBL)) \
227 drm_ut_debug_printk(__func__, fmt, ##args); \
228 } while (0)
229
230
231
232
233
234
235
236#define DRM_IF_VERSION(maj, min) (maj << 16 | min)
237
238
239
240
241
242
243
244
245
246typedef int drm_ioctl_t(struct drm_device *dev, void *data,
247 struct drm_file *file_priv);
248
249typedef int drm_ioctl_compat_t(struct file *filp, unsigned int cmd,
250 unsigned long arg);
251
252#define DRM_IOCTL_NR(n) _IOC_NR(n)
253#define DRM_MAJOR 226
254
255#define DRM_AUTH 0x1
256#define DRM_MASTER 0x2
257#define DRM_ROOT_ONLY 0x4
258#define DRM_CONTROL_ALLOW 0x8
259#define DRM_UNLOCKED 0x10
260#define DRM_RENDER_ALLOW 0x20
261
262struct drm_ioctl_desc {
263 unsigned int cmd;
264 int flags;
265 drm_ioctl_t *func;
266 const char *name;
267};
268
269
270
271
272
273
274#define DRM_IOCTL_DEF_DRV(ioctl, _func, _flags) \
275 [DRM_IOCTL_NR(DRM_IOCTL_##ioctl) - DRM_COMMAND_BASE] = { \
276 .cmd = DRM_IOCTL_##ioctl, \
277 .func = _func, \
278 .flags = _flags, \
279 .name = #ioctl \
280 }
281
282
283struct drm_pending_event {
284 struct drm_event *event;
285 struct list_head link;
286 struct drm_file *file_priv;
287 pid_t pid;
288
289 void (*destroy)(struct drm_pending_event *event);
290};
291
292
293struct drm_prime_file_private {
294 struct list_head head;
295 struct mutex lock;
296};
297
298
299struct drm_file {
300 unsigned authenticated :1;
301
302 unsigned is_master :1;
303
304 unsigned stereo_allowed :1;
305
306
307
308
309 unsigned universal_planes:1;
310
311 unsigned atomic:1;
312
313
314
315
316 unsigned allowed_master:1;
317
318 struct pid *pid;
319 kuid_t uid;
320 drm_magic_t magic;
321 struct list_head lhead;
322 struct drm_minor *minor;
323 unsigned long lock_count;
324
325
326 struct idr object_idr;
327
328 spinlock_t table_lock;
329
330 struct file *filp;
331 void *driver_priv;
332
333 struct drm_master *master;
334
335
336
337
338
339
340
341 struct list_head fbs;
342 struct mutex fbs_lock;
343
344
345
346 struct list_head blobs;
347
348 wait_queue_head_t event_wait;
349 struct list_head event_list;
350 int event_space;
351
352 struct mutex event_read_lock;
353
354 struct drm_prime_file_private prime;
355};
356
357
358
359
360struct drm_lock_data {
361 struct drm_hw_lock *hw_lock;
362
363 struct drm_file *file_priv;
364 wait_queue_head_t lock_queue;
365 unsigned long lock_time;
366 spinlock_t spinlock;
367 uint32_t kernel_waiters;
368 uint32_t user_waiters;
369 int idle_has_lock;
370};
371
372
373
374
375
376
377
378
379
380
381
382
383struct drm_master {
384 struct kref refcount;
385 struct drm_minor *minor;
386 char *unique;
387 int unique_len;
388 struct idr magic_map;
389 struct drm_lock_data lock;
390 void *driver_priv;
391};
392
393
394
395
396#define DRM_VBLANKTIME_RBSIZE 2
397
398
399#define DRM_CALLED_FROM_VBLIRQ 1
400#define DRM_VBLANKTIME_SCANOUTPOS_METHOD (1 << 0)
401#define DRM_VBLANKTIME_IN_VBLANK (1 << 1)
402
403
404#define DRM_SCANOUTPOS_VALID (1 << 0)
405#define DRM_SCANOUTPOS_IN_VBLANK (1 << 1)
406#define DRM_SCANOUTPOS_ACCURATE (1 << 2)
407
408
409
410
411
412
413struct drm_driver {
414 int (*load) (struct drm_device *, unsigned long flags);
415 int (*firstopen) (struct drm_device *);
416 int (*open) (struct drm_device *, struct drm_file *);
417 void (*preclose) (struct drm_device *, struct drm_file *file_priv);
418 void (*postclose) (struct drm_device *, struct drm_file *);
419 void (*lastclose) (struct drm_device *);
420 int (*unload) (struct drm_device *);
421 int (*suspend) (struct drm_device *, pm_message_t state);
422 int (*resume) (struct drm_device *);
423 int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
424 int (*dma_quiescent) (struct drm_device *);
425 int (*context_dtor) (struct drm_device *dev, int context);
426 int (*set_busid)(struct drm_device *dev, struct drm_master *master);
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445 u32 (*get_vblank_counter) (struct drm_device *dev, unsigned int pipe);
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460 int (*enable_vblank) (struct drm_device *dev, unsigned int pipe);
461
462
463
464
465
466
467
468
469
470
471 void (*disable_vblank) (struct drm_device *dev, unsigned int pipe);
472
473
474
475
476
477
478
479
480
481
482
483
484 int (*device_is_agp) (struct drm_device *dev);
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517 int (*get_scanout_position) (struct drm_device *dev, unsigned int pipe,
518 unsigned int flags, int *vpos, int *hpos,
519 ktime_t *stime, ktime_t *etime,
520 const struct drm_display_mode *mode);
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552 int (*get_vblank_timestamp) (struct drm_device *dev, unsigned int pipe,
553 int *max_error,
554 struct timeval *vblank_time,
555 unsigned flags);
556
557
558
559 irqreturn_t(*irq_handler) (int irq, void *arg);
560 void (*irq_preinstall) (struct drm_device *dev);
561 int (*irq_postinstall) (struct drm_device *dev);
562 void (*irq_uninstall) (struct drm_device *dev);
563
564
565 int (*master_create)(struct drm_device *dev, struct drm_master *master);
566 void (*master_destroy)(struct drm_device *dev, struct drm_master *master);
567
568
569
570
571
572 int (*master_set)(struct drm_device *dev, struct drm_file *file_priv,
573 bool from_open);
574 void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv,
575 bool from_release);
576
577 int (*debugfs_init)(struct drm_minor *minor);
578 void (*debugfs_cleanup)(struct drm_minor *minor);
579
580
581
582
583
584
585
586 void (*gem_free_object) (struct drm_gem_object *obj);
587 int (*gem_open_object) (struct drm_gem_object *, struct drm_file *);
588 void (*gem_close_object) (struct drm_gem_object *, struct drm_file *);
589
590
591
592
593
594 struct drm_gem_object *(*gem_create_object)(struct drm_device *dev,
595 size_t size);
596
597
598
599 int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv,
600 uint32_t handle, uint32_t flags, int *prime_fd);
601
602 int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv,
603 int prime_fd, uint32_t *handle);
604
605 struct dma_buf * (*gem_prime_export)(struct drm_device *dev,
606 struct drm_gem_object *obj, int flags);
607
608 struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev,
609 struct dma_buf *dma_buf);
610
611 int (*gem_prime_pin)(struct drm_gem_object *obj);
612 void (*gem_prime_unpin)(struct drm_gem_object *obj);
613 struct reservation_object * (*gem_prime_res_obj)(
614 struct drm_gem_object *obj);
615 struct sg_table *(*gem_prime_get_sg_table)(struct drm_gem_object *obj);
616 struct drm_gem_object *(*gem_prime_import_sg_table)(
617 struct drm_device *dev,
618 struct dma_buf_attachment *attach,
619 struct sg_table *sgt);
620 void *(*gem_prime_vmap)(struct drm_gem_object *obj);
621 void (*gem_prime_vunmap)(struct drm_gem_object *obj, void *vaddr);
622 int (*gem_prime_mmap)(struct drm_gem_object *obj,
623 struct vm_area_struct *vma);
624
625
626 void (*vgaarb_irq)(struct drm_device *dev, bool state);
627
628
629 int (*dumb_create)(struct drm_file *file_priv,
630 struct drm_device *dev,
631 struct drm_mode_create_dumb *args);
632 int (*dumb_map_offset)(struct drm_file *file_priv,
633 struct drm_device *dev, uint32_t handle,
634 uint64_t *offset);
635 int (*dumb_destroy)(struct drm_file *file_priv,
636 struct drm_device *dev,
637 uint32_t handle);
638
639
640 const struct vm_operations_struct *gem_vm_ops;
641
642 int major;
643 int minor;
644 int patchlevel;
645 char *name;
646 char *desc;
647 char *date;
648
649 u32 driver_features;
650 int dev_priv_size;
651 const struct drm_ioctl_desc *ioctls;
652 int num_ioctls;
653 const struct file_operations *fops;
654
655
656 struct list_head legacy_dev_list;
657};
658
659enum drm_minor_type {
660 DRM_MINOR_LEGACY,
661 DRM_MINOR_CONTROL,
662 DRM_MINOR_RENDER,
663 DRM_MINOR_CNT,
664};
665
666
667
668
669
670struct drm_info_list {
671 const char *name;
672 int (*show)(struct seq_file*, void*);
673 u32 driver_features;
674 void *data;
675};
676
677
678
679
680struct drm_info_node {
681 struct list_head list;
682 struct drm_minor *minor;
683 const struct drm_info_list *info_ent;
684 struct dentry *dent;
685};
686
687
688
689
690struct drm_minor {
691 int index;
692 int type;
693 struct device *kdev;
694 struct drm_device *dev;
695
696 struct dentry *debugfs_root;
697
698 struct list_head debugfs_list;
699 struct mutex debugfs_lock;
700
701
702 struct drm_master *master;
703};
704
705
706struct drm_pending_vblank_event {
707 struct drm_pending_event base;
708 unsigned int pipe;
709 struct drm_event_vblank event;
710};
711
712struct drm_vblank_crtc {
713 struct drm_device *dev;
714 wait_queue_head_t queue;
715 struct timer_list disable_timer;
716
717
718 u32 count;
719
720 struct timeval time[DRM_VBLANKTIME_RBSIZE];
721
722 atomic_t refcount;
723 u32 last;
724
725 u32 last_wait;
726 unsigned int inmodeset;
727 unsigned int pipe;
728 int framedur_ns;
729 int linedur_ns;
730 bool enabled;
731
732};
733
734
735
736
737
738struct drm_device {
739 struct list_head legacy_dev_list;
740 int if_version;
741
742
743
744 struct kref ref;
745 struct device *dev;
746 struct drm_driver *driver;
747 void *dev_private;
748 struct drm_minor *control;
749 struct drm_minor *primary;
750 struct drm_minor *render;
751 atomic_t unplugged;
752 struct inode *anon_inode;
753 char *unique;
754
755
756
757
758 struct mutex struct_mutex;
759 struct mutex master_mutex;
760
761
762
763
764 int open_count;
765 spinlock_t buf_lock;
766 int buf_use;
767 atomic_t buf_alloc;
768
769
770 struct list_head filelist;
771
772
773
774 struct list_head maplist;
775 struct drm_open_hash map_hash;
776
777
778
779 struct list_head ctxlist;
780 struct mutex ctxlist_mutex;
781
782 struct idr ctx_idr;
783
784 struct list_head vmalist;
785
786
787
788
789
790 struct drm_device_dma *dma;
791
792
793
794
795
796 __volatile__ long context_flag;
797 int last_context;
798
799
800
801
802 bool irq_enabled;
803 int irq;
804
805
806
807
808
809
810
811 bool vblank_disable_allowed;
812
813
814
815
816
817
818
819
820
821 bool vblank_disable_immediate;
822
823
824 struct drm_vblank_crtc *vblank;
825
826 spinlock_t vblank_time_lock;
827 spinlock_t vbl_lock;
828
829 u32 max_vblank_count;
830
831
832
833
834 struct list_head vblank_event_list;
835 spinlock_t event_lock;
836
837
838
839 struct drm_agp_head *agp;
840
841 struct pci_dev *pdev;
842#ifdef __alpha__
843 struct pci_controller *hose;
844#endif
845
846 struct platform_device *platformdev;
847 struct virtio_device *virtdev;
848
849 struct drm_sg_mem *sg;
850 unsigned int num_crtcs;
851
852 struct {
853 int context;
854 struct drm_hw_lock *lock;
855 } sigdata;
856
857 struct drm_local_map *agp_buffer_map;
858 unsigned int agp_buffer_token;
859
860 struct drm_mode_config mode_config;
861
862
863
864 struct mutex object_name_lock;
865 struct idr object_name_idr;
866 struct drm_vma_offset_manager *vma_offset_manager;
867
868 int switch_power_state;
869};
870
871#define DRM_SWITCH_POWER_ON 0
872#define DRM_SWITCH_POWER_OFF 1
873#define DRM_SWITCH_POWER_CHANGING 2
874#define DRM_SWITCH_POWER_DYNAMIC_OFF 3
875
876static __inline__ int drm_core_check_feature(struct drm_device *dev,
877 int feature)
878{
879 return ((dev->driver->driver_features & feature) ? 1 : 0);
880}
881
882static inline void drm_device_set_unplugged(struct drm_device *dev)
883{
884 smp_wmb();
885 atomic_set(&dev->unplugged, 1);
886}
887
888static inline int drm_device_is_unplugged(struct drm_device *dev)
889{
890 int ret = atomic_read(&dev->unplugged);
891 smp_rmb();
892 return ret;
893}
894
895static inline bool drm_is_render_client(const struct drm_file *file_priv)
896{
897 return file_priv->minor->type == DRM_MINOR_RENDER;
898}
899
900static inline bool drm_is_control_client(const struct drm_file *file_priv)
901{
902 return file_priv->minor->type == DRM_MINOR_CONTROL;
903}
904
905static inline bool drm_is_primary_client(const struct drm_file *file_priv)
906{
907 return file_priv->minor->type == DRM_MINOR_LEGACY;
908}
909
910
911
912
913
914
915extern int drm_ioctl_permit(u32 flags, struct drm_file *file_priv);
916extern long drm_ioctl(struct file *filp,
917 unsigned int cmd, unsigned long arg);
918extern long drm_compat_ioctl(struct file *filp,
919 unsigned int cmd, unsigned long arg);
920extern bool drm_ioctl_flags(unsigned int nr, unsigned int *flags);
921
922
923extern int drm_open(struct inode *inode, struct file *filp);
924extern ssize_t drm_read(struct file *filp, char __user *buffer,
925 size_t count, loff_t *offset);
926extern int drm_release(struct inode *inode, struct file *filp);
927extern int drm_new_set_master(struct drm_device *dev, struct drm_file *fpriv);
928
929
930extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait);
931
932
933int drm_noop(struct drm_device *dev, void *data,
934 struct drm_file *file_priv);
935int drm_invalid_op(struct drm_device *dev, void *data,
936 struct drm_file *file_priv);
937
938
939void drm_clflush_pages(struct page *pages[], unsigned long num_pages);
940void drm_clflush_sg(struct sg_table *st);
941void drm_clflush_virt_range(void *addr, unsigned long length);
942
943
944
945
946
947
948
949extern int drm_irq_install(struct drm_device *dev, int irq);
950extern int drm_irq_uninstall(struct drm_device *dev);
951
952extern int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs);
953extern int drm_wait_vblank(struct drm_device *dev, void *data,
954 struct drm_file *filp);
955extern u32 drm_vblank_count(struct drm_device *dev, unsigned int pipe);
956extern u32 drm_crtc_vblank_count(struct drm_crtc *crtc);
957extern u32 drm_vblank_count_and_time(struct drm_device *dev, unsigned int pipe,
958 struct timeval *vblanktime);
959extern u32 drm_crtc_vblank_count_and_time(struct drm_crtc *crtc,
960 struct timeval *vblanktime);
961extern void drm_send_vblank_event(struct drm_device *dev, unsigned int pipe,
962 struct drm_pending_vblank_event *e);
963extern void drm_crtc_send_vblank_event(struct drm_crtc *crtc,
964 struct drm_pending_vblank_event *e);
965extern void drm_arm_vblank_event(struct drm_device *dev, unsigned int pipe,
966 struct drm_pending_vblank_event *e);
967extern void drm_crtc_arm_vblank_event(struct drm_crtc *crtc,
968 struct drm_pending_vblank_event *e);
969extern bool drm_handle_vblank(struct drm_device *dev, unsigned int pipe);
970extern bool drm_crtc_handle_vblank(struct drm_crtc *crtc);
971extern int drm_vblank_get(struct drm_device *dev, unsigned int pipe);
972extern void drm_vblank_put(struct drm_device *dev, unsigned int pipe);
973extern int drm_crtc_vblank_get(struct drm_crtc *crtc);
974extern void drm_crtc_vblank_put(struct drm_crtc *crtc);
975extern void drm_wait_one_vblank(struct drm_device *dev, unsigned int pipe);
976extern void drm_crtc_wait_one_vblank(struct drm_crtc *crtc);
977extern void drm_vblank_off(struct drm_device *dev, unsigned int pipe);
978extern void drm_vblank_on(struct drm_device *dev, unsigned int pipe);
979extern void drm_crtc_vblank_off(struct drm_crtc *crtc);
980extern void drm_crtc_vblank_reset(struct drm_crtc *crtc);
981extern void drm_crtc_vblank_on(struct drm_crtc *crtc);
982extern void drm_vblank_cleanup(struct drm_device *dev);
983extern u32 drm_vblank_no_hw_counter(struct drm_device *dev, unsigned int pipe);
984
985extern int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev,
986 unsigned int pipe, int *max_error,
987 struct timeval *vblank_time,
988 unsigned flags,
989 const struct drm_display_mode *mode);
990extern void drm_calc_timestamping_constants(struct drm_crtc *crtc,
991 const struct drm_display_mode *mode);
992
993
994
995
996
997
998
999
1000static inline wait_queue_head_t *drm_crtc_vblank_waitqueue(struct drm_crtc *crtc)
1001{
1002 return &crtc->dev->vblank[drm_crtc_index(crtc)].queue;
1003}
1004
1005
1006extern void drm_vblank_pre_modeset(struct drm_device *dev, unsigned int pipe);
1007extern void drm_vblank_post_modeset(struct drm_device *dev, unsigned int pipe);
1008
1009
1010extern struct drm_master *drm_master_get(struct drm_master *master);
1011extern void drm_master_put(struct drm_master **master);
1012
1013extern void drm_put_dev(struct drm_device *dev);
1014extern void drm_unplug_dev(struct drm_device *dev);
1015extern unsigned int drm_debug;
1016extern bool drm_atomic;
1017
1018
1019#if defined(CONFIG_DEBUG_FS)
1020extern int drm_debugfs_create_files(const struct drm_info_list *files,
1021 int count, struct dentry *root,
1022 struct drm_minor *minor);
1023extern int drm_debugfs_remove_files(const struct drm_info_list *files,
1024 int count, struct drm_minor *minor);
1025#else
1026static inline int drm_debugfs_create_files(const struct drm_info_list *files,
1027 int count, struct dentry *root,
1028 struct drm_minor *minor)
1029{
1030 return 0;
1031}
1032
1033static inline int drm_debugfs_remove_files(const struct drm_info_list *files,
1034 int count, struct drm_minor *minor)
1035{
1036 return 0;
1037}
1038#endif
1039
1040extern struct dma_buf *drm_gem_prime_export(struct drm_device *dev,
1041 struct drm_gem_object *obj, int flags);
1042extern int drm_gem_prime_handle_to_fd(struct drm_device *dev,
1043 struct drm_file *file_priv, uint32_t handle, uint32_t flags,
1044 int *prime_fd);
1045extern struct drm_gem_object *drm_gem_prime_import(struct drm_device *dev,
1046 struct dma_buf *dma_buf);
1047extern int drm_gem_prime_fd_to_handle(struct drm_device *dev,
1048 struct drm_file *file_priv, int prime_fd, uint32_t *handle);
1049extern void drm_gem_dmabuf_release(struct dma_buf *dma_buf);
1050
1051extern int drm_prime_sg_to_page_addr_arrays(struct sg_table *sgt, struct page **pages,
1052 dma_addr_t *addrs, int max_pages);
1053extern struct sg_table *drm_prime_pages_to_sg(struct page **pages, unsigned int nr_pages);
1054extern void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg);
1055
1056
1057extern struct drm_dma_handle *drm_pci_alloc(struct drm_device *dev, size_t size,
1058 size_t align);
1059extern void drm_pci_free(struct drm_device *dev, struct drm_dma_handle * dmah);
1060
1061
1062extern void drm_sysfs_hotplug_event(struct drm_device *dev);
1063
1064
1065struct drm_device *drm_dev_alloc(struct drm_driver *driver,
1066 struct device *parent);
1067void drm_dev_ref(struct drm_device *dev);
1068void drm_dev_unref(struct drm_device *dev);
1069int drm_dev_register(struct drm_device *dev, unsigned long flags);
1070void drm_dev_unregister(struct drm_device *dev);
1071int drm_dev_set_unique(struct drm_device *dev, const char *name);
1072
1073struct drm_minor *drm_minor_acquire(unsigned int minor_id);
1074void drm_minor_release(struct drm_minor *minor);
1075
1076
1077
1078
1079static __inline__ int drm_pci_device_is_agp(struct drm_device *dev)
1080{
1081 if (dev->driver->device_is_agp != NULL) {
1082 int err = (*dev->driver->device_is_agp) (dev);
1083
1084 if (err != 2) {
1085 return err;
1086 }
1087 }
1088
1089 return pci_find_capability(dev->pdev, PCI_CAP_ID_AGP);
1090}
1091void drm_pci_agp_destroy(struct drm_device *dev);
1092
1093extern int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver);
1094extern void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver);
1095#ifdef CONFIG_PCI
1096extern int drm_get_pci_dev(struct pci_dev *pdev,
1097 const struct pci_device_id *ent,
1098 struct drm_driver *driver);
1099extern int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master);
1100#else
1101static inline int drm_get_pci_dev(struct pci_dev *pdev,
1102 const struct pci_device_id *ent,
1103 struct drm_driver *driver)
1104{
1105 return -ENOSYS;
1106}
1107
1108static inline int drm_pci_set_busid(struct drm_device *dev,
1109 struct drm_master *master)
1110{
1111 return -ENOSYS;
1112}
1113#endif
1114
1115#define DRM_PCIE_SPEED_25 1
1116#define DRM_PCIE_SPEED_50 2
1117#define DRM_PCIE_SPEED_80 4
1118
1119extern int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *speed_mask);
1120extern int drm_pcie_get_max_link_width(struct drm_device *dev, u32 *mlw);
1121
1122
1123extern int drm_platform_init(struct drm_driver *driver, struct platform_device *platform_device);
1124extern int drm_platform_set_busid(struct drm_device *d, struct drm_master *m);
1125
1126
1127static __inline__ bool drm_can_sleep(void)
1128{
1129 if (in_atomic() || in_dbg_master() || irqs_disabled())
1130 return false;
1131 return true;
1132}
1133
1134
1135#define for_each_if(condition) if (!(condition)) {} else
1136
1137#endif
1138