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