[linux-2.6-block.git] / include / drm / drm_drv.h

/*
 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
 * Copyright (c) 2009-2010, Code Aurora Forum.
 * Copyright 2016 Intel Corp.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#ifndef _DRM_DRV_H_
#define _DRM_DRV_H_

#include <linux/list.h>
#include <linux/irqreturn.h>

struct drm_device;
struct drm_file;
struct drm_gem_object;
struct drm_master;
struct drm_minor;
struct dma_buf_attachment;
struct drm_display_mode;
struct drm_mode_create_dumb;

/* driver capabilities and requirements mask */
#define DRIVER_USE_AGP			0x1
#define DRIVER_LEGACY			0x2
#define DRIVER_PCI_DMA			0x8
#define DRIVER_SG			0x10
#define DRIVER_HAVE_DMA			0x20
#define DRIVER_HAVE_IRQ			0x40
#define DRIVER_IRQ_SHARED		0x80
#define DRIVER_GEM			0x1000
#define DRIVER_MODESET			0x2000
#define DRIVER_PRIME			0x4000
#define DRIVER_RENDER			0x8000
#define DRIVER_ATOMIC			0x10000
#define DRIVER_KMS_LEGACY_CONTEXT	0x20000

/**
 * struct drm_driver - DRM driver structure
 *
 * This structure represent the common code for a family of cards. There will
 * one drm_device for each card present in this family. It contains lots of
 * vfunc entries, and a pile of those probably should be moved to more
 * appropriate places like &drm_mode_config_funcs or into a new operations
 * structure for GEM drivers.
 */
struct drm_driver {
	int (*load) (struct drm_device *, unsigned long flags);
	int (*firstopen) (struct drm_device *);
	int (*open) (struct drm_device *, struct drm_file *);
	void (*preclose) (struct drm_device *, struct drm_file *file_priv);
	void (*postclose) (struct drm_device *, struct drm_file *);
	void (*lastclose) (struct drm_device *);
	int (*unload) (struct drm_device *);
	int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
	int (*dma_quiescent) (struct drm_device *);
	int (*context_dtor) (struct drm_device *dev, int context);
	int (*set_busid)(struct drm_device *dev, struct drm_master *master);

	/**
	 * @get_vblank_counter:
	 *
	 * Driver callback for fetching a raw hardware vblank counter for the
	 * CRTC specified with the pipe argument.  If a device doesn't have a
	 * hardware counter, the driver can simply use
	 * drm_vblank_no_hw_counter() function. The DRM core will account for
	 * missed vblank events while interrupts where disabled based on system
	 * timestamps.
	 *
	 * Wraparound handling and loss of events due to modesetting is dealt
	 * with in the DRM core code, as long as drivers call
	 * drm_crtc_vblank_off() and drm_crtc_vblank_on() when disabling or
	 * enabling a CRTC.
	 *
	 * Returns:
	 *
	 * Raw vblank counter value.
	 */
	u32 (*get_vblank_counter) (struct drm_device *dev, unsigned int pipe);

	/**
	 * @enable_vblank:
	 *
	 * Enable vblank interrupts for the CRTC specified with the pipe
	 * argument.
	 *
	 * Returns:
	 *
	 * Zero on success, appropriate errno if the given @crtc's vblank
	 * interrupt cannot be enabled.
	 */
	int (*enable_vblank) (struct drm_device *dev, unsigned int pipe);

	/**
	 * @disable_vblank:
	 *
	 * Disable vblank interrupts for the CRTC specified with the pipe
	 * argument.
	 */
	void (*disable_vblank) (struct drm_device *dev, unsigned int pipe);

	/**
	 * @device_is_agp:
	 *
	 * Called by drm_device_is_agp().  Typically used to determine if a card
	 * is really attached to AGP or not.
	 *
	 * Returns:
	 *
	 * One of three values is returned depending on whether or not the
	 * card is absolutely not AGP (return of 0), absolutely is AGP
	 * (return of 1), or may or may not be AGP (return of 2).
	 */
	int (*device_is_agp) (struct drm_device *dev);

