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