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