	/**
	 * @get_scanout_position:
	 *
	 * Called by vblank timestamping code.
	 *
	 * Returns the current display scanout position from a crtc, and an
	 * optional accurate ktime_get() timestamp of when position was
	 * measured. Note that this is a helper callback which is only used if a
	 * driver uses drm_calc_vbltimestamp_from_scanoutpos() for the
	 * @get_vblank_timestamp callback.
	 *
	 * Parameters:
	 *
	 * dev:
	 *     DRM device.
	 * pipe:
	 *     Id of the crtc to query.
	 * flags:
	 *     Flags from the caller (DRM_CALLED_FROM_VBLIRQ or 0).
	 * vpos:
	 *     Target location for current vertical scanout position.
	 * hpos:
	 *     Target location for current horizontal scanout position.
	 * stime:
	 *     Target location for timestamp taken immediately before
	 *     scanout position query. Can be NULL to skip timestamp.
	 * etime:
	 *     Target location for timestamp taken immediately after
	 *     scanout position query. Can be NULL to skip timestamp.
	 * mode:
	 *     Current display timings.
	 *
	 * Returns vpos as a positive number while in active scanout area.
	 * Returns vpos as a negative number inside vblank, counting the number
	 * of scanlines to go until end of vblank, e.g., -1 means "one scanline
	 * until start of active scanout / end of vblank."
	 *
	 * Returns:
	 *
	 * Flags, or'ed together as follows:
	 *
	 * DRM_SCANOUTPOS_VALID:
	 *     Query successful.
	 * DRM_SCANOUTPOS_INVBL:
	 *     Inside vblank.
	 * DRM_SCANOUTPOS_ACCURATE: Returned position is accurate. A lack of
	 *     this flag means that returned position may be offset by a
	 *     constant but unknown small number of scanlines wrt. real scanout
	 *     position.
	 *
	 */
	int (*get_scanout_position) (struct drm_device *dev, unsigned int pipe,
				     unsigned int flags, int *vpos, int *hpos,
				     ktime_t *stime, ktime_t *etime,
				     const struct drm_display_mode *mode);

	/**
	 * @get_vblank_timestamp:
	 *
	 * Called by drm_get_last_vbltimestamp(). Should return a precise
	 * timestamp when the most recent VBLANK interval ended or will end.
	 *
	 * Specifically, the timestamp in @vblank_time should correspond as
	 * closely as possible to the time when the first video scanline of
	 * the video frame after the end of VBLANK will start scanning out,
	 * the time immediately after end of the VBLANK interval. If the
	 * @crtc is currently inside VBLANK, this will be a time in the future.
	 * If the @crtc is currently scanning out a frame, this will be the
	 * past start time of the current scanout. This is meant to adhere
	 * to the OpenML OML_sync_control extension specification.
	 *
	 * Paramters:
	 *
	 * dev:
	 *     dev DRM device handle.
	 * pipe:
	 *     crtc for which timestamp should be returned.
	 * max_error:
	 *     Maximum allowable timestamp error in nanoseconds.
	 *     Implementation should strive to provide timestamp
	 *     with an error of at most max_error nanoseconds.
	 *     Returns true upper bound on error for timestamp.
	 * vblank_time:
	 *     Target location for returned vblank timestamp.
	 * flags:
	 *     0 = Defaults, no special treatment needed.
	 *     DRM_CALLED_FROM_VBLIRQ = Function is called from vblank
	 *     irq handler. Some drivers need to apply some workarounds
	 *     for gpu-specific vblank irq quirks if flag is set.
	 *
	 * Returns:
	 *
	 * Zero if timestamping isn't supported in current display mode or a
	 * negative number on failure. A positive status code on success,
	 * which describes how the vblank_time timestamp was computed.
	 */
	int (*get_vblank_timestamp) (struct drm_device *dev, unsigned int pipe,
				     int *max_error,
				     struct timeval *vblank_time,
				     unsigned flags);

	/* these have to be filled in */

