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#ifndef _DRM_P_H_
35#define _DRM_P_H_
36
37#ifdef __KERNEL__
38#ifdef __alpha__
39
40
41
42#include <asm/current.h>
43#endif
44#include <linux/module.h>
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/pci.h>
52#include <linux/jiffies.h>
53#include <linux/smp_lock.h>
54#include <linux/dma-mapping.h>
55#include <linux/mm.h>
56#include <linux/cdev.h>
57#include <linux/mutex.h>
58#if defined(__alpha__) || defined(__powerpc__)
59#include <asm/pgtable.h>
60#endif
61#include <asm/io.h>
62#include <asm/mman.h>
63#include <asm/uaccess.h>
64#ifdef CONFIG_MTRR
65#include <asm/mtrr.h>
66#endif
67#if defined(CONFIG_AGP) || defined(CONFIG_AGP_MODULE)
68#include <linux/types.h>
69#include <linux/agp_backend.h>
70#endif
71#include <linux/workqueue.h>
72#include <linux/poll.h>
73#include <asm/pgalloc.h>
74#include "drm.h"
75
76#include <linux/idr.h>
77
78#define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE)))
79#define __OS_HAS_MTRR (defined(CONFIG_MTRR))
80
81struct drm_file;
82struct drm_device;
83
84#include "drm_os_linux.h"
85#include "drm_hashtab.h"
86#include "drm_mm.h"
87
88#define DRM_UT_CORE 0x01
89#define DRM_UT_DRIVER 0x02
90#define DRM_UT_KMS 0x04
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123extern void drm_ut_debug_printk(unsigned int request_level,
124 const char *prefix,
125 const char *function_name,
126 const char *format, ...);
127
128
129
130
131
132#define DRIVER_USE_AGP 0x1
133#define DRIVER_REQUIRE_AGP 0x2
134#define DRIVER_USE_MTRR 0x4
135#define DRIVER_PCI_DMA 0x8
136#define DRIVER_SG 0x10
137#define DRIVER_HAVE_DMA 0x20
138#define DRIVER_HAVE_IRQ 0x40
139#define DRIVER_IRQ_SHARED 0x80
140#define DRIVER_IRQ_VBL 0x100
141#define DRIVER_DMA_QUEUE 0x200
142#define DRIVER_FB_DMA 0x400
143#define DRIVER_IRQ_VBL2 0x800
144#define DRIVER_GEM 0x1000
145#define DRIVER_MODESET 0x2000
146
147
148
149
150
151#define DRM_DEBUG_CODE 2
152
153
154#define DRM_MAGIC_HASH_ORDER 4
155#define DRM_KERNEL_CONTEXT 0
156#define DRM_RESERVED_CONTEXTS 1
157#define DRM_LOOPING_LIMIT 5000000
158#define DRM_TIME_SLICE (HZ/20)
159#define DRM_LOCK_SLICE 1
160
161#define DRM_FLAG_DEBUG 0x01
162
163#define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)
164#define DRM_MAP_HASH_OFFSET 0x10000000
165
166
167
168
169
170
171
172
173
174
175
176
177
178#define DRM_ERROR(fmt, arg...) \
179 printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* " fmt , __func__ , ##arg)
180
181
182
183
184
185
186
187
188#define DRM_MEM_ERROR(area, fmt, arg...) \
189 printk(KERN_ERR "[" DRM_NAME ":%s:%s] *ERROR* " fmt , __func__, \
190 drm_mem_stats[area].name , ##arg)
191
192#define DRM_INFO(fmt, arg...) printk(KERN_INFO "[" DRM_NAME "] " fmt , ##arg)
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#define DRM_PROC_LIMIT (PAGE_SIZE-80)
249
250#define DRM_PROC_PRINT(fmt, arg...) \
251 len += sprintf(&buf[len], fmt , ##arg); \
252 if (len > DRM_PROC_LIMIT) { *eof = 1; return len - offset; }
253
254#define DRM_PROC_PRINT_RET(ret, fmt, arg...) \
255 len += sprintf(&buf[len], fmt , ##arg); \
256 if (len > DRM_PROC_LIMIT) { ret; *eof = 1; return len - offset; }
257
258
259
260
261
262
263
264#define DRM_ARRAY_SIZE(x) ARRAY_SIZE(x)
265
266#define DRM_LEFTCOUNT(x) (((x)->rp + (x)->count - (x)->wp) % ((x)->count + 1))
267#define DRM_BUFCOUNT(x) ((x)->count - DRM_LEFTCOUNT(x))
268#define DRM_WAITCOUNT(dev,idx) DRM_BUFCOUNT(&dev->queuelist[idx]->waitlist)
269
270#define DRM_IF_VERSION(maj, min) (maj << 16 | min)
271
272
273
274
275
276
277
278#define DRM_GET_PRIV_SAREA(_dev, _ctx, _map) do { \
279 (_map) = (_dev)->context_sareas[_ctx]; \
280} while(0)
281
282
283
284
285
286
287
288#define LOCK_TEST_WITH_RETURN( dev, _file_priv ) \
289do { \
290 if (!_DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock) || \
291 _file_priv->master->lock.file_priv != _file_priv) { \
292 DRM_ERROR( "%s called without lock held, held %d owner %p %p\n",\
293 __func__, _DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock),\
294 _file_priv->master->lock.file_priv, _file_priv); \
295 return -EINVAL; \
296 } \
297} while (0)
298
299
300
301
302#define DRM_COPY( name, value ) \
303 len = strlen( value ); \
304 if ( len > name##_len ) len = name##_len; \
305 name##_len = strlen( value ); \
306 if ( len && name ) { \
307 if ( copy_to_user( name, value, len ) ) \
308 return -EFAULT; \
309 }
310
311
312
313
314
315
316
317
318
319typedef int drm_ioctl_t(struct drm_device *dev, void *data,
320 struct drm_file *file_priv);
321
322typedef int drm_ioctl_compat_t(struct file *filp, unsigned int cmd,
323 unsigned long arg);
324
325#define DRM_AUTH 0x1
326#define DRM_MASTER 0x2
327#define DRM_ROOT_ONLY 0x4
328#define DRM_CONTROL_ALLOW 0x8
329
330struct drm_ioctl_desc {
331 unsigned int cmd;
332 int flags;
333 drm_ioctl_t *func;
334};
335
336
337
338
339
340#define DRM_IOCTL_DEF(ioctl, _func, _flags) \
341 [DRM_IOCTL_NR(ioctl)] = {.cmd = ioctl, .func = _func, .flags = _flags}
342
343struct drm_magic_entry {
344 struct list_head head;
345 struct drm_hash_item hash_item;
346 struct drm_file *priv;
347};
348
349struct drm_vma_entry {
350 struct list_head head;
351 struct vm_area_struct *vma;
352 pid_t pid;
353};
354
355
356
357
358struct drm_buf {
359 int idx;
360 int total;
361 int order;
362 int used;
363 unsigned long offset;
364 void *address;
365 unsigned long bus_address;
366 struct drm_buf *next;
367 __volatile__ int waiting;
368 __volatile__ int pending;
369 wait_queue_head_t dma_wait;
370 struct drm_file *file_priv;
371 int context;
372 int while_locked;
373 enum {
374 DRM_LIST_NONE = 0,
375 DRM_LIST_FREE = 1,
376 DRM_LIST_WAIT = 2,
377 DRM_LIST_PEND = 3,
378 DRM_LIST_PRIO = 4,
379 DRM_LIST_RECLAIM = 5
380 } list;
381
382 int dev_priv_size;
383 void *dev_private;
384};
385
386
387struct drm_waitlist {
388 int count;
389 struct drm_buf **bufs;
390 struct drm_buf **rp;
391 struct drm_buf **wp;
392 struct drm_buf **end;
393 spinlock_t read_lock;
394 spinlock_t write_lock;
395};
396
397struct drm_freelist {
398 int initialized;
399 atomic_t count;
400 struct drm_buf *next;
401
402 wait_queue_head_t waiting;
403 int low_mark;
404 int high_mark;
405 atomic_t wfh;
406 spinlock_t lock;
407};
408
409typedef struct drm_dma_handle {
410 dma_addr_t busaddr;
411 void *vaddr;
412 size_t size;
413} drm_dma_handle_t;
414
415
416
417
418struct drm_buf_entry {
419 int buf_size;
420 int buf_count;
421 struct drm_buf *buflist;
422 int seg_count;
423 int page_order;
424 struct drm_dma_handle **seglist;
425
426 struct drm_freelist freelist;
427};
428
429
430struct drm_file {
431 int authenticated;
432 pid_t pid;
433 uid_t uid;
434 drm_magic_t magic;
435 unsigned long ioctl_count;
436 struct list_head lhead;
437 struct drm_minor *minor;
438 unsigned long lock_count;
439
440
441 struct idr object_idr;
442
443 spinlock_t table_lock;
444
445 struct file *filp;
446 void *driver_priv;
447
448 int is_master;
449 struct drm_master *master;
450
451 struct list_head fbs;
452};
453
454
455struct drm_queue {
456 atomic_t use_count;
457 atomic_t finalization;
458 atomic_t block_count;
459 atomic_t block_read;
460 wait_queue_head_t read_queue;
461 atomic_t block_write;
462 wait_queue_head_t write_queue;
463 atomic_t total_queued;
464 atomic_t total_flushed;
465 atomic_t total_locks;
466 enum drm_ctx_flags flags;
467 struct drm_waitlist waitlist;
468 wait_queue_head_t flush_queue;
469};
470
471
472
473
474struct drm_lock_data {
475 struct drm_hw_lock *hw_lock;
476
477 struct drm_file *file_priv;
478 wait_queue_head_t lock_queue;
479 unsigned long lock_time;
480 spinlock_t spinlock;
481 uint32_t kernel_waiters;
482 uint32_t user_waiters;
483 int idle_has_lock;
484};
485
486
487
488
489struct drm_device_dma {
490
491 struct drm_buf_entry bufs[DRM_MAX_ORDER + 1];
492 int buf_count;
493 struct drm_buf **buflist;
494 int seg_count;
495 int page_count;
496 unsigned long *pagelist;
497 unsigned long byte_count;
498 enum {
499 _DRM_DMA_USE_AGP = 0x01,
500 _DRM_DMA_USE_SG = 0x02,
501 _DRM_DMA_USE_FB = 0x04,
502 _DRM_DMA_USE_PCI_RO = 0x08
503 } flags;
504
505};
506
507
508
509
510struct drm_agp_mem {
511 unsigned long handle;
512 DRM_AGP_MEM *memory;
513 unsigned long bound;
514 int pages;
515 struct list_head head;
516};
517
518
519
520
521
522
523struct drm_agp_head {
524 DRM_AGP_KERN agp_info;
525 struct list_head memory;
526 unsigned long mode;
527 struct agp_bridge_data *bridge;
528 int enabled;
529 int acquired;
530 unsigned long base;
531 int agp_mtrr;
532 int cant_use_aperture;
533 unsigned long page_mask;
534};
535
536
537
538
539struct drm_sg_mem {
540 unsigned long handle;
541 void *virtual;
542 int pages;
543 struct page **pagelist;
544 dma_addr_t *busaddr;
545};
546
547struct drm_sigdata {
548 int context;
549 struct drm_hw_lock *lock;
550};
551
552
553
554
555
556struct drm_local_map {
557 resource_size_t offset;
558 unsigned long size;
559 enum drm_map_type type;
560 enum drm_map_flags flags;
561 void *handle;
562
563 int mtrr;
564};
565
566typedef struct drm_local_map drm_local_map_t;
567
568
569
570
571struct drm_map_list {
572 struct list_head head;
573 struct drm_hash_item hash;
574 struct drm_local_map *map;
575 uint64_t user_token;
576 struct drm_master *master;
577 struct drm_mm_node *file_offset_node;
578};
579
580
581
582
583struct drm_ctx_list {
584 struct list_head head;
585 drm_context_t handle;
586 struct drm_file *tag;
587};
588
589
590#define DRM_ATI_GART_MAIN 1
591#define DRM_ATI_GART_FB 2
592
593#define DRM_ATI_GART_PCI 1
594#define DRM_ATI_GART_PCIE 2
595#define DRM_ATI_GART_IGP 3
596
597struct drm_ati_pcigart_info {
598 int gart_table_location;
599 int gart_reg_if;
600 void *addr;
601 dma_addr_t bus_addr;
602 dma_addr_t table_mask;
603 struct drm_dma_handle *table_handle;
604 struct drm_local_map mapping;
605 int table_size;
606};
607
608
609
610
611struct drm_gem_mm {
612 struct drm_mm offset_manager;
613 struct drm_open_hash offset_hash;
614};
615
616
617
618
619
620struct drm_gem_object {
621
622 struct kref refcount;
623
624
625 struct kref handlecount;
626
627
628 struct drm_device *dev;
629
630
631 struct file *filp;
632
633
634 struct drm_map_list map_list;
635
636
637
638
639
640 size_t size;
641
642
643
644
645
646 int name;
647
648
649
650
651
652
653
654 uint32_t read_domains;
655 uint32_t write_domain;
656
657
658
659
660
661
662
663 uint32_t pending_read_domains;
664 uint32_t pending_write_domain;
665
666 void *driver_private;
667};
668
669#include "drm_crtc.h"
670
671
672struct drm_master {
673
674 struct kref refcount;
675
676 struct list_head head;
677 struct drm_minor *minor;
678
679 char *unique;
680 int unique_len;
681 int unique_size;
682
683 int blocked;
684
685
686
687 struct drm_open_hash magiclist;
688 struct list_head magicfree;
689
690
691 struct drm_lock_data lock;
692
693 void *driver_priv;
694};
695
696
697
698
699
700
701struct drm_driver {
702 int (*load) (struct drm_device *, unsigned long flags);
703 int (*firstopen) (struct drm_device *);
704 int (*open) (struct drm_device *, struct drm_file *);
705 void (*preclose) (struct drm_device *, struct drm_file *file_priv);
706 void (*postclose) (struct drm_device *, struct drm_file *);
707 void (*lastclose) (struct drm_device *);
708 int (*unload) (struct drm_device *);
709 int (*suspend) (struct drm_device *, pm_message_t state);
710 int (*resume) (struct drm_device *);
711 int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
712 void (*dma_ready) (struct drm_device *);
713 int (*dma_quiescent) (struct drm_device *);
714 int (*context_ctor) (struct drm_device *dev, int context);
715 int (*context_dtor) (struct drm_device *dev, int context);
716 int (*kernel_context_switch) (struct drm_device *dev, int old,
717 int new);
718 void (*kernel_context_switch_unlock) (struct drm_device *dev);
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 irqreturn_t(*irq_handler) (DRM_IRQ_ARGS);
781 void (*irq_preinstall) (struct drm_device *dev);
782 int (*irq_postinstall) (struct drm_device *dev);
783 void (*irq_uninstall) (struct drm_device *dev);
784 void (*reclaim_buffers) (struct drm_device *dev,
785 struct drm_file * file_priv);
786 void (*reclaim_buffers_locked) (struct drm_device *dev,
787 struct drm_file *file_priv);
788 void (*reclaim_buffers_idlelocked) (struct drm_device *dev,
789 struct drm_file *file_priv);
790 resource_size_t (*get_map_ofs) (struct drm_local_map * map);
791 resource_size_t (*get_reg_ofs) (struct drm_device *dev);
792 void (*set_version) (struct drm_device *dev,
793 struct drm_set_version *sv);
794
795
796 int (*master_create)(struct drm_device *dev, struct drm_master *master);
797 void (*master_destroy)(struct drm_device *dev, struct drm_master *master);
798
799 int (*proc_init)(struct drm_minor *minor);
800 void (*proc_cleanup)(struct drm_minor *minor);
801 int (*debugfs_init)(struct drm_minor *minor);
802 void (*debugfs_cleanup)(struct drm_minor *minor);
803
804
805
806
807
808
809
810 int (*gem_init_object) (struct drm_gem_object *obj);
811 void (*gem_free_object) (struct drm_gem_object *obj);
812
813
814 void (*vgaarb_irq)(struct drm_device *dev, bool state);
815
816
817 struct vm_operations_struct *gem_vm_ops;
818
819 int major;
820 int minor;
821 int patchlevel;
822 char *name;
823 char *desc;
824 char *date;
825
826 u32 driver_features;
827 int dev_priv_size;
828 struct drm_ioctl_desc *ioctls;
829 int num_ioctls;
830 struct file_operations fops;
831 struct pci_driver pci_driver;
832
833 struct list_head device_list;
834};
835
836#define DRM_MINOR_UNASSIGNED 0
837#define DRM_MINOR_LEGACY 1
838#define DRM_MINOR_CONTROL 2
839#define DRM_MINOR_RENDER 3
840
841
842
843
844
845
846struct drm_debugfs_list {
847 const char *name;
848 int (*show)(struct seq_file*, void*);
849 u32 driver_features;
850};
851
852
853
854
855struct drm_debugfs_node {
856 struct list_head list;
857 struct drm_minor *minor;
858 struct drm_debugfs_list *debugfs_ent;
859 struct dentry *dent;
860};
861
862
863
864
865
866struct drm_info_list {
867 const char *name;
868 int (*show)(struct seq_file*, void*);
869 u32 driver_features;
870 void *data;
871};
872
873
874
875
876struct drm_info_node {
877 struct list_head list;
878 struct drm_minor *minor;
879 struct drm_info_list *info_ent;
880 struct dentry *dent;
881};
882
883
884
885
886struct drm_minor {
887 int index;
888 int type;
889 dev_t device;
890 struct device kdev;
891 struct drm_device *dev;
892
893 struct proc_dir_entry *proc_root;
894 struct drm_info_node proc_nodes;
895 struct dentry *debugfs_root;
896 struct drm_info_node debugfs_nodes;
897
898 struct drm_master *master;
899 struct list_head master_list;
900 struct drm_mode_group mode_group;
901};
902
903
904
905
906
907struct drm_device {
908 struct list_head driver_item;
909 char *devname;
910 int if_version;
911
912
913
914 spinlock_t count_lock;
915 struct mutex struct_mutex;
916
917
918
919
920 int open_count;
921 atomic_t ioctl_count;
922 atomic_t vma_count;
923 int buf_use;
924 atomic_t buf_alloc;
925
926
927
928
929 unsigned long counters;
930 enum drm_stat_type types[15];
931 atomic_t counts[15];
932
933
934 struct list_head filelist;
935
936
937
938 struct list_head maplist;
939 int map_count;
940 struct drm_open_hash map_hash;
941
942
943
944 struct list_head ctxlist;
945 int ctx_count;
946 struct mutex ctxlist_mutex;
947
948 struct idr ctx_idr;
949
950 struct list_head vmalist;
951
952
953
954
955
956 int queue_count;
957 int queue_reserved;
958 int queue_slots;
959 struct drm_queue **queuelist;
960 struct drm_device_dma *dma;
961
962
963
964
965 int irq_enabled;
966 __volatile__ long context_flag;
967 __volatile__ long interrupt_flag;
968 __volatile__ long dma_flag;
969 struct timer_list timer;
970 wait_queue_head_t context_wait;
971 int last_checked;
972 int last_context;
973 unsigned long last_switch;
974
975
976 struct work_struct work;
977
978
979
980
981
982
983
984
985
986 int vblank_disable_allowed;
987
988 wait_queue_head_t *vbl_queue;
989 atomic_t *_vblank_count;
990 spinlock_t vbl_lock;
991 atomic_t *vblank_refcount;
992 u32 *last_vblank;
993
994 int *vblank_enabled;
995
996 int *vblank_inmodeset;
997 u32 *last_vblank_wait;
998 struct timer_list vblank_disable_timer;
999
1000 u32 max_vblank_count;
1001
1002
1003 cycles_t ctx_start;
1004 cycles_t lck_start;
1005
1006 struct fasync_struct *buf_async;
1007 wait_queue_head_t buf_readers;
1008 wait_queue_head_t buf_writers;
1009
1010 struct drm_agp_head *agp;
1011
1012 struct pci_dev *pdev;
1013 int pci_vendor;
1014 int pci_device;
1015#ifdef __alpha__
1016 struct pci_controller *hose;
1017#endif
1018 struct drm_sg_mem *sg;
1019 int num_crtcs;
1020 void *dev_private;
1021 void *mm_private;
1022 struct address_space *dev_mapping;
1023 struct drm_sigdata sigdata;
1024 sigset_t sigmask;
1025
1026 struct drm_driver *driver;
1027 struct drm_local_map *agp_buffer_map;
1028 unsigned int agp_buffer_token;
1029 struct drm_minor *control;
1030 struct drm_minor *primary;
1031
1032
1033
1034 spinlock_t drw_lock;
1035 struct idr drw_idr;
1036
1037
1038 struct drm_mode_config mode_config;
1039
1040
1041
1042 spinlock_t object_name_lock;
1043 struct idr object_name_idr;
1044 atomic_t object_count;
1045 atomic_t object_memory;
1046 atomic_t pin_count;
1047 atomic_t pin_memory;
1048 atomic_t gtt_count;
1049 atomic_t gtt_memory;
1050 uint32_t gtt_total;
1051 uint32_t invalidate_domains;
1052 uint32_t flush_domains;
1053
1054
1055};
1056
1057static inline int drm_dev_to_irq(struct drm_device *dev)
1058{
1059 return dev->pdev->irq;
1060}
1061
1062static __inline__ int drm_core_check_feature(struct drm_device *dev,
1063 int feature)
1064{
1065 return ((dev->driver->driver_features & feature) ? 1 : 0);
1066}
1067
1068#ifdef __alpha__
1069#define drm_get_pci_domain(dev) dev->hose->index
1070#else
1071#define drm_get_pci_domain(dev) 0
1072#endif
1073
1074#if __OS_HAS_AGP
1075static inline int drm_core_has_AGP(struct drm_device *dev)
1076{
1077 return drm_core_check_feature(dev, DRIVER_USE_AGP);
1078}
1079#else
1080#define drm_core_has_AGP(dev) (0)
1081#endif
1082
1083#if __OS_HAS_MTRR
1084static inline int drm_core_has_MTRR(struct drm_device *dev)
1085{
1086 return drm_core_check_feature(dev, DRIVER_USE_MTRR);
1087}
1088
1089#define DRM_MTRR_WC MTRR_TYPE_WRCOMB
1090
1091static inline int drm_mtrr_add(unsigned long offset, unsigned long size,
1092 unsigned int flags)
1093{
1094 return mtrr_add(offset, size, flags, 1);
1095}
1096
1097static inline int drm_mtrr_del(int handle, unsigned long offset,
1098 unsigned long size, unsigned int flags)
1099{
1100 return mtrr_del(handle, offset, size);
1101}
1102
1103#else
1104#define drm_core_has_MTRR(dev) (0)
1105
1106#define DRM_MTRR_WC 0
1107
1108static inline int drm_mtrr_add(unsigned long offset, unsigned long size,
1109 unsigned int flags)
1110{
1111 return 0;
1112}
1113
1114static inline int drm_mtrr_del(int handle, unsigned long offset,
1115 unsigned long size, unsigned int flags)
1116{
1117 return 0;
1118}
1119#endif
1120
1121
1122
1123
1124
1125
1126extern int drm_init(struct drm_driver *driver);
1127extern void drm_exit(struct drm_driver *driver);
1128extern int drm_ioctl(struct inode *inode, struct file *filp,
1129 unsigned int cmd, unsigned long arg);
1130extern long drm_compat_ioctl(struct file *filp,
1131 unsigned int cmd, unsigned long arg);
1132extern int drm_lastclose(struct drm_device *dev);
1133
1134
1135extern int drm_open(struct inode *inode, struct file *filp);
1136extern int drm_stub_open(struct inode *inode, struct file *filp);
1137extern int drm_fasync(int fd, struct file *filp, int on);
1138extern int drm_release(struct inode *inode, struct file *filp);
1139
1140
1141extern int drm_mmap(struct file *filp, struct vm_area_struct *vma);
1142extern int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma);
1143extern void drm_vm_open_locked(struct vm_area_struct *vma);
1144extern resource_size_t drm_core_get_map_ofs(struct drm_local_map * map);
1145extern resource_size_t drm_core_get_reg_ofs(struct drm_device *dev);
1146extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait);
1147
1148
1149#include "drm_memory.h"
1150extern void drm_mem_init(void);
1151extern int drm_mem_info(char *buf, char **start, off_t offset,
1152 int request, int *eof, void *data);
1153extern void *drm_realloc(void *oldpt, size_t oldsize, size_t size, int area);
1154
1155extern DRM_AGP_MEM *drm_alloc_agp(struct drm_device *dev, int pages, u32 type);
1156extern int drm_free_agp(DRM_AGP_MEM * handle, int pages);
1157extern int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start);
1158extern DRM_AGP_MEM *drm_agp_bind_pages(struct drm_device *dev,
1159 struct page **pages,
1160 unsigned long num_pages,
1161 uint32_t gtt_offset,
1162 uint32_t type);
1163extern int drm_unbind_agp(DRM_AGP_MEM * handle);
1164
1165
1166extern int drm_irq_by_busid(struct drm_device *dev, void *data,
1167 struct drm_file *file_priv);
1168extern int drm_getunique(struct drm_device *dev, void *data,
1169 struct drm_file *file_priv);
1170extern int drm_setunique(struct drm_device *dev, void *data,
1171 struct drm_file *file_priv);
1172extern int drm_getmap(struct drm_device *dev, void *data,
1173 struct drm_file *file_priv);
1174extern int drm_getclient(struct drm_device *dev, void *data,
1175 struct drm_file *file_priv);
1176extern int drm_getstats(struct drm_device *dev, void *data,
1177 struct drm_file *file_priv);
1178extern int drm_setversion(struct drm_device *dev, void *data,
1179 struct drm_file *file_priv);
1180extern int drm_noop(struct drm_device *dev, void *data,
1181 struct drm_file *file_priv);
1182
1183
1184extern int drm_resctx(struct drm_device *dev, void *data,
1185 struct drm_file *file_priv);
1186extern int drm_addctx(struct drm_device *dev, void *data,
1187 struct drm_file *file_priv);
1188extern int drm_modctx(struct drm_device *dev, void *data,
1189 struct drm_file *file_priv);
1190extern int drm_getctx(struct drm_device *dev, void *data,
1191 struct drm_file *file_priv);
1192extern int drm_switchctx(struct drm_device *dev, void *data,
1193 struct drm_file *file_priv);
1194extern int drm_newctx(struct drm_device *dev, void *data,
1195 struct drm_file *file_priv);
1196extern int drm_rmctx(struct drm_device *dev, void *data,
1197 struct drm_file *file_priv);
1198
1199extern int drm_ctxbitmap_init(struct drm_device *dev);
1200extern void drm_ctxbitmap_cleanup(struct drm_device *dev);
1201extern void drm_ctxbitmap_free(struct drm_device *dev, int ctx_handle);
1202
1203extern int drm_setsareactx(struct drm_device *dev, void *data,
1204 struct drm_file *file_priv);
1205extern int drm_getsareactx(struct drm_device *dev, void *data,
1206 struct drm_file *file_priv);
1207
1208
1209extern int drm_adddraw(struct drm_device *dev, void *data,
1210 struct drm_file *file_priv);
1211extern int drm_rmdraw(struct drm_device *dev, void *data,
1212 struct drm_file *file_priv);
1213extern int drm_update_drawable_info(struct drm_device *dev, void *data,
1214 struct drm_file *file_priv);
1215extern struct drm_drawable_info *drm_get_drawable_info(struct drm_device *dev,
1216 drm_drawable_t id);
1217extern void drm_drawable_free_all(struct drm_device *dev);
1218
1219
1220extern int drm_getmagic(struct drm_device *dev, void *data,
1221 struct drm_file *file_priv);
1222extern int drm_authmagic(struct drm_device *dev, void *data,
1223 struct drm_file *file_priv);
1224
1225
1226void drm_clflush_pages(struct page *pages[], unsigned long num_pages);
1227
1228
1229extern int drm_lock(struct drm_device *dev, void *data,
1230 struct drm_file *file_priv);
1231extern int drm_unlock(struct drm_device *dev, void *data,
1232 struct drm_file *file_priv);
1233extern int drm_lock_take(struct drm_lock_data *lock_data, unsigned int context);
1234extern int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context);
1235extern void drm_idlelock_take(struct drm_lock_data *lock_data);
1236extern void drm_idlelock_release(struct drm_lock_data *lock_data);
1237
1238
1239
1240
1241
1242
1243extern int drm_i_have_hw_lock(struct drm_device *dev, struct drm_file *file_priv);
1244
1245
1246extern int drm_addbufs_agp(struct drm_device *dev, struct drm_buf_desc * request);
1247extern int drm_addbufs_pci(struct drm_device *dev, struct drm_buf_desc * request);
1248extern int drm_addmap(struct drm_device *dev, resource_size_t offset,
1249 unsigned int size, enum drm_map_type type,
1250 enum drm_map_flags flags, struct drm_local_map **map_ptr);
1251extern int drm_addmap_ioctl(struct drm_device *dev, void *data,
1252 struct drm_file *file_priv);
1253extern int drm_rmmap(struct drm_device *dev, struct drm_local_map *map);
1254extern int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map);
1255extern int drm_rmmap_ioctl(struct drm_device *dev, void *data,
1256 struct drm_file *file_priv);
1257extern int drm_addbufs(struct drm_device *dev, void *data,
1258 struct drm_file *file_priv);
1259extern int drm_infobufs(struct drm_device *dev, void *data,
1260 struct drm_file *file_priv);
1261extern int drm_markbufs(struct drm_device *dev, void *data,
1262 struct drm_file *file_priv);
1263extern int drm_freebufs(struct drm_device *dev, void *data,
1264 struct drm_file *file_priv);
1265extern int drm_mapbufs(struct drm_device *dev, void *data,
1266 struct drm_file *file_priv);
1267extern int drm_order(unsigned long size);
1268extern resource_size_t drm_get_resource_start(struct drm_device *dev,
1269 unsigned int resource);
1270extern resource_size_t drm_get_resource_len(struct drm_device *dev,
1271 unsigned int resource);
1272
1273
1274extern int drm_dma_setup(struct drm_device *dev);
1275extern void drm_dma_takedown(struct drm_device *dev);
1276extern void drm_free_buffer(struct drm_device *dev, struct drm_buf * buf);
1277extern void drm_core_reclaim_buffers(struct drm_device *dev,
1278 struct drm_file *filp);
1279
1280
1281extern int drm_control(struct drm_device *dev, void *data,
1282 struct drm_file *file_priv);
1283extern irqreturn_t drm_irq_handler(DRM_IRQ_ARGS);
1284extern int drm_irq_install(struct drm_device *dev);
1285extern int drm_irq_uninstall(struct drm_device *dev);
1286extern void drm_driver_irq_preinstall(struct drm_device *dev);
1287extern void drm_driver_irq_postinstall(struct drm_device *dev);
1288extern void drm_driver_irq_uninstall(struct drm_device *dev);
1289
1290extern int drm_vblank_init(struct drm_device *dev, int num_crtcs);
1291extern int drm_wait_vblank(struct drm_device *dev, void *data,
1292 struct drm_file *filp);
1293extern int drm_vblank_wait(struct drm_device *dev, unsigned int *vbl_seq);
1294extern u32 drm_vblank_count(struct drm_device *dev, int crtc);
1295extern void drm_handle_vblank(struct drm_device *dev, int crtc);
1296extern int drm_vblank_get(struct drm_device *dev, int crtc);
1297extern void drm_vblank_put(struct drm_device *dev, int crtc);
1298extern void drm_vblank_cleanup(struct drm_device *dev);
1299
1300extern void drm_vblank_pre_modeset(struct drm_device *dev, int crtc);
1301extern void drm_vblank_post_modeset(struct drm_device *dev, int crtc);
1302extern int drm_modeset_ctl(struct drm_device *dev, void *data,
1303 struct drm_file *file_priv);
1304
1305
1306extern struct drm_agp_head *drm_agp_init(struct drm_device *dev);
1307extern int drm_agp_acquire(struct drm_device *dev);
1308extern int drm_agp_acquire_ioctl(struct drm_device *dev, void *data,
1309 struct drm_file *file_priv);
1310extern int drm_agp_release(struct drm_device *dev);
1311extern int drm_agp_release_ioctl(struct drm_device *dev, void *data,
1312 struct drm_file *file_priv);
1313extern int drm_agp_enable(struct drm_device *dev, struct drm_agp_mode mode);
1314extern int drm_agp_enable_ioctl(struct drm_device *dev, void *data,
1315 struct drm_file *file_priv);
1316extern int drm_agp_info(struct drm_device *dev, struct drm_agp_info *info);
1317extern int drm_agp_info_ioctl(struct drm_device *dev, void *data,
1318 struct drm_file *file_priv);
1319extern int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request);
1320extern int drm_agp_alloc_ioctl(struct drm_device *dev, void *data,
1321 struct drm_file *file_priv);
1322extern int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request);
1323extern int drm_agp_free_ioctl(struct drm_device *dev, void *data,
1324 struct drm_file *file_priv);
1325extern int drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request);
1326extern int drm_agp_unbind_ioctl(struct drm_device *dev, void *data,
1327 struct drm_file *file_priv);
1328extern int drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request);
1329extern int drm_agp_bind_ioctl(struct drm_device *dev, void *data,
1330 struct drm_file *file_priv);
1331extern DRM_AGP_MEM *drm_agp_allocate_memory(struct agp_bridge_data *bridge, size_t pages, u32 type);
1332extern int drm_agp_free_memory(DRM_AGP_MEM * handle);
1333extern int drm_agp_bind_memory(DRM_AGP_MEM * handle, off_t start);
1334extern int drm_agp_unbind_memory(DRM_AGP_MEM * handle);
1335extern void drm_agp_chipset_flush(struct drm_device *dev);
1336
1337
1338extern int drm_setmaster_ioctl(struct drm_device *dev, void *data,
1339 struct drm_file *file_priv);
1340extern int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
1341 struct drm_file *file_priv);
1342struct drm_master *drm_master_create(struct drm_minor *minor);
1343extern struct drm_master *drm_master_get(struct drm_master *master);
1344extern void drm_master_put(struct drm_master **master);
1345extern int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
1346 struct drm_driver *driver);
1347extern void drm_put_dev(struct drm_device *dev);
1348extern int drm_put_minor(struct drm_minor **minor);
1349extern unsigned int drm_debug;
1350
1351extern struct class *drm_class;
1352extern struct proc_dir_entry *drm_proc_root;
1353extern struct dentry *drm_debugfs_root;
1354
1355extern struct idr drm_minors_idr;
1356
1357extern struct drm_local_map *drm_getsarea(struct drm_device *dev);
1358
1359
1360extern int drm_proc_init(struct drm_minor *minor, int minor_id,
1361 struct proc_dir_entry *root);
1362extern int drm_proc_cleanup(struct drm_minor *minor, struct proc_dir_entry *root);
1363
1364
1365#if defined(CONFIG_DEBUG_FS)
1366extern int drm_debugfs_init(struct drm_minor *minor, int minor_id,
1367 struct dentry *root);
1368extern int drm_debugfs_create_files(struct drm_info_list *files, int count,
1369 struct dentry *root, struct drm_minor *minor);
1370extern int drm_debugfs_remove_files(struct drm_info_list *files, int count,
1371 struct drm_minor *minor);
1372extern int drm_debugfs_cleanup(struct drm_minor *minor);
1373#endif
1374
1375
1376extern int drm_name_info(struct seq_file *m, void *data);
1377extern int drm_vm_info(struct seq_file *m, void *data);
1378extern int drm_queues_info(struct seq_file *m, void *data);
1379extern int drm_bufs_info(struct seq_file *m, void *data);
1380extern int drm_vblank_info(struct seq_file *m, void *data);
1381extern int drm_clients_info(struct seq_file *m, void* data);
1382extern int drm_gem_name_info(struct seq_file *m, void *data);
1383extern int drm_gem_object_info(struct seq_file *m, void* data);
1384
1385#if DRM_DEBUG_CODE
1386extern int drm_vma_info(struct seq_file *m, void *data);
1387#endif
1388
1389
1390extern void drm_sg_cleanup(struct drm_sg_mem * entry);
1391extern int drm_sg_alloc_ioctl(struct drm_device *dev, void *data,
1392 struct drm_file *file_priv);
1393extern int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request);
1394extern int drm_sg_free(struct drm_device *dev, void *data,
1395 struct drm_file *file_priv);
1396
1397
1398extern int drm_ati_pcigart_init(struct drm_device *dev,
1399 struct drm_ati_pcigart_info * gart_info);
1400extern int drm_ati_pcigart_cleanup(struct drm_device *dev,
1401 struct drm_ati_pcigart_info * gart_info);
1402
1403extern drm_dma_handle_t *drm_pci_alloc(struct drm_device *dev, size_t size,
1404 size_t align, dma_addr_t maxaddr);
1405extern void __drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
1406extern void drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
1407
1408
1409struct drm_sysfs_class;
1410extern struct class *drm_sysfs_create(struct module *owner, char *name);
1411extern void drm_sysfs_destroy(void);
1412extern int drm_sysfs_device_add(struct drm_minor *minor);
1413extern void drm_sysfs_hotplug_event(struct drm_device *dev);
1414extern void drm_sysfs_device_remove(struct drm_minor *minor);
1415extern char *drm_get_connector_status_name(enum drm_connector_status status);
1416extern int drm_sysfs_connector_add(struct drm_connector *connector);
1417extern void drm_sysfs_connector_remove(struct drm_connector *connector);
1418
1419
1420int drm_gem_init(struct drm_device *dev);
1421void drm_gem_destroy(struct drm_device *dev);
1422void drm_gem_object_free(struct kref *kref);
1423struct drm_gem_object *drm_gem_object_alloc(struct drm_device *dev,
1424 size_t size);
1425void drm_gem_object_handle_free(struct kref *kref);
1426void drm_gem_vm_open(struct vm_area_struct *vma);
1427void drm_gem_vm_close(struct vm_area_struct *vma);
1428int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma);
1429
1430static inline void
1431drm_gem_object_reference(struct drm_gem_object *obj)
1432{
1433 kref_get(&obj->refcount);
1434}
1435
1436static inline void
1437drm_gem_object_unreference(struct drm_gem_object *obj)
1438{
1439 if (obj == NULL)
1440 return;
1441
1442 kref_put(&obj->refcount, drm_gem_object_free);
1443}
1444
1445int drm_gem_handle_create(struct drm_file *file_priv,
1446 struct drm_gem_object *obj,
1447 u32 *handlep);
1448
1449static inline void
1450drm_gem_object_handle_reference(struct drm_gem_object *obj)
1451{
1452 drm_gem_object_reference(obj);
1453 kref_get(&obj->handlecount);
1454}
1455
1456static inline void
1457drm_gem_object_handle_unreference(struct drm_gem_object *obj)
1458{
1459 if (obj == NULL)
1460 return;
1461
1462
1463
1464
1465
1466
1467 kref_put(&obj->handlecount, drm_gem_object_handle_free);
1468 drm_gem_object_unreference(obj);
1469}
1470
1471struct drm_gem_object *drm_gem_object_lookup(struct drm_device *dev,
1472 struct drm_file *filp,
1473 u32 handle);
1474int drm_gem_close_ioctl(struct drm_device *dev, void *data,
1475 struct drm_file *file_priv);
1476int drm_gem_flink_ioctl(struct drm_device *dev, void *data,
1477 struct drm_file *file_priv);
1478int drm_gem_open_ioctl(struct drm_device *dev, void *data,
1479 struct drm_file *file_priv);
1480void drm_gem_open(struct drm_device *dev, struct drm_file *file_private);
1481void drm_gem_release(struct drm_device *dev, struct drm_file *file_private);
1482
1483extern void drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev);
1484extern void drm_core_ioremap_wc(struct drm_local_map *map, struct drm_device *dev);
1485extern void drm_core_ioremapfree(struct drm_local_map *map, struct drm_device *dev);
1486
1487static __inline__ struct drm_local_map *drm_core_findmap(struct drm_device *dev,
1488 unsigned int token)
1489{
1490 struct drm_map_list *_entry;
1491 list_for_each_entry(_entry, &dev->maplist, head)
1492 if (_entry->user_token == token)
1493 return _entry->map;
1494 return NULL;
1495}
1496
1497static __inline__ int drm_device_is_agp(struct drm_device *dev)
1498{
1499 if (dev->driver->device_is_agp != NULL) {
1500 int err = (*dev->driver->device_is_agp) (dev);
1501
1502 if (err != 2) {
1503 return err;
1504 }
1505 }
1506
1507 return pci_find_capability(dev->pdev, PCI_CAP_ID_AGP);
1508}
1509
1510static __inline__ int drm_device_is_pcie(struct drm_device *dev)
1511{
1512 return pci_find_capability(dev->pdev, PCI_CAP_ID_EXP);
1513}
1514
1515static __inline__ void drm_core_dropmap(struct drm_local_map *map)
1516{
1517}
1518
1519
1520static __inline__ void *drm_calloc_large(size_t nmemb, size_t size)
1521{
1522 if (size * nmemb <= PAGE_SIZE)
1523 return kcalloc(nmemb, size, GFP_KERNEL);
1524
1525 if (size != 0 && nmemb > ULONG_MAX / size)
1526 return NULL;
1527
1528 return __vmalloc(size * nmemb,
1529 GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO, PAGE_KERNEL);
1530}
1531
1532static __inline void drm_free_large(void *ptr)
1533{
1534 if (!is_vmalloc_addr(ptr))
1535 return kfree(ptr);
1536
1537 vfree(ptr);
1538}
1539
1540
1541#endif
1542#endif
1543