| 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 <video/nomodeset.h> |
| 34 |
|
| 35 |
#include <drm/drm_device.h> |
| 36 |
|
| 37 |
struct dmem_cgroup_region; |
| 38 |
struct drm_fb_helper; |
| 39 |
struct drm_fb_helper_surface_size; |
| 40 |
struct drm_file; |
| 41 |
struct drm_gem_object; |
| 42 |
struct drm_master; |
| 43 |
struct drm_minor; |
| 44 |
struct dma_buf; |
| 45 |
struct dma_buf_attachment; |
| 46 |
struct drm_display_mode; |
| 47 |
struct drm_mode_create_dumb; |
| 48 |
struct drm_printer; |
| 49 |
struct sg_table; |
| 50 |
|
| 51 |
/** |
| 52 |
* enum drm_driver_feature - feature flags |
| 53 |
* |
| 54 |
* See &drm_driver.driver_features, drm_device.driver_features and |
| 55 |
* drm_core_check_feature(). |
| 56 |
*/ |
| 57 |
enum drm_driver_feature { |
| 58 |
/** |
| 59 |
* @DRIVER_GEM: |
| 60 |
* |
| 61 |
* Driver use the GEM memory manager. This should be set for all modern |
| 62 |
* drivers. |
| 63 |
*/ |
| 64 |
DRIVER_GEM = BIT(0), |
| 65 |
/** |
| 66 |
* @DRIVER_MODESET: |
| 67 |
* |
| 68 |
* Driver supports mode setting interfaces (KMS). |
| 69 |
*/ |
| 70 |
DRIVER_MODESET = BIT(1), |
| 71 |
/** |
| 72 |
* @DRIVER_RENDER: |
| 73 |
* |
| 74 |
* Driver supports dedicated render nodes. See also the :ref:`section on |
| 75 |
* render nodes <drm_render_node>` for details. |
| 76 |
*/ |
| 77 |
DRIVER_RENDER = BIT(3), |
| 78 |
/** |
| 79 |
* @DRIVER_ATOMIC: |
| 80 |
* |
| 81 |
* Driver supports the full atomic modesetting userspace API. Drivers |
| 82 |
* which only use atomic internally, but do not support the full |
| 83 |
* userspace API (e.g. not all properties converted to atomic, or |
| 84 |
* multi-plane updates are not guaranteed to be tear-free) should not |
| 85 |
* set this flag. |
| 86 |
*/ |
| 87 |
DRIVER_ATOMIC = BIT(4), |
| 88 |
/** |
| 89 |
* @DRIVER_SYNCOBJ: |
| 90 |
* |
| 91 |
* Driver supports &drm_syncobj for explicit synchronization of command |
| 92 |
* submission. |
| 93 |
*/ |
| 94 |
DRIVER_SYNCOBJ = BIT(5), |
| 95 |
/** |
| 96 |
* @DRIVER_SYNCOBJ_TIMELINE: |
| 97 |
* |
| 98 |
* Driver supports the timeline flavor of &drm_syncobj for explicit |
| 99 |
* synchronization of command submission. |
| 100 |
*/ |
| 101 |
DRIVER_SYNCOBJ_TIMELINE = BIT(6), |
| 102 |
/** |
| 103 |
* @DRIVER_COMPUTE_ACCEL: |
| 104 |
* |
| 105 |
* Driver supports compute acceleration devices. This flag is mutually exclusive with |
| 106 |
* @DRIVER_RENDER and @DRIVER_MODESET. Devices that support both graphics and compute |
| 107 |
* acceleration should be handled by two drivers that are connected using auxiliary bus. |
| 108 |
*/ |
| 109 |
DRIVER_COMPUTE_ACCEL = BIT(7), |
| 110 |
/** |
| 111 |
* @DRIVER_GEM_GPUVA: |
| 112 |
* |
| 113 |
* Driver supports user defined GPU VA bindings for GEM objects. |
| 114 |
*/ |
| 115 |
DRIVER_GEM_GPUVA = BIT(8), |
| 116 |
/** |
| 117 |
* @DRIVER_CURSOR_HOTSPOT: |
| 118 |
* |
| 119 |
* Driver supports and requires cursor hotspot information in the |
| 120 |
* cursor plane (e.g. cursor plane has to actually track the mouse |
| 121 |
* cursor and the clients are required to set hotspot in order for |
| 122 |
* the cursor planes to work correctly). |
| 123 |
*/ |
| 124 |
DRIVER_CURSOR_HOTSPOT = BIT(9), |
| 125 |
|
| 126 |
/* IMPORTANT: Below are all the legacy flags, add new ones above. */ |
| 127 |
|
| 128 |
/** |
| 129 |
* @DRIVER_USE_AGP: |
| 130 |
* |
| 131 |
* Set up DRM AGP support, see drm_agp_init(), the DRM core will manage |
| 132 |
* AGP resources. New drivers don't need this. |
| 133 |
*/ |
| 134 |
DRIVER_USE_AGP = BIT(25), |
| 135 |
/** |
| 136 |
* @DRIVER_LEGACY: |
| 137 |
* |
| 138 |
* Denote a legacy driver using shadow attach. Do not use. |
| 139 |
*/ |
| 140 |
DRIVER_LEGACY = BIT(26), |
| 141 |
/** |
| 142 |
* @DRIVER_PCI_DMA: |
| 143 |
* |
| 144 |
* Driver is capable of PCI DMA, mapping of PCI DMA buffers to userspace |
| 145 |
* will be enabled. Only for legacy drivers. Do not use. |
| 146 |
*/ |
| 147 |
DRIVER_PCI_DMA = BIT(27), |
| 148 |
/** |
| 149 |
* @DRIVER_SG: |
| 150 |
* |
| 151 |
* Driver can perform scatter/gather DMA, allocation and mapping of |
| 152 |
* scatter/gather buffers will be enabled. Only for legacy drivers. Do |
| 153 |
* not use. |
| 154 |
*/ |
| 155 |
DRIVER_SG = BIT(28), |
| 156 |
|
| 157 |
/** |
| 158 |
* @DRIVER_HAVE_DMA: |
| 159 |
* |
| 160 |
* Driver supports DMA, the userspace DMA API will be supported. Only |
| 161 |
* for legacy drivers. Do not use. |
| 162 |
*/ |
| 163 |
DRIVER_HAVE_DMA = BIT(29), |
| 164 |
/** |
| 165 |
* @DRIVER_HAVE_IRQ: |
| 166 |
* |
| 167 |
* Legacy irq support. Only for legacy drivers. Do not use. |
| 168 |
*/ |
| 169 |
DRIVER_HAVE_IRQ = BIT(30), |
| 170 |
}; |
| 171 |
|
| 172 |
/** |
| 173 |
* struct drm_driver - DRM driver structure |
| 174 |
* |
| 175 |
* This structure represent the common code for a family of cards. There will be |
| 176 |
* one &struct drm_device for each card present in this family. It contains lots |
| 177 |
* of vfunc entries, and a pile of those probably should be moved to more |
| 178 |
* appropriate places like &drm_mode_config_funcs or into a new operations |
| 179 |
* structure for GEM drivers. |
| 180 |
*/ |
| 181 |
struct drm_driver { |
| 182 |
/** |
| 183 |
* @load: |
| 184 |
* |
| 185 |
* Backward-compatible driver callback to complete initialization steps |
| 186 |
* after the driver is registered. For this reason, may suffer from |
| 187 |
* race conditions and its use is deprecated for new drivers. It is |
| 188 |
* therefore only supported for existing drivers not yet converted to |
| 189 |
* the new scheme. See devm_drm_dev_alloc() and drm_dev_register() for |
| 190 |
* proper and race-free way to set up a &struct drm_device. |
| 191 |
* |
| 192 |
* This is deprecated, do not use! |
| 193 |
* |
| 194 |
* Returns: |
| 195 |
* |
| 196 |
* Zero on success, non-zero value on failure. |
| 197 |
*/ |
| 198 |
int (*load) (struct drm_device *, unsigned long flags); |
| 199 |
|
| 200 |
/** |
| 201 |
* @open: |
| 202 |
* |
| 203 |
* Driver callback when a new &struct drm_file is opened. Useful for |
| 204 |
* setting up driver-private data structures like buffer allocators, |
| 205 |
* execution contexts or similar things. Such driver-private resources |
| 206 |
* must be released again in @postclose. |
| 207 |
* |
| 208 |
* Since the display/modeset side of DRM can only be owned by exactly |
| 209 |
* one &struct drm_file (see &drm_file.is_master and &drm_device.master) |
| 210 |
* there should never be a need to set up any modeset related resources |
| 211 |
* in this callback. Doing so would be a driver design bug. |
| 212 |
* |
| 213 |
* Returns: |
| 214 |
* |
| 215 |
* 0 on success, a negative error code on failure, which will be |
| 216 |
* promoted to userspace as the result of the open() system call. |
| 217 |
*/ |
| 218 |
int (*open) (struct drm_device *, struct drm_file *); |
| 219 |
|
| 220 |
/** |
| 221 |
* @postclose: |
| 222 |
* |
| 223 |
* One of the driver callbacks when a new &struct drm_file is closed. |
| 224 |
* Useful for tearing down driver-private data structures allocated in |
| 225 |
* @open like buffer allocators, execution contexts or similar things. |
| 226 |
* |
| 227 |
* Since the display/modeset side of DRM can only be owned by exactly |
| 228 |
* one &struct drm_file (see &drm_file.is_master and &drm_device.master) |
| 229 |
* there should never be a need to tear down any modeset related |
| 230 |
* resources in this callback. Doing so would be a driver design bug. |
| 231 |
*/ |
| 232 |
void (*postclose) (struct drm_device *, struct drm_file *); |
| 233 |
|
| 234 |
/** |
| 235 |
* @unload: |
| 236 |
* |
| 237 |
* Reverse the effects of the driver load callback. Ideally, |
| 238 |
* the clean up performed by the driver should happen in the |
| 239 |
* reverse order of the initialization. Similarly to the load |
| 240 |
* hook, this handler is deprecated and its usage should be |
| 241 |
* dropped in favor of an open-coded teardown function at the |
| 242 |
* driver layer. See drm_dev_unregister() and drm_dev_put() |
| 243 |
* for the proper way to remove a &struct drm_device. |
| 244 |
* |
| 245 |
* The unload() hook is called right after unregistering |
| 246 |
* the device. |
| 247 |
* |
| 248 |
*/ |
| 249 |
void (*unload) (struct drm_device *); |
| 250 |
|
| 251 |
/** |
| 252 |
* @release: |
| 253 |
* |
| 254 |
* Optional callback for destroying device data after the final |
| 255 |
* reference is released, i.e. the device is being destroyed. |
| 256 |
* |
| 257 |
* This is deprecated, clean up all memory allocations associated with a |
| 258 |
* &drm_device using drmm_add_action(), drmm_kmalloc() and related |
| 259 |
* managed resources functions. |
| 260 |
*/ |
| 261 |
void (*release) (struct drm_device *); |
| 262 |
|
| 263 |
/** |
| 264 |
* @master_set: |
| 265 |
* |
| 266 |
* Called whenever the minor master is set. Only used by vmwgfx. |
| 267 |
*/ |
| 268 |
void (*master_set)(struct drm_device *dev, struct drm_file *file_priv, |
| 269 |
bool from_open); |
| 270 |
/** |
| 271 |
* @master_drop: |
| 272 |
* |
| 273 |
* Called whenever the minor master is dropped. Only used by vmwgfx. |
| 274 |
*/ |
| 275 |
void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv); |
| 276 |
|
| 277 |
/** |
| 278 |
* @debugfs_init: |
| 279 |
* |
| 280 |
* Allows drivers to create driver-specific debugfs files. |
| 281 |
*/ |
| 282 |
void (*debugfs_init)(struct drm_minor *minor); |
| 283 |
|
| 284 |
/** |
| 285 |
* @gem_create_object: constructor for gem objects |
| 286 |
* |
| 287 |
* Hook for allocating the GEM object struct, for use by the CMA |
| 288 |
* and SHMEM GEM helpers. Returns a GEM object on success, or an |
| 289 |
* ERR_PTR()-encoded error code otherwise. |
| 290 |
*/ |
| 291 |
struct drm_gem_object *(*gem_create_object)(struct drm_device *dev, |
| 292 |
size_t size); |
| 293 |
|
| 294 |
/** |
| 295 |
* @prime_handle_to_fd: |
| 296 |
* |
| 297 |
* PRIME export function. Only used by vmwgfx. |
| 298 |
*/ |
| 299 |
int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv, |
| 300 |
uint32_t handle, uint32_t flags, int *prime_fd); |
| 301 |
/** |
| 302 |
* @prime_fd_to_handle: |
| 303 |
* |
| 304 |
* PRIME import function. Only used by vmwgfx. |
| 305 |
*/ |
| 306 |
int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv, |
| 307 |
int prime_fd, uint32_t *handle); |
| 308 |
|
| 309 |
/** |
| 310 |
* @gem_prime_import: |
| 311 |
* |
| 312 |
* Import hook for GEM drivers. |
| 313 |
* |
| 314 |
* This defaults to drm_gem_prime_import() if not set. |
| 315 |
*/ |
| 316 |
struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev, |
| 317 |
struct dma_buf *dma_buf); |
| 318 |
/** |
| 319 |
* @gem_prime_import_sg_table: |
| 320 |
* |
| 321 |
* Optional hook used by the PRIME helper functions |
| 322 |
* drm_gem_prime_import() respectively drm_gem_prime_import_dev(). |
| 323 |
*/ |
| 324 |
struct drm_gem_object *(*gem_prime_import_sg_table)( |
| 325 |
struct drm_device *dev, |
| 326 |
struct dma_buf_attachment *attach, |
| 327 |
struct sg_table *sgt); |
| 328 |
|
| 329 |
/** |
| 330 |
* @dumb_create: |
| 331 |
* |
| 332 |
* This creates a new dumb buffer in the driver's backing storage manager (GEM, |
| 333 |
* TTM or something else entirely) and returns the resulting buffer handle. This |
| 334 |
* handle can then be wrapped up into a framebuffer modeset object. |
| 335 |
* |
| 336 |
* Note that userspace is not allowed to use such objects for render |
| 337 |
* acceleration - drivers must create their own private ioctls for such a use |
| 338 |
* case. |
| 339 |
* |
| 340 |
* Width, height and depth are specified in the &drm_mode_create_dumb |
| 341 |
* argument. The callback needs to fill the handle, pitch and size for |
| 342 |
* the created buffer. |
| 343 |
* |
| 344 |
* Called by the user via ioctl. |
| 345 |
* |
| 346 |
* Returns: |
| 347 |
* |
| 348 |
* Zero on success, negative errno on failure. |
| 349 |
*/ |
| 350 |
int (*dumb_create)(struct drm_file *file_priv, |
| 351 |
struct drm_device *dev, |
| 352 |
struct drm_mode_create_dumb *args); |
| 353 |
/** |
| 354 |
* @dumb_map_offset: |
| 355 |
* |
| 356 |
* Allocate an offset in the drm device node's address space to be able to |
| 357 |
* memory map a dumb buffer. |
| 358 |
* |
| 359 |
* The default implementation is drm_gem_create_mmap_offset(). GEM based |
| 360 |
* drivers must not overwrite this. |
| 361 |
* |
| 362 |
* Called by the user via ioctl. |
| 363 |
* |
| 364 |
* Returns: |
| 365 |
* |
| 366 |
* Zero on success, negative errno on failure. |
| 367 |
*/ |
| 368 |
int (*dumb_map_offset)(struct drm_file *file_priv, |
| 369 |
struct drm_device *dev, uint32_t handle, |
| 370 |
uint64_t *offset); |
| 371 |
|
| 372 |
/** |
| 373 |
* @fbdev_probe: |
| 374 |
* |
| 375 |
* Allocates and initialize the fb_info structure for fbdev emulation. |
| 376 |
* Furthermore it also needs to allocate the DRM framebuffer used to |
| 377 |
* back the fbdev. |
| 378 |
* |
| 379 |
* This callback is mandatory for fbdev support. |
| 380 |
* |
| 381 |
* Returns: |
| 382 |
* |
| 383 |
* 0 on success ot a negative error code otherwise. |
| 384 |
*/ |
| 385 |
int (*fbdev_probe)(struct drm_fb_helper *fbdev_helper, |
| 386 |
struct drm_fb_helper_surface_size *sizes); |
| 387 |
|
| 388 |
/** |
| 389 |
* @show_fdinfo: |
| 390 |
* |
| 391 |
* Print device specific fdinfo. See Documentation/gpu/drm-usage-stats.rst. |
| 392 |
*/ |
| 393 |
void (*show_fdinfo)(struct drm_printer *p, struct drm_file *f); |
| 394 |
|
| 395 |
/** @major: driver major number */ |
| 396 |
int major; |
| 397 |
/** @minor: driver minor number */ |
| 398 |
int minor; |
| 399 |
/** @patchlevel: driver patch level */ |
| 400 |
int patchlevel; |
| 401 |
/** @name: driver name */ |
| 402 |
char *name; |
| 403 |
/** @desc: driver description */ |
| 404 |
char *desc; |
| 405 |
|
| 406 |
/** |
| 407 |
* @driver_features: |
| 408 |
* Driver features, see &enum drm_driver_feature. Drivers can disable |
| 409 |
* some features on a per-instance basis using |
| 410 |
* &drm_device.driver_features. |
| 411 |
*/ |
| 412 |
u32 driver_features; |
| 413 |
|
| 414 |
/** |
| 415 |
* @ioctls: |
| 416 |
* |
| 417 |
* Array of driver-private IOCTL description entries. See the chapter on |
| 418 |
* :ref:`IOCTL support in the userland interfaces |
| 419 |
* chapter<drm_driver_ioctl>` for the full details. |
| 420 |
*/ |
| 421 |
|
| 422 |
const struct drm_ioctl_desc *ioctls; |
| 423 |
/** @num_ioctls: Number of entries in @ioctls. */ |
| 424 |
int num_ioctls; |
| 425 |
|
| 426 |
/** |
| 427 |
* @fops: |
| 428 |
* |
| 429 |
* File operations for the DRM device node. See the discussion in |
| 430 |
* :ref:`file operations<drm_driver_fops>` for in-depth coverage and |
| 431 |
* some examples. |
| 432 |
*/ |
| 433 |
const struct file_operations *fops; |
| 434 |
}; |
| 435 |
|
| 436 |
void *__devm_drm_dev_alloc(struct device *parent, |
| 437 |
const struct drm_driver *driver, |
| 438 |
size_t size, size_t offset); |
| 439 |
|
| 440 |
struct dmem_cgroup_region * |
| 441 |
drmm_cgroup_register_region(struct drm_device *dev, |
| 442 |
const char *region_name, u64 size); |
| 443 |
|
| 444 |
/** |
| 445 |
* devm_drm_dev_alloc - Resource managed allocation of a &drm_device instance |
| 446 |
* @parent: Parent device object |
| 447 |
* @driver: DRM driver |
| 448 |
* @type: the type of the struct which contains struct &drm_device |
| 449 |
* @member: the name of the &drm_device within @type. |
| 450 |
* |
| 451 |
* This allocates and initialize a new DRM device. No device registration is done. |
| 452 |
* Call drm_dev_register() to advertice the device to user space and register it |
| 453 |
* with other core subsystems. This should be done last in the device |
| 454 |
* initialization sequence to make sure userspace can't access an inconsistent |
| 455 |
* state. |
| 456 |
* |
| 457 |
* The initial ref-count of the object is 1. Use drm_dev_get() and |
| 458 |
* drm_dev_put() to take and drop further ref-counts. |
| 459 |
* |
| 460 |
* It is recommended that drivers embed &struct drm_device into their own device |
| 461 |
* structure. |
| 462 |
* |
| 463 |
* Note that this manages the lifetime of the resulting &drm_device |
| 464 |
* automatically using devres. The DRM device initialized with this function is |
| 465 |
* automatically put on driver detach using drm_dev_put(). |
| 466 |
* |
| 467 |
* RETURNS: |
| 468 |
* Pointer to new DRM device, or ERR_PTR on failure. |
| 469 |
*/ |
| 470 |
#define devm_drm_dev_alloc(parent, driver, type, member) \ |
| 471 |
((type *) __devm_drm_dev_alloc(parent, driver, sizeof(type), \ |
| 472 |
offsetof(type, member))) |
| 473 |
|
| 474 |
struct drm_device *drm_dev_alloc(const struct drm_driver *driver, |
| 475 |
struct device *parent); |
| 476 |
|
| 477 |
void *__drm_dev_alloc(struct device *parent, |
| 478 |
const struct drm_driver *driver, |
| 479 |
size_t size, size_t offset); |
| 480 |
|
| 481 |
int drm_dev_register(struct drm_device *dev, unsigned long flags); |
| 482 |
void drm_dev_unregister(struct drm_device *dev); |
| 483 |
|
| 484 |
void drm_dev_get(struct drm_device *dev); |
| 485 |
void drm_dev_put(struct drm_device *dev); |
| 486 |
void drm_put_dev(struct drm_device *dev); |
| 487 |
bool drm_dev_enter(struct drm_device *dev, int *idx); |
| 488 |
void drm_dev_exit(int idx); |
| 489 |
void drm_dev_unplug(struct drm_device *dev); |
| 490 |
int drm_dev_wedged_event(struct drm_device *dev, unsigned long method, |
| 491 |
struct drm_wedge_task_info *info); |
| 492 |
|
| 493 |
/** |
| 494 |
* drm_dev_is_unplugged - is a DRM device unplugged |
| 495 |
* @dev: DRM device |
| 496 |
* |
| 497 |
* This function can be called to check whether a hotpluggable is unplugged. |
| 498 |
* Unplugging itself is singalled through drm_dev_unplug(). If a device is |
| 499 |
* unplugged, these two functions guarantee that any store before calling |
| 500 |
* drm_dev_unplug() is visible to callers of this function after it completes |
| 501 |
* |
| 502 |
* WARNING: This function fundamentally races against drm_dev_unplug(). It is |
| 503 |
* recommended that drivers instead use the underlying drm_dev_enter() and |
| 504 |
* drm_dev_exit() function pairs. |
| 505 |
*/ |
| 506 |
static inline bool drm_dev_is_unplugged(struct drm_device *dev) |
| 507 |
{ |
| 508 |
int idx; |
| 509 |
|
| 510 |
if (drm_dev_enter(dev, &idx)) { |
| 511 |
drm_dev_exit(idx); |
| 512 |
return false; |
| 513 |
} |
| 514 |
|
| 515 |
return true; |
| 516 |
} |
| 517 |
|
| 518 |
/** |
| 519 |
* drm_core_check_all_features - check driver feature flags mask |
| 520 |
* @dev: DRM device to check |
| 521 |
* @features: feature flag(s) mask |
| 522 |
* |
| 523 |
* This checks @dev for driver features, see &drm_driver.driver_features, |
| 524 |
* &drm_device.driver_features, and the various &enum drm_driver_feature flags. |
| 525 |
* |
| 526 |
* Returns true if all features in the @features mask are supported, false |
| 527 |
* otherwise. |
| 528 |
*/ |
| 529 |
static inline bool drm_core_check_all_features(const struct drm_device *dev, |
| 530 |
u32 features) |
| 531 |
{ |
| 532 |
u32 supported = dev->driver->driver_features & dev->driver_features; |
| 533 |
|
| 534 |
return features && (supported & features) == features; |
| 535 |
} |
| 536 |
|
| 537 |
/** |
| 538 |
* drm_core_check_feature - check driver feature flags |
| 539 |
* @dev: DRM device to check |
| 540 |
* @feature: feature flag |
| 541 |
* |
| 542 |
* This checks @dev for driver features, see &drm_driver.driver_features, |
| 543 |
* &drm_device.driver_features, and the various &enum drm_driver_feature flags. |
| 544 |
* |
| 545 |
* Returns true if the @feature is supported, false otherwise. |
| 546 |
*/ |
| 547 |
static inline bool drm_core_check_feature(const struct drm_device *dev, |
| 548 |
enum drm_driver_feature feature) |
| 549 |
{ |
| 550 |
return drm_core_check_all_features(dev, feature); |
| 551 |
} |
| 552 |
|
| 553 |
/** |
| 554 |
* drm_drv_uses_atomic_modeset - check if the driver implements |
| 555 |
* atomic_commit() |
| 556 |
* @dev: DRM device |
| 557 |
* |
| 558 |
* This check is useful if drivers do not have DRIVER_ATOMIC set but |
| 559 |
* have atomic modesetting internally implemented. |
| 560 |
*/ |
| 561 |
static inline bool drm_drv_uses_atomic_modeset(struct drm_device *dev) |
| 562 |
{ |
| 563 |
return drm_core_check_feature(dev, DRIVER_ATOMIC) || |
| 564 |
(dev->mode_config.funcs && dev->mode_config.funcs->atomic_commit != NULL); |
| 565 |
} |
| 566 |
|
| 567 |
|
| 568 |
/* TODO: Inline drm_firmware_drivers_only() in all its callers. */ |
| 569 |
static inline bool drm_firmware_drivers_only(void) |
| 570 |
{ |
| 571 |
return video_firmware_drivers_only(); |
| 572 |
} |
| 573 |
|
| 574 |
#if defined(CONFIG_DEBUG_FS) |
| 575 |
void drm_debugfs_dev_init(struct drm_device *dev); |
| 576 |
void drm_debugfs_init_root(void); |
| 577 |
void drm_debugfs_remove_root(void); |
| 578 |
void drm_debugfs_bridge_params(void); |
| 579 |
#else |
| 580 |
static inline void drm_debugfs_dev_init(struct drm_device *dev) |
| 581 |
{ |
| 582 |
} |
| 583 |
|
| 584 |
static inline void drm_debugfs_init_root(void) |
| 585 |
{ |
| 586 |
} |
| 587 |
|
| 588 |
static inline void drm_debugfs_remove_root(void) |
| 589 |
{ |
| 590 |
} |
| 591 |
|
| 592 |
static inline void drm_debugfs_bridge_params(void) |
| 593 |
{ |
| 594 |
} |
| 595 |
#endif |
| 596 |
|
| 597 |
#endif |