1/* 2 * Internal Header for the Direct Rendering Manager 3 * 4 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. 5 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. 6 * Copyright (c) 2009-2010, Code Aurora Forum. 7 * All rights reserved. 8 * 9 * Author: Rickard E. (Rik) Faith <faith@valinux.com> 10 * Author: Gareth Hughes <gareth@valinux.com> 11 * 12 * Permission is hereby granted, free of charge, to any person obtaining a 13 * copy of this software and associated documentation files (the "Software"), 14 * to deal in the Software without restriction, including without limitation 15 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 16 * and/or sell copies of the Software, and to permit persons to whom the 17 * Software is furnished to do so, subject to the following conditions: 18 * 19 * The above copyright notice and this permission notice (including the next 20 * paragraph) shall be included in all copies or substantial portions of the 21 * Software. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 24 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 25 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 26 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 27 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 28 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 29 * OTHER DEALINGS IN THE SOFTWARE. 30 */ 31 32#ifndef _DRM_P_H_ 33#define _DRM_P_H_ 34 35#include <linux/agp_backend.h> 36#include <linux/cdev.h> 37#include <linux/dma-mapping.h> 38#include <linux/file.h> 39#include <linux/fs.h> 40#include <linux/highmem.h> 41#include <linux/idr.h> 42#include <linux/init.h> 43#include <linux/io.h> 44#include <linux/jiffies.h> 45#include <linux/kernel.h> 46#include <linux/kref.h> 47#include <linux/miscdevice.h> 48#include <linux/mm.h> 49#include <linux/mutex.h> 50#include <linux/pci.h> 51#include <linux/platform_device.h> 52#include <linux/poll.h> 53#include <linux/ratelimit.h> 54#include <linux/sched.h> 55#include <linux/slab.h> 56#include <linux/types.h> 57#include <linux/vmalloc.h> 58#include <linux/workqueue.h> 59 60#include <asm/mman.h> 61#include <asm/pgalloc.h> 62#include <asm/uaccess.h> 63 64#include <uapi/drm/drm.h> 65#include <uapi/drm/drm_mode.h> 66 67#include <drm/drm_agpsupport.h> 68#include <drm/drm_crtc.h> 69#include <drm/drm_global.h> 70#include <drm/drm_hashtab.h> 71#include <drm/drm_mem_util.h> 72#include <drm/drm_mm.h> 73#include <drm/drm_os_linux.h> 74#include <drm/drm_sarea.h> 75#include <drm/drm_vma_manager.h> 76 77struct module; 78 79struct drm_file; 80struct drm_device; 81struct drm_agp_head; 82struct drm_local_map; 83struct drm_device_dma; 84struct drm_dma_handle; 85struct drm_gem_object; 86 87struct device_node; 88struct videomode; 89struct reservation_object; 90struct dma_buf_attachment; 91 92/* 93 * 4 debug categories are defined: 94 * 95 * CORE: Used in the generic drm code: drm_ioctl.c, drm_mm.c, drm_memory.c, ... 96 * This is the category used by the DRM_DEBUG() macro. 97 * 98 * DRIVER: Used in the vendor specific part of the driver: i915, radeon, ... 99 * This is the category used by the DRM_DEBUG_DRIVER() macro. 100 * 101 * KMS: used in the modesetting code. 102 * This is the category used by the DRM_DEBUG_KMS() macro. 103 * 104 * PRIME: used in the prime code. 105 * This is the category used by the DRM_DEBUG_PRIME() macro. 106 * 107 * ATOMIC: used in the atomic code. 108 * This is the category used by the DRM_DEBUG_ATOMIC() macro. 109 * 110 * Enabling verbose debug messages is done through the drm.debug parameter, 111 * each category being enabled by a bit. 112 * 113 * drm.debug=0x1 will enable CORE messages 114 * drm.debug=0x2 will enable DRIVER messages 115 * drm.debug=0x3 will enable CORE and DRIVER messages 116 * ... 117 * drm.debug=0xf will enable all messages 118 * 119 * An interesting feature is that it's possible to enable verbose logging at 120 * run-time by echoing the debug value in its sysfs node: 121 * # echo 0xf > /sys/module/drm/parameters/debug 122 */ 123#define DRM_UT_CORE 0x01 124#define DRM_UT_DRIVER 0x02 125#define DRM_UT_KMS 0x04 126#define DRM_UT_PRIME 0x08 127#define DRM_UT_ATOMIC 0x10 128 129extern __printf(2, 3) 130void drm_ut_debug_printk(const char *function_name, 131 const char *format, ...); 132extern __printf(1, 2) 133void drm_err(const char *format, ...); 134 135/***********************************************************************/ 136/** \name DRM template customization defaults */ 137/*@{*/ 138 139/* driver capabilities and requirements mask */ 140#define DRIVER_USE_AGP 0x1 141#define DRIVER_PCI_DMA 0x8 142#define DRIVER_SG 0x10 143#define DRIVER_HAVE_DMA 0x20 144#define DRIVER_HAVE_IRQ 0x40 145#define DRIVER_IRQ_SHARED 0x80 146#define DRIVER_GEM 0x1000 147#define DRIVER_MODESET 0x2000 148#define DRIVER_PRIME 0x4000 149#define DRIVER_RENDER 0x8000 150#define DRIVER_ATOMIC 0x10000 151 152/***********************************************************************/ 153/** \name Macros to make printk easier */ 154/*@{*/ 155 156/** 157 * Error output. 158 * 159 * \param fmt printf() like format string. 160 * \param arg arguments 161 */ 162#define DRM_ERROR(fmt, ...) \ 163 drm_err(fmt, ##__VA_ARGS__) 164 165/** 166 * Rate limited error output. Like DRM_ERROR() but won't flood the log. 167 * 168 * \param fmt printf() like format string. 169 * \param arg arguments 170 */ 171#define DRM_ERROR_RATELIMITED(fmt, ...) \ 172({ \ 173 static DEFINE_RATELIMIT_STATE(_rs, \ 174 DEFAULT_RATELIMIT_INTERVAL, \ 175 DEFAULT_RATELIMIT_BURST); \ 176 \ 177 if (__ratelimit(&_rs)) \ 178 drm_err(fmt, ##__VA_ARGS__); \ 179}) 180 181#define DRM_INFO(fmt, ...) \ 182 printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__) 183 184#define DRM_INFO_ONCE(fmt, ...) \ 185 printk_once(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__) 186 187/** 188 * Debug output. 189 * 190 * \param fmt printf() like format string. 191 * \param arg arguments 192 */ 193#define DRM_DEBUG(fmt, args...) \ 194 do { \ 195 if (unlikely(drm_debug & DRM_UT_CORE)) \ 196 drm_ut_debug_printk(__func__, fmt, ##args); \ 197 } while (0) 198 199#define DRM_DEBUG_DRIVER(fmt, args...) \ 200 do { \ 201 if (unlikely(drm_debug & DRM_UT_DRIVER)) \ 202 drm_ut_debug_printk(__func__, fmt, ##args); \ 203 } while (0) 204#define DRM_DEBUG_KMS(fmt, args...) \ 205 do { \ 206 if (unlikely(drm_debug & DRM_UT_KMS)) \ 207 drm_ut_debug_printk(__func__, fmt, ##args); \ 208 } while (0) 209#define DRM_DEBUG_PRIME(fmt, args...) \ 210 do { \ 211 if (unlikely(drm_debug & DRM_UT_PRIME)) \ 212 drm_ut_debug_printk(__func__, fmt, ##args); \ 213 } while (0) 214#define DRM_DEBUG_ATOMIC(fmt, args...) \ 215 do { \ 216 if (unlikely(drm_debug & DRM_UT_ATOMIC)) \ 217 drm_ut_debug_printk(__func__, fmt, ##args); \ 218 } while (0) 219 220/*@}*/ 221 222/***********************************************************************/ 223/** \name Internal types and structures */ 224/*@{*/ 225 226#define DRM_IF_VERSION(maj, min) (maj << 16 | min) 227 228/** 229 * Ioctl function type. 230 * 231 * \param inode device inode. 232 * \param file_priv DRM file private pointer. 233 * \param cmd command. 234 * \param arg argument. 235 */ 236typedef int drm_ioctl_t(struct drm_device *dev, void *data, 237 struct drm_file *file_priv); 238 239typedef int drm_ioctl_compat_t(struct file *filp, unsigned int cmd, 240 unsigned long arg); 241 242#define DRM_IOCTL_NR(n) _IOC_NR(n) 243#define DRM_MAJOR 226 244 245#define DRM_AUTH 0x1 246#define DRM_MASTER 0x2 247#define DRM_ROOT_ONLY 0x4 248#define DRM_CONTROL_ALLOW 0x8 249#define DRM_UNLOCKED 0x10 250#define DRM_RENDER_ALLOW 0x20 251 252struct drm_ioctl_desc { 253 unsigned int cmd; 254 int flags; 255 drm_ioctl_t *func; 256 const char *name; 257}; 258 259/** 260 * Creates a driver or general drm_ioctl_desc array entry for the given 261 * ioctl, for use by drm_ioctl(). 262 */ 263 264#define DRM_IOCTL_DEF_DRV(ioctl, _func, _flags) \ 265 [DRM_IOCTL_NR(DRM_IOCTL_##ioctl) - DRM_COMMAND_BASE] = { \ 266 .cmd = DRM_IOCTL_##ioctl, \ 267 .func = _func, \ 268 .flags = _flags, \ 269 .name = #ioctl \ 270 } 271 272/* Event queued up for userspace to read */ 273struct drm_pending_event { 274 struct drm_event *event; 275 struct list_head link; 276 struct drm_file *file_priv; 277 pid_t pid; /* pid of requester, no guarantee it's valid by the time 278 we deliver the event, for tracing only */ 279 void (*destroy)(struct drm_pending_event *event); 280}; 281 282/* initial implementaton using a linked list - todo hashtab */ 283struct drm_prime_file_private { 284 struct list_head head; 285 struct mutex lock; 286}; 287 288/** File private data */ 289struct drm_file { 290 unsigned authenticated :1; 291 /* Whether we're master for a minor. Protected by master_mutex */ 292 unsigned is_master :1; 293 /* true when the client has asked us to expose stereo 3D mode flags */ 294 unsigned stereo_allowed :1; 295 /* 296 * true if client understands CRTC primary planes and cursor planes 297 * in the plane list 298 */ 299 unsigned universal_planes:1; 300 /* true if client understands atomic properties */ 301 unsigned atomic:1; 302 303 struct pid *pid; 304 kuid_t uid; 305 drm_magic_t magic; 306 struct list_head lhead; 307 struct drm_minor *minor; 308 unsigned long lock_count; 309 310 /** Mapping of mm object handles to object pointers. */ 311 struct idr object_idr; 312 /** Lock for synchronization of access to object_idr. */ 313 spinlock_t table_lock; 314 315 struct file *filp; 316 void *driver_priv; 317 318 struct drm_master *master; /* master this node is currently associated with 319 N.B. not always minor->master */ 320 /** 321 * fbs - List of framebuffers associated with this file. 322 * 323 * Protected by fbs_lock. Note that the fbs list holds a reference on 324 * the fb object to prevent it from untimely disappearing. 325 */ 326 struct list_head fbs; 327 struct mutex fbs_lock; 328 329 wait_queue_head_t event_wait; 330 struct list_head event_list; 331 int event_space; 332 333 struct drm_prime_file_private prime; 334}; 335 336/** 337 * Lock data. 338 */ 339struct drm_lock_data { 340 struct drm_hw_lock *hw_lock; /**< Hardware lock */ 341 /** Private of lock holder's file (NULL=kernel) */ 342 struct drm_file *file_priv; 343 wait_queue_head_t lock_queue; /**< Queue of blocked processes */ 344 unsigned long lock_time; /**< Time of last lock in jiffies */ 345 spinlock_t spinlock; 346 uint32_t kernel_waiters; 347 uint32_t user_waiters; 348 int idle_has_lock; 349}; 350 351/** 352 * struct drm_master - drm master structure 353 * 354 * @refcount: Refcount for this master object. 355 * @minor: Link back to minor char device we are master for. Immutable. 356 * @unique: Unique identifier: e.g. busid. Protected by drm_global_mutex. 357 * @unique_len: Length of unique field. Protected by drm_global_mutex. 358 * @magiclist: Hash of used authentication tokens. Protected by struct_mutex. 359 * @magicfree: List of used authentication tokens. Protected by struct_mutex. 360 * @lock: DRI lock information. 361 * @driver_priv: Pointer to driver-private information. 362 */ 363struct drm_master { 364 struct kref refcount; 365 struct drm_minor *minor; 366 char *unique; 367 int unique_len; 368 struct drm_open_hash magiclist; 369 struct list_head magicfree; 370 struct drm_lock_data lock; 371 void *driver_priv; 372}; 373 374/* Size of ringbuffer for vblank timestamps. Just double-buffer 375 * in initial implementation. 376 */ 377#define DRM_VBLANKTIME_RBSIZE 2 378 379/* Flags and return codes for get_vblank_timestamp() driver function. */ 380#define DRM_CALLED_FROM_VBLIRQ 1 381#define DRM_VBLANKTIME_SCANOUTPOS_METHOD (1 << 0) 382#define DRM_VBLANKTIME_IN_VBLANK (1 << 1) 383 384/* get_scanout_position() return flags */ 385#define DRM_SCANOUTPOS_VALID (1 << 0) 386#define DRM_SCANOUTPOS_IN_VBLANK (1 << 1) 387#define DRM_SCANOUTPOS_ACCURATE (1 << 2) 388 389/** 390 * DRM driver structure. This structure represent the common code for 391 * a family of cards. There will one drm_device for each card present 392 * in this family 393 */ 394struct drm_driver { 395 int (*load) (struct drm_device *, unsigned long flags); 396 int (*firstopen) (struct drm_device *); 397 int (*open) (struct drm_device *, struct drm_file *); 398 void (*preclose) (struct drm_device *, struct drm_file *file_priv); 399 void (*postclose) (struct drm_device *, struct drm_file *); 400 void (*lastclose) (struct drm_device *); 401 int (*unload) (struct drm_device *); 402 int (*suspend) (struct drm_device *, pm_message_t state); 403 int (*resume) (struct drm_device *); 404 int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv); 405 int (*dma_quiescent) (struct drm_device *); 406 int (*context_dtor) (struct drm_device *dev, int context); 407 int (*set_busid)(struct drm_device *dev, struct drm_master *master); 408 409 /** 410 * get_vblank_counter - get raw hardware vblank counter 411 * @dev: DRM device 412 * @crtc: counter to fetch 413 * 414 * Driver callback for fetching a raw hardware vblank counter for @crtc. 415 * If a device doesn't have a hardware counter, the driver can simply 416 * return the value of drm_vblank_count. The DRM core will account for 417 * missed vblank events while interrupts where disabled based on system 418 * timestamps. 419 * 420 * Wraparound handling and loss of events due to modesetting is dealt 421 * with in the DRM core code. 422 * 423 * RETURNS 424 * Raw vblank counter value. 425 */ 426 u32 (*get_vblank_counter) (struct drm_device *dev, int crtc); 427 428 /** 429 * enable_vblank - enable vblank interrupt events 430 * @dev: DRM device 431 * @crtc: which irq to enable 432 * 433 * Enable vblank interrupts for @crtc. If the device doesn't have 434 * a hardware vblank counter, this routine should be a no-op, since 435 * interrupts will have to stay on to keep the count accurate. 436 * 437 * RETURNS 438 * Zero on success, appropriate errno if the given @crtc's vblank 439 * interrupt cannot be enabled. 440 */ 441 int (*enable_vblank) (struct drm_device *dev, int crtc); 442 443 /** 444 * disable_vblank - disable vblank interrupt events 445 * @dev: DRM device 446 * @crtc: which irq to enable 447 * 448 * Disable vblank interrupts for @crtc. If the device doesn't have 449 * a hardware vblank counter, this routine should be a no-op, since 450 * interrupts will have to stay on to keep the count accurate. 451 */ 452 void (*disable_vblank) (struct drm_device *dev, int crtc); 453 454 /** 455 * Called by \c drm_device_is_agp. Typically used to determine if a 456 * card is really attached to AGP or not. 457 * 458 * \param dev DRM device handle 459 * 460 * \returns 461 * One of three values is returned depending on whether or not the 462 * card is absolutely \b not AGP (return of 0), absolutely \b is AGP 463 * (return of 1), or may or may not be AGP (return of 2). 464 */ 465 int (*device_is_agp) (struct drm_device *dev); 466 467 /** 468 * Called by vblank timestamping code. 469 * 470 * Return the current display scanout position from a crtc, and an 471 * optional accurate ktime_get timestamp of when position was measured. 472 * 473 * \param dev DRM device. 474 * \param crtc Id of the crtc to query. 475 * \param flags Flags from the caller (DRM_CALLED_FROM_VBLIRQ or 0). 476 * \param *vpos Target location for current vertical scanout position. 477 * \param *hpos Target location for current horizontal scanout position. 478 * \param *stime Target location for timestamp taken immediately before 479 * scanout position query. Can be NULL to skip timestamp. 480 * \param *etime Target location for timestamp taken immediately after 481 * scanout position query. Can be NULL to skip timestamp. 482 * 483 * Returns vpos as a positive number while in active scanout area. 484 * Returns vpos as a negative number inside vblank, counting the number 485 * of scanlines to go until end of vblank, e.g., -1 means "one scanline 486 * until start of active scanout / end of vblank." 487 * 488 * \return Flags, or'ed together as follows: 489 * 490 * DRM_SCANOUTPOS_VALID = Query successful. 491 * DRM_SCANOUTPOS_INVBL = Inside vblank. 492 * DRM_SCANOUTPOS_ACCURATE = Returned position is accurate. A lack of 493 * this flag means that returned position may be offset by a constant 494 * but unknown small number of scanlines wrt. real scanout position. 495 * 496 */ 497 int (*get_scanout_position) (struct drm_device *dev, int crtc, 498 unsigned int flags, 499 int *vpos, int *hpos, ktime_t *stime, 500 ktime_t *etime); 501 502 /** 503 * Called by \c drm_get_last_vbltimestamp. Should return a precise 504 * timestamp when the most recent VBLANK interval ended or will end. 505 * 506 * Specifically, the timestamp in @vblank_time should correspond as 507 * closely as possible to the time when the first video scanline of 508 * the video frame after the end of VBLANK will start scanning out, 509 * the time immediately after end of the VBLANK interval. If the 510 * @crtc is currently inside VBLANK, this will be a time in the future. 511 * If the @crtc is currently scanning out a frame, this will be the 512 * past start time of the current scanout. This is meant to adhere 513 * to the OpenML OML_sync_control extension specification. 514 * 515 * \param dev dev DRM device handle. 516 * \param crtc crtc for which timestamp should be returned. 517 * \param *max_error Maximum allowable timestamp error in nanoseconds. 518 * Implementation should strive to provide timestamp 519 * with an error of at most *max_error nanoseconds. 520 * Returns true upper bound on error for timestamp. 521 * \param *vblank_time Target location for returned vblank timestamp. 522 * \param flags 0 = Defaults, no special treatment needed. 523 * \param DRM_CALLED_FROM_VBLIRQ = Function is called from vblank 524 * irq handler. Some drivers need to apply some workarounds 525 * for gpu-specific vblank irq quirks if flag is set. 526 * 527 * \returns 528 * Zero if timestamping isn't supported in current display mode or a 529 * negative number on failure. A positive status code on success, 530 * which describes how the vblank_time timestamp was computed. 531 */ 532 int (*get_vblank_timestamp) (struct drm_device *dev, int crtc, 533 int *max_error, 534 struct timeval *vblank_time, 535 unsigned flags); 536 537 /* these have to be filled in */ 538 539 irqreturn_t(*irq_handler) (int irq, void *arg); 540 void (*irq_preinstall) (struct drm_device *dev); 541 int (*irq_postinstall) (struct drm_device *dev); 542 void (*irq_uninstall) (struct drm_device *dev); 543 544 /* Master routines */ 545 int (*master_create)(struct drm_device *dev, struct drm_master *master); 546 void (*master_destroy)(struct drm_device *dev, struct drm_master *master); 547 /** 548 * master_set is called whenever the minor master is set. 549 * master_drop is called whenever the minor master is dropped. 550 */ 551 552 int (*master_set)(struct drm_device *dev, struct drm_file *file_priv, 553 bool from_open); 554 void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv, 555 bool from_release); 556 557 int (*debugfs_init)(struct drm_minor *minor); 558 void (*debugfs_cleanup)(struct drm_minor *minor); 559 560 /** 561 * Driver-specific constructor for drm_gem_objects, to set up 562 * obj->driver_private. 563 * 564 * Returns 0 on success. 565 */ 566 void (*gem_free_object) (struct drm_gem_object *obj); 567 int (*gem_open_object) (struct drm_gem_object *, struct drm_file *); 568 void (*gem_close_object) (struct drm_gem_object *, struct drm_file *); 569 570 /* prime: */ 571 /* export handle -> fd (see drm_gem_prime_handle_to_fd() helper) */ 572 int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv, 573 uint32_t handle, uint32_t flags, int *prime_fd); 574 /* import fd -> handle (see drm_gem_prime_fd_to_handle() helper) */ 575 int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv, 576 int prime_fd, uint32_t *handle); 577 /* export GEM -> dmabuf */ 578 struct dma_buf * (*gem_prime_export)(struct drm_device *dev, 579 struct drm_gem_object *obj, int flags); 580 /* import dmabuf -> GEM */ 581 struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev, 582 struct dma_buf *dma_buf); 583 /* low-level interface used by drm_gem_prime_{import,export} */ 584 int (*gem_prime_pin)(struct drm_gem_object *obj); 585 void (*gem_prime_unpin)(struct drm_gem_object *obj); 586 struct reservation_object * (*gem_prime_res_obj)( 587 struct drm_gem_object *obj); 588 struct sg_table *(*gem_prime_get_sg_table)(struct drm_gem_object *obj); 589 struct drm_gem_object *(*gem_prime_import_sg_table)( 590 struct drm_device *dev, 591 struct dma_buf_attachment *attach, 592 struct sg_table *sgt); 593 void *(*gem_prime_vmap)(struct drm_gem_object *obj); 594 void (*gem_prime_vunmap)(struct drm_gem_object *obj, void *vaddr); 595 int (*gem_prime_mmap)(struct drm_gem_object *obj, 596 struct vm_area_struct *vma); 597 598 /* vga arb irq handler */ 599 void (*vgaarb_irq)(struct drm_device *dev, bool state); 600 601 /* dumb alloc support */ 602 int (*dumb_create)(struct drm_file *file_priv, 603 struct drm_device *dev, 604 struct drm_mode_create_dumb *args); 605 int (*dumb_map_offset)(struct drm_file *file_priv, 606 struct drm_device *dev, uint32_t handle, 607 uint64_t *offset); 608 int (*dumb_destroy)(struct drm_file *file_priv, 609 struct drm_device *dev, 610 uint32_t handle); 611 612 /* Driver private ops for this object */ 613 const struct vm_operations_struct *gem_vm_ops; 614 615 int major; 616 int minor; 617 int patchlevel; 618 char *name; 619 char *desc; 620 char *date; 621 622 u32 driver_features; 623 int dev_priv_size; 624 const struct drm_ioctl_desc *ioctls; 625 int num_ioctls; 626 const struct file_operations *fops; 627 628 /* List of devices hanging off this driver with stealth attach. */ 629 struct list_head legacy_dev_list; 630}; 631 632enum drm_minor_type { 633 DRM_MINOR_LEGACY, 634 DRM_MINOR_CONTROL, 635 DRM_MINOR_RENDER, 636 DRM_MINOR_CNT, 637}; 638 639/** 640 * Info file list entry. This structure represents a debugfs or proc file to 641 * be created by the drm core 642 */ 643struct drm_info_list { 644 const char *name; /** file name */ 645 int (*show)(struct seq_file*, void*); /** show callback */ 646 u32 driver_features; /**< Required driver features for this entry */ 647 void *data; 648}; 649 650/** 651 * debugfs node structure. This structure represents a debugfs file. 652 */ 653struct drm_info_node { 654 struct list_head list; 655 struct drm_minor *minor; 656 const struct drm_info_list *info_ent; 657 struct dentry *dent; 658}; 659 660/** 661 * DRM minor structure. This structure represents a drm minor number. 662 */ 663struct drm_minor { 664 int index; /**< Minor device number */ 665 int type; /**< Control or render */ 666 struct device *kdev; /**< Linux device */ 667 struct drm_device *dev; 668 669 struct dentry *debugfs_root; 670 671 struct list_head debugfs_list; 672 struct mutex debugfs_lock; /* Protects debugfs_list. */ 673 674 /* currently active master for this node. Protected by master_mutex */ 675 struct drm_master *master; 676 struct drm_mode_group mode_group; 677}; 678 679 680struct drm_pending_vblank_event { 681 struct drm_pending_event base; 682 int pipe; 683 struct drm_event_vblank event; 684}; 685 686struct drm_vblank_crtc { 687 struct drm_device *dev; /* pointer to the drm_device */ 688 wait_queue_head_t queue; /**< VBLANK wait queue */ 689 struct timeval time[DRM_VBLANKTIME_RBSIZE]; /**< timestamp of current count */ 690 struct timer_list disable_timer; /* delayed disable timer */ 691 atomic_t count; /**< number of VBLANK interrupts */ 692 atomic_t refcount; /* number of users of vblank interruptsper crtc */ 693 u32 last; /* protected by dev->vbl_lock, used */ 694 /* for wraparound handling */ 695 u32 last_wait; /* Last vblank seqno waited per CRTC */ 696 unsigned int inmodeset; /* Display driver is setting mode */ 697 int crtc; /* crtc index */ 698 bool enabled; /* so we don't call enable more than 699 once per disable */ 700}; 701 702/** 703 * DRM device structure. This structure represent a complete card that 704 * may contain multiple heads. 705 */ 706struct drm_device { 707 struct list_head legacy_dev_list;/**< list of devices per driver for stealth attach cleanup */ 708 int if_version; /**< Highest interface version set */ 709 710 /** \name Lifetime Management */ 711 /*@{ */ 712 struct kref ref; /**< Object ref-count */ 713 struct device *dev; /**< Device structure of bus-device */ 714 struct drm_driver *driver; /**< DRM driver managing the device */ 715 void *dev_private; /**< DRM driver private data */ 716 struct drm_minor *control; /**< Control node */ 717 struct drm_minor *primary; /**< Primary node */ 718 struct drm_minor *render; /**< Render node */ 719 atomic_t unplugged; /**< Flag whether dev is dead */ 720 struct inode *anon_inode; /**< inode for private address-space */ 721 char *unique; /**< unique name of the device */ 722 /*@} */ 723 724 /** \name Locks */ 725 /*@{ */ 726 struct mutex struct_mutex; /**< For others */ 727 struct mutex master_mutex; /**< For drm_minor::master and drm_file::is_master */ 728 /*@} */ 729 730 /** \name Usage Counters */ 731 /*@{ */ 732 int open_count; /**< Outstanding files open, protected by drm_global_mutex. */ 733 spinlock_t buf_lock; /**< For drm_device::buf_use and a few other things. */ 734 int buf_use; /**< Buffers in use -- cannot alloc */ 735 atomic_t buf_alloc; /**< Buffer allocation in progress */ 736 /*@} */ 737 738 struct list_head filelist; 739 740 /** \name Memory management */ 741 /*@{ */ 742 struct list_head maplist; /**< Linked list of regions */ 743 struct drm_open_hash map_hash; /**< User token hash table for maps */ 744 745 /** \name Context handle management */ 746 /*@{ */ 747 struct list_head ctxlist; /**< Linked list of context handles */ 748 struct mutex ctxlist_mutex; /**< For ctxlist */ 749 750 struct idr ctx_idr; 751 752 struct list_head vmalist; /**< List of vmas (for debugging) */ 753 754 /*@} */ 755 756 /** \name DMA support */ 757 /*@{ */ 758 struct drm_device_dma *dma; /**< Optional pointer for DMA support */ 759 /*@} */ 760 761 /** \name Context support */ 762 /*@{ */ 763 764 __volatile__ long context_flag; /**< Context swapping flag */ 765 int last_context; /**< Last current context */ 766 /*@} */ 767 768 /** \name VBLANK IRQ support */ 769 /*@{ */ 770 bool irq_enabled; 771 int irq; 772 773 /* 774 * At load time, disabling the vblank interrupt won't be allowed since 775 * old clients may not call the modeset ioctl and therefore misbehave. 776 * Once the modeset ioctl *has* been called though, we can safely 777 * disable them when unused. 778 */ 779 bool vblank_disable_allowed; 780 781 /* 782 * If true, vblank interrupt will be disabled immediately when the 783 * refcount drops to zero, as opposed to via the vblank disable 784 * timer. 785 * This can be set to true it the hardware has a working vblank 786 * counter and the driver uses drm_vblank_on() and drm_vblank_off() 787 * appropriately. 788 */ 789 bool vblank_disable_immediate; 790 791 /* array of size num_crtcs */ 792 struct drm_vblank_crtc *vblank; 793 794 spinlock_t vblank_time_lock; /**< Protects vblank count and time updates during vblank enable/disable */ 795 spinlock_t vbl_lock; 796 797 u32 max_vblank_count; /**< size of vblank counter register */ 798 799 /** 800 * List of events 801 */ 802 struct list_head vblank_event_list; 803 spinlock_t event_lock; 804 805 /*@} */ 806 807 struct drm_agp_head *agp; /**< AGP data */ 808 809 struct pci_dev *pdev; /**< PCI device structure */ 810#ifdef __alpha__ 811 struct pci_controller *hose; 812#endif 813 814 struct platform_device *platformdev; /**< Platform device struture */ 815 816 struct drm_sg_mem *sg; /**< Scatter gather memory */ 817 unsigned int num_crtcs; /**< Number of CRTCs on this device */ 818 sigset_t sigmask; 819 820 struct { 821 int context; 822 struct drm_hw_lock *lock; 823 } sigdata; 824 825 struct drm_local_map *agp_buffer_map; 826 unsigned int agp_buffer_token; 827 828 struct drm_mode_config mode_config; /**< Current mode config */ 829 830 /** \name GEM information */ 831 /*@{ */ 832 struct mutex object_name_lock; 833 struct idr object_name_idr; 834 struct drm_vma_offset_manager *vma_offset_manager; 835 /*@} */ 836 int switch_power_state; 837}; 838 839#define DRM_SWITCH_POWER_ON 0 840#define DRM_SWITCH_POWER_OFF 1 841#define DRM_SWITCH_POWER_CHANGING 2 842#define DRM_SWITCH_POWER_DYNAMIC_OFF 3 843 844static __inline__ int drm_core_check_feature(struct drm_device *dev, 845 int feature) 846{ 847 return ((dev->driver->driver_features & feature) ? 1 : 0); 848} 849 850static inline void drm_device_set_unplugged(struct drm_device *dev) 851{ 852 smp_wmb(); 853 atomic_set(&dev->unplugged, 1); 854} 855 856static inline int drm_device_is_unplugged(struct drm_device *dev) 857{ 858 int ret = atomic_read(&dev->unplugged); 859 smp_rmb(); 860 return ret; 861} 862 863static inline bool drm_is_render_client(const struct drm_file *file_priv) 864{ 865 return file_priv->minor->type == DRM_MINOR_RENDER; 866} 867 868static inline bool drm_is_control_client(const struct drm_file *file_priv) 869{ 870 return file_priv->minor->type == DRM_MINOR_CONTROL; 871} 872 873static inline bool drm_is_primary_client(const struct drm_file *file_priv) 874{ 875 return file_priv->minor->type == DRM_MINOR_LEGACY; 876} 877 878/******************************************************************/ 879/** \name Internal function definitions */ 880/*@{*/ 881 882 /* Driver support (drm_drv.h) */ 883extern long drm_ioctl(struct file *filp, 884 unsigned int cmd, unsigned long arg); 885extern long drm_compat_ioctl(struct file *filp, 886 unsigned int cmd, unsigned long arg); 887extern bool drm_ioctl_flags(unsigned int nr, unsigned int *flags); 888 889 /* Device support (drm_fops.h) */ 890extern int drm_open(struct inode *inode, struct file *filp); 891extern ssize_t drm_read(struct file *filp, char __user *buffer, 892 size_t count, loff_t *offset); 893extern int drm_release(struct inode *inode, struct file *filp); 894 895 /* Mapping support (drm_vm.h) */ 896extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait); 897 898/* Misc. IOCTL support (drm_ioctl.c) */ 899int drm_noop(struct drm_device *dev, void *data, 900 struct drm_file *file_priv); 901 902/* Cache management (drm_cache.c) */ 903void drm_clflush_pages(struct page *pages[], unsigned long num_pages); 904void drm_clflush_sg(struct sg_table *st); 905void drm_clflush_virt_range(void *addr, unsigned long length); 906 907/* 908 * These are exported to drivers so that they can implement fencing using 909 * DMA quiscent + idle. DMA quiescent usually requires the hardware lock. 910 */ 911 912 /* IRQ support (drm_irq.h) */ 913extern int drm_irq_install(struct drm_device *dev, int irq); 914extern int drm_irq_uninstall(struct drm_device *dev); 915 916extern int drm_vblank_init(struct drm_device *dev, int num_crtcs); 917extern int drm_wait_vblank(struct drm_device *dev, void *data, 918 struct drm_file *filp); 919extern u32 drm_vblank_count(struct drm_device *dev, int crtc); 920extern u32 drm_crtc_vblank_count(struct drm_crtc *crtc); 921extern u32 drm_vblank_count_and_time(struct drm_device *dev, int crtc, 922 struct timeval *vblanktime); 923extern void drm_send_vblank_event(struct drm_device *dev, int crtc, 924 struct drm_pending_vblank_event *e); 925extern void drm_crtc_send_vblank_event(struct drm_crtc *crtc, 926 struct drm_pending_vblank_event *e); 927extern bool drm_handle_vblank(struct drm_device *dev, int crtc); 928extern bool drm_crtc_handle_vblank(struct drm_crtc *crtc); 929extern int drm_vblank_get(struct drm_device *dev, int crtc); 930extern void drm_vblank_put(struct drm_device *dev, int crtc); 931extern int drm_crtc_vblank_get(struct drm_crtc *crtc); 932extern void drm_crtc_vblank_put(struct drm_crtc *crtc); 933extern void drm_wait_one_vblank(struct drm_device *dev, int crtc); 934extern void drm_crtc_wait_one_vblank(struct drm_crtc *crtc); 935extern void drm_vblank_off(struct drm_device *dev, int crtc); 936extern void drm_vblank_on(struct drm_device *dev, int crtc); 937extern void drm_crtc_vblank_off(struct drm_crtc *crtc); 938extern void drm_crtc_vblank_reset(struct drm_crtc *crtc); 939extern void drm_crtc_vblank_on(struct drm_crtc *crtc); 940extern void drm_vblank_cleanup(struct drm_device *dev); 941 942extern int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev, 943 int crtc, int *max_error, 944 struct timeval *vblank_time, 945 unsigned flags, 946 const struct drm_crtc *refcrtc, 947 const struct drm_display_mode *mode); 948extern void drm_calc_timestamping_constants(struct drm_crtc *crtc, 949 const struct drm_display_mode *mode); 950 951/** 952 * drm_crtc_vblank_waitqueue - get vblank waitqueue for the CRTC 953 * @crtc: which CRTC's vblank waitqueue to retrieve 954 * 955 * This function returns a pointer to the vblank waitqueue for the CRTC. 956 * Drivers can use this to implement vblank waits using wait_event() & co. 957 */ 958static inline wait_queue_head_t *drm_crtc_vblank_waitqueue(struct drm_crtc *crtc) 959{ 960 return &crtc->dev->vblank[drm_crtc_index(crtc)].queue; 961} 962 963/* Modesetting support */ 964extern void drm_vblank_pre_modeset(struct drm_device *dev, int crtc); 965extern void drm_vblank_post_modeset(struct drm_device *dev, int crtc); 966 967 /* Stub support (drm_stub.h) */ 968extern struct drm_master *drm_master_get(struct drm_master *master); 969extern void drm_master_put(struct drm_master **master); 970 971extern void drm_put_dev(struct drm_device *dev); 972extern void drm_unplug_dev(struct drm_device *dev); 973extern unsigned int drm_debug; 974extern bool drm_atomic; 975 976 /* Debugfs support */ 977#if defined(CONFIG_DEBUG_FS) 978extern int drm_debugfs_create_files(const struct drm_info_list *files, 979 int count, struct dentry *root, 980 struct drm_minor *minor); 981extern int drm_debugfs_remove_files(const struct drm_info_list *files, 982 int count, struct drm_minor *minor); 983#else 984static inline int drm_debugfs_create_files(const struct drm_info_list *files, 985 int count, struct dentry *root, 986 struct drm_minor *minor) 987{ 988 return 0; 989} 990 991static inline int drm_debugfs_remove_files(const struct drm_info_list *files, 992 int count, struct drm_minor *minor) 993{ 994 return 0; 995} 996#endif 997 998extern struct dma_buf *drm_gem_prime_export(struct drm_device *dev, 999 struct drm_gem_object *obj, int flags); 1000extern int drm_gem_prime_handle_to_fd(struct drm_device *dev, 1001 struct drm_file *file_priv, uint32_t handle, uint32_t flags, 1002 int *prime_fd); 1003extern struct drm_gem_object *drm_gem_prime_import(struct drm_device *dev, 1004 struct dma_buf *dma_buf); 1005extern int drm_gem_prime_fd_to_handle(struct drm_device *dev, 1006 struct drm_file *file_priv, int prime_fd, uint32_t *handle); 1007extern void drm_gem_dmabuf_release(struct dma_buf *dma_buf); 1008 1009extern int drm_prime_sg_to_page_addr_arrays(struct sg_table *sgt, struct page **pages, 1010 dma_addr_t *addrs, int max_pages); 1011extern struct sg_table *drm_prime_pages_to_sg(struct page **pages, unsigned int nr_pages); 1012extern void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg); 1013 1014 1015extern struct drm_dma_handle *drm_pci_alloc(struct drm_device *dev, size_t size, 1016 size_t align); 1017extern void drm_pci_free(struct drm_device *dev, struct drm_dma_handle * dmah); 1018 1019 /* sysfs support (drm_sysfs.c) */ 1020extern void drm_sysfs_hotplug_event(struct drm_device *dev); 1021 1022 1023struct drm_device *drm_dev_alloc(struct drm_driver *driver, 1024 struct device *parent); 1025void drm_dev_ref(struct drm_device *dev); 1026void drm_dev_unref(struct drm_device *dev); 1027int drm_dev_register(struct drm_device *dev, unsigned long flags); 1028void drm_dev_unregister(struct drm_device *dev); 1029int drm_dev_set_unique(struct drm_device *dev, const char *fmt, ...); 1030 1031struct drm_minor *drm_minor_acquire(unsigned int minor_id); 1032void drm_minor_release(struct drm_minor *minor); 1033 1034/*@}*/ 1035 1036/* PCI section */ 1037static __inline__ int drm_pci_device_is_agp(struct drm_device *dev) 1038{ 1039 if (dev->driver->device_is_agp != NULL) { 1040 int err = (*dev->driver->device_is_agp) (dev); 1041 1042 if (err != 2) { 1043 return err; 1044 } 1045 } 1046 1047 return pci_find_capability(dev->pdev, PCI_CAP_ID_AGP); 1048} 1049void drm_pci_agp_destroy(struct drm_device *dev); 1050 1051extern int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver); 1052extern void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver); 1053#ifdef CONFIG_PCI 1054extern int drm_get_pci_dev(struct pci_dev *pdev, 1055 const struct pci_device_id *ent, 1056 struct drm_driver *driver); 1057extern int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master); 1058#else 1059static inline int drm_get_pci_dev(struct pci_dev *pdev, 1060 const struct pci_device_id *ent, 1061 struct drm_driver *driver) 1062{ 1063 return -ENOSYS; 1064} 1065 1066static inline int drm_pci_set_busid(struct drm_device *dev, 1067 struct drm_master *master) 1068{ 1069 return -ENOSYS; 1070} 1071#endif 1072 1073#define DRM_PCIE_SPEED_25 1 1074#define DRM_PCIE_SPEED_50 2 1075#define DRM_PCIE_SPEED_80 4 1076 1077extern int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *speed_mask); 1078 1079/* platform section */ 1080extern int drm_platform_init(struct drm_driver *driver, struct platform_device *platform_device); 1081extern int drm_platform_set_busid(struct drm_device *d, struct drm_master *m); 1082 1083/* returns true if currently okay to sleep */ 1084static __inline__ bool drm_can_sleep(void) 1085{ 1086 if (in_atomic() || in_dbg_master() || irqs_disabled()) 1087 return false; 1088 return true; 1089} 1090 1091#endif 1092