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
33
34
35#ifndef _DRM_P_H_
36#define _DRM_P_H_
37
38#ifdef __KERNEL__
39#ifdef __alpha__
40
41
42
43#include <asm/current.h>
44#endif
45#include <linux/kernel.h>
46#include <linux/kref.h>
47#include <linux/miscdevice.h>
48#include <linux/fs.h>
49#include <linux/init.h>
50#include <linux/file.h>
51#include <linux/platform_device.h>
52#include <linux/pci.h>
53#include <linux/jiffies.h>
54#include <linux/dma-mapping.h>
55#include <linux/mm.h>
56#include <linux/cdev.h>
57#include <linux/mutex.h>
58#include <linux/io.h>
59#include <linux/slab.h>
60#include <linux/ratelimit.h>
61#if defined(__alpha__) || defined(__powerpc__)
62#include <asm/pgtable.h>
63#endif
64#include <asm/mman.h>
65#include <asm/uaccess.h>
66#include <linux/types.h>
67#include <linux/agp_backend.h>
68#include <linux/workqueue.h>
69#include <linux/poll.h>
70#include <asm/pgalloc.h>
71#include <drm/drm.h>
72#include <drm/drm_sarea.h>
73#include <drm/drm_vma_manager.h>
74
75#include <linux/idr.h>
76
77#define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE)))
78
79struct module;
80
81struct drm_file;
82struct drm_device;
83
84struct device_node;
85struct videomode;
86
87#include <drm/drm_os_linux.h>
88#include <drm/drm_hashtab.h>
89#include <drm/drm_mm.h>
90
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#define DRM_UT_CORE 0x01
120#define DRM_UT_DRIVER 0x02
121#define DRM_UT_KMS 0x04
122#define DRM_UT_PRIME 0x08
123
124extern __printf(2, 3)
125void drm_ut_debug_printk(const char *function_name,
126 const char *format, ...);
127extern __printf(2, 3)
128int drm_err(const char *func, const char *format, ...);
129
130
131
132
133
134
135#define DRIVER_USE_AGP 0x1
136#define DRIVER_PCI_DMA 0x8
137#define DRIVER_SG 0x10
138#define DRIVER_HAVE_DMA 0x20
139#define DRIVER_HAVE_IRQ 0x40
140#define DRIVER_IRQ_SHARED 0x80
141#define DRIVER_GEM 0x1000
142#define DRIVER_MODESET 0x2000
143#define DRIVER_PRIME 0x4000
144#define DRIVER_RENDER 0x8000
145
146#define DRIVER_BUS_PCI 0x1
147#define DRIVER_BUS_PLATFORM 0x2
148#define DRIVER_BUS_USB 0x3
149#define DRIVER_BUS_HOST1X 0x4
150
151
152
153
154
155#define DRM_DEBUG_CODE 2
156
157
158#define DRM_MAGIC_HASH_ORDER 4
159#define DRM_KERNEL_CONTEXT 0
160#define DRM_RESERVED_CONTEXTS 1
161
162#define DRM_MAP_HASH_OFFSET 0x10000000
163
164
165
166
167
168
169
170
171
172
173
174
175
176#define DRM_ERROR(fmt, ...) \
177 drm_err(__func__, fmt, ##__VA_ARGS__)
178
179
180
181
182
183
184
185#define DRM_ERROR_RATELIMITED(fmt, ...) \
186({ \
187 static DEFINE_RATELIMIT_STATE(_rs, \
188 DEFAULT_RATELIMIT_INTERVAL, \
189 DEFAULT_RATELIMIT_BURST); \
190 \
191 if (__ratelimit(&_rs)) \
192 drm_err(__func__, fmt, ##__VA_ARGS__); \
193})
194
195#define DRM_INFO(fmt, ...) \
196 printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__)
197
198#define DRM_INFO_ONCE(fmt, ...) \
199 printk_once(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__)
200
201
202
203
204
205
206
207#if DRM_DEBUG_CODE
208#define DRM_DEBUG(fmt, args...) \
209 do { \
210 if (unlikely(drm_debug & DRM_UT_CORE)) \
211 drm_ut_debug_printk(__func__, fmt, ##args); \
212 } while (0)
213
214#define DRM_DEBUG_DRIVER(fmt, args...) \
215 do { \
216 if (unlikely(drm_debug & DRM_UT_DRIVER)) \
217 drm_ut_debug_printk(__func__, fmt, ##args); \
218 } while (0)
219#define DRM_DEBUG_KMS(fmt, args...) \
220 do { \
221 if (unlikely(drm_debug & DRM_UT_KMS)) \
222 drm_ut_debug_printk(__func__, fmt, ##args); \
223 } while (0)
224#define DRM_DEBUG_PRIME(fmt, args...) \
225 do { \
226 if (unlikely(drm_debug & DRM_UT_PRIME)) \
227 drm_ut_debug_printk(__func__, fmt, ##args); \
228 } while (0)
229#else
230#define DRM_DEBUG_DRIVER(fmt, args...) do { } while (0)
231#define DRM_DEBUG_KMS(fmt, args...) do { } while (0)
232#define DRM_DEBUG_PRIME(fmt, args...) do { } while (0)
233#define DRM_DEBUG(fmt, arg...) do { } while (0)
234#endif
235
236
237
238
239
240
241
242#define DRM_ARRAY_SIZE(x) ARRAY_SIZE(x)
243
244#define DRM_IF_VERSION(maj, min) (maj << 16 | min)
245
246
247
248
249
250
251
252#define LOCK_TEST_WITH_RETURN( dev, _file_priv ) \
253do { \
254 if (!_DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock) || \
255 _file_priv->master->lock.file_priv != _file_priv) { \
256 DRM_ERROR( "%s called without lock held, held %d owner %p %p\n",\
257 __func__, _DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock),\
258 _file_priv->master->lock.file_priv, _file_priv); \
259 return -EINVAL; \
260 } \
261} while (0)
262
263
264
265
266
267
268
269
270
271typedef int drm_ioctl_t(struct drm_device *dev, void *data,
272 struct drm_file *file_priv);
273
274typedef int drm_ioctl_compat_t(struct file *filp, unsigned int cmd,
275 unsigned long arg);
276
277#define DRM_IOCTL_NR(n) _IOC_NR(n)
278#define DRM_MAJOR 226
279
280#define DRM_AUTH 0x1
281#define DRM_MASTER 0x2
282#define DRM_ROOT_ONLY 0x4
283#define DRM_CONTROL_ALLOW 0x8
284#define DRM_UNLOCKED 0x10
285#define DRM_RENDER_ALLOW 0x20
286
287struct drm_ioctl_desc {
288 unsigned int cmd;
289 int flags;
290 drm_ioctl_t *func;
291 unsigned int cmd_drv;
292 const char *name;
293};
294
295
296
297
298
299
300#define DRM_IOCTL_DEF_DRV(ioctl, _func, _flags) \
301 [DRM_IOCTL_NR(DRM_##ioctl)] = {.cmd = DRM_##ioctl, .func = _func, .flags = _flags, .cmd_drv = DRM_IOCTL_##ioctl, .name = #ioctl}
302
303struct drm_magic_entry {
304 struct list_head head;
305 struct drm_hash_item hash_item;
306 struct drm_file *priv;
307};
308
309struct drm_vma_entry {
310 struct list_head head;
311 struct vm_area_struct *vma;
312 pid_t pid;
313};
314
315
316
317
318struct drm_buf {
319 int idx;
320 int total;
321 int order;
322 int used;
323 unsigned long offset;
324 void *address;
325 unsigned long bus_address;
326 struct drm_buf *next;
327 __volatile__ int waiting;
328 __volatile__ int pending;
329 struct drm_file *file_priv;
330 int context;
331 int while_locked;
332 enum {
333 DRM_LIST_NONE = 0,
334 DRM_LIST_FREE = 1,
335 DRM_LIST_WAIT = 2,
336 DRM_LIST_PEND = 3,
337 DRM_LIST_PRIO = 4,
338 DRM_LIST_RECLAIM = 5
339 } list;
340
341 int dev_priv_size;
342 void *dev_private;
343};
344
345
346struct drm_waitlist {
347 int count;
348 struct drm_buf **bufs;
349 struct drm_buf **rp;
350 struct drm_buf **wp;
351 struct drm_buf **end;
352 spinlock_t read_lock;
353 spinlock_t write_lock;
354};
355
356struct drm_freelist {
357 int initialized;
358 atomic_t count;
359 struct drm_buf *next;
360
361 wait_queue_head_t waiting;
362 int low_mark;
363 int high_mark;
364 atomic_t wfh;
365 spinlock_t lock;
366};
367
368typedef struct drm_dma_handle {
369 dma_addr_t busaddr;
370 void *vaddr;
371 size_t size;
372} drm_dma_handle_t;
373
374
375
376
377struct drm_buf_entry {
378 int buf_size;
379 int buf_count;
380 struct drm_buf *buflist;
381 int seg_count;
382 int page_order;
383 struct drm_dma_handle **seglist;
384
385 struct drm_freelist freelist;
386};
387
388
389struct drm_pending_event {
390 struct drm_event *event;
391 struct list_head link;
392 struct drm_file *file_priv;
393 pid_t pid;
394
395 void (*destroy)(struct drm_pending_event *event);
396};
397
398
399struct drm_prime_file_private {
400 struct list_head head;
401 struct mutex lock;
402};
403
404
405struct drm_file {
406 unsigned always_authenticated :1;
407 unsigned authenticated :1;
408
409 unsigned is_master :1;
410
411 unsigned stereo_allowed :1;
412
413
414
415
416 unsigned universal_planes:1;
417
418 struct pid *pid;
419 kuid_t uid;
420 drm_magic_t magic;
421 struct list_head lhead;
422 struct drm_minor *minor;
423 unsigned long lock_count;
424
425
426 struct idr object_idr;
427
428 spinlock_t table_lock;
429
430 struct file *filp;
431 void *driver_priv;
432
433 struct drm_master *master;
434
435
436
437
438
439
440
441 struct list_head fbs;
442 struct mutex fbs_lock;
443
444 wait_queue_head_t event_wait;
445 struct list_head event_list;
446 int event_space;
447
448 struct drm_prime_file_private prime;
449};
450
451
452struct drm_queue {
453 atomic_t use_count;
454 atomic_t finalization;
455 atomic_t block_count;
456 atomic_t block_read;
457 wait_queue_head_t read_queue;
458 atomic_t block_write;
459 wait_queue_head_t write_queue;
460 atomic_t total_queued;
461 atomic_t total_flushed;
462 atomic_t total_locks;
463 enum drm_ctx_flags flags;
464 struct drm_waitlist waitlist;
465 wait_queue_head_t flush_queue;
466};
467
468
469
470
471struct drm_lock_data {
472 struct drm_hw_lock *hw_lock;
473
474 struct drm_file *file_priv;
475 wait_queue_head_t lock_queue;
476 unsigned long lock_time;
477 spinlock_t spinlock;
478 uint32_t kernel_waiters;
479 uint32_t user_waiters;
480 int idle_has_lock;
481};
482
483
484
485
486struct drm_device_dma {
487
488 struct drm_buf_entry bufs[DRM_MAX_ORDER + 1];
489 int buf_count;
490 struct drm_buf **buflist;
491 int seg_count;
492 int page_count;
493 unsigned long *pagelist;
494 unsigned long byte_count;
495 enum {
496 _DRM_DMA_USE_AGP = 0x01,
497 _DRM_DMA_USE_SG = 0x02,
498 _DRM_DMA_USE_FB = 0x04,
499 _DRM_DMA_USE_PCI_RO = 0x08
500 } flags;
501
502};
503
504
505
506
507struct drm_agp_mem {
508 unsigned long handle;
509 struct agp_memory *memory;
510 unsigned long bound;
511 int pages;
512 struct list_head head;
513};
514
515
516
517
518
519
520struct drm_agp_head {
521 struct agp_kern_info agp_info;
522 struct list_head memory;
523 unsigned long mode;
524 struct agp_bridge_data *bridge;
525 int enabled;
526 int acquired;
527 unsigned long base;
528 int agp_mtrr;
529 int cant_use_aperture;
530 unsigned long page_mask;
531};
532
533
534
535
536struct drm_sg_mem {
537 unsigned long handle;
538 void *virtual;
539 int pages;
540 struct page **pagelist;
541 dma_addr_t *busaddr;
542};
543
544struct drm_sigdata {
545 int context;
546 struct drm_hw_lock *lock;
547};
548
549
550
551
552
553struct drm_local_map {
554 resource_size_t offset;
555 unsigned long size;
556 enum drm_map_type type;
557 enum drm_map_flags flags;
558 void *handle;
559
560 int mtrr;
561};
562
563typedef struct drm_local_map drm_local_map_t;
564
565
566
567
568struct drm_map_list {
569 struct list_head head;
570 struct drm_hash_item hash;
571 struct drm_local_map *map;
572 uint64_t user_token;
573 struct drm_master *master;
574};
575
576
577
578
579struct drm_ctx_list {
580 struct list_head head;
581 drm_context_t handle;
582 struct drm_file *tag;
583};
584
585
586#define DRM_ATI_GART_MAIN 1
587#define DRM_ATI_GART_FB 2
588
589#define DRM_ATI_GART_PCI 1
590#define DRM_ATI_GART_PCIE 2
591#define DRM_ATI_GART_IGP 3
592
593struct drm_ati_pcigart_info {
594 int gart_table_location;
595 int gart_reg_if;
596 void *addr;
597 dma_addr_t bus_addr;
598 dma_addr_t table_mask;
599 struct drm_dma_handle *table_handle;
600 struct drm_local_map mapping;
601 int table_size;
602};
603
604
605
606
607
608struct drm_gem_object {
609
610 struct kref refcount;
611
612
613
614
615
616
617
618
619
620
621 unsigned handle_count;
622
623
624 struct drm_device *dev;
625
626
627 struct file *filp;
628
629
630 struct drm_vma_offset_node vma_node;
631
632
633
634
635
636 size_t size;
637
638
639
640
641
642 int name;
643
644
645
646
647
648
649
650 uint32_t read_domains;
651 uint32_t write_domain;
652
653
654
655
656
657
658
659 uint32_t pending_read_domains;
660 uint32_t pending_write_domain;
661
662
663
664
665
666
667
668
669
670
671 struct dma_buf *dma_buf;
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688 struct dma_buf_attachment *import_attach;
689};
690
691#include <drm/drm_crtc.h>
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706struct drm_master {
707 struct kref refcount;
708 struct drm_minor *minor;
709 char *unique;
710 int unique_len;
711 int unique_size;
712 struct drm_open_hash magiclist;
713 struct list_head magicfree;
714 struct drm_lock_data lock;
715 void *driver_priv;
716};
717
718
719
720
721#define DRM_VBLANKTIME_RBSIZE 2
722
723
724#define DRM_CALLED_FROM_VBLIRQ 1
725#define DRM_VBLANKTIME_SCANOUTPOS_METHOD (1 << 0)
726#define DRM_VBLANKTIME_INVBL (1 << 1)
727
728
729#define DRM_SCANOUTPOS_VALID (1 << 0)
730#define DRM_SCANOUTPOS_INVBL (1 << 1)
731#define DRM_SCANOUTPOS_ACCURATE (1 << 2)
732
733struct drm_bus {
734 int bus_type;
735 int (*get_irq)(struct drm_device *dev);
736 const char *(*get_name)(struct drm_device *dev);
737 int (*set_busid)(struct drm_device *dev, struct drm_master *master);
738 int (*set_unique)(struct drm_device *dev, struct drm_master *master,
739 struct drm_unique *unique);
740 int (*irq_by_busid)(struct drm_device *dev, struct drm_irq_busid *p);
741};
742
743
744
745
746
747
748struct drm_driver {
749 int (*load) (struct drm_device *, unsigned long flags);
750 int (*firstopen) (struct drm_device *);
751 int (*open) (struct drm_device *, struct drm_file *);
752 void (*preclose) (struct drm_device *, struct drm_file *file_priv);
753 void (*postclose) (struct drm_device *, struct drm_file *);
754 void (*lastclose) (struct drm_device *);
755 int (*unload) (struct drm_device *);
756 int (*suspend) (struct drm_device *, pm_message_t state);
757 int (*resume) (struct drm_device *);
758 int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
759 int (*dma_quiescent) (struct drm_device *);
760 int (*context_dtor) (struct drm_device *dev, int context);
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779 u32 (*get_vblank_counter) (struct drm_device *dev, int crtc);
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794 int (*enable_vblank) (struct drm_device *dev, int crtc);
795
796
797
798
799
800
801
802
803
804
805 void (*disable_vblank) (struct drm_device *dev, int crtc);
806
807
808
809
810
811
812
813
814
815
816
817
818 int (*device_is_agp) (struct drm_device *dev);
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850 int (*get_scanout_position) (struct drm_device *dev, int crtc,
851 unsigned int flags,
852 int *vpos, int *hpos, ktime_t *stime,
853 ktime_t *etime);
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885 int (*get_vblank_timestamp) (struct drm_device *dev, int crtc,
886 int *max_error,
887 struct timeval *vblank_time,
888 unsigned flags);
889
890
891
892 irqreturn_t(*irq_handler) (int irq, void *arg);
893 void (*irq_preinstall) (struct drm_device *dev);
894 int (*irq_postinstall) (struct drm_device *dev);
895 void (*irq_uninstall) (struct drm_device *dev);
896
897
898 int (*master_create)(struct drm_device *dev, struct drm_master *master);
899 void (*master_destroy)(struct drm_device *dev, struct drm_master *master);
900
901
902
903
904
905 int (*master_set)(struct drm_device *dev, struct drm_file *file_priv,
906 bool from_open);
907 void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv,
908 bool from_release);
909
910 int (*debugfs_init)(struct drm_minor *minor);
911 void (*debugfs_cleanup)(struct drm_minor *minor);
912
913
914
915
916
917
918
919 void (*gem_free_object) (struct drm_gem_object *obj);
920 int (*gem_open_object) (struct drm_gem_object *, struct drm_file *);
921 void (*gem_close_object) (struct drm_gem_object *, struct drm_file *);
922
923
924
925 int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv,
926 uint32_t handle, uint32_t flags, int *prime_fd);
927
928 int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv,
929 int prime_fd, uint32_t *handle);
930
931 struct dma_buf * (*gem_prime_export)(struct drm_device *dev,
932 struct drm_gem_object *obj, int flags);
933
934 struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev,
935 struct dma_buf *dma_buf);
936
937 int (*gem_prime_pin)(struct drm_gem_object *obj);
938 void (*gem_prime_unpin)(struct drm_gem_object *obj);
939 struct sg_table *(*gem_prime_get_sg_table)(struct drm_gem_object *obj);
940 struct drm_gem_object *(*gem_prime_import_sg_table)(
941 struct drm_device *dev, size_t size,
942 struct sg_table *sgt);
943 void *(*gem_prime_vmap)(struct drm_gem_object *obj);
944 void (*gem_prime_vunmap)(struct drm_gem_object *obj, void *vaddr);
945 int (*gem_prime_mmap)(struct drm_gem_object *obj,
946 struct vm_area_struct *vma);
947
948
949 void (*vgaarb_irq)(struct drm_device *dev, bool state);
950
951
952 int (*dumb_create)(struct drm_file *file_priv,
953 struct drm_device *dev,
954 struct drm_mode_create_dumb *args);
955 int (*dumb_map_offset)(struct drm_file *file_priv,
956 struct drm_device *dev, uint32_t handle,
957 uint64_t *offset);
958 int (*dumb_destroy)(struct drm_file *file_priv,
959 struct drm_device *dev,
960 uint32_t handle);
961
962
963 const struct vm_operations_struct *gem_vm_ops;
964
965 int major;
966 int minor;
967 int patchlevel;
968 char *name;
969 char *desc;
970 char *date;
971
972 u32 driver_features;
973 int dev_priv_size;
974 const struct drm_ioctl_desc *ioctls;
975 int num_ioctls;
976 const struct file_operations *fops;
977 union {
978 struct pci_driver *pci;
979 struct platform_device *platform_device;
980 struct usb_driver *usb;
981 } kdriver;
982 struct drm_bus *bus;
983
984
985 struct list_head legacy_dev_list;
986};
987
988enum drm_minor_type {
989 DRM_MINOR_LEGACY,
990 DRM_MINOR_CONTROL,
991 DRM_MINOR_RENDER,
992 DRM_MINOR_CNT,
993};
994
995
996
997
998
999struct drm_info_list {
1000 const char *name;
1001 int (*show)(struct seq_file*, void*);
1002 u32 driver_features;
1003 void *data;
1004};
1005
1006
1007
1008
1009struct drm_info_node {
1010 struct list_head list;
1011 struct drm_minor *minor;
1012 const struct drm_info_list *info_ent;
1013 struct dentry *dent;
1014};
1015
1016
1017
1018
1019struct drm_minor {
1020 int index;
1021 int type;
1022 struct device *kdev;
1023 struct drm_device *dev;
1024
1025 struct dentry *debugfs_root;
1026
1027 struct list_head debugfs_list;
1028 struct mutex debugfs_lock;
1029
1030
1031 struct drm_master *master;
1032 struct drm_mode_group mode_group;
1033};
1034
1035
1036struct drm_pending_vblank_event {
1037 struct drm_pending_event base;
1038 int pipe;
1039 struct drm_event_vblank event;
1040};
1041
1042struct drm_vblank_crtc {
1043 wait_queue_head_t queue;
1044 struct timeval time[DRM_VBLANKTIME_RBSIZE];
1045 atomic_t count;
1046 atomic_t refcount;
1047 u32 last;
1048
1049 u32 last_wait;
1050 unsigned int inmodeset;
1051 bool enabled;
1052
1053};
1054
1055
1056
1057
1058
1059struct drm_device {
1060 struct list_head legacy_dev_list;
1061 char *devname;
1062 int if_version;
1063
1064
1065
1066 struct kref ref;
1067 struct device *dev;
1068 struct drm_driver *driver;
1069 void *dev_private;
1070 struct drm_minor *control;
1071 struct drm_minor *primary;
1072 struct drm_minor *render;
1073 atomic_t unplugged;
1074 struct inode *anon_inode;
1075
1076
1077
1078
1079 spinlock_t count_lock;
1080 struct mutex struct_mutex;
1081 struct mutex master_mutex;
1082
1083
1084
1085
1086 int open_count;
1087 int buf_use;
1088 atomic_t buf_alloc;
1089
1090
1091 struct list_head filelist;
1092
1093
1094
1095 struct list_head maplist;
1096 struct drm_open_hash map_hash;
1097
1098
1099
1100 struct list_head ctxlist;
1101 struct mutex ctxlist_mutex;
1102
1103 struct idr ctx_idr;
1104
1105 struct list_head vmalist;
1106
1107
1108
1109
1110
1111 struct drm_device_dma *dma;
1112
1113
1114
1115
1116 bool irq_enabled;
1117 __volatile__ long context_flag;
1118 int last_context;
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130 bool vblank_disable_allowed;
1131
1132
1133 struct drm_vblank_crtc *vblank;
1134
1135 spinlock_t vblank_time_lock;
1136 spinlock_t vbl_lock;
1137 struct timer_list vblank_disable_timer;
1138
1139 u32 max_vblank_count;
1140
1141
1142
1143
1144 struct list_head vblank_event_list;
1145 spinlock_t event_lock;
1146
1147
1148
1149 struct drm_agp_head *agp;
1150
1151 struct pci_dev *pdev;
1152#ifdef __alpha__
1153 struct pci_controller *hose;
1154#endif
1155
1156 struct platform_device *platformdev;
1157 struct usb_device *usbdev;
1158
1159 struct drm_sg_mem *sg;
1160 unsigned int num_crtcs;
1161 struct drm_sigdata sigdata;
1162 sigset_t sigmask;
1163
1164 struct drm_local_map *agp_buffer_map;
1165 unsigned int agp_buffer_token;
1166
1167 struct drm_mode_config mode_config;
1168
1169
1170
1171 struct mutex object_name_lock;
1172 struct idr object_name_idr;
1173 struct drm_vma_offset_manager *vma_offset_manager;
1174
1175 int switch_power_state;
1176};
1177
1178#define DRM_SWITCH_POWER_ON 0
1179#define DRM_SWITCH_POWER_OFF 1
1180#define DRM_SWITCH_POWER_CHANGING 2
1181#define DRM_SWITCH_POWER_DYNAMIC_OFF 3
1182
1183static __inline__ int drm_core_check_feature(struct drm_device *dev,
1184 int feature)
1185{
1186 return ((dev->driver->driver_features & feature) ? 1 : 0);
1187}
1188
1189static inline int drm_dev_to_irq(struct drm_device *dev)
1190{
1191 return dev->driver->bus->get_irq(dev);
1192}
1193
1194static inline void drm_device_set_unplugged(struct drm_device *dev)
1195{
1196 smp_wmb();
1197 atomic_set(&dev->unplugged, 1);
1198}
1199
1200static inline int drm_device_is_unplugged(struct drm_device *dev)
1201{
1202 int ret = atomic_read(&dev->unplugged);
1203 smp_rmb();
1204 return ret;
1205}
1206
1207static inline bool drm_modeset_is_locked(struct drm_device *dev)
1208{
1209 return mutex_is_locked(&dev->mode_config.mutex);
1210}
1211
1212static inline bool drm_is_render_client(const struct drm_file *file_priv)
1213{
1214 return file_priv->minor->type == DRM_MINOR_RENDER;
1215}
1216
1217static inline bool drm_is_control_client(const struct drm_file *file_priv)
1218{
1219 return file_priv->minor->type == DRM_MINOR_CONTROL;
1220}
1221
1222static inline bool drm_is_primary_client(const struct drm_file *file_priv)
1223{
1224 return file_priv->minor->type == DRM_MINOR_LEGACY;
1225}
1226
1227
1228
1229
1230
1231
1232extern long drm_ioctl(struct file *filp,
1233 unsigned int cmd, unsigned long arg);
1234extern long drm_compat_ioctl(struct file *filp,
1235 unsigned int cmd, unsigned long arg);
1236extern int drm_lastclose(struct drm_device *dev);
1237extern bool drm_ioctl_flags(unsigned int nr, unsigned int *flags);
1238
1239
1240extern struct mutex drm_global_mutex;
1241extern int drm_open(struct inode *inode, struct file *filp);
1242extern int drm_stub_open(struct inode *inode, struct file *filp);
1243extern ssize_t drm_read(struct file *filp, char __user *buffer,
1244 size_t count, loff_t *offset);
1245extern int drm_release(struct inode *inode, struct file *filp);
1246
1247
1248extern int drm_mmap(struct file *filp, struct vm_area_struct *vma);
1249extern int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma);
1250extern void drm_vm_open_locked(struct drm_device *dev, struct vm_area_struct *vma);
1251extern void drm_vm_close_locked(struct drm_device *dev, struct vm_area_struct *vma);
1252extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait);
1253
1254
1255#include <drm/drm_memory.h>
1256
1257
1258
1259extern int drm_irq_by_busid(struct drm_device *dev, void *data,
1260 struct drm_file *file_priv);
1261extern int drm_getunique(struct drm_device *dev, void *data,
1262 struct drm_file *file_priv);
1263extern int drm_setunique(struct drm_device *dev, void *data,
1264 struct drm_file *file_priv);
1265extern int drm_getmap(struct drm_device *dev, void *data,
1266 struct drm_file *file_priv);
1267extern int drm_getclient(struct drm_device *dev, void *data,
1268 struct drm_file *file_priv);
1269extern int drm_getstats(struct drm_device *dev, void *data,
1270 struct drm_file *file_priv);
1271extern int drm_getcap(struct drm_device *dev, void *data,
1272 struct drm_file *file_priv);
1273extern int drm_setclientcap(struct drm_device *dev, void *data,
1274 struct drm_file *file_priv);
1275extern int drm_setversion(struct drm_device *dev, void *data,
1276 struct drm_file *file_priv);
1277extern int drm_noop(struct drm_device *dev, void *data,
1278 struct drm_file *file_priv);
1279
1280
1281extern int drm_resctx(struct drm_device *dev, void *data,
1282 struct drm_file *file_priv);
1283extern int drm_addctx(struct drm_device *dev, void *data,
1284 struct drm_file *file_priv);
1285extern int drm_getctx(struct drm_device *dev, void *data,
1286 struct drm_file *file_priv);
1287extern int drm_switchctx(struct drm_device *dev, void *data,
1288 struct drm_file *file_priv);
1289extern int drm_newctx(struct drm_device *dev, void *data,
1290 struct drm_file *file_priv);
1291extern int drm_rmctx(struct drm_device *dev, void *data,
1292 struct drm_file *file_priv);
1293
1294extern int drm_ctxbitmap_init(struct drm_device *dev);
1295extern void drm_ctxbitmap_cleanup(struct drm_device *dev);
1296extern void drm_ctxbitmap_free(struct drm_device *dev, int ctx_handle);
1297
1298extern int drm_setsareactx(struct drm_device *dev, void *data,
1299 struct drm_file *file_priv);
1300extern int drm_getsareactx(struct drm_device *dev, void *data,
1301 struct drm_file *file_priv);
1302
1303
1304extern int drm_getmagic(struct drm_device *dev, void *data,
1305 struct drm_file *file_priv);
1306extern int drm_authmagic(struct drm_device *dev, void *data,
1307 struct drm_file *file_priv);
1308extern int drm_remove_magic(struct drm_master *master, drm_magic_t magic);
1309
1310
1311void drm_clflush_pages(struct page *pages[], unsigned long num_pages);
1312void drm_clflush_sg(struct sg_table *st);
1313void drm_clflush_virt_range(char *addr, unsigned long length);
1314
1315
1316extern int drm_lock(struct drm_device *dev, void *data,
1317 struct drm_file *file_priv);
1318extern int drm_unlock(struct drm_device *dev, void *data,
1319 struct drm_file *file_priv);
1320extern int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context);
1321extern void drm_idlelock_take(struct drm_lock_data *lock_data);
1322extern void drm_idlelock_release(struct drm_lock_data *lock_data);
1323
1324
1325
1326
1327
1328
1329extern int drm_i_have_hw_lock(struct drm_device *dev, struct drm_file *file_priv);
1330
1331
1332extern int drm_addbufs_agp(struct drm_device *dev, struct drm_buf_desc * request);
1333extern int drm_addbufs_pci(struct drm_device *dev, struct drm_buf_desc * request);
1334extern int drm_addmap(struct drm_device *dev, resource_size_t offset,
1335 unsigned int size, enum drm_map_type type,
1336 enum drm_map_flags flags, struct drm_local_map **map_ptr);
1337extern int drm_addmap_ioctl(struct drm_device *dev, void *data,
1338 struct drm_file *file_priv);
1339extern int drm_rmmap(struct drm_device *dev, struct drm_local_map *map);
1340extern int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map);
1341extern int drm_rmmap_ioctl(struct drm_device *dev, void *data,
1342 struct drm_file *file_priv);
1343extern int drm_addbufs(struct drm_device *dev, void *data,
1344 struct drm_file *file_priv);
1345extern int drm_infobufs(struct drm_device *dev, void *data,
1346 struct drm_file *file_priv);
1347extern int drm_markbufs(struct drm_device *dev, void *data,
1348 struct drm_file *file_priv);
1349extern int drm_freebufs(struct drm_device *dev, void *data,
1350 struct drm_file *file_priv);
1351extern int drm_mapbufs(struct drm_device *dev, void *data,
1352 struct drm_file *file_priv);
1353extern int drm_dma_ioctl(struct drm_device *dev, void *data,
1354 struct drm_file *file_priv);
1355
1356
1357extern int drm_legacy_dma_setup(struct drm_device *dev);
1358extern void drm_legacy_dma_takedown(struct drm_device *dev);
1359extern void drm_free_buffer(struct drm_device *dev, struct drm_buf * buf);
1360extern void drm_core_reclaim_buffers(struct drm_device *dev,
1361 struct drm_file *filp);
1362
1363
1364extern int drm_control(struct drm_device *dev, void *data,
1365 struct drm_file *file_priv);
1366extern int drm_irq_install(struct drm_device *dev);
1367extern int drm_irq_uninstall(struct drm_device *dev);
1368
1369extern int drm_vblank_init(struct drm_device *dev, int num_crtcs);
1370extern int drm_wait_vblank(struct drm_device *dev, void *data,
1371 struct drm_file *filp);
1372extern u32 drm_vblank_count(struct drm_device *dev, int crtc);
1373extern u32 drm_vblank_count_and_time(struct drm_device *dev, int crtc,
1374 struct timeval *vblanktime);
1375extern void drm_send_vblank_event(struct drm_device *dev, int crtc,
1376 struct drm_pending_vblank_event *e);
1377extern bool drm_handle_vblank(struct drm_device *dev, int crtc);
1378extern int drm_vblank_get(struct drm_device *dev, int crtc);
1379extern void drm_vblank_put(struct drm_device *dev, int crtc);
1380extern void drm_vblank_off(struct drm_device *dev, int crtc);
1381extern void drm_vblank_cleanup(struct drm_device *dev);
1382extern u32 drm_get_last_vbltimestamp(struct drm_device *dev, int crtc,
1383 struct timeval *tvblank, unsigned flags);
1384extern int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev,
1385 int crtc, int *max_error,
1386 struct timeval *vblank_time,
1387 unsigned flags,
1388 const struct drm_crtc *refcrtc,
1389 const struct drm_display_mode *mode);
1390extern void drm_calc_timestamping_constants(struct drm_crtc *crtc,
1391 const struct drm_display_mode *mode);
1392
1393
1394
1395extern void drm_vblank_pre_modeset(struct drm_device *dev, int crtc);
1396extern void drm_vblank_post_modeset(struct drm_device *dev, int crtc);
1397extern int drm_modeset_ctl(struct drm_device *dev, void *data,
1398 struct drm_file *file_priv);
1399
1400
1401
1402#include <drm/drm_agpsupport.h>
1403
1404
1405extern int drm_setmaster_ioctl(struct drm_device *dev, void *data,
1406 struct drm_file *file_priv);
1407extern int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
1408 struct drm_file *file_priv);
1409struct drm_master *drm_master_create(struct drm_minor *minor);
1410extern struct drm_master *drm_master_get(struct drm_master *master);
1411extern void drm_master_put(struct drm_master **master);
1412
1413extern void drm_put_dev(struct drm_device *dev);
1414extern void drm_unplug_dev(struct drm_device *dev);
1415extern unsigned int drm_debug;
1416extern unsigned int drm_rnodes;
1417extern unsigned int drm_universal_planes;
1418
1419extern unsigned int drm_vblank_offdelay;
1420extern unsigned int drm_timestamp_precision;
1421extern unsigned int drm_timestamp_monotonic;
1422
1423extern struct class *drm_class;
1424extern struct dentry *drm_debugfs_root;
1425
1426extern struct idr drm_minors_idr;
1427
1428extern struct drm_local_map *drm_getsarea(struct drm_device *dev);
1429
1430
1431#if defined(CONFIG_DEBUG_FS)
1432extern int drm_debugfs_init(struct drm_minor *minor, int minor_id,
1433 struct dentry *root);
1434extern int drm_debugfs_create_files(const struct drm_info_list *files,
1435 int count, struct dentry *root,
1436 struct drm_minor *minor);
1437extern int drm_debugfs_remove_files(const struct drm_info_list *files,
1438 int count, struct drm_minor *minor);
1439extern int drm_debugfs_cleanup(struct drm_minor *minor);
1440#else
1441static inline int drm_debugfs_init(struct drm_minor *minor, int minor_id,
1442 struct dentry *root)
1443{
1444 return 0;
1445}
1446
1447static inline int drm_debugfs_create_files(const struct drm_info_list *files,
1448 int count, struct dentry *root,
1449 struct drm_minor *minor)
1450{
1451 return 0;
1452}
1453
1454static inline int drm_debugfs_remove_files(const struct drm_info_list *files,
1455 int count, struct drm_minor *minor)
1456{
1457 return 0;
1458}
1459
1460static inline int drm_debugfs_cleanup(struct drm_minor *minor)
1461{
1462 return 0;
1463}
1464#endif
1465
1466
1467extern int drm_name_info(struct seq_file *m, void *data);
1468extern int drm_vm_info(struct seq_file *m, void *data);
1469extern int drm_bufs_info(struct seq_file *m, void *data);
1470extern int drm_vblank_info(struct seq_file *m, void *data);
1471extern int drm_clients_info(struct seq_file *m, void* data);
1472extern int drm_gem_name_info(struct seq_file *m, void *data);
1473
1474
1475extern struct dma_buf *drm_gem_prime_export(struct drm_device *dev,
1476 struct drm_gem_object *obj, int flags);
1477extern int drm_gem_prime_handle_to_fd(struct drm_device *dev,
1478 struct drm_file *file_priv, uint32_t handle, uint32_t flags,
1479 int *prime_fd);
1480extern struct drm_gem_object *drm_gem_prime_import(struct drm_device *dev,
1481 struct dma_buf *dma_buf);
1482extern int drm_gem_prime_fd_to_handle(struct drm_device *dev,
1483 struct drm_file *file_priv, int prime_fd, uint32_t *handle);
1484extern void drm_gem_dmabuf_release(struct dma_buf *dma_buf);
1485
1486extern int drm_prime_handle_to_fd_ioctl(struct drm_device *dev, void *data,
1487 struct drm_file *file_priv);
1488extern int drm_prime_fd_to_handle_ioctl(struct drm_device *dev, void *data,
1489 struct drm_file *file_priv);
1490
1491extern int drm_prime_sg_to_page_addr_arrays(struct sg_table *sgt, struct page **pages,
1492 dma_addr_t *addrs, int max_pages);
1493extern struct sg_table *drm_prime_pages_to_sg(struct page **pages, int nr_pages);
1494extern void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg);
1495
1496int drm_gem_dumb_destroy(struct drm_file *file,
1497 struct drm_device *dev,
1498 uint32_t handle);
1499
1500void drm_prime_init_file_private(struct drm_prime_file_private *prime_fpriv);
1501void drm_prime_destroy_file_private(struct drm_prime_file_private *prime_fpriv);
1502void drm_prime_remove_buf_handle_locked(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf);
1503
1504#if DRM_DEBUG_CODE
1505extern int drm_vma_info(struct seq_file *m, void *data);
1506#endif
1507
1508
1509extern void drm_legacy_sg_cleanup(struct drm_device *dev);
1510extern int drm_sg_alloc(struct drm_device *dev, void *data,
1511 struct drm_file *file_priv);
1512extern int drm_sg_free(struct drm_device *dev, void *data,
1513 struct drm_file *file_priv);
1514
1515
1516extern int drm_ati_pcigart_init(struct drm_device *dev,
1517 struct drm_ati_pcigart_info * gart_info);
1518extern int drm_ati_pcigart_cleanup(struct drm_device *dev,
1519 struct drm_ati_pcigart_info * gart_info);
1520
1521extern drm_dma_handle_t *drm_pci_alloc(struct drm_device *dev, size_t size,
1522 size_t align);
1523extern void __drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
1524extern void drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
1525
1526
1527struct drm_sysfs_class;
1528extern struct class *drm_sysfs_create(struct module *owner, char *name);
1529extern void drm_sysfs_destroy(void);
1530extern int drm_sysfs_device_add(struct drm_minor *minor);
1531extern void drm_sysfs_hotplug_event(struct drm_device *dev);
1532extern void drm_sysfs_device_remove(struct drm_minor *minor);
1533extern int drm_sysfs_connector_add(struct drm_connector *connector);
1534extern void drm_sysfs_connector_remove(struct drm_connector *connector);
1535
1536
1537int drm_gem_init(struct drm_device *dev);
1538void drm_gem_destroy(struct drm_device *dev);
1539void drm_gem_object_release(struct drm_gem_object *obj);
1540void drm_gem_object_free(struct kref *kref);
1541int drm_gem_object_init(struct drm_device *dev,
1542 struct drm_gem_object *obj, size_t size);
1543void drm_gem_private_object_init(struct drm_device *dev,
1544 struct drm_gem_object *obj, size_t size);
1545void drm_gem_vm_open(struct vm_area_struct *vma);
1546void drm_gem_vm_close(struct vm_area_struct *vma);
1547int drm_gem_mmap_obj(struct drm_gem_object *obj, unsigned long obj_size,
1548 struct vm_area_struct *vma);
1549int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma);
1550
1551#include <drm/drm_global.h>
1552
1553static inline void
1554drm_gem_object_reference(struct drm_gem_object *obj)
1555{
1556 kref_get(&obj->refcount);
1557}
1558
1559static inline void
1560drm_gem_object_unreference(struct drm_gem_object *obj)
1561{
1562 if (obj != NULL)
1563 kref_put(&obj->refcount, drm_gem_object_free);
1564}
1565
1566static inline void
1567drm_gem_object_unreference_unlocked(struct drm_gem_object *obj)
1568{
1569 if (obj && !atomic_add_unless(&obj->refcount.refcount, -1, 1)) {
1570 struct drm_device *dev = obj->dev;
1571
1572 mutex_lock(&dev->struct_mutex);
1573 if (likely(atomic_dec_and_test(&obj->refcount.refcount)))
1574 drm_gem_object_free(&obj->refcount);
1575 mutex_unlock(&dev->struct_mutex);
1576 }
1577}
1578
1579int drm_gem_handle_create_tail(struct drm_file *file_priv,
1580 struct drm_gem_object *obj,
1581 u32 *handlep);
1582int drm_gem_handle_create(struct drm_file *file_priv,
1583 struct drm_gem_object *obj,
1584 u32 *handlep);
1585int drm_gem_handle_delete(struct drm_file *filp, u32 handle);
1586
1587
1588void drm_gem_free_mmap_offset(struct drm_gem_object *obj);
1589int drm_gem_create_mmap_offset(struct drm_gem_object *obj);
1590int drm_gem_create_mmap_offset_size(struct drm_gem_object *obj, size_t size);
1591
1592struct page **drm_gem_get_pages(struct drm_gem_object *obj, gfp_t gfpmask);
1593void drm_gem_put_pages(struct drm_gem_object *obj, struct page **pages,
1594 bool dirty, bool accessed);
1595
1596struct drm_gem_object *drm_gem_object_lookup(struct drm_device *dev,
1597 struct drm_file *filp,
1598 u32 handle);
1599int drm_gem_close_ioctl(struct drm_device *dev, void *data,
1600 struct drm_file *file_priv);
1601int drm_gem_flink_ioctl(struct drm_device *dev, void *data,
1602 struct drm_file *file_priv);
1603int drm_gem_open_ioctl(struct drm_device *dev, void *data,
1604 struct drm_file *file_priv);
1605void drm_gem_open(struct drm_device *dev, struct drm_file *file_private);
1606void drm_gem_release(struct drm_device *dev, struct drm_file *file_private);
1607
1608extern void drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev);
1609extern void drm_core_ioremap_wc(struct drm_local_map *map, struct drm_device *dev);
1610extern void drm_core_ioremapfree(struct drm_local_map *map, struct drm_device *dev);
1611
1612static __inline__ struct drm_local_map *drm_core_findmap(struct drm_device *dev,
1613 unsigned int token)
1614{
1615 struct drm_map_list *_entry;
1616 list_for_each_entry(_entry, &dev->maplist, head)
1617 if (_entry->user_token == token)
1618 return _entry->map;
1619 return NULL;
1620}
1621
1622static __inline__ void drm_core_dropmap(struct drm_local_map *map)
1623{
1624}
1625
1626#include <drm/drm_mem_util.h>
1627
1628struct drm_device *drm_dev_alloc(struct drm_driver *driver,
1629 struct device *parent);
1630void drm_dev_ref(struct drm_device *dev);
1631void drm_dev_unref(struct drm_device *dev);
1632int drm_dev_register(struct drm_device *dev, unsigned long flags);
1633void drm_dev_unregister(struct drm_device *dev);
1634
1635struct drm_minor *drm_minor_acquire(unsigned int minor_id);
1636void drm_minor_release(struct drm_minor *minor);
1637
1638
1639
1640
1641static __inline__ int drm_pci_device_is_agp(struct drm_device *dev)
1642{
1643 if (dev->driver->device_is_agp != NULL) {
1644 int err = (*dev->driver->device_is_agp) (dev);
1645
1646 if (err != 2) {
1647 return err;
1648 }
1649 }
1650
1651 return pci_find_capability(dev->pdev, PCI_CAP_ID_AGP);
1652}
1653void drm_pci_agp_destroy(struct drm_device *dev);
1654
1655extern int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver);
1656extern void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver);
1657extern int drm_get_pci_dev(struct pci_dev *pdev,
1658 const struct pci_device_id *ent,
1659 struct drm_driver *driver);
1660
1661#define DRM_PCIE_SPEED_25 1
1662#define DRM_PCIE_SPEED_50 2
1663#define DRM_PCIE_SPEED_80 4
1664
1665extern int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *speed_mask);
1666
1667
1668extern int drm_platform_init(struct drm_driver *driver, struct platform_device *platform_device);
1669
1670
1671static __inline__ bool drm_can_sleep(void)
1672{
1673 if (in_atomic() || in_dbg_master() || irqs_disabled())
1674 return false;
1675 return true;
1676}
1677
1678#endif
1679#endif
1680