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
 35struct drm_file;
 36struct drm_gem_object;
 37struct drm_master;
 38struct drm_minor;
 39struct dma_buf_attachment;
 40struct drm_display_mode;
 41struct drm_mode_create_dumb;
 42struct 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 */
 50enum 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_RENDER:
 66	 *
 67	 * Driver supports dedicated render nodes. See also the :ref:`section on
 68	 * render nodes <drm_render_node>` for details.
 69	 */
 70	DRIVER_RENDER			= BIT(3),
 71	/**
 72	 * @DRIVER_ATOMIC:
 73	 *
 74	 * Driver supports the full atomic modesetting userspace API. Drivers
 75	 * which only use atomic internally, but do not the support the full
 76	 * userspace API (e.g. not all properties converted to atomic, or
 77	 * multi-plane updates are not guaranteed to be tear-free) should not
 78	 * set this flag.
 79	 */
 80	DRIVER_ATOMIC			= BIT(4),
 81	/**
 82	 * @DRIVER_SYNCOBJ:
 83	 *
 84	 * Driver supports &drm_syncobj for explicit synchronization of command
 85	 * submission.
 86	 */
 87	DRIVER_SYNCOBJ                  = BIT(5),
 88	/**
 89	 * @DRIVER_SYNCOBJ_TIMELINE:
 90	 *
 91	 * Driver supports the timeline flavor of &drm_syncobj for explicit
 92	 * synchronization of command submission.
 93	 */
 94	DRIVER_SYNCOBJ_TIMELINE         = BIT(6),
 95
 96	/* IMPORTANT: Below are all the legacy flags, add new ones above. */
 97
 98	/**
 99	 * @DRIVER_USE_AGP:
100	 *
101	 * Set up DRM AGP support, see drm_agp_init(), the DRM core will manage
102	 * AGP resources. New drivers don't need this.
103	 */
104	DRIVER_USE_AGP			= BIT(25),
105	/**
106	 * @DRIVER_LEGACY:
107	 *
108	 * Denote a legacy driver using shadow attach. Do not use.
109	 */
110	DRIVER_LEGACY			= BIT(26),
111	/**
112	 * @DRIVER_PCI_DMA:
113	 *
114	 * Driver is capable of PCI DMA, mapping of PCI DMA buffers to userspace
115	 * will be enabled. Only for legacy drivers. Do not use.
116	 */
117	DRIVER_PCI_DMA			= BIT(27),
118	/**
119	 * @DRIVER_SG:
120	 *
121	 * Driver can perform scatter/gather DMA, allocation and mapping of
122	 * scatter/gather buffers will be enabled. Only for legacy drivers. Do
123	 * not use.
124	 */
125	DRIVER_SG			= BIT(28),
126
127	/**
128	 * @DRIVER_HAVE_DMA:
129	 *
130	 * Driver supports DMA, the userspace DMA API will be supported. Only
131	 * for legacy drivers. Do not use.
132	 */
133	DRIVER_HAVE_DMA			= BIT(29),
134	/**
135	 * @DRIVER_HAVE_IRQ:
136	 *
137	 * Legacy irq support. Only for legacy drivers. Do not use.
138	 *
139	 * New drivers can either use the drm_irq_install() and
140	 * drm_irq_uninstall() helper functions, or roll their own irq support
141	 * code by calling request_irq() directly.
142	 */
143	DRIVER_HAVE_IRQ			= BIT(30),
144	/**
145	 * @DRIVER_KMS_LEGACY_CONTEXT:
146	 *
147	 * Used only by nouveau for backwards compatibility with existing
148	 * userspace.  Do not use.
149	 */
150	DRIVER_KMS_LEGACY_CONTEXT	= BIT(31),
151};
152
153/**
154 * struct drm_driver - DRM driver structure
155 *
156 * This structure represent the common code for a family of cards. There will be
157 * one &struct drm_device for each card present in this family. It contains lots
158 * of vfunc entries, and a pile of those probably should be moved to more
159 * appropriate places like &drm_mode_config_funcs or into a new operations
160 * structure for GEM drivers.
161 */
162struct drm_driver {
163	/**
164	 * @load:
165	 *
166	 * Backward-compatible driver callback to complete
167	 * initialization steps after the driver is registered.  For
168	 * this reason, may suffer from race conditions and its use is
169	 * deprecated for new drivers.  It is therefore only supported
170	 * for existing drivers not yet converted to the new scheme.
171	 * See drm_dev_init() and drm_dev_register() for proper and
172	 * race-free way to set up a &struct drm_device.
173	 *
174	 * This is deprecated, do not use!
175	 *
176	 * Returns:
177	 *
178	 * Zero on success, non-zero value on failure.
179	 */
180	int (*load) (struct drm_device *, unsigned long flags);
181
182	/**
183	 * @open:
184	 *
185	 * Driver callback when a new &struct drm_file is opened. Useful for
186	 * setting up driver-private data structures like buffer allocators,
187	 * execution contexts or similar things. Such driver-private resources
188	 * must be released again in @postclose.
189	 *
190	 * Since the display/modeset side of DRM can only be owned by exactly
191	 * one &struct drm_file (see &drm_file.is_master and &drm_device.master)
192	 * there should never be a need to set up any modeset related resources
193	 * in this callback. Doing so would be a driver design bug.
194	 *
195	 * Returns:
196	 *
197	 * 0 on success, a negative error code on failure, which will be
198	 * promoted to userspace as the result of the open() system call.
199	 */
200	int (*open) (struct drm_device *, struct drm_file *);
201
202	/**
203	 * @postclose:
204	 *
205	 * One of the driver callbacks when a new &struct drm_file is closed.
206	 * Useful for tearing down driver-private data structures allocated in
207	 * @open like buffer allocators, execution contexts or similar things.
208	 *
209	 * Since the display/modeset side of DRM can only be owned by exactly
210	 * one &struct drm_file (see &drm_file.is_master and &drm_device.master)
211	 * there should never be a need to tear down any modeset related
212	 * resources in this callback. Doing so would be a driver design bug.
213	 */
214	void (*postclose) (struct drm_device *, struct drm_file *);
215
216	/**
217	 * @lastclose:
218	 *
219	 * Called when the last &struct drm_file has been closed and there's
220	 * currently no userspace client for the &struct drm_device.
221	 *
222	 * Modern drivers should only use this to force-restore the fbdev
223	 * framebuffer using drm_fb_helper_restore_fbdev_mode_unlocked().
224	 * Anything else would indicate there's something seriously wrong.
225	 * Modern drivers can also use this to execute delayed power switching
226	 * state changes, e.g. in conjunction with the :ref:`vga_switcheroo`
227	 * infrastructure.
228	 *
229	 * This is called after @postclose hook has been called.
230	 *
231	 * NOTE:
232	 *
233	 * All legacy drivers use this callback to de-initialize the hardware.
234	 * This is purely because of the shadow-attach model, where the DRM
235	 * kernel driver does not really own the hardware. Instead ownershipe is
236	 * handled with the help of userspace through an inheritedly racy dance
237	 * to set/unset the VT into raw mode.
238	 *
239	 * Legacy drivers initialize the hardware in the @firstopen callback,
240	 * which isn't even called for modern drivers.
241	 */
242	void (*lastclose) (struct drm_device *);
243
244	/**
245	 * @unload:
246	 *
247	 * Reverse the effects of the driver load callback.  Ideally,
248	 * the clean up performed by the driver should happen in the
249	 * reverse order of the initialization.  Similarly to the load
250	 * hook, this handler is deprecated and its usage should be
251	 * dropped in favor of an open-coded teardown function at the
252	 * driver layer.  See drm_dev_unregister() and drm_dev_put()
253	 * for the proper way to remove a &struct drm_device.
254	 *
255	 * The unload() hook is called right after unregistering
256	 * the device.
257	 *
258	 */
259	void (*unload) (struct drm_device *);
260
261	/**
262	 * @release:
263	 *
264	 * Optional callback for destroying device data after the final
265	 * reference is released, i.e. the device is being destroyed.
266	 *
267	 * This is deprecated, clean up all memory allocations associated with a
268	 * &drm_device using drmm_add_action(), drmm_kmalloc() and related
269	 * managed resources functions.
270	 */
271	void (*release) (struct drm_device *);
272
273	/**
274	 * @irq_handler:
275	 *
276	 * Interrupt handler called when using drm_irq_install(). Not used by
277	 * drivers which implement their own interrupt handling.
278	 */
279	irqreturn_t(*irq_handler) (int irq, void *arg);
280
281	/**
282	 * @irq_preinstall:
283	 *
284	 * Optional callback used by drm_irq_install() which is called before
285	 * the interrupt handler is registered. This should be used to clear out
286	 * any pending interrupts (from e.g. firmware based drives) and reset
287	 * the interrupt handling registers.
288	 */
289	void (*irq_preinstall) (struct drm_device *dev);
290
291	/**
292	 * @irq_postinstall:
293	 *
294	 * Optional callback used by drm_irq_install() which is called after
295	 * the interrupt handler is registered. This should be used to enable
296	 * interrupt generation in the hardware.
297	 */
298	int (*irq_postinstall) (struct drm_device *dev);
299
300	/**
301	 * @irq_uninstall:
302	 *
303	 * Optional callback used by drm_irq_uninstall() which is called before
304	 * the interrupt handler is unregistered. This should be used to disable
305	 * interrupt generation in the hardware.
306	 */
307	void (*irq_uninstall) (struct drm_device *dev);
308
309	/**
310	 * @master_set:
311	 *
312	 * Called whenever the minor master is set. Only used by vmwgfx.
313	 */
314	void (*master_set)(struct drm_device *dev, struct drm_file *file_priv,
315			   bool from_open);
316	/**
317	 * @master_drop:
318	 *
319	 * Called whenever the minor master is dropped. Only used by vmwgfx.
320	 */
321	void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv);
322
323	/**
324	 * @debugfs_init:
325	 *
326	 * Allows drivers to create driver-specific debugfs files.
327	 */
328	void (*debugfs_init)(struct drm_minor *minor);
329
330	/**
331	 * @gem_free_object_unlocked: deconstructor for drm_gem_objects
332	 *
333	 * This is deprecated and should not be used by new drivers. Use
334	 * &drm_gem_object_funcs.free instead.
335	 */
336	void (*gem_free_object_unlocked) (struct drm_gem_object *obj);
337
338	/**
339	 * @gem_open_object:
340	 *
341	 * This callback is deprecated in favour of &drm_gem_object_funcs.open.
342	 *
343	 * Driver hook called upon gem handle creation
344	 */
345	int (*gem_open_object) (struct drm_gem_object *, struct drm_file *);
346
347	/**
348	 * @gem_close_object:
349	 *
350	 * This callback is deprecated in favour of &drm_gem_object_funcs.close.
351	 *
352	 * Driver hook called upon gem handle release
353	 */
354	void (*gem_close_object) (struct drm_gem_object *, struct drm_file *);
355
356	/**
357	 * @gem_create_object: constructor for gem objects
358	 *
359	 * Hook for allocating the GEM object struct, for use by the CMA and
360	 * SHMEM GEM helpers.
361	 */
362	struct drm_gem_object *(*gem_create_object)(struct drm_device *dev,
363						    size_t size);
364	/**
365	 * @prime_handle_to_fd:
366	 *
367	 * Main PRIME export function. Should be implemented with
368	 * drm_gem_prime_handle_to_fd() for GEM based drivers.
369	 *
370	 * For an in-depth discussion see :ref:`PRIME buffer sharing
371	 * documentation <prime_buffer_sharing>`.
372	 */
373	int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv,
374				uint32_t handle, uint32_t flags, int *prime_fd);
375	/**
376	 * @prime_fd_to_handle:
377	 *
378	 * Main PRIME import function. Should be implemented with
379	 * drm_gem_prime_fd_to_handle() for GEM based drivers.
380	 *
381	 * For an in-depth discussion see :ref:`PRIME buffer sharing
382	 * documentation <prime_buffer_sharing>`.
383	 */
384	int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv,
385				int prime_fd, uint32_t *handle);
386	/**
387	 * @gem_prime_export:
388	 *
389	 * Export hook for GEM drivers. Deprecated in favour of
390	 * &drm_gem_object_funcs.export.
391	 */
392	struct dma_buf * (*gem_prime_export)(struct drm_gem_object *obj,
393					     int flags);
394	/**
395	 * @gem_prime_import:
396	 *
397	 * Import hook for GEM drivers.
398	 *
399	 * This defaults to drm_gem_prime_import() if not set.
400	 */
401	struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev,
402				struct dma_buf *dma_buf);
403
404	/**
405	 * @gem_prime_pin:
406	 *
407	 * Deprecated hook in favour of &drm_gem_object_funcs.pin.
408	 */
409	int (*gem_prime_pin)(struct drm_gem_object *obj);
410
411	/**
412	 * @gem_prime_unpin:
413	 *
414	 * Deprecated hook in favour of &drm_gem_object_funcs.unpin.
415	 */
416	void (*gem_prime_unpin)(struct drm_gem_object *obj);
417
418
419	/**
420	 * @gem_prime_get_sg_table:
421	 *
422	 * Deprecated hook in favour of &drm_gem_object_funcs.get_sg_table.
423	 */
424	struct sg_table *(*gem_prime_get_sg_table)(struct drm_gem_object *obj);
425
426	/**
427	 * @gem_prime_import_sg_table:
428	 *
429	 * Optional hook used by the PRIME helper functions
430	 * drm_gem_prime_import() respectively drm_gem_prime_import_dev().
431	 */
432	struct drm_gem_object *(*gem_prime_import_sg_table)(
433				struct drm_device *dev,
434				struct dma_buf_attachment *attach,
435				struct sg_table *sgt);
436	/**
437	 * @gem_prime_vmap:
438	 *
439	 * Deprecated vmap hook for GEM drivers. Please use
440	 * &drm_gem_object_funcs.vmap instead.
441	 */
442	void *(*gem_prime_vmap)(struct drm_gem_object *obj);
443
444	/**
445	 * @gem_prime_vunmap:
446	 *
447	 * Deprecated vunmap hook for GEM drivers. Please use
448	 * &drm_gem_object_funcs.vunmap instead.
449	 */
450	void (*gem_prime_vunmap)(struct drm_gem_object *obj, void *vaddr);
451
452	/**
453	 * @gem_prime_mmap:
454	 *
455	 * mmap hook for GEM drivers, used to implement dma-buf mmap in the
456	 * PRIME helpers.
457	 *
458	 * FIXME: There's way too much duplication going on here, and also moved
459	 * to &drm_gem_object_funcs.
460	 */
461	int (*gem_prime_mmap)(struct drm_gem_object *obj,
462				struct vm_area_struct *vma);
463
464	/**
465	 * @dumb_create:
466	 *
467	 * This creates a new dumb buffer in the driver's backing storage manager (GEM,
468	 * TTM or something else entirely) and returns the resulting buffer handle. This
469	 * handle can then be wrapped up into a framebuffer modeset object.
470	 *
471	 * Note that userspace is not allowed to use such objects for render
472	 * acceleration - drivers must create their own private ioctls for such a use
473	 * case.
474	 *
475	 * Width, height and depth are specified in the &drm_mode_create_dumb
476	 * argument. The callback needs to fill the handle, pitch and size for
477	 * the created buffer.
478	 *
479	 * Called by the user via ioctl.
480	 *
481	 * Returns:
482	 *
483	 * Zero on success, negative errno on failure.
484	 */
485	int (*dumb_create)(struct drm_file *file_priv,
486			   struct drm_device *dev,
487			   struct drm_mode_create_dumb *args);
488	/**
489	 * @dumb_map_offset:
490	 *
491	 * Allocate an offset in the drm device node's address space to be able to
492	 * memory map a dumb buffer.
493	 *
494	 * The default implementation is drm_gem_create_mmap_offset(). GEM based
495	 * drivers must not overwrite this.
496	 *
497	 * Called by the user via ioctl.
498	 *
499	 * Returns:
500	 *
501	 * Zero on success, negative errno on failure.
502	 */
503	int (*dumb_map_offset)(struct drm_file *file_priv,
504			       struct drm_device *dev, uint32_t handle,
505			       uint64_t *offset);
506	/**
507	 * @dumb_destroy:
508	 *
509	 * This destroys the userspace handle for the given dumb backing storage buffer.
510	 * Since buffer objects must be reference counted in the kernel a buffer object
511	 * won't be immediately freed if a framebuffer modeset object still uses it.
512	 *
513	 * Called by the user via ioctl.
514	 *
515	 * The default implementation is drm_gem_dumb_destroy(). GEM based drivers
516	 * must not overwrite this.
517	 *
518	 * Returns:
519	 *
520	 * Zero on success, negative errno on failure.
521	 */
522	int (*dumb_destroy)(struct drm_file *file_priv,
523			    struct drm_device *dev,
524			    uint32_t handle);
525
526	/**
527	 * @gem_vm_ops: Driver private ops for this object
528	 *
529	 * For GEM drivers this is deprecated in favour of
530	 * &drm_gem_object_funcs.vm_ops.
531	 */
532	const struct vm_operations_struct *gem_vm_ops;
533
534	/** @major: driver major number */
535	int major;
536	/** @minor: driver minor number */
537	int minor;
538	/** @patchlevel: driver patch level */
539	int patchlevel;
540	/** @name: driver name */
541	char *name;
542	/** @desc: driver description */
543	char *desc;
544	/** @date: driver date */
545	char *date;
546
547	/**
548	 * @driver_features:
549	 * Driver features, see &enum drm_driver_feature. Drivers can disable
550	 * some features on a per-instance basis using
551	 * &drm_device.driver_features.
552	 */
553	u32 driver_features;
554
555	/**
556	 * @ioctls:
557	 *
558	 * Array of driver-private IOCTL description entries. See the chapter on
559	 * :ref:`IOCTL support in the userland interfaces
560	 * chapter<drm_driver_ioctl>` for the full details.
561	 */
562
563	const struct drm_ioctl_desc *ioctls;
564	/** @num_ioctls: Number of entries in @ioctls. */
565	int num_ioctls;
566
567	/**
568	 * @fops:
569	 *
570	 * File operations for the DRM device node. See the discussion in
571	 * :ref:`file operations<drm_driver_fops>` for in-depth coverage and
572	 * some examples.
573	 */
574	const struct file_operations *fops;
575
576	/* Everything below here is for legacy driver, never use! */
577	/* private: */
578
579	/* List of devices hanging off this driver with stealth attach. */
580	struct list_head legacy_dev_list;
581	int (*firstopen) (struct drm_device *);
582	void (*preclose) (struct drm_device *, struct drm_file *file_priv);
583	int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
584	int (*dma_quiescent) (struct drm_device *);
585	int (*context_dtor) (struct drm_device *dev, int context);
586	u32 (*get_vblank_counter)(struct drm_device *dev, unsigned int pipe);
587	int (*enable_vblank)(struct drm_device *dev, unsigned int pipe);
588	void (*disable_vblank)(struct drm_device *dev, unsigned int pipe);
589	int dev_priv_size;
590};
591
592int drm_dev_init(struct drm_device *dev,
593		 struct drm_driver *driver,
594		 struct device *parent);
595int devm_drm_dev_init(struct device *parent,
596		      struct drm_device *dev,
597		      struct drm_driver *driver);
598
599void *__devm_drm_dev_alloc(struct device *parent, struct drm_driver *driver,
600			   size_t size, size_t offset);
601
602/**
603 * devm_drm_dev_alloc - Resource managed allocation of a &drm_device instance
604 * @parent: Parent device object
605 * @driver: DRM driver
606 * @type: the type of the struct which contains struct &drm_device
607 * @member: the name of the &drm_device within @type.
608 *
609 * This allocates and initialize a new DRM device. No device registration is done.
610 * Call drm_dev_register() to advertice the device to user space and register it
611 * with other core subsystems. This should be done last in the device
612 * initialization sequence to make sure userspace can't access an inconsistent
613 * state.
614 *
615 * The initial ref-count of the object is 1. Use drm_dev_get() and
616 * drm_dev_put() to take and drop further ref-counts.
617 *
618 * It is recommended that drivers embed &struct drm_device into their own device
619 * structure.
620 *
621 * Note that this manages the lifetime of the resulting &drm_device
622 * automatically using devres. The DRM device initialized with this function is
623 * automatically put on driver detach using drm_dev_put().
624 *
625 * RETURNS:
626 * Pointer to new DRM device, or ERR_PTR on failure.
627 */
628#define devm_drm_dev_alloc(parent, driver, type, member) \
629	((type *) __devm_drm_dev_alloc(parent, driver, sizeof(type), \
630				       offsetof(type, member)))
631
632struct drm_device *drm_dev_alloc(struct drm_driver *driver,
633				 struct device *parent);
634int drm_dev_register(struct drm_device *dev, unsigned long flags);
635void drm_dev_unregister(struct drm_device *dev);
636
637void drm_dev_get(struct drm_device *dev);
638void drm_dev_put(struct drm_device *dev);
639void drm_put_dev(struct drm_device *dev);
640bool drm_dev_enter(struct drm_device *dev, int *idx);
641void drm_dev_exit(int idx);
642void drm_dev_unplug(struct drm_device *dev);
643
644/**
645 * drm_dev_is_unplugged - is a DRM device unplugged
646 * @dev: DRM device
647 *
648 * This function can be called to check whether a hotpluggable is unplugged.
649 * Unplugging itself is singalled through drm_dev_unplug(). If a device is
650 * unplugged, these two functions guarantee that any store before calling
651 * drm_dev_unplug() is visible to callers of this function after it completes
652 *
653 * WARNING: This function fundamentally races against drm_dev_unplug(). It is
654 * recommended that drivers instead use the underlying drm_dev_enter() and
655 * drm_dev_exit() function pairs.
656 */
657static inline bool drm_dev_is_unplugged(struct drm_device *dev)
658{
659	int idx;
660
661	if (drm_dev_enter(dev, &idx)) {
662		drm_dev_exit(idx);
663		return false;
664	}
665
666	return true;
667}
668
669/**
670 * drm_core_check_all_features - check driver feature flags mask
671 * @dev: DRM device to check
672 * @features: feature flag(s) mask
673 *
674 * This checks @dev for driver features, see &drm_driver.driver_features,
675 * &drm_device.driver_features, and the various &enum drm_driver_feature flags.
676 *
677 * Returns true if all features in the @features mask are supported, false
678 * otherwise.
679 */
680static inline bool drm_core_check_all_features(const struct drm_device *dev,
681					       u32 features)
682{
683	u32 supported = dev->driver->driver_features & dev->driver_features;
684
685	return features && (supported & features) == features;
686}
687
688/**
689 * drm_core_check_feature - check driver feature flags
690 * @dev: DRM device to check
691 * @feature: feature flag
692 *
693 * This checks @dev for driver features, see &drm_driver.driver_features,
694 * &drm_device.driver_features, and the various &enum drm_driver_feature flags.
695 *
696 * Returns true if the @feature is supported, false otherwise.
697 */
698static inline bool drm_core_check_feature(const struct drm_device *dev,
699					  enum drm_driver_feature feature)
700{
701	return drm_core_check_all_features(dev, feature);
702}
703
704/**
705 * drm_drv_uses_atomic_modeset - check if the driver implements
706 * atomic_commit()
707 * @dev: DRM device
708 *
709 * This check is useful if drivers do not have DRIVER_ATOMIC set but
710 * have atomic modesetting internally implemented.
711 */
712static inline bool drm_drv_uses_atomic_modeset(struct drm_device *dev)
713{
714	return drm_core_check_feature(dev, DRIVER_ATOMIC) ||
715		(dev->mode_config.funcs && dev->mode_config.funcs->atomic_commit != NULL);
716}
717
718
719int drm_dev_set_unique(struct drm_device *dev, const char *name);
720
721
722#endif