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