1/** 2 * \file drmP.h 3 * Private header for Direct Rendering Manager 4 * 5 * \author Rickard E. (Rik) Faith <faith@valinux.com> 6 * \author Gareth Hughes <gareth@valinux.com> 7 */ 8 9/* 10 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. 11 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. 12 * All rights reserved. 13 * 14 * Permission is hereby granted, free of charge, to any person obtaining a 15 * copy of this software and associated documentation files (the "Software"), 16 * to deal in the Software without restriction, including without limitation 17 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 18 * and/or sell copies of the Software, and to permit persons to whom the 19 * Software is furnished to do so, subject to the following conditions: 20 * 21 * The above copyright notice and this permission notice (including the next 22 * paragraph) shall be included in all copies or substantial portions of the 23 * Software. 24 * 25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 26 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 27 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 28 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 29 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 30 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 31 * OTHER DEALINGS IN THE SOFTWARE. 32 */ 33 34#ifndef _DRM_P_H_ 35#define _DRM_P_H_ 36 37/* If you want the memory alloc debug functionality, change define below */ 38/* #define DEBUG_MEMORY */ 39 40#ifdef __KERNEL__ 41#ifdef __alpha__ 42/* add include of current.h so that "current" is defined 43 * before static inline funcs in wait.h. Doing this so we 44 * can build the DRM (part of PI DRI). 4/21/2000 S + B */ 45#include <asm/current.h> 46#endif /* __alpha__ */ 47#include <linux/module.h> 48#include <linux/kernel.h> 49#include <linux/miscdevice.h> 50#include <linux/fs.h> 51#include <linux/proc_fs.h> 52#include <linux/init.h> 53#include <linux/file.h> 54#include <linux/pci.h> 55#include <linux/jiffies.h> 56#include <linux/smp_lock.h> /* For (un)lock_kernel */ 57#include <linux/mm.h> 58#include <linux/cdev.h> 59#include <linux/mutex.h> 60#if defined(__alpha__) || defined(__powerpc__) 61#include <asm/pgtable.h> /* For pte_wrprotect */ 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#define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE))) 79#define __OS_HAS_MTRR (defined(CONFIG_MTRR)) 80 81#include "drm_os_linux.h" 82#include "drm_hashtab.h" 83 84/***********************************************************************/ 85/** \name DRM template customization defaults */ 86/*@{*/ 87 88/* driver capabilities and requirements mask */ 89#define DRIVER_USE_AGP 0x1 90#define DRIVER_REQUIRE_AGP 0x2 91#define DRIVER_USE_MTRR 0x4 92#define DRIVER_PCI_DMA 0x8 93#define DRIVER_SG 0x10 94#define DRIVER_HAVE_DMA 0x20 95#define DRIVER_HAVE_IRQ 0x40 96#define DRIVER_IRQ_SHARED 0x80 97#define DRIVER_IRQ_VBL 0x100 98#define DRIVER_DMA_QUEUE 0x200 99#define DRIVER_FB_DMA 0x400 100#define DRIVER_IRQ_VBL2 0x800 101 102/***********************************************************************/ 103/** \name Begin the DRM... */ 104/*@{*/ 105 106#define DRM_DEBUG_CODE 2 /**< Include debugging code if > 1, then 107 also include looping detection. */ 108 109#define DRM_MAGIC_HASH_ORDER 4 /**< Size of key hash table. Must be power of 2. */ 110#define DRM_KERNEL_CONTEXT 0 /**< Change drm_resctx if changed */ 111#define DRM_RESERVED_CONTEXTS 1 /**< Change drm_resctx if changed */ 112#define DRM_LOOPING_LIMIT 5000000 113#define DRM_TIME_SLICE (HZ/20) /**< Time slice for GLXContexts */ 114#define DRM_LOCK_SLICE 1 /**< Time slice for lock, in jiffies */ 115 116#define DRM_FLAG_DEBUG 0x01 117 118#define DRM_MEM_DMA 0 119#define DRM_MEM_SAREA 1 120#define DRM_MEM_DRIVER 2 121#define DRM_MEM_MAGIC 3 122#define DRM_MEM_IOCTLS 4 123#define DRM_MEM_MAPS 5 124#define DRM_MEM_VMAS 6 125#define DRM_MEM_BUFS 7 126#define DRM_MEM_SEGS 8 127#define DRM_MEM_PAGES 9 128#define DRM_MEM_FILES 10 129#define DRM_MEM_QUEUES 11 130#define DRM_MEM_CMDS 12 131#define DRM_MEM_MAPPINGS 13 132#define DRM_MEM_BUFLISTS 14 133#define DRM_MEM_AGPLISTS 15 134#define DRM_MEM_TOTALAGP 16 135#define DRM_MEM_BOUNDAGP 17 136#define DRM_MEM_CTXBITMAP 18 137#define DRM_MEM_STUB 19 138#define DRM_MEM_SGLISTS 20 139#define DRM_MEM_CTXLIST 21 140#define DRM_MEM_MM 22 141#define DRM_MEM_HASHTAB 23 142 143#define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8) 144#define DRM_MAP_HASH_OFFSET 0x10000000 145 146/*@}*/ 147 148/***********************************************************************/ 149/** \name Macros to make printk easier */ 150/*@{*/ 151 152/** 153 * Error output. 154 * 155 * \param fmt printf() like format string. 156 * \param arg arguments 157 */ 158#define DRM_ERROR(fmt, arg...) \ 159 printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* " fmt , __FUNCTION__ , ##arg) 160 161/** 162 * Memory error output. 163 * 164 * \param area memory area where the error occurred. 165 * \param fmt printf() like format string. 166 * \param arg arguments 167 */ 168#define DRM_MEM_ERROR(area, fmt, arg...) \ 169 printk(KERN_ERR "[" DRM_NAME ":%s:%s] *ERROR* " fmt , __FUNCTION__, \ 170 drm_mem_stats[area].name , ##arg) 171 172#define DRM_INFO(fmt, arg...) printk(KERN_INFO "[" DRM_NAME "] " fmt , ##arg) 173 174/** 175 * Debug output. 176 * 177 * \param fmt printf() like format string. 178 * \param arg arguments 179 */ 180#if DRM_DEBUG_CODE 181#define DRM_DEBUG(fmt, arg...) \ 182 do { \ 183 if ( drm_debug ) \ 184 printk(KERN_DEBUG \ 185 "[" DRM_NAME ":%s] " fmt , \ 186 __FUNCTION__ , ##arg); \ 187 } while (0) 188#else 189#define DRM_DEBUG(fmt, arg...) do { } while (0) 190#endif 191 192#define DRM_PROC_LIMIT (PAGE_SIZE-80) 193 194#define DRM_PROC_PRINT(fmt, arg...) \ 195 len += sprintf(&buf[len], fmt , ##arg); \ 196 if (len > DRM_PROC_LIMIT) { *eof = 1; return len - offset; } 197 198#define DRM_PROC_PRINT_RET(ret, fmt, arg...) \ 199 len += sprintf(&buf[len], fmt , ##arg); \ 200 if (len > DRM_PROC_LIMIT) { ret; *eof = 1; return len - offset; } 201 202/*@}*/ 203 204/***********************************************************************/ 205/** \name Internal types and structures */ 206/*@{*/ 207 208#define DRM_ARRAY_SIZE(x) ARRAY_SIZE(x) 209 210#define DRM_LEFTCOUNT(x) (((x)->rp + (x)->count - (x)->wp) % ((x)->count + 1)) 211#define DRM_BUFCOUNT(x) ((x)->count - DRM_LEFTCOUNT(x)) 212#define DRM_WAITCOUNT(dev,idx) DRM_BUFCOUNT(&dev->queuelist[idx]->waitlist) 213 214#define DRM_IF_VERSION(maj, min) (maj << 16 | min) 215/** 216 * Get the private SAREA mapping. 217 * 218 * \param _dev DRM device. 219 * \param _ctx context number. 220 * \param _map output mapping. 221 */ 222#define DRM_GET_PRIV_SAREA(_dev, _ctx, _map) do { \ 223 (_map) = (_dev)->context_sareas[_ctx]; \ 224} while(0) 225 226/** 227 * Test that the hardware lock is held by the caller, returning otherwise. 228 * 229 * \param dev DRM device. 230 * \param filp file pointer of the caller. 231 */ 232#define LOCK_TEST_WITH_RETURN( dev, filp ) \ 233do { \ 234 if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) || \ 235 dev->lock.filp != filp ) { \ 236 DRM_ERROR( "%s called without lock held\n", \ 237 __FUNCTION__ ); \ 238 return -EINVAL; \ 239 } \ 240} while (0) 241 242/** 243 * Copy and IOCTL return string to user space 244 */ 245#define DRM_COPY( name, value ) \ 246 len = strlen( value ); \ 247 if ( len > name##_len ) len = name##_len; \ 248 name##_len = strlen( value ); \ 249 if ( len && name ) { \ 250 if ( copy_to_user( name, value, len ) ) \ 251 return -EFAULT; \ 252 } 253 254/** 255 * Ioctl function type. 256 * 257 * \param inode device inode. 258 * \param filp file pointer. 259 * \param cmd command. 260 * \param arg argument. 261 */ 262typedef int drm_ioctl_t(struct inode *inode, struct file *filp, 263 unsigned int cmd, unsigned long arg); 264 265typedef int drm_ioctl_compat_t(struct file *filp, unsigned int cmd, 266 unsigned long arg); 267 268#define DRM_AUTH 0x1 269#define DRM_MASTER 0x2 270#define DRM_ROOT_ONLY 0x4 271 272typedef struct drm_ioctl_desc { 273 drm_ioctl_t *func; 274 int flags; 275} drm_ioctl_desc_t; 276 277typedef struct drm_devstate { 278 pid_t owner; /**< X server pid holding x_lock */ 279} drm_devstate_t; 280 281typedef struct drm_magic_entry { 282 drm_hash_item_t hash_item; 283 struct list_head head; 284 struct drm_file *priv; 285 struct drm_magic_entry *next; 286} drm_magic_entry_t; 287 288typedef struct drm_magic_head { 289 struct drm_magic_entry *head; 290 struct drm_magic_entry *tail; 291} drm_magic_head_t; 292 293typedef struct drm_vma_entry { 294 struct vm_area_struct *vma; 295 struct drm_vma_entry *next; 296 pid_t pid; 297} drm_vma_entry_t; 298 299/** 300 * DMA buffer. 301 */ 302typedef struct drm_buf { 303 int idx; /**< Index into master buflist */ 304 int total; /**< Buffer size */ 305 int order; /**< log-base-2(total) */ 306 int used; /**< Amount of buffer in use (for DMA) */ 307 unsigned long offset; /**< Byte offset (used internally) */ 308 void *address; /**< Address of buffer */ 309 unsigned long bus_address; /**< Bus address of buffer */ 310 struct drm_buf *next; /**< Kernel-only: used for free list */ 311 __volatile__ int waiting; /**< On kernel DMA queue */ 312 __volatile__ int pending; /**< On hardware DMA queue */ 313 wait_queue_head_t dma_wait; /**< Processes waiting */ 314 struct file *filp; /**< Pointer to holding file descr */ 315 int context; /**< Kernel queue for this buffer */ 316 int while_locked; /**< Dispatch this buffer while locked */ 317 enum { 318 DRM_LIST_NONE = 0, 319 DRM_LIST_FREE = 1, 320 DRM_LIST_WAIT = 2, 321 DRM_LIST_PEND = 3, 322 DRM_LIST_PRIO = 4, 323 DRM_LIST_RECLAIM = 5 324 } list; /**< Which list we're on */ 325 326 int dev_priv_size; /**< Size of buffer private storage */ 327 void *dev_private; /**< Per-buffer private storage */ 328} drm_buf_t; 329 330/** bufs is one longer than it has to be */ 331typedef struct drm_waitlist { 332 int count; /**< Number of possible buffers */ 333 drm_buf_t **bufs; /**< List of pointers to buffers */ 334 drm_buf_t **rp; /**< Read pointer */ 335 drm_buf_t **wp; /**< Write pointer */ 336 drm_buf_t **end; /**< End pointer */ 337 spinlock_t read_lock; 338 spinlock_t write_lock; 339} drm_waitlist_t; 340 341typedef struct drm_freelist { 342 int initialized; /**< Freelist in use */ 343 atomic_t count; /**< Number of free buffers */ 344 drm_buf_t *next; /**< End pointer */ 345 346 wait_queue_head_t waiting; /**< Processes waiting on free bufs */ 347 int low_mark; /**< Low water mark */ 348 int high_mark; /**< High water mark */ 349 atomic_t wfh; /**< If waiting for high mark */ 350 spinlock_t lock; 351} drm_freelist_t; 352 353typedef struct drm_dma_handle { 354 dma_addr_t busaddr; 355 void *vaddr; 356 size_t size; 357} drm_dma_handle_t; 358 359/** 360 * Buffer entry. There is one of this for each buffer size order. 361 */ 362typedef struct drm_buf_entry { 363 int buf_size; /**< size */ 364 int buf_count; /**< number of buffers */ 365 drm_buf_t *buflist; /**< buffer list */ 366 int seg_count; 367 int page_order; 368 drm_dma_handle_t **seglist; 369 370 drm_freelist_t freelist; 371} drm_buf_entry_t; 372 373/** File private data */ 374typedef struct drm_file { 375 int authenticated; 376 int master; 377 int minor; 378 pid_t pid; 379 uid_t uid; 380 drm_magic_t magic; 381 unsigned long ioctl_count; 382 struct drm_file *next; 383 struct drm_file *prev; 384 struct drm_head *head; 385 int remove_auth_on_close; 386 unsigned long lock_count; 387 void *driver_priv; 388} drm_file_t; 389 390/** Wait queue */ 391typedef struct drm_queue { 392 atomic_t use_count; /**< Outstanding uses (+1) */ 393 atomic_t finalization; /**< Finalization in progress */ 394 atomic_t block_count; /**< Count of processes waiting */ 395 atomic_t block_read; /**< Queue blocked for reads */ 396 wait_queue_head_t read_queue; /**< Processes waiting on block_read */ 397 atomic_t block_write; /**< Queue blocked for writes */ 398 wait_queue_head_t write_queue; /**< Processes waiting on block_write */ 399 atomic_t total_queued; /**< Total queued statistic */ 400 atomic_t total_flushed; /**< Total flushes statistic */ 401 atomic_t total_locks; /**< Total locks statistics */ 402 drm_ctx_flags_t flags; /**< Context preserving and 2D-only */ 403 drm_waitlist_t waitlist; /**< Pending buffers */ 404 wait_queue_head_t flush_queue; /**< Processes waiting until flush */ 405} drm_queue_t; 406 407/** 408 * Lock data. 409 */ 410typedef struct drm_lock_data { 411 drm_hw_lock_t *hw_lock; /**< Hardware lock */ 412 struct file *filp; /**< File descr of lock holder (0=kernel) */ 413 wait_queue_head_t lock_queue; /**< Queue of blocked processes */ 414 unsigned long lock_time; /**< Time of last lock in jiffies */ 415 spinlock_t spinlock; 416 uint32_t kernel_waiters; 417 uint32_t user_waiters; 418 int idle_has_lock; 419} drm_lock_data_t; 420 421/** 422 * DMA data. 423 */ 424typedef struct drm_device_dma { 425 426 drm_buf_entry_t bufs[DRM_MAX_ORDER + 1]; /**< buffers, grouped by their size order */ 427 int buf_count; /**< total number of buffers */ 428 drm_buf_t **buflist; /**< Vector of pointers into drm_device_dma::bufs */ 429 int seg_count; 430 int page_count; /**< number of pages */ 431 unsigned long *pagelist; /**< page list */ 432 unsigned long byte_count; 433 enum { 434 _DRM_DMA_USE_AGP = 0x01, 435 _DRM_DMA_USE_SG = 0x02, 436 _DRM_DMA_USE_FB = 0x04, 437 _DRM_DMA_USE_PCI_RO = 0x08 438 } flags; 439 440} drm_device_dma_t; 441 442/** 443 * AGP memory entry. Stored as a doubly linked list. 444 */ 445typedef struct drm_agp_mem { 446 unsigned long handle; /**< handle */ 447 DRM_AGP_MEM *memory; 448 unsigned long bound; /**< address */ 449 int pages; 450 struct drm_agp_mem *prev; /**< previous entry */ 451 struct drm_agp_mem *next; /**< next entry */ 452} drm_agp_mem_t; 453 454/** 455 * AGP data. 456 * 457 * \sa drm_agp_init() and drm_device::agp. 458 */ 459typedef struct drm_agp_head { 460 DRM_AGP_KERN agp_info; /**< AGP device information */ 461 drm_agp_mem_t *memory; /**< memory entries */ 462 unsigned long mode; /**< AGP mode */ 463 struct agp_bridge_data *bridge; 464 int enabled; /**< whether the AGP bus as been enabled */ 465 int acquired; /**< whether the AGP device has been acquired */ 466 unsigned long base; 467 int agp_mtrr; 468 int cant_use_aperture; 469 unsigned long page_mask; 470} drm_agp_head_t; 471 472/** 473 * Scatter-gather memory. 474 */ 475typedef struct drm_sg_mem { 476 unsigned long handle; 477 void *virtual; 478 int pages; 479 struct page **pagelist; 480 dma_addr_t *busaddr; 481} drm_sg_mem_t; 482 483typedef struct drm_sigdata { 484 int context; 485 drm_hw_lock_t *lock; 486} drm_sigdata_t; 487 488/** 489 * Mappings list 490 */ 491typedef struct drm_map_list { 492 struct list_head head; /**< list head */ 493 drm_hash_item_t hash; 494 drm_map_t *map; /**< mapping */ 495 unsigned int user_token; 496} drm_map_list_t; 497 498typedef drm_map_t drm_local_map_t; 499 500/** 501 * Context handle list 502 */ 503typedef struct drm_ctx_list { 504 struct list_head head; /**< list head */ 505 drm_context_t handle; /**< context handle */ 506 drm_file_t *tag; /**< associated fd private data */ 507} drm_ctx_list_t; 508 509typedef struct drm_vbl_sig { 510 struct list_head head; 511 unsigned int sequence; 512 struct siginfo info; 513 struct task_struct *task; 514} drm_vbl_sig_t; 515 516/* location of GART table */ 517#define DRM_ATI_GART_MAIN 1 518#define DRM_ATI_GART_FB 2 519 520#define DRM_ATI_GART_PCI 1 521#define DRM_ATI_GART_PCIE 2 522#define DRM_ATI_GART_IGP 3 523 524typedef struct ati_pcigart_info { 525 int gart_table_location; 526 int gart_reg_if; 527 void *addr; 528 dma_addr_t bus_addr; 529 drm_local_map_t mapping; 530 int table_size; 531} drm_ati_pcigart_info; 532 533/* 534 * Generic memory manager structs 535 */ 536typedef struct drm_mm_node { 537 struct list_head fl_entry; 538 struct list_head ml_entry; 539 int free; 540 unsigned long start; 541 unsigned long size; 542 struct drm_mm *mm; 543 void *private; 544} drm_mm_node_t; 545 546typedef struct drm_mm { 547 struct list_head fl_entry; 548 struct list_head ml_entry; 549} drm_mm_t; 550 551/** 552 * DRM driver structure. This structure represent the common code for 553 * a family of cards. There will one drm_device for each card present 554 * in this family 555 */ 556struct drm_device; 557 558struct drm_driver { 559 int (*load) (struct drm_device *, unsigned long flags); 560 int (*firstopen) (struct drm_device *); 561 int (*open) (struct drm_device *, drm_file_t *); 562 void (*preclose) (struct drm_device *, struct file * filp); 563 void (*postclose) (struct drm_device *, drm_file_t *); 564 void (*lastclose) (struct drm_device *); 565 int (*unload) (struct drm_device *); 566 int (*dma_ioctl) (DRM_IOCTL_ARGS); 567 void (*dma_ready) (struct drm_device *); 568 int (*dma_quiescent) (struct drm_device *); 569 int (*context_ctor) (struct drm_device * dev, int context); 570 int (*context_dtor) (struct drm_device * dev, int context); 571 int (*kernel_context_switch) (struct drm_device * dev, int old, 572 int new); 573 void (*kernel_context_switch_unlock) (struct drm_device * dev); 574 int (*vblank_wait) (struct drm_device * dev, unsigned int *sequence); 575 int (*vblank_wait2) (struct drm_device * dev, unsigned int *sequence); 576 int (*dri_library_name) (struct drm_device *dev, char *buf); 577 578 /** 579 * Called by \c drm_device_is_agp. Typically used to determine if a 580 * card is really attached to AGP or not. 581 * 582 * \param dev DRM device handle 583 * 584 * \returns 585 * One of three values is returned depending on whether or not the 586 * card is absolutely \b not AGP (return of 0), absolutely \b is AGP 587 * (return of 1), or may or may not be AGP (return of 2). 588 */ 589 int (*device_is_agp) (struct drm_device * dev); 590 591 /* these have to be filled in */ 592 593 irqreturn_t(*irq_handler) (DRM_IRQ_ARGS); 594 void (*irq_preinstall) (struct drm_device * dev); 595 void (*irq_postinstall) (struct drm_device * dev); 596 void (*irq_uninstall) (struct drm_device * dev); 597 void (*reclaim_buffers) (struct drm_device * dev, struct file * filp); 598 void (*reclaim_buffers_locked) (struct drm_device *dev, 599 struct file *filp); 600 void (*reclaim_buffers_idlelocked) (struct drm_device *dev, 601 struct file * filp); 602 unsigned long (*get_map_ofs) (drm_map_t * map); 603 unsigned long (*get_reg_ofs) (struct drm_device * dev); 604 void (*set_version) (struct drm_device * dev, drm_set_version_t * sv); 605 606 int major; 607 int minor; 608 int patchlevel; 609 char *name; 610 char *desc; 611 char *date; 612 613 u32 driver_features; 614 int dev_priv_size; 615 drm_ioctl_desc_t *ioctls; 616 int num_ioctls; 617 struct file_operations fops; 618 struct pci_driver pci_driver; 619}; 620 621/** 622 * DRM head structure. This structure represent a video head on a card 623 * that may contain multiple heads. Embed one per head of these in the 624 * private drm_device structure. 625 */ 626typedef struct drm_head { 627 int minor; /**< Minor device number */ 628 struct drm_device *dev; 629 struct proc_dir_entry *dev_root; /**< proc directory entry */ 630 dev_t device; /**< Device number for mknod */ 631 struct class_device *dev_class; 632} drm_head_t; 633 634/** 635 * DRM device structure. This structure represent a complete card that 636 * may contain multiple heads. 637 */ 638typedef struct drm_device { 639 char *unique; /**< Unique identifier: e.g., busid */ 640 int unique_len; /**< Length of unique field */ 641 char *devname; /**< For /proc/interrupts */ 642 int if_version; /**< Highest interface version set */ 643 644 int blocked; /**< Blocked due to VC switch? */ 645 646 /** \name Locks */ 647 /*@{ */ 648 spinlock_t count_lock; /**< For inuse, drm_device::open_count, drm_device::buf_use */ 649 struct mutex struct_mutex; /**< For others */ 650 /*@} */ 651 652 /** \name Usage Counters */ 653 /*@{ */ 654 int open_count; /**< Outstanding files open */ 655 atomic_t ioctl_count; /**< Outstanding IOCTLs pending */ 656 atomic_t vma_count; /**< Outstanding vma areas open */ 657 int buf_use; /**< Buffers in use -- cannot alloc */ 658 atomic_t buf_alloc; /**< Buffer allocation in progress */ 659 /*@} */ 660 661 /** \name Performance counters */ 662 /*@{ */ 663 unsigned long counters; 664 drm_stat_type_t types[15]; 665 atomic_t counts[15]; 666 /*@} */ 667 668 /** \name Authentication */ 669 /*@{ */ 670 drm_file_t *file_first; /**< file list head */ 671 drm_file_t *file_last; /**< file list tail */ 672 drm_open_hash_t magiclist; /**< magic hash table */ 673 struct list_head magicfree; 674 /*@} */ 675 676 /** \name Memory management */ 677 /*@{ */ 678 drm_map_list_t *maplist; /**< Linked list of regions */ 679 int map_count; /**< Number of mappable regions */ 680 drm_open_hash_t map_hash; /**< User token hash table for maps */ 681 682 /** \name Context handle management */ 683 /*@{ */ 684 drm_ctx_list_t *ctxlist; /**< Linked list of context handles */ 685 int ctx_count; /**< Number of context handles */ 686 struct mutex ctxlist_mutex; /**< For ctxlist */ 687 688 drm_map_t **context_sareas; /**< per-context SAREA's */ 689 int max_context; 690 691 drm_vma_entry_t *vmalist; /**< List of vmas (for debugging) */ 692 drm_lock_data_t lock; /**< Information on hardware lock */ 693 /*@} */ 694 695 /** \name DMA queues (contexts) */ 696 /*@{ */ 697 int queue_count; /**< Number of active DMA queues */ 698 int queue_reserved; /**< Number of reserved DMA queues */ 699 int queue_slots; /**< Actual length of queuelist */ 700 drm_queue_t **queuelist; /**< Vector of pointers to DMA queues */ 701 drm_device_dma_t *dma; /**< Optional pointer for DMA support */ 702 /*@} */ 703 704 /** \name Context support */ 705 /*@{ */ 706 int irq; /**< Interrupt used by board */ 707 int irq_enabled; /**< True if irq handler is enabled */ 708 __volatile__ long context_flag; /**< Context swapping flag */ 709 __volatile__ long interrupt_flag; /**< Interruption handler flag */ 710 __volatile__ long dma_flag; /**< DMA dispatch flag */ 711 struct timer_list timer; /**< Timer for delaying ctx switch */ 712 wait_queue_head_t context_wait; /**< Processes waiting on ctx switch */ 713 int last_checked; /**< Last context checked for DMA */ 714 int last_context; /**< Last current context */ 715 unsigned long last_switch; /**< jiffies at last context switch */ 716 /*@} */ 717 718 struct work_struct work; 719 /** \name VBLANK IRQ support */ 720 /*@{ */ 721 722 wait_queue_head_t vbl_queue; /**< VBLANK wait queue */ 723 atomic_t vbl_received; 724 atomic_t vbl_received2; /**< number of secondary VBLANK interrupts */ 725 spinlock_t vbl_lock; 726 drm_vbl_sig_t vbl_sigs; /**< signal list to send on VBLANK */ 727 drm_vbl_sig_t vbl_sigs2; /**< signals to send on secondary VBLANK */ 728 unsigned int vbl_pending; 729 spinlock_t tasklet_lock; /**< For drm_locked_tasklet */ 730 void (*locked_tasklet_func)(struct drm_device *dev); 731 732 /*@} */ 733 cycles_t ctx_start; 734 cycles_t lck_start; 735 736 struct fasync_struct *buf_async;/**< Processes waiting for SIGIO */ 737 wait_queue_head_t buf_readers; /**< Processes waiting to read */ 738 wait_queue_head_t buf_writers; /**< Processes waiting to ctx switch */ 739 740 drm_agp_head_t *agp; /**< AGP data */ 741 742 struct pci_dev *pdev; /**< PCI device structure */ 743 int pci_vendor; /**< PCI vendor id */ 744 int pci_device; /**< PCI device id */ 745#ifdef __alpha__ 746 struct pci_controller *hose; 747#endif 748 drm_sg_mem_t *sg; /**< Scatter gather memory */ 749 unsigned long *ctx_bitmap; /**< context bitmap */ 750 void *dev_private; /**< device private data */ 751 drm_sigdata_t sigdata; /**< For block_all_signals */ 752 sigset_t sigmask; 753 754 struct drm_driver *driver; 755 drm_local_map_t *agp_buffer_map; 756 unsigned int agp_buffer_token; 757 drm_head_t primary; /**< primary screen head */ 758 759 /** \name Drawable information */ 760 /*@{ */ 761 spinlock_t drw_lock; 762 unsigned int drw_bitfield_length; 763 u32 *drw_bitfield; 764 unsigned int drw_info_length; 765 drm_drawable_info_t **drw_info; 766 /*@} */ 767} drm_device_t; 768 769static __inline__ int drm_core_check_feature(struct drm_device *dev, 770 int feature) 771{ 772 return ((dev->driver->driver_features & feature) ? 1 : 0); 773} 774 775#ifdef __alpha__ 776#define drm_get_pci_domain(dev) dev->hose->index 777#else 778#define drm_get_pci_domain(dev) 0 779#endif 780 781#if __OS_HAS_AGP 782static inline int drm_core_has_AGP(struct drm_device *dev) 783{ 784 return drm_core_check_feature(dev, DRIVER_USE_AGP); 785} 786#else 787#define drm_core_has_AGP(dev) (0) 788#endif 789 790#if __OS_HAS_MTRR 791static inline int drm_core_has_MTRR(struct drm_device *dev) 792{ 793 return drm_core_check_feature(dev, DRIVER_USE_MTRR); 794} 795 796#define DRM_MTRR_WC MTRR_TYPE_WRCOMB 797 798static inline int drm_mtrr_add(unsigned long offset, unsigned long size, 799 unsigned int flags) 800{ 801 return mtrr_add(offset, size, flags, 1); 802} 803 804static inline int drm_mtrr_del(int handle, unsigned long offset, 805 unsigned long size, unsigned int flags) 806{ 807 return mtrr_del(handle, offset, size); 808} 809 810#else 811#define drm_core_has_MTRR(dev) (0) 812 813#define DRM_MTRR_WC 0 814 815static inline int drm_mtrr_add(unsigned long offset, unsigned long size, 816 unsigned int flags) 817{ 818 return 0; 819} 820 821static inline int drm_mtrr_del(int handle, unsigned long offset, 822 unsigned long size, unsigned int flags) 823{ 824 return 0; 825} 826#endif 827 828/******************************************************************/ 829/** \name Internal function definitions */ 830/*@{*/ 831 832 /* Driver support (drm_drv.h) */ 833extern int drm_init(struct drm_driver *driver); 834extern void drm_exit(struct drm_driver *driver); 835extern int drm_ioctl(struct inode *inode, struct file *filp, 836 unsigned int cmd, unsigned long arg); 837extern long drm_compat_ioctl(struct file *filp, 838 unsigned int cmd, unsigned long arg); 839extern int drm_lastclose(drm_device_t *dev); 840 841 /* Device support (drm_fops.h) */ 842extern int drm_open(struct inode *inode, struct file *filp); 843extern int drm_stub_open(struct inode *inode, struct file *filp); 844extern int drm_fasync(int fd, struct file *filp, int on); 845extern int drm_release(struct inode *inode, struct file *filp); 846 847 /* Mapping support (drm_vm.h) */ 848extern int drm_mmap(struct file *filp, struct vm_area_struct *vma); 849extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait); 850 851 /* Memory management support (drm_memory.h) */ 852#include "drm_memory.h" 853extern void drm_mem_init(void); 854extern int drm_mem_info(char *buf, char **start, off_t offset, 855 int request, int *eof, void *data); 856extern void *drm_realloc(void *oldpt, size_t oldsize, size_t size, int area); 857 858extern DRM_AGP_MEM *drm_alloc_agp(drm_device_t * dev, int pages, u32 type); 859extern int drm_free_agp(DRM_AGP_MEM * handle, int pages); 860extern int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start); 861extern int drm_unbind_agp(DRM_AGP_MEM * handle); 862 863 /* Misc. IOCTL support (drm_ioctl.h) */ 864extern int drm_irq_by_busid(struct inode *inode, struct file *filp, 865 unsigned int cmd, unsigned long arg); 866extern int drm_getunique(struct inode *inode, struct file *filp, 867 unsigned int cmd, unsigned long arg); 868extern int drm_setunique(struct inode *inode, struct file *filp, 869 unsigned int cmd, unsigned long arg); 870extern int drm_getmap(struct inode *inode, struct file *filp, 871 unsigned int cmd, unsigned long arg); 872extern int drm_getclient(struct inode *inode, struct file *filp, 873 unsigned int cmd, unsigned long arg); 874extern int drm_getstats(struct inode *inode, struct file *filp, 875 unsigned int cmd, unsigned long arg); 876extern int drm_setversion(struct inode *inode, struct file *filp, 877 unsigned int cmd, unsigned long arg); 878extern int drm_noop(struct inode *inode, struct file *filp, 879 unsigned int cmd, unsigned long arg); 880 881 /* Context IOCTL support (drm_context.h) */ 882extern int drm_resctx(struct inode *inode, struct file *filp, 883 unsigned int cmd, unsigned long arg); 884extern int drm_addctx(struct inode *inode, struct file *filp, 885 unsigned int cmd, unsigned long arg); 886extern int drm_modctx(struct inode *inode, struct file *filp, 887 unsigned int cmd, unsigned long arg); 888extern int drm_getctx(struct inode *inode, struct file *filp, 889 unsigned int cmd, unsigned long arg); 890extern int drm_switchctx(struct inode *inode, struct file *filp, 891 unsigned int cmd, unsigned long arg); 892extern int drm_newctx(struct inode *inode, struct file *filp, 893 unsigned int cmd, unsigned long arg); 894extern int drm_rmctx(struct inode *inode, struct file *filp, 895 unsigned int cmd, unsigned long arg); 896 897extern int drm_ctxbitmap_init(drm_device_t * dev); 898extern void drm_ctxbitmap_cleanup(drm_device_t * dev); 899extern void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle); 900 901extern int drm_setsareactx(struct inode *inode, struct file *filp, 902 unsigned int cmd, unsigned long arg); 903extern int drm_getsareactx(struct inode *inode, struct file *filp, 904 unsigned int cmd, unsigned long arg); 905 906 /* Drawable IOCTL support (drm_drawable.h) */ 907extern int drm_adddraw(struct inode *inode, struct file *filp, 908 unsigned int cmd, unsigned long arg); 909extern int drm_rmdraw(struct inode *inode, struct file *filp, 910 unsigned int cmd, unsigned long arg); 911extern int drm_update_drawable_info(struct inode *inode, struct file *filp, 912 unsigned int cmd, unsigned long arg); 913extern drm_drawable_info_t *drm_get_drawable_info(drm_device_t *dev, 914 drm_drawable_t id); 915 916 /* Authentication IOCTL support (drm_auth.h) */ 917extern int drm_getmagic(struct inode *inode, struct file *filp, 918 unsigned int cmd, unsigned long arg); 919extern int drm_authmagic(struct inode *inode, struct file *filp, 920 unsigned int cmd, unsigned long arg); 921 922 /* Locking IOCTL support (drm_lock.h) */ 923extern int drm_lock(struct inode *inode, struct file *filp, 924 unsigned int cmd, unsigned long arg); 925extern int drm_unlock(struct inode *inode, struct file *filp, 926 unsigned int cmd, unsigned long arg); 927extern int drm_lock_take(drm_lock_data_t *lock_data, unsigned int context); 928extern int drm_lock_free(drm_lock_data_t *lock_data, unsigned int context); 929extern void drm_idlelock_take(drm_lock_data_t *lock_data); 930extern void drm_idlelock_release(drm_lock_data_t *lock_data); 931 932/* 933 * These are exported to drivers so that they can implement fencing using 934 * DMA quiscent + idle. DMA quiescent usually requires the hardware lock. 935 */ 936 937extern int drm_i_have_hw_lock(struct file *filp); 938extern int drm_kernel_take_hw_lock(struct file *filp); 939 940 /* Buffer management support (drm_bufs.h) */ 941extern int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request); 942extern int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request); 943extern int drm_addmap(drm_device_t * dev, unsigned int offset, 944 unsigned int size, drm_map_type_t type, 945 drm_map_flags_t flags, drm_local_map_t ** map_ptr); 946extern int drm_addmap_ioctl(struct inode *inode, struct file *filp, 947 unsigned int cmd, unsigned long arg); 948extern int drm_rmmap(drm_device_t * dev, drm_local_map_t * map); 949extern int drm_rmmap_locked(drm_device_t * dev, drm_local_map_t * map); 950extern int drm_rmmap_ioctl(struct inode *inode, struct file *filp, 951 unsigned int cmd, unsigned long arg); 952 953extern int drm_order(unsigned long size); 954extern int drm_addbufs(struct inode *inode, struct file *filp, 955 unsigned int cmd, unsigned long arg); 956extern int drm_infobufs(struct inode *inode, struct file *filp, 957 unsigned int cmd, unsigned long arg); 958extern int drm_markbufs(struct inode *inode, struct file *filp, 959 unsigned int cmd, unsigned long arg); 960extern int drm_freebufs(struct inode *inode, struct file *filp, 961 unsigned int cmd, unsigned long arg); 962extern int drm_mapbufs(struct inode *inode, struct file *filp, 963 unsigned int cmd, unsigned long arg); 964extern unsigned long drm_get_resource_start(drm_device_t * dev, 965 unsigned int resource); 966extern unsigned long drm_get_resource_len(drm_device_t * dev, 967 unsigned int resource); 968 969 /* DMA support (drm_dma.h) */ 970extern int drm_dma_setup(drm_device_t * dev); 971extern void drm_dma_takedown(drm_device_t * dev); 972extern void drm_free_buffer(drm_device_t * dev, drm_buf_t * buf); 973extern void drm_core_reclaim_buffers(drm_device_t * dev, struct file *filp); 974 975 /* IRQ support (drm_irq.h) */ 976extern int drm_control(struct inode *inode, struct file *filp, 977 unsigned int cmd, unsigned long arg); 978extern irqreturn_t drm_irq_handler(DRM_IRQ_ARGS); 979extern int drm_irq_uninstall(drm_device_t * dev); 980extern void drm_driver_irq_preinstall(drm_device_t * dev); 981extern void drm_driver_irq_postinstall(drm_device_t * dev); 982extern void drm_driver_irq_uninstall(drm_device_t * dev); 983 984extern int drm_wait_vblank(struct inode *inode, struct file *filp, 985 unsigned int cmd, unsigned long arg); 986extern int drm_vblank_wait(drm_device_t * dev, unsigned int *vbl_seq); 987extern void drm_vbl_send_signals(drm_device_t * dev); 988extern void drm_locked_tasklet(drm_device_t *dev, void(*func)(drm_device_t*)); 989 990 /* AGP/GART support (drm_agpsupport.h) */ 991extern drm_agp_head_t *drm_agp_init(drm_device_t * dev); 992extern int drm_agp_acquire(drm_device_t * dev); 993extern int drm_agp_acquire_ioctl(struct inode *inode, struct file *filp, 994 unsigned int cmd, unsigned long arg); 995extern int drm_agp_release(drm_device_t * dev); 996extern int drm_agp_release_ioctl(struct inode *inode, struct file *filp, 997 unsigned int cmd, unsigned long arg); 998extern int drm_agp_enable(drm_device_t * dev, drm_agp_mode_t mode); 999extern int drm_agp_enable_ioctl(struct inode *inode, struct file *filp, 1000 unsigned int cmd, unsigned long arg); 1001extern int drm_agp_info(drm_device_t * dev, drm_agp_info_t * info); 1002extern int drm_agp_info_ioctl(struct inode *inode, struct file *filp, 1003 unsigned int cmd, unsigned long arg); 1004extern int drm_agp_alloc(drm_device_t *dev, drm_agp_buffer_t *request); 1005extern int drm_agp_alloc_ioctl(struct inode *inode, struct file *filp, 1006 unsigned int cmd, unsigned long arg); 1007extern int drm_agp_free(drm_device_t *dev, drm_agp_buffer_t *request); 1008extern int drm_agp_free_ioctl(struct inode *inode, struct file *filp, 1009 unsigned int cmd, unsigned long arg); 1010extern int drm_agp_unbind(drm_device_t *dev, drm_agp_binding_t *request); 1011extern int drm_agp_unbind_ioctl(struct inode *inode, struct file *filp, 1012 unsigned int cmd, unsigned long arg); 1013extern int drm_agp_bind(drm_device_t *dev, drm_agp_binding_t *request); 1014extern int drm_agp_bind_ioctl(struct inode *inode, struct file *filp, 1015 unsigned int cmd, unsigned long arg); 1016extern DRM_AGP_MEM *drm_agp_allocate_memory(struct agp_bridge_data *bridge, 1017 size_t pages, u32 type); 1018extern int drm_agp_free_memory(DRM_AGP_MEM * handle); 1019extern int drm_agp_bind_memory(DRM_AGP_MEM * handle, off_t start); 1020extern int drm_agp_unbind_memory(DRM_AGP_MEM * handle); 1021 1022 /* Stub support (drm_stub.h) */ 1023extern int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent, 1024 struct drm_driver *driver); 1025extern int drm_put_dev(drm_device_t * dev); 1026extern int drm_put_head(drm_head_t * head); 1027extern unsigned int drm_debug; 1028extern unsigned int drm_cards_limit; 1029extern drm_head_t **drm_heads; 1030extern struct class *drm_class; 1031extern struct proc_dir_entry *drm_proc_root; 1032 1033 /* Proc support (drm_proc.h) */ 1034extern int drm_proc_init(drm_device_t * dev, 1035 int minor, 1036 struct proc_dir_entry *root, 1037 struct proc_dir_entry **dev_root); 1038extern int drm_proc_cleanup(int minor, 1039 struct proc_dir_entry *root, 1040 struct proc_dir_entry *dev_root); 1041 1042 /* Scatter Gather Support (drm_scatter.h) */ 1043extern void drm_sg_cleanup(drm_sg_mem_t * entry); 1044extern int drm_sg_alloc(struct inode *inode, struct file *filp, 1045 unsigned int cmd, unsigned long arg); 1046extern int drm_sg_free(struct inode *inode, struct file *filp, 1047 unsigned int cmd, unsigned long arg); 1048 1049 /* ATI PCIGART support (ati_pcigart.h) */ 1050extern int drm_ati_pcigart_init(drm_device_t * dev, 1051 drm_ati_pcigart_info * gart_info); 1052extern int drm_ati_pcigart_cleanup(drm_device_t * dev, 1053 drm_ati_pcigart_info * gart_info); 1054 1055extern drm_dma_handle_t *drm_pci_alloc(drm_device_t * dev, size_t size, 1056 size_t align, dma_addr_t maxaddr); 1057extern void __drm_pci_free(drm_device_t * dev, drm_dma_handle_t * dmah); 1058extern void drm_pci_free(drm_device_t * dev, drm_dma_handle_t * dmah); 1059 1060 /* sysfs support (drm_sysfs.c) */ 1061extern struct class *drm_sysfs_create(struct module *owner, char *name); 1062extern void drm_sysfs_destroy(struct class *cs); 1063extern struct class_device *drm_sysfs_device_add(struct class *cs, 1064 drm_head_t *head); 1065extern void drm_sysfs_device_remove(struct class_device *class_dev); 1066 1067/* 1068 * Basic memory manager support (drm_mm.c) 1069 */ 1070extern drm_mm_node_t *drm_mm_get_block(drm_mm_node_t * parent, 1071 unsigned long size, 1072 unsigned alignment); 1073void drm_mm_put_block(drm_mm_node_t * cur); 1074extern drm_mm_node_t *drm_mm_search_free(const drm_mm_t *mm, unsigned long size, 1075 unsigned alignment, int best_match); 1076extern int drm_mm_init(drm_mm_t *mm, unsigned long start, unsigned long size); 1077extern void drm_mm_takedown(drm_mm_t *mm); 1078extern int drm_mm_clean(drm_mm_t *mm); 1079extern unsigned long drm_mm_tail_space(drm_mm_t *mm); 1080extern int drm_mm_remove_space_from_tail(drm_mm_t *mm, unsigned long size); 1081extern int drm_mm_add_space_to_tail(drm_mm_t *mm, unsigned long size); 1082 1083extern void drm_core_ioremap(struct drm_map *map, struct drm_device *dev); 1084extern void drm_core_ioremapfree(struct drm_map *map, struct drm_device *dev); 1085 1086static __inline__ struct drm_map *drm_core_findmap(struct drm_device *dev, 1087 unsigned int token) 1088{ 1089 drm_map_list_t *_entry; 1090 list_for_each_entry(_entry, &dev->maplist->head, head) 1091 if (_entry->user_token == token) 1092 return _entry->map; 1093 return NULL; 1094} 1095 1096static __inline__ int drm_device_is_agp(drm_device_t * dev) 1097{ 1098 if (dev->driver->device_is_agp != NULL) { 1099 int err = (*dev->driver->device_is_agp) (dev); 1100 1101 if (err != 2) { 1102 return err; 1103 } 1104 } 1105 1106 return pci_find_capability(dev->pdev, PCI_CAP_ID_AGP); 1107} 1108 1109static __inline__ int drm_device_is_pcie(drm_device_t * dev) 1110{ 1111 return pci_find_capability(dev->pdev, PCI_CAP_ID_EXP); 1112} 1113 1114static __inline__ void drm_core_dropmap(struct drm_map *map) 1115{ 1116} 1117 1118#ifndef DEBUG_MEMORY 1119/** Wrapper around kmalloc() */ 1120static __inline__ void *drm_alloc(size_t size, int area) 1121{ 1122 return kmalloc(size, GFP_KERNEL); 1123} 1124 1125/** Wrapper around kfree() */ 1126static __inline__ void drm_free(void *pt, size_t size, int area) 1127{ 1128 kfree(pt); 1129} 1130 1131/** Wrapper around kcalloc() */ 1132static __inline__ void *drm_calloc(size_t nmemb, size_t size, int area) 1133{ 1134 return kcalloc(nmemb, size, GFP_KERNEL); 1135} 1136#else 1137extern void *drm_alloc(size_t size, int area); 1138extern void drm_free(void *pt, size_t size, int area); 1139extern void *drm_calloc(size_t nmemb, size_t size, int area); 1140#endif 1141 1142/*@}*/ 1143 1144extern unsigned long drm_core_get_map_ofs(drm_map_t * map); 1145extern unsigned long drm_core_get_reg_ofs(struct drm_device *dev); 1146 1147#endif /* __KERNEL__ */ 1148#endif 1149