1 /* 2 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. 3 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. 4 * Copyright (c) 2009-2010, Code Aurora Forum. 5 * Copyright 2016 Intel Corp. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the next 15 * paragraph) shall be included in all copies or substantial portions of the 16 * Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 21 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 22 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 23 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 24 * OTHER DEALINGS IN THE SOFTWARE. 25 */ 26 27 #ifndef _DRM_DRV_H_ 28 #define _DRM_DRV_H_ 29 30 #include <linux/list.h> 31 #include <linux/irqreturn.h> 32 33 #include <drm/drm_device.h> 34 35 struct drm_file; 36 struct drm_gem_object; 37 struct drm_master; 38 struct drm_minor; 39 struct dma_buf_attachment; 40 struct drm_display_mode; 41 struct drm_mode_create_dumb; 42 struct drm_printer; 43 44 /** 45 * enum drm_driver_feature - feature flags 46 * 47 * See &drm_driver.driver_features, drm_device.driver_features and 48 * drm_core_check_feature(). 49 */ 50 enum drm_driver_feature { 51 /** 52 * @DRIVER_GEM: 53 * 54 * Driver use the GEM memory manager. This should be set for all modern 55 * drivers. 56 */ 57 DRIVER_GEM = BIT(0), 58 /** 59 * @DRIVER_MODESET: 60 * 61 * Driver supports mode setting interfaces (KMS). 62 */ 63 DRIVER_MODESET = BIT(1), 64 /** 65 * @DRIVER_PRIME: 66 * 67 * Driver implements DRM PRIME buffer sharing. 68 */ 69 DRIVER_PRIME = BIT(2), 70 /** 71 * @DRIVER_RENDER: 72 * 73 * Driver supports dedicated render nodes. See also the :ref:`section on 74 * render nodes <drm_render_node>` for details. 75 */ 76 DRIVER_RENDER = BIT(3), 77 /** 78 * @DRIVER_ATOMIC: 79 * 80 * Driver supports the full atomic modesetting userspace API. Drivers 81 * which only use atomic internally, but do not the support the full 82 * userspace API (e.g. not all properties converted to atomic, or 83 * multi-plane updates are not guaranteed to be tear-free) should not 84 * set this flag. 85 */ 86 DRIVER_ATOMIC = BIT(4), 87 /** 88 * @DRIVER_SYNCOBJ: 89 * 90 * Driver supports &drm_syncobj for explicit synchronization of command 91 * submission. 92 */ 93 DRIVER_SYNCOBJ = BIT(5), 94 95 /* IMPORTANT: Below are all the legacy flags, add new ones above. */ 96 97 /** 98 * @DRIVER_USE_AGP: 99 * 100 * Set up DRM AGP support, see drm_agp_init(), the DRM core will manage 101 * AGP resources. New drivers don't need this. 102 */ 103 DRIVER_USE_AGP = BIT(24), 104 /** 105 * @DRIVER_LEGACY: 106 * 107 * Denote a legacy driver using shadow attach. Do not use. 108 */ 109 DRIVER_LEGACY = BIT(25), 110 /** 111 * @DRIVER_PCI_DMA: 112 * 113 * Driver is capable of PCI DMA, mapping of PCI DMA buffers to userspace 114 * will be enabled. Only for legacy drivers. Do not use. 115 */ 116 DRIVER_PCI_DMA = BIT(26), 117 /** 118 * @DRIVER_SG: 119 * 120 * Driver can perform scatter/gather DMA, allocation and mapping of 121 * scatter/gather buffers will be enabled. Only for legacy drivers. Do 122 * not use. 123 */ 124 DRIVER_SG = BIT(27), 125 126 /** 127 * @DRIVER_HAVE_DMA: 128 * 129 * Driver supports DMA, the userspace DMA API will be supported. Only 130 * for legacy drivers. Do not use. 131 */ 132 DRIVER_HAVE_DMA = BIT(28), 133 /** 134 * @DRIVER_HAVE_IRQ: 135 * 136 * Legacy irq support. Only for legacy drivers. Do not use. 137 * 138 * New drivers can either use the drm_irq_install() and 139 * drm_irq_uninstall() helper functions, or roll their own irq support 140 * code by calling request_irq() directly. 141 */ 142 DRIVER_HAVE_IRQ = BIT(29), 143 /** 144 * @DRIVER_IRQ_SHARED: 145 * 146 * Indicates to drm_irq_install() that a shared irq should be requested. 147 * 148 * FIXME: This should be an explicit argument for non-legacy drivers, or 149 * at least the default for PCI devices (which would cover all current 150 * users). 151 */ 152 DRIVER_IRQ_SHARED = BIT(30), 153 /** 154 * @DRIVER_KMS_LEGACY_CONTEXT: 155 * 156 * Used only by nouveau for backwards compatibility with existing 157 * userspace. Do not use. 158 */ 159 DRIVER_KMS_LEGACY_CONTEXT = BIT(31), 160 }; 161 162 /** 163 * struct drm_driver - DRM driver structure 164 * 165 * This structure represent the common code for a family of cards. There will 166 * one drm_device for each card present in this family. It contains lots of 167 * vfunc entries, and a pile of those probably should be moved to more 168 * appropriate places like &drm_mode_config_funcs or into a new operations 169 * structure for GEM drivers. 170 */ 171 struct drm_driver { 172 /** 173 * @load: 174 * 175 * Backward-compatible driver callback to complete 176 * initialization steps after the driver is registered. For 177 * this reason, may suffer from race conditions and its use is 178 * deprecated for new drivers. It is therefore only supported 179 * for existing drivers not yet converted to the new scheme. 180 * See drm_dev_init() and drm_dev_register() for proper and 181 * race-free way to set up a &struct drm_device. 182 * 183 * This is deprecated, do not use! 184 * 185 * Returns: 186 * 187 * Zero on success, non-zero value on failure. 188 */ 189 int (*load) (struct drm_device *, unsigned long flags); 190 191 /** 192 * @open: 193 * 194 * Driver callback when a new &struct drm_file is opened. Useful for 195 * setting up driver-private data structures like buffer allocators, 196 * execution contexts or similar things. Such driver-private resources 197 * must be released again in @postclose. 198 * 199 * Since the display/modeset side of DRM can only be owned by exactly 200 * one &struct drm_file (see &drm_file.is_master and &drm_device.master) 201 * there should never be a need to set up any modeset related resources 202 * in this callback. Doing so would be a driver design bug. 203 * 204 * Returns: 205 * 206 * 0 on success, a negative error code on failure, which will be 207 * promoted to userspace as the result of the open() system call. 208 */ 209 int (*open) (struct drm_device *, struct drm_file *); 210 211 /** 212 * @postclose: 213 * 214 * One of the driver callbacks when a new &struct drm_file is closed. 215 * Useful for tearing down driver-private data structures allocated in 216 * @open like buffer allocators, execution contexts or similar things. 217 * 218 * Since the display/modeset side of DRM can only be owned by exactly 219 * one &struct drm_file (see &drm_file.is_master and &drm_device.master) 220 * there should never be a need to tear down any modeset related 221 * resources in this callback. Doing so would be a driver design bug. 222 */ 223 void (*postclose) (struct drm_device *, struct drm_file *); 224 225 /** 226 * @lastclose: 227 * 228 * Called when the last &struct drm_file has been closed and there's 229 * currently no userspace client for the &struct drm_device. 230 * 231 * Modern drivers should only use this to force-restore the fbdev 232 * framebuffer using drm_fb_helper_restore_fbdev_mode_unlocked(). 233 * Anything else would indicate there's something seriously wrong. 234 * Modern drivers can also use this to execute delayed power switching 235 * state changes, e.g. in conjunction with the :ref:`vga_switcheroo` 236 * infrastructure. 237 * 238 * This is called after @postclose hook has been called. 239 * 240 * NOTE: 241 * 242 * All legacy drivers use this callback to de-initialize the hardware. 243 * This is purely because of the shadow-attach model, where the DRM 244 * kernel driver does not really own the hardware. Instead ownershipe is 245 * handled with the help of userspace through an inheritedly racy dance 246 * to set/unset the VT into raw mode. 247 * 248 * Legacy drivers initialize the hardware in the @firstopen callback, 249 * which isn't even called for modern drivers. 250 */ 251 void (*lastclose) (struct drm_device *); 252 253 /** 254 * @unload: 255 * 256 * Reverse the effects of the driver load callback. Ideally, 257 * the clean up performed by the driver should happen in the 258 * reverse order of the initialization. Similarly to the load 259 * hook, this handler is deprecated and its usage should be 260 * dropped in favor of an open-coded teardown function at the 261 * driver layer. See drm_dev_unregister() and drm_dev_put() 262 * for the proper way to remove a &struct drm_device. 263 * 264 * The unload() hook is called right after unregistering 265 * the device. 266 * 267 */ 268 void (*unload) (struct drm_device *); 269 270 /** 271 * @release: 272 * 273 * Optional callback for destroying device data after the final 274 * reference is released, i.e. the device is being destroyed. Drivers 275 * using this callback are responsible for calling drm_dev_fini() 276 * to finalize the device and then freeing the struct themselves. 277 */ 278 void (*release) (struct drm_device *); 279 280 /** 281 * @get_vblank_counter: 282 * 283 * Driver callback for fetching a raw hardware vblank counter for the 284 * CRTC specified with the pipe argument. If a device doesn't have a 285 * hardware counter, the driver can simply leave the hook as NULL. 286 * The DRM core will account for missed vblank events while interrupts 287 * where disabled based on system timestamps. 288 * 289 * Wraparound handling and loss of events due to modesetting is dealt 290 * with in the DRM core code, as long as drivers call 291 * drm_crtc_vblank_off() and drm_crtc_vblank_on() when disabling or 292 * enabling a CRTC. 293 * 294 * This is deprecated and should not be used by new drivers. 295 * Use &drm_crtc_funcs.get_vblank_counter instead. 296 * 297 * Returns: 298 * 299 * Raw vblank counter value. 300 */ 301 u32 (*get_vblank_counter) (struct drm_device *dev, unsigned int pipe); 302 303 /** 304 * @enable_vblank: 305 * 306 * Enable vblank interrupts for the CRTC specified with the pipe 307 * argument. 308 * 309 * This is deprecated and should not be used by new drivers. 310 * Use &drm_crtc_funcs.enable_vblank instead. 311 * 312 * Returns: 313 * 314 * Zero on success, appropriate errno if the given @crtc's vblank 315 * interrupt cannot be enabled. 316 */ 317 int (*enable_vblank) (struct drm_device *dev, unsigned int pipe); 318 319 /** 320 * @disable_vblank: 321 * 322 * Disable vblank interrupts for the CRTC specified with the pipe 323 * argument. 324 * 325 * This is deprecated and should not be used by new drivers. 326 * Use &drm_crtc_funcs.disable_vblank instead. 327 */ 328 void (*disable_vblank) (struct drm_device *dev, unsigned int pipe); 329 330 /** 331 * @get_scanout_position: 332 * 333 * Called by vblank timestamping code. 334 * 335 * Returns the current display scanout position from a crtc, and an 336 * optional accurate ktime_get() timestamp of when position was 337 * measured. Note that this is a helper callback which is only used if a 338 * driver uses drm_calc_vbltimestamp_from_scanoutpos() for the 339 * @get_vblank_timestamp callback. 340 * 341 * Parameters: 342 * 343 * dev: 344 * DRM device. 345 * pipe: 346 * Id of the crtc to query. 347 * in_vblank_irq: 348 * True when called from drm_crtc_handle_vblank(). Some drivers 349 * need to apply some workarounds for gpu-specific vblank irq quirks 350 * if flag is set. 351 * vpos: 352 * Target location for current vertical scanout position. 353 * hpos: 354 * Target location for current horizontal scanout position. 355 * stime: 356 * Target location for timestamp taken immediately before 357 * scanout position query. Can be NULL to skip timestamp. 358 * etime: 359 * Target location for timestamp taken immediately after 360 * scanout position query. Can be NULL to skip timestamp. 361 * mode: 362 * Current display timings. 363 * 364 * Returns vpos as a positive number while in active scanout area. 365 * Returns vpos as a negative number inside vblank, counting the number 366 * of scanlines to go until end of vblank, e.g., -1 means "one scanline 367 * until start of active scanout / end of vblank." 368 * 369 * Returns: 370 * 371 * True on success, false if a reliable scanout position counter could 372 * not be read out. 373 * 374 * FIXME: 375 * 376 * Since this is a helper to implement @get_vblank_timestamp, we should 377 * move it to &struct drm_crtc_helper_funcs, like all the other 378 * helper-internal hooks. 379 */ 380 bool (*get_scanout_position) (struct drm_device *dev, unsigned int pipe, 381 bool in_vblank_irq, int *vpos, int *hpos, 382 ktime_t *stime, ktime_t *etime, 383 const struct drm_display_mode *mode); 384 385 /** 386 * @get_vblank_timestamp: 387 * 388 * Called by drm_get_last_vbltimestamp(). Should return a precise 389 * timestamp when the most recent VBLANK interval ended or will end. 390 * 391 * Specifically, the timestamp in @vblank_time should correspond as 392 * closely as possible to the time when the first video scanline of 393 * the video frame after the end of VBLANK will start scanning out, 394 * the time immediately after end of the VBLANK interval. If the 395 * @crtc is currently inside VBLANK, this will be a time in the future. 396 * If the @crtc is currently scanning out a frame, this will be the 397 * past start time of the current scanout. This is meant to adhere 398 * to the OpenML OML_sync_control extension specification. 399 * 400 * Paramters: 401 * 402 * dev: 403 * dev DRM device handle. 404 * pipe: 405 * crtc for which timestamp should be returned. 406 * max_error: 407 * Maximum allowable timestamp error in nanoseconds. 408 * Implementation should strive to provide timestamp 409 * with an error of at most max_error nanoseconds. 410 * Returns true upper bound on error for timestamp. 411 * vblank_time: 412 * Target location for returned vblank timestamp. 413 * in_vblank_irq: 414 * True when called from drm_crtc_handle_vblank(). Some drivers 415 * need to apply some workarounds for gpu-specific vblank irq quirks 416 * if flag is set. 417 * 418 * Returns: 419 * 420 * True on success, false on failure, which means the core should 421 * fallback to a simple timestamp taken in drm_crtc_handle_vblank(). 422 * 423 * FIXME: 424 * 425 * We should move this hook to &struct drm_crtc_funcs like all the other 426 * vblank hooks. 427 */ 428 bool (*get_vblank_timestamp) (struct drm_device *dev, unsigned int pipe, 429 int *max_error, 430 ktime_t *vblank_time, 431 bool in_vblank_irq); 432 433 /** 434 * @irq_handler: 435 * 436 * Interrupt handler called when using drm_irq_install(). Not used by 437 * drivers which implement their own interrupt handling. 438 */ 439 irqreturn_t(*irq_handler) (int irq, void *arg); 440 441 /** 442 * @irq_preinstall: 443 * 444 * Optional callback used by drm_irq_install() which is called before 445 * the interrupt handler is registered. This should be used to clear out 446 * any pending interrupts (from e.g. firmware based drives) and reset 447 * the interrupt handling registers. 448 */ 449 void (*irq_preinstall) (struct drm_device *dev); 450 451 /** 452 * @irq_postinstall: 453 * 454 * Optional callback used by drm_irq_install() which is called after 455 * the interrupt handler is registered. This should be used to enable 456 * interrupt generation in the hardware. 457 */ 458 int (*irq_postinstall) (struct drm_device *dev); 459 460 /** 461 * @irq_uninstall: 462 * 463 * Optional callback used by drm_irq_uninstall() which is called before 464 * the interrupt handler is unregistered. This should be used to disable 465 * interrupt generation in the hardware. 466 */ 467 void (*irq_uninstall) (struct drm_device *dev); 468 469 /** 470 * @master_create: 471 * 472 * Called whenever a new master is created. Only used by vmwgfx. 473 */ 474 int (*master_create)(struct drm_device *dev, struct drm_master *master); 475 476 /** 477 * @master_destroy: 478 * 479 * Called whenever a master is destroyed. Only used by vmwgfx. 480 */ 481 void (*master_destroy)(struct drm_device *dev, struct drm_master *master); 482 483 /** 484 * @master_set: 485 * 486 * Called whenever the minor master is set. Only used by vmwgfx. 487 */ 488 int (*master_set)(struct drm_device *dev, struct drm_file *file_priv, 489 bool from_open); 490 /** 491 * @master_drop: 492 * 493 * Called whenever the minor master is dropped. Only used by vmwgfx. 494 */ 495 void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv); 496 497 /** 498 * @debugfs_init: 499 * 500 * Allows drivers to create driver-specific debugfs files. 501 */ 502 int (*debugfs_init)(struct drm_minor *minor); 503 504 /** 505 * @gem_free_object: deconstructor for drm_gem_objects 506 * 507 * This is deprecated and should not be used by new drivers. Use 508 * @gem_free_object_unlocked instead. 509 */ 510 void (*gem_free_object) (struct drm_gem_object *obj); 511 512 /** 513 * @gem_free_object_unlocked: deconstructor for drm_gem_objects 514 * 515 * This is for drivers which are not encumbered with &drm_device.struct_mutex 516 * legacy locking schemes. Use this hook instead of @gem_free_object. 517 */ 518 void (*gem_free_object_unlocked) (struct drm_gem_object *obj); 519 520 /** 521 * @gem_open_object: 522 * 523 * Driver hook called upon gem handle creation 524 */ 525 int (*gem_open_object) (struct drm_gem_object *, struct drm_file *); 526 527 /** 528 * @gem_close_object: 529 * 530 * Driver hook called upon gem handle release 531 */ 532 void (*gem_close_object) (struct drm_gem_object *, struct drm_file *); 533 534 /** 535 * @gem_print_info: 536 * 537 * If driver subclasses struct &drm_gem_object, it can implement this 538 * optional hook for printing additional driver specific info. 539 * 540 * drm_printf_indent() should be used in the callback passing it the 541 * indent argument. 542 * 543 * This callback is called from drm_gem_print_info(). 544 */ 545 void (*gem_print_info)(struct drm_printer *p, unsigned int indent, 546 const struct drm_gem_object *obj); 547 548 /** 549 * @gem_create_object: constructor for gem objects 550 * 551 * Hook for allocating the GEM object struct, for use by core 552 * helpers. 553 */ 554 struct drm_gem_object *(*gem_create_object)(struct drm_device *dev, 555 size_t size); 556 557 /* prime: */ 558 /** 559 * @prime_handle_to_fd: 560 * 561 * export handle -> fd (see drm_gem_prime_handle_to_fd() helper) 562 */ 563 int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv, 564 uint32_t handle, uint32_t flags, int *prime_fd); 565 /** 566 * @prime_fd_to_handle: 567 * 568 * import fd -> handle (see drm_gem_prime_fd_to_handle() helper) 569 */ 570 int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv, 571 int prime_fd, uint32_t *handle); 572 /** 573 * @gem_prime_export: 574 * 575 * export GEM -> dmabuf 576 * 577 * This defaults to drm_gem_prime_export() if not set. 578 */ 579 struct dma_buf * (*gem_prime_export)(struct drm_device *dev, 580 struct drm_gem_object *obj, int flags); 581 /** 582 * @gem_prime_import: 583 * 584 * import dmabuf -> GEM 585 * 586 * This defaults to drm_gem_prime_import() if not set. 587 */ 588 struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev, 589 struct dma_buf *dma_buf); 590 int (*gem_prime_pin)(struct drm_gem_object *obj); 591 void (*gem_prime_unpin)(struct drm_gem_object *obj); 592 struct reservation_object * (*gem_prime_res_obj)( 593 struct drm_gem_object *obj); 594 struct sg_table *(*gem_prime_get_sg_table)(struct drm_gem_object *obj); 595 struct drm_gem_object *(*gem_prime_import_sg_table)( 596 struct drm_device *dev, 597 struct dma_buf_attachment *attach, 598 struct sg_table *sgt); 599 void *(*gem_prime_vmap)(struct drm_gem_object *obj); 600 void (*gem_prime_vunmap)(struct drm_gem_object *obj, void *vaddr); 601 int (*gem_prime_mmap)(struct drm_gem_object *obj, 602 struct vm_area_struct *vma); 603 604 /** 605 * @dumb_create: 606 * 607 * This creates a new dumb buffer in the driver's backing storage manager (GEM, 608 * TTM or something else entirely) and returns the resulting buffer handle. This 609 * handle can then be wrapped up into a framebuffer modeset object. 610 * 611 * Note that userspace is not allowed to use such objects for render 612 * acceleration - drivers must create their own private ioctls for such a use 613 * case. 614 * 615 * Width, height and depth are specified in the &drm_mode_create_dumb 616 * argument. The callback needs to fill the handle, pitch and size for 617 * the created buffer. 618 * 619 * Called by the user via ioctl. 620 * 621 * Returns: 622 * 623 * Zero on success, negative errno on failure. 624 */ 625 int (*dumb_create)(struct drm_file *file_priv, 626 struct drm_device *dev, 627 struct drm_mode_create_dumb *args); 628 /** 629 * @dumb_map_offset: 630 * 631 * Allocate an offset in the drm device node's address space to be able to 632 * memory map a dumb buffer. 633 * 634 * The default implementation is drm_gem_create_mmap_offset(). GEM based 635 * drivers must not overwrite this. 636 * 637 * Called by the user via ioctl. 638 * 639 * Returns: 640 * 641 * Zero on success, negative errno on failure. 642 */ 643 int (*dumb_map_offset)(struct drm_file *file_priv, 644 struct drm_device *dev, uint32_t handle, 645 uint64_t *offset); 646 /** 647 * @dumb_destroy: 648 * 649 * This destroys the userspace handle for the given dumb backing storage buffer. 650 * Since buffer objects must be reference counted in the kernel a buffer object 651 * won't be immediately freed if a framebuffer modeset object still uses it. 652 * 653 * Called by the user via ioctl. 654 * 655 * The default implementation is drm_gem_dumb_destroy(). GEM based drivers 656 * must not overwrite this. 657 * 658 * Returns: 659 * 660 * Zero on success, negative errno on failure. 661 */ 662 int (*dumb_destroy)(struct drm_file *file_priv, 663 struct drm_device *dev, 664 uint32_t handle); 665 666 /** 667 * @gem_vm_ops: Driver private ops for this object 668 */ 669 const struct vm_operations_struct *gem_vm_ops; 670 671 /** @major: driver major number */ 672 int major; 673 /** @minor: driver minor number */ 674 int minor; 675 /** @patchlevel: driver patch level */ 676 int patchlevel; 677 /** @name: driver name */ 678 char *name; 679 /** @desc: driver description */ 680 char *desc; 681 /** @date: driver date */ 682 char *date; 683 684 /** 685 * @driver_features: 686 * Driver features, see &enum drm_driver_feature. Drivers can disable 687 * some features on a per-instance basis using 688 * &drm_device.driver_features. 689 */ 690 u32 driver_features; 691 692 /** 693 * @ioctls: 694 * 695 * Array of driver-private IOCTL description entries. See the chapter on 696 * :ref:`IOCTL support in the userland interfaces 697 * chapter<drm_driver_ioctl>` for the full details. 698 */ 699 700 const struct drm_ioctl_desc *ioctls; 701 /** @num_ioctls: Number of entries in @ioctls. */ 702 int num_ioctls; 703 704 /** 705 * @fops: 706 * 707 * File operations for the DRM device node. See the discussion in 708 * :ref:`file operations<drm_driver_fops>` for in-depth coverage and 709 * some examples. 710 */ 711 const struct file_operations *fops; 712 713 /* Everything below here is for legacy driver, never use! */ 714 /* private: */ 715 716 /* List of devices hanging off this driver with stealth attach. */ 717 struct list_head legacy_dev_list; 718 int (*firstopen) (struct drm_device *); 719 void (*preclose) (struct drm_device *, struct drm_file *file_priv); 720 int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv); 721 int (*dma_quiescent) (struct drm_device *); 722 int (*context_dtor) (struct drm_device *dev, int context); 723 int dev_priv_size; 724 }; 725 726 extern unsigned int drm_debug; 727 728 int drm_dev_init(struct drm_device *dev, 729 struct drm_driver *driver, 730 struct device *parent); 731 void drm_dev_fini(struct drm_device *dev); 732 733 struct drm_device *drm_dev_alloc(struct drm_driver *driver, 734 struct device *parent); 735 int drm_dev_register(struct drm_device *dev, unsigned long flags); 736 void drm_dev_unregister(struct drm_device *dev); 737 738 void drm_dev_get(struct drm_device *dev); 739 void drm_dev_put(struct drm_device *dev); 740 void drm_put_dev(struct drm_device *dev); 741 bool drm_dev_enter(struct drm_device *dev, int *idx); 742 void drm_dev_exit(int idx); 743 void drm_dev_unplug(struct drm_device *dev); 744 745 /** 746 * drm_dev_is_unplugged - is a DRM device unplugged 747 * @dev: DRM device 748 * 749 * This function can be called to check whether a hotpluggable is unplugged. 750 * Unplugging itself is singalled through drm_dev_unplug(). If a device is 751 * unplugged, these two functions guarantee that any store before calling 752 * drm_dev_unplug() is visible to callers of this function after it completes 753 * 754 * WARNING: This function fundamentally races against drm_dev_unplug(). It is 755 * recommended that drivers instead use the underlying drm_dev_enter() and 756 * drm_dev_exit() function pairs. 757 */ 758 static inline bool drm_dev_is_unplugged(struct drm_device *dev) 759 { 760 int idx; 761 762 if (drm_dev_enter(dev, &idx)) { 763 drm_dev_exit(idx); 764 return false; 765 } 766 767 return true; 768 } 769 770 /** 771 * drm_core_check_feature - check driver feature flags 772 * @dev: DRM device to check 773 * @feature: feature flag 774 * 775 * This checks @dev for driver features, see &drm_driver.driver_features, 776 * &drm_device.driver_features, and the various &enum drm_driver_feature flags. 777 * 778 * Returns true if the @feature is supported, false otherwise. 779 */ 780 static inline bool drm_core_check_feature(struct drm_device *dev, u32 feature) 781 { 782 return dev->driver->driver_features & dev->driver_features & feature; 783 } 784 785 /** 786 * drm_drv_uses_atomic_modeset - check if the driver implements 787 * atomic_commit() 788 * @dev: DRM device 789 * 790 * This check is useful if drivers do not have DRIVER_ATOMIC set but 791 * have atomic modesetting internally implemented. 792 */ 793 static inline bool drm_drv_uses_atomic_modeset(struct drm_device *dev) 794 { 795 return drm_core_check_feature(dev, DRIVER_ATOMIC) || 796 (dev->mode_config.funcs && dev->mode_config.funcs->atomic_commit != NULL); 797 } 798 799 800 int drm_dev_set_unique(struct drm_device *dev, const char *name); 801 802 803 #endif 804