	irqreturn_t(*irq_handler) (int irq, void *arg);
	void (*irq_preinstall) (struct drm_device *dev);
	int (*irq_postinstall) (struct drm_device *dev);
	void (*irq_uninstall) (struct drm_device *dev);

	/**
	 * @master_create:
	 *
	 * Called whenever a new master is created. Only used by vmwgfx.
	 */
	int (*master_create)(struct drm_device *dev, struct drm_master *master);

	/**
	 * @master_destroy:
	 *
	 * Called whenever a master is destroyed. Only used by vmwgfx.
	 */
	void (*master_destroy)(struct drm_device *dev, struct drm_master *master);

	/**
	 * @master_set:
	 *
	 * Called whenever the minor master is set. Only used by vmwgfx.
	 */
	int (*master_set)(struct drm_device *dev, struct drm_file *file_priv,
			  bool from_open);
	/**
	 * @master_drop:
	 *
	 * Called whenever the minor master is dropped. Only used by vmwgfx.
	 */
	void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv);

	int (*debugfs_init)(struct drm_minor *minor);
	void (*debugfs_cleanup)(struct drm_minor *minor);

	/**
	 * @gem_free_object: deconstructor for drm_gem_objects
	 *
	 * This is deprecated and should not be used by new drivers. Use
	 * @gem_free_object_unlocked instead.
	 */
	void (*gem_free_object) (struct drm_gem_object *obj);

	/**
	 * @gem_free_object_unlocked: deconstructor for drm_gem_objects
	 *
	 * This is for drivers which are not encumbered with dev->struct_mutex
	 * legacy locking schemes. Use this hook instead of @gem_free_object.
	 */
	void (*gem_free_object_unlocked) (struct drm_gem_object *obj);

	int (*gem_open_object) (struct drm_gem_object *, struct drm_file *);
	void (*gem_close_object) (struct drm_gem_object *, struct drm_file *);

	/**
	 * Hook for allocating the GEM object struct, for use by core
	 * helpers.
	 */
	struct drm_gem_object *(*gem_create_object)(struct drm_device *dev,
						    size_t size);

	/* prime: */
	/* export handle -> fd (see drm_gem_prime_handle_to_fd() helper) */
	int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv,
				uint32_t handle, uint32_t flags, int *prime_fd);
	/* import fd -> handle (see drm_gem_prime_fd_to_handle() helper) */
	int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv,
				int prime_fd, uint32_t *handle);
	/* export GEM -> dmabuf */
	struct dma_buf * (*gem_prime_export)(struct drm_device *dev,
				struct drm_gem_object *obj, int flags);
	/* import dmabuf -> GEM */
	struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev,
				struct dma_buf *dma_buf);
	/* low-level interface used by drm_gem_prime_{import,export} */
	int (*gem_prime_pin)(struct drm_gem_object *obj);
	void (*gem_prime_unpin)(struct drm_gem_object *obj);
	struct reservation_object * (*gem_prime_res_obj)(
				struct drm_gem_object *obj);
	struct sg_table *(*gem_prime_get_sg_table)(struct drm_gem_object *obj);
	struct drm_gem_object *(*gem_prime_import_sg_table)(
				struct drm_device *dev,
				struct dma_buf_attachment *attach,
				struct sg_table *sgt);
	void *(*gem_prime_vmap)(struct drm_gem_object *obj);
	void (*gem_prime_vunmap)(struct drm_gem_object *obj, void *vaddr);
	int (*gem_prime_mmap)(struct drm_gem_object *obj,
				struct vm_area_struct *vma);

	/* vga arb irq handler */
	void (*vgaarb_irq)(struct drm_device *dev, bool state);

	/**
	 * @dumb_create:
	 *
	 * This creates a new dumb buffer in the driver's backing storage manager (GEM,
	 * TTM or something else entirely) and returns the resulting buffer handle. This
	 * handle can then be wrapped up into a framebuffer modeset object.
	 *
	 * Note that userspace is not allowed to use such objects for render
	 * acceleration - drivers must create their own private ioctls for such a use
	 * case.
	 *
	 * Width, height and depth are specified in the &drm_mode_create_dumb
	 * argument. The callback needs to fill the handle, pitch and size for
	 * the created buffer.
	 *
	 * Called by the user via ioctl.
	 *
	 * Returns:
	 *
	 * Zero on success, negative errno on failure.
	 */
	int (*dumb_create)(struct drm_file *file_priv,
			   struct drm_device *dev,
			   struct drm_mode_create_dumb *args);
	/**
	 * @dumb_map_offset:
	 *
	 * Allocate an offset in the drm device node's address space to be able to
	 * memory map a dumb buffer. GEM-based drivers must use
	 * drm_gem_create_mmap_offset() to implement this.
	 *
	 * Called by the user via ioctl.
	 *
	 * Returns:
	 *
	 * Zero on success, negative errno on failure.
	 */
	int (*dumb_map_offset)(struct drm_file *file_priv,
			       struct drm_device *dev, uint32_t handle,
			       uint64_t *offset);
	/**
	 * @dumb_destroy:
	 *
	 * This destroys the userspace handle for the given dumb backing storage buffer.
	 * Since buffer objects must be reference counted in the kernel a buffer object
	 * won't be immediately freed if a framebuffer modeset object still uses it.
	 *
	 * Called by the user via ioctl.
	 *
	 * Returns:
	 *
	 * Zero on success, negative errno on failure.
	 */
	int (*dumb_destroy)(struct drm_file *file_priv,
			    struct drm_device *dev,
			    uint32_t handle);

	/* Driver private ops for this object */
	const struct vm_operations_struct *gem_vm_ops;

	int major;
	int minor;
	int patchlevel;
	char *name;
	char *desc;
	char *date;

	u32 driver_features;
	int dev_priv_size;
	const struct drm_ioctl_desc *ioctls;
	int num_ioctls;
	const struct file_operations *fops;

	/* List of devices hanging off this driver with stealth attach. */
	struct list_head legacy_dev_list;
};

extern __printf(6, 7)
void drm_dev_printk(const struct device *dev, const char *level,
		    unsigned int category, const char *function_name,
		    const char *prefix, const char *format, ...);
extern __printf(3, 4)
void drm_printk(const char *level, unsigned int category,
		const char *format, ...);
extern unsigned int drm_debug;

int drm_dev_init(struct drm_device *dev,
		 struct drm_driver *driver,
		 struct device *parent);
struct drm_device *drm_dev_alloc(struct drm_driver *driver,
				 struct device *parent);
int drm_dev_register(struct drm_device *dev, unsigned long flags);
void drm_dev_unregister(struct drm_device *dev);

void drm_dev_ref(struct drm_device *dev);
void drm_dev_unref(struct drm_device *dev);
void drm_put_dev(struct drm_device *dev);
void drm_unplug_dev(struct drm_device *dev);

#endif
Commit	Line	Data
85e634bc DV	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	struct drm_device;
	34	struct drm_file;
	35	struct drm_gem_object;
	36	struct drm_master;
	37	struct drm_minor;
	38	struct dma_buf_attachment;
	39	struct drm_display_mode;
	40	struct drm_mode_create_dumb;
	41
	42	/* driver capabilities and requirements mask */
	43	#define DRIVER_USE_AGP 0x1
	44	#define DRIVER_LEGACY 0x2
	45	#define DRIVER_PCI_DMA 0x8
	46	#define DRIVER_SG 0x10
	47	#define DRIVER_HAVE_DMA 0x20
	48	#define DRIVER_HAVE_IRQ 0x40
	49	#define DRIVER_IRQ_SHARED 0x80
	50	#define DRIVER_GEM 0x1000
	51	#define DRIVER_MODESET 0x2000
	52	#define DRIVER_PRIME 0x4000
	53	#define DRIVER_RENDER 0x8000
	54	#define DRIVER_ATOMIC 0x10000
	55	#define DRIVER_KMS_LEGACY_CONTEXT 0x20000
	56
	57	/**
	58	* struct drm_driver - DRM driver structure
	59	*
	60	* This structure represent the common code for a family of cards. There will
	61	* one drm_device for each card present in this family. It contains lots of
	62	* vfunc entries, and a pile of those probably should be moved to more
	63	* appropriate places like &drm_mode_config_funcs or into a new operations
	64	* structure for GEM drivers.
65	*/
66	struct drm_driver {
67	int (load) (struct drm_device , unsigned long flags);
68	int (firstopen) (struct drm_device );
69	int (open) (struct drm_device , struct drm_file *);
70	void (preclose) (struct drm_device , struct drm_file *file_priv);
71	void (postclose) (struct drm_device , struct drm_file *);
72	void (lastclose) (struct drm_device );
73	int (unload) (struct drm_device );
74	int (dma_ioctl) (struct drm_device dev, void data, struct drm_file file_priv);
75	int (dma_quiescent) (struct drm_device );
76	int (context_dtor) (struct drm_device dev, int context);
77	int (set_busid)(struct drm_device dev, struct drm_master *master);
78
79	/**
6c4789ed	80	* @get_vblank_counter:
85e634bc	81	*
6c4789ed DV	82	* Driver callback for fetching a raw hardware vblank counter for the
	83	* CRTC specified with the pipe argument. If a device doesn't have a
	84	* hardware counter, the driver can simply use
	85	* drm_vblank_no_hw_counter() function. The DRM core will account for
85e634bc DV	86	* missed vblank events while interrupts where disabled based on system
	87	* timestamps.
	88	*
	89	* Wraparound handling and loss of events due to modesetting is dealt
6c4789ed DV	90	* with in the DRM core code, as long as drivers call
	91	* drm_crtc_vblank_off() and drm_crtc_vblank_on() when disabling or
	92	* enabling a CRTC.
	93	*
	94	* Returns:
85e634bc	95	*
85e634bc DV	96	* Raw vblank counter value.
	97	*/
	98	u32 (get_vblank_counter) (struct drm_device dev, unsigned int pipe);
	99
	100	/**
6c4789ed DV	101	* @enable_vblank:
	102	*
	103	* Enable vblank interrupts for the CRTC specified with the pipe
	104	* argument.
85e634bc	105	*
6c4789ed	106	* Returns:
85e634bc	107	*
85e634bc DV	108	* Zero on success, appropriate errno if the given @crtc's vblank
	109	* interrupt cannot be enabled.
	110	*/
	111	int (enable_vblank) (struct drm_device dev, unsigned int pipe);
	112
	113	/**
6c4789ed	114	* @disable_vblank:
85e634bc	115	*
6c4789ed DV	116	* Disable vblank interrupts for the CRTC specified with the pipe
6c4789ed DV	117	* argument.
85e634bc DV	118	*/
	119	void (disable_vblank) (struct drm_device dev, unsigned int pipe);
	120
	121	/**
6c4789ed DV	122	* @device_is_agp:
	123	*
	124	* Called by drm_device_is_agp(). Typically used to determine if a card
	125	* is really attached to AGP or not.
85e634bc	126	*
6c4789ed	127	* Returns:
85e634bc	128	*
85e634bc	129	* One of three values is returned depending on whether or not the
6c4789ed	130	* card is absolutely not AGP (return of 0), absolutely is AGP
85e634bc DV	131	* (return of 1), or may or may not be AGP (return of 2).
	132	*/
	133	int (device_is_agp) (struct drm_device dev);
	134
	135	/**
6c4789ed DV	136	* @get_scanout_position:
6c4789ed DV	137	*
85e634bc DV	138	* Called by vblank timestamping code.
85e634bc DV	139	*
6c4789ed DV	140	* Returns the current display scanout position from a crtc, and an
	141	* optional accurate ktime_get() timestamp of when position was
	142	* measured. Note that this is a helper callback which is only used if a
	143	* driver uses drm_calc_vbltimestamp_from_scanoutpos() for the
	144	* @get_vblank_timestamp callback.
	145	*
	146	* Parameters:
85e634bc	147	*
6c4789ed DV	148	* dev:
	149	* DRM device.
	150	* pipe:
	151	* Id of the crtc to query.
	152	* flags:
	153	* Flags from the caller (DRM_CALLED_FROM_VBLIRQ or 0).
	154	* vpos:
	155	* Target location for current vertical scanout position.
	156	* hpos:
	157	* Target location for current horizontal scanout position.
	158	* stime:
	159	* Target location for timestamp taken immediately before
	160	* scanout position query. Can be NULL to skip timestamp.
	161	* etime:
	162	* Target location for timestamp taken immediately after
	163	* scanout position query. Can be NULL to skip timestamp.
	164	* mode:
	165	* Current display timings.
85e634bc DV	166	*
	167	* Returns vpos as a positive number while in active scanout area.
	168	* Returns vpos as a negative number inside vblank, counting the number
	169	* of scanlines to go until end of vblank, e.g., -1 means "one scanline
	170	* until start of active scanout / end of vblank."
	171	*
6c4789ed DV	172	* Returns:
	173	*
	174	* Flags, or'ed together as follows:
85e634bc	175	*
6c4789ed DV	176	* DRM_SCANOUTPOS_VALID:
	177	* Query successful.
	178	* DRM_SCANOUTPOS_INVBL:
	179	* Inside vblank.
	180	* DRM_SCANOUTPOS_ACCURATE: Returned position is accurate. A lack of
	181	* this flag means that returned position may be offset by a
	182	* constant but unknown small number of scanlines wrt. real scanout
	183	* position.
85e634bc DV	184	*
	185	*/
	186	int (get_scanout_position) (struct drm_device dev, unsigned int pipe,
	187	unsigned int flags, int vpos, int hpos,
	188	ktime_t stime, ktime_t etime,
	189	const struct drm_display_mode *mode);
	190
	191	/**
6c4789ed DV	192	* @get_vblank_timestamp:
	193	*
	194	* Called by drm_get_last_vbltimestamp(). Should return a precise
85e634bc DV	195	* timestamp when the most recent VBLANK interval ended or will end.
	196	*
	197	* Specifically, the timestamp in @vblank_time should correspond as
	198	* closely as possible to the time when the first video scanline of
	199	* the video frame after the end of VBLANK will start scanning out,
	200	* the time immediately after end of the VBLANK interval. If the
	201	* @crtc is currently inside VBLANK, this will be a time in the future.
	202	* If the @crtc is currently scanning out a frame, this will be the
	203	* past start time of the current scanout. This is meant to adhere
	204	* to the OpenML OML_sync_control extension specification.
	205	*
6c4789ed DV	206	* Paramters:
	207	*
	208	* dev:
	209	* dev DRM device handle.
	210	* pipe:
	211	* crtc for which timestamp should be returned.
	212	* max_error:
	213	* Maximum allowable timestamp error in nanoseconds.
	214	* Implementation should strive to provide timestamp
	215	* with an error of at most max_error nanoseconds.
	216	* Returns true upper bound on error for timestamp.
	217	* vblank_time:
	218	* Target location for returned vblank timestamp.
	219	* flags:
	220	* 0 = Defaults, no special treatment needed.
	221	* DRM_CALLED_FROM_VBLIRQ = Function is called from vblank
	222	* irq handler. Some drivers need to apply some workarounds
	223	* for gpu-specific vblank irq quirks if flag is set.
	224	*
	225	* Returns:
	226	*
85e634bc DV	227	* Zero if timestamping isn't supported in current display mode or a
	228	* negative number on failure. A positive status code on success,
	229	* which describes how the vblank_time timestamp was computed.
	230	*/
	231	int (get_vblank_timestamp) (struct drm_device dev, unsigned int pipe,
	232	int *max_error,
	233	struct timeval *vblank_time,
	234	unsigned flags);
	235
	236	/* these have to be filled in */
	237
	238	irqreturn_t(irq_handler) (int irq, void arg);
	239	void (irq_preinstall) (struct drm_device dev);
	240	int (irq_postinstall) (struct drm_device dev);
	241	void (irq_uninstall) (struct drm_device dev);
	242
6c4789ed DV	243	/**
	244	* @master_create:
	245	*
	246	* Called whenever a new master is created. Only used by vmwgfx.
	247	*/
85e634bc	248	int (master_create)(struct drm_device dev, struct drm_master *master);
6c4789ed	249
85e634bc	250	/**
6c4789ed DV	251	* @master_destroy:
	252	*
	253	* Called whenever a master is destroyed. Only used by vmwgfx.
85e634bc	254	*/
6c4789ed	255	void (master_destroy)(struct drm_device dev, struct drm_master *master);
85e634bc	256
6c4789ed DV	257	/**
	258	* @master_set:
	259	*
	260	* Called whenever the minor master is set. Only used by vmwgfx.
	261	*/
85e634bc DV	262	int (master_set)(struct drm_device dev, struct drm_file *file_priv,
85e634bc DV	263	bool from_open);
6c4789ed DV	264	/**
	265	* @master_drop:
	266	*
	267	* Called whenever the minor master is dropped. Only used by vmwgfx.
	268	*/
85e634bc DV	269	void (master_drop)(struct drm_device dev, struct drm_file *file_priv);
	270
	271	int (debugfs_init)(struct drm_minor minor);
	272	void (debugfs_cleanup)(struct drm_minor minor);
	273
	274	/**
	275	* @gem_free_object: deconstructor for drm_gem_objects
	276	*
	277	* This is deprecated and should not be used by new drivers. Use
	278	* @gem_free_object_unlocked instead.
	279	*/
	280	void (gem_free_object) (struct drm_gem_object obj);
	281
	282	/**
	283	* @gem_free_object_unlocked: deconstructor for drm_gem_objects
	284	*
	285	* This is for drivers which are not encumbered with dev->struct_mutex
	286	* legacy locking schemes. Use this hook instead of @gem_free_object.
	287	*/
	288	void (gem_free_object_unlocked) (struct drm_gem_object obj);
	289
	290	int (gem_open_object) (struct drm_gem_object , struct drm_file *);
	291	void (gem_close_object) (struct drm_gem_object , struct drm_file *);
	292
	293	/**
	294	* Hook for allocating the GEM object struct, for use by core
	295	* helpers.
	296	*/
	297	struct drm_gem_object (gem_create_object)(struct drm_device *dev,
	298	size_t size);
	299
	300	/* prime: */
	301	/* export handle -> fd (see drm_gem_prime_handle_to_fd() helper) */
	302	int (prime_handle_to_fd)(struct drm_device dev, struct drm_file *file_priv,
	303	uint32_t handle, uint32_t flags, int *prime_fd);
	304	/* import fd -> handle (see drm_gem_prime_fd_to_handle() helper) */
	305	int (prime_fd_to_handle)(struct drm_device dev, struct drm_file *file_priv,
	306	int prime_fd, uint32_t *handle);
	307	/* export GEM -> dmabuf */
	308	struct dma_buf * (gem_prime_export)(struct drm_device dev,
	309	struct drm_gem_object *obj, int flags);
	310	/* import dmabuf -> GEM */
	311	struct drm_gem_object * (gem_prime_import)(struct drm_device dev,
	312	struct dma_buf *dma_buf);
	313	/* low-level interface used by drm_gem_prime_{import,export} */
	314	int (gem_prime_pin)(struct drm_gem_object obj);
	315	void (gem_prime_unpin)(struct drm_gem_object obj);
	316	struct reservation_object * (*gem_prime_res_obj)(
	317	struct drm_gem_object *obj);
	318	struct sg_table (gem_prime_get_sg_table)(struct drm_gem_object *obj);
	319	struct drm_gem_object (gem_prime_import_sg_table)(
	320	struct drm_device *dev,
	321	struct dma_buf_attachment *attach,
	322	struct sg_table *sgt);
	323	void (gem_prime_vmap)(struct drm_gem_object *obj);
	324	void (gem_prime_vunmap)(struct drm_gem_object obj, void *vaddr);
	325	int (gem_prime_mmap)(struct drm_gem_object obj,
	326	struct vm_area_struct *vma);
	327
	328	/* vga arb irq handler */
	329	void (vgaarb_irq)(struct drm_device dev, bool state);
	330
4f93624e DV	331	/**
	332	* @dumb_create:
	333	*
	334	* This creates a new dumb buffer in the driver's backing storage manager (GEM,
	335	* TTM or something else entirely) and returns the resulting buffer handle. This
	336	* handle can then be wrapped up into a framebuffer modeset object.
	337	*
	338	* Note that userspace is not allowed to use such objects for render
	339	* acceleration - drivers must create their own private ioctls for such a use
	340	* case.
	341	*
	342	* Width, height and depth are specified in the &drm_mode_create_dumb
	343	* argument. The callback needs to fill the handle, pitch and size for
	344	* the created buffer.
	345	*
	346	* Called by the user via ioctl.
	347	*
	348	* Returns:
	349	*
	350	* Zero on success, negative errno on failure.
	351	*/
85e634bc DV	352	int (dumb_create)(struct drm_file file_priv,
	353	struct drm_device *dev,
	354	struct drm_mode_create_dumb *args);
4f93624e DV	355	/**
	356	* @dumb_map_offset:
	357	*
	358	* Allocate an offset in the drm device node's address space to be able to
	359	* memory map a dumb buffer. GEM-based drivers must use
	360	* drm_gem_create_mmap_offset() to implement this.
	361	*
	362	* Called by the user via ioctl.
	363	*
	364	* Returns:
	365	*
	366	* Zero on success, negative errno on failure.
	367	*/
85e634bc DV	368	int (dumb_map_offset)(struct drm_file file_priv,
	369	struct drm_device *dev, uint32_t handle,
	370	uint64_t *offset);
4f93624e DV	371	/**
	372	* @dumb_destroy:
	373	*
	374	* This destroys the userspace handle for the given dumb backing storage buffer.
	375	* Since buffer objects must be reference counted in the kernel a buffer object
	376	* won't be immediately freed if a framebuffer modeset object still uses it.
	377	*
	378	* Called by the user via ioctl.
	379	*
	380	* Returns:
	381	*
	382	* Zero on success, negative errno on failure.
	383	*/
85e634bc DV	384	int (dumb_destroy)(struct drm_file file_priv,
	385	struct drm_device *dev,
	386	uint32_t handle);
	387
	388	/* Driver private ops for this object */
	389	const struct vm_operations_struct *gem_vm_ops;
	390
	391	int major;
	392	int minor;
	393	int patchlevel;
	394	char *name;
	395	char *desc;
	396	char *date;
	397
	398	u32 driver_features;
	399	int dev_priv_size;
	400	const struct drm_ioctl_desc *ioctls;
	401	int num_ioctls;
	402	const struct file_operations *fops;
	403
	404	/* List of devices hanging off this driver with stealth attach. */
	405	struct list_head legacy_dev_list;
	406	};
	407
	408	extern __printf(6, 7)
	409	void drm_dev_printk(const struct device dev, const char level,
	410	unsigned int category, const char *function_name,
	411	const char prefix, const char format, ...);
	412	extern __printf(3, 4)
	413	void drm_printk(const char *level, unsigned int category,
	414	const char *format, ...);
	415	extern unsigned int drm_debug;
	416
	417	int drm_dev_init(struct drm_device *dev,
	418	struct drm_driver *driver,
	419	struct device *parent);
	420	struct drm_device drm_dev_alloc(struct drm_driver driver,
	421	struct device *parent);
	422	int drm_dev_register(struct drm_device *dev, unsigned long flags);
	423	void drm_dev_unregister(struct drm_device *dev);
	424
	425	void drm_dev_ref(struct drm_device *dev);
	426	void drm_dev_unref(struct drm_device *dev);
	427	void drm_put_dev(struct drm_device *dev);
	428	void drm_unplug_dev(struct drm_device *dev);
	429
	430	#endif