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

/*
 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
 * Copyright (c) 2009-2010, Code Aurora Forum.
 * All rights reserved.
 *
 * Author: Rickard E. (Rik) Faith <faith@valinux.com>
 * Author: Gareth Hughes <gareth@valinux.com>
 *
 * 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_FILE_H_
#define _DRM_FILE_H_

#include <linux/types.h>
#include <linux/completion.h>
#include <linux/idr.h>

#include <uapi/drm/drm.h>

#include <drm/drm_prime.h>

struct dma_fence;
struct drm_file;
struct drm_device;
struct device;
struct file;

/*
 * FIXME: Not sure we want to have drm_minor here in the end, but to avoid
 * header include loops we need it here for now.
 */

/* Note that the order of this enum is ABI (it determines
 * /dev/dri/renderD* numbers).
 */
enum drm_minor_type {
	DRM_MINOR_PRIMARY,
	DRM_MINOR_CONTROL,
	DRM_MINOR_RENDER,
};

/**
 * struct drm_minor - DRM device minor structure
 *
 * This structure represents a DRM minor number for device nodes in /dev.
 * Entirely opaque to drivers and should never be inspected directly by drivers.
 * Drivers instead should only interact with &struct drm_file and of course
 * &struct drm_device, which is also where driver-private data and resources can
 * be attached to.
 */
struct drm_minor {
	/* private: */
	int index;			/* Minor device number */
	int type;                       /* Control or render */
	struct device *kdev;		/* Linux device */
	struct drm_device *dev;

	struct dentry *debugfs_root;

	struct list_head debugfs_list;
	struct mutex debugfs_lock; /* Protects debugfs_list. */
};

/**
 * struct drm_pending_event - Event queued up for userspace to read
 *
 * This represents a DRM event. Drivers can use this as a generic completion
 * mechanism, which supports kernel-internal &struct completion, &struct dma_fence
 * and also the DRM-specific &struct drm_event delivery mechanism.
 */
struct drm_pending_event {
	/**
	 * @completion:
	 *
	 * Optional pointer to a kernel internal completion signalled when
	 * drm_send_event() is called, useful to internally synchronize with
	 * nonblocking operations.
	 */
	struct completion *completion;

	/**
	 * @completion_release:
	 *
	 * Optional callback currently only used by the atomic modeset helpers
	 * to clean up the reference count for the structure @completion is
	 * stored in.
	 */
	void (*completion_release)(struct completion *completion);

	/**
	 * @event:
	 *
	 * Pointer to the actual event that should be sent to userspace to be
	 * read using drm_read(). Can be optional, since nowadays events are
	 * also used to signal kernel internal threads with @completion or DMA
	 * transactions using @fence.
	 */
	struct drm_event *event;

	/**
	 * @fence:
	 *
	 * Optional DMA fence to unblock other hardware transactions which
	 * depend upon the nonblocking DRM operation this event represents.
	 */
	struct dma_fence *fence;

	/**
	 * @file_priv:
	 *
	 * &struct drm_file where @event should be delivered to. Only set when
	 * @event is set.
	 */
	struct drm_file *file_priv;

	/**
	 * @link:
	 *
	 * Double-linked list to keep track of this event. Can be used by the
	 * driver up to the point when it calls drm_send_event(), after that
	 * this list entry is owned by the core for its own book-keeping.
	 */
	struct list_head link;

	/**
	 * @pending_link:
	 *
	 * Entry on &drm_file.pending_event_list, to keep track of all pending
	 * events for @file_priv, to allow correct unwinding of them when
	 * userspace closes the file before the event is delivered.
	 */
	struct list_head pending_link;
};

/**
 * struct drm_file - DRM file private data
 *
 * This structure tracks DRM state per open file descriptor.
 */
struct drm_file {
	/**
	 * @authenticated:
	 *
	 * Whether the client is allowed to submit rendering, which for legacy
	 * nodes means it must be authenticated.
	 *
	 * See also the :ref:`section on primary nodes and authentication
	 * <drm_primary_node>`.
	 */
	bool authenticated;

	/**
	 * @stereo_allowed:
	 *
	 * True when the client has asked us to expose stereo 3D mode flags.
	 */
	bool stereo_allowed;

	/**
	 * @universal_planes:
	 *
	 * True if client understands CRTC primary planes and cursor planes
	 * in the plane list. Automatically set when @atomic is set.
	 */
	bool universal_planes;

	/** @atomic: True if client understands atomic properties. */
	bool atomic;

	/**
	 * @aspect_ratio_allowed:
	 *
	 * True, if client can handle picture aspect ratios, and has requested
	 * to pass this information along with the mode.
	 */
	bool aspect_ratio_allowed;

	/**
	 * @writeback_connectors:
	 *
	 * True if client understands writeback connectors
	 */
	bool writeback_connectors;

	/**
	 * @was_master:
	 *
	 * This client has or had, master capability. Protected by struct
	 * &drm_device.master_mutex.
	 *
	 * This is used to ensure that CAP_SYS_ADMIN is not enforced, if the
	 * client is or was master in the past.
	 */
	bool was_master;

	/**
	 * @is_master:
	 *
	 * This client is the creator of @master. Protected by struct
	 * &drm_device.master_mutex.
	 *
	 * See also the :ref:`section on primary nodes and authentication
	 * <drm_primary_node>`.
	 */
	bool is_master;

	/**
	 * @master:
	 *
	 * Master this node is currently associated with. Protected by struct
	 * &drm_device.master_mutex, and serialized by @master_lookup_lock.
	 *
	 * Only relevant if drm_is_primary_client() returns true. Note that
	 * this only matches &drm_device.master if the master is the currently
	 * active one.
	 *
	 * To update @master, both &drm_device.master_mutex and
	 * @master_lookup_lock need to be held, therefore holding either of
	 * them is safe and enough for the read side.
	 *
	 * When dereferencing this pointer, either hold struct
	 * &drm_device.master_mutex for the duration of the pointer's use, or
	 * use drm_file_get_master() if struct &drm_device.master_mutex is not
	 * currently held and there is no other need to hold it. This prevents
	 * @master from being freed during use.
	 *
	 * See also @authentication and @is_master and the :ref:`section on
	 * primary nodes and authentication <drm_primary_node>`.
	 */
	struct drm_master *master;

	/** @master_lookup_lock: Serializes @master. */
	spinlock_t master_lookup_lock;

	/** @pid: Process that opened this file. */
	struct pid *pid;

	/** @magic: Authentication magic, see @authenticated. */
	drm_magic_t magic;

	/**
	 * @lhead:
	 *
	 * List of all open files of a DRM device, linked into
	 * &drm_device.filelist. Protected by &drm_device.filelist_mutex.
	 */
	struct list_head lhead;

	/** @minor: &struct drm_minor for this file. */
	struct drm_minor *minor;

	/**
	 * @object_idr:
	 *
	 * Mapping of mm object handles to object pointers. Used by the GEM
	 * subsystem. Protected by @table_lock.
	 */
	struct idr object_idr;

	/** @table_lock: Protects @object_idr. */
	spinlock_t table_lock;

	/** @syncobj_idr: Mapping of sync object handles to object pointers. */
	struct idr syncobj_idr;
	/** @syncobj_table_lock: Protects @syncobj_idr. */
	spinlock_t syncobj_table_lock;

	/** @filp: Pointer to the core file structure. */
	struct file *filp;

	/**
	 * @driver_priv:
	 *
	 * Optional pointer for driver private data. Can be allocated in
	 * &drm_driver.open and should be freed in &drm_driver.postclose.
	 */
	void *driver_priv;

	/**
	 * @fbs:
	 *
	 * List of &struct drm_framebuffer associated with this file, using the
	 * &drm_framebuffer.filp_head entry.
	 *
	 * Protected by @fbs_lock. Note that the @fbs list holds a reference on
	 * the framebuffer object to prevent it from untimely disappearing.
	 */
	struct list_head fbs;

	/** @fbs_lock: Protects @fbs. */
	struct mutex fbs_lock;

	/**
	 * @blobs:
	 *
	 * User-created blob properties; this retains a reference on the
	 * property.
	 *
	 * Protected by @drm_mode_config.blob_lock;
	 */
	struct list_head blobs;

	/** @event_wait: Waitqueue for new events added to @event_list. */
	wait_queue_head_t event_wait;

	/**
	 * @pending_event_list:
	 *
	 * List of pending &struct drm_pending_event, used to clean up pending
	 * events in case this file gets closed before the event is signalled.
	 * Uses the &drm_pending_event.pending_link entry.
	 *
	 * Protect by &drm_device.event_lock.
	 */
	struct list_head pending_event_list;

	/**
	 * @event_list:
	 *
	 * List of &struct drm_pending_event, ready for delivery to userspace
	 * through drm_read(). Uses the &drm_pending_event.link entry.
	 *
	 * Protect by &drm_device.event_lock.
	 */
	struct list_head event_list;

	/**
	 * @event_space:
	 *
	 * Available event space to prevent userspace from
	 * exhausting kernel memory. Currently limited to the fairly arbitrary
	 * value of 4KB.
	 */
	int event_space;

	/** @event_read_lock: Serializes drm_read(). */
	struct mutex event_read_lock;

	/**
	 * @prime:
	 *
	 * Per-file buffer caches used by the PRIME buffer sharing code.
	 */
	struct drm_prime_file_private prime;

	/* private: */
#if IS_ENABLED(CONFIG_DRM_LEGACY)
	unsigned long lock_count; /* DRI1 legacy lock count */
#endif
};

/**
 * drm_is_primary_client - is this an open file of the primary node
 * @file_priv: DRM file
 *
 * Returns true if this is an open file of the primary node, i.e.
 * &drm_file.minor of @file_priv is a primary minor.
 *
 * See also the :ref:`section on primary nodes and authentication
 * <drm_primary_node>`.
 */
static inline bool drm_is_primary_client(const struct drm_file *file_priv)
{
	return file_priv->minor->type == DRM_MINOR_PRIMARY;
}

/**
 * drm_is_render_client - is this an open file of the render node
 * @file_priv: DRM file
 *
 * Returns true if this is an open file of the render node, i.e.
 * &drm_file.minor of @file_priv is a render minor.
 *
 * See also the :ref:`section on render nodes <drm_render_node>`.
 */
static inline bool drm_is_render_client(const struct drm_file *file_priv)
{
	return file_priv->minor->type == DRM_MINOR_RENDER;
}

int drm_open(struct inode *inode, struct file *filp);
ssize_t drm_read(struct file *filp, char __user *buffer,
		 size_t count, loff_t *offset);
int drm_release(struct inode *inode, struct file *filp);
int drm_release_noglobal(struct inode *inode, struct file *filp);
__poll_t drm_poll(struct file *filp, struct poll_table_struct *wait);
int drm_event_reserve_init_locked(struct drm_device *dev,
				  struct drm_file *file_priv,
				  struct drm_pending_event *p,
				  struct drm_event *e);
int drm_event_reserve_init(struct drm_device *dev,
			   struct drm_file *file_priv,
			   struct drm_pending_event *p,
			   struct drm_event *e);
void drm_event_cancel_free(struct drm_device *dev,
			   struct drm_pending_event *p);
void drm_send_event_locked(struct drm_device *dev, struct drm_pending_event *e);
void drm_send_event(struct drm_device *dev, struct drm_pending_event *e);
void drm_send_event_timestamp_locked(struct drm_device *dev,
				     struct drm_pending_event *e,
				     ktime_t timestamp);

struct file *mock_drm_getfile(struct drm_minor *minor, unsigned int flags);

#ifdef CONFIG_MMU
struct drm_vma_offset_manager;
unsigned long drm_get_unmapped_area(struct file *file,
				    unsigned long uaddr, unsigned long len,
				    unsigned long pgoff, unsigned long flags,
				    struct drm_vma_offset_manager *mgr);
#endif /* CONFIG_MMU */


#endif /* _DRM_FILE_H_ */
Commit	Line	Data
a8f8b1d9 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	* All rights reserved.
	6	*
	7	* Author: Rickard E. (Rik) Faith <faith@valinux.com>
	8	* Author: Gareth Hughes <gareth@valinux.com>
	9	*
	10	* Permission is hereby granted, free of charge, to any person obtaining a
	11	* copy of this software and associated documentation files (the "Software"),
	12	* to deal in the Software without restriction, including without limitation
	13	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	14	* and/or sell copies of the Software, and to permit persons to whom the
	15	* Software is furnished to do so, subject to the following conditions:
	16	*
	17	* The above copyright notice and this permission notice (including the next
	18	* paragraph) shall be included in all copies or substantial portions of the
	19	* Software.
	20	*
	21	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	22	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	23	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	24	* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
	25	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	26	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	27	* OTHER DEALINGS IN THE SOFTWARE.
	28	*/
	29
	30	#ifndef _DRM_FILE_H_
	31	#define _DRM_FILE_H_
	32
	33	#include <linux/types.h>
	34	#include <linux/completion.h>
39e23674	35	#include <linux/idr.h>
a8f8b1d9 DV	36
	37	#include <uapi/drm/drm.h>
	38
	39	#include <drm/drm_prime.h>
	40
	41	struct dma_fence;
	42	struct drm_file;
	43	struct drm_device;
3ed4351a	44	struct device;
4748aa16	45	struct file;
a8f8b1d9 DV	46
	47	/*
	48	* FIXME: Not sure we want to have drm_minor here in the end, but to avoid
	49	* header include loops we need it here for now.
	50	*/
b93658f8	51
c9ac371d EA	52	/* Note that the order of this enum is ABI (it determines
	53	* /dev/dri/renderD* numbers).
	54	*/
a8f8b1d9 DV	55	enum drm_minor_type {
a8f8b1d9 DV	56	DRM_MINOR_PRIMARY,
c9ac371d	57	DRM_MINOR_CONTROL,
a8f8b1d9 DV	58	DRM_MINOR_RENDER,
	59	};
	60
	61	/**
b93658f8 DV	62	* struct drm_minor - DRM device minor structure
	63	*
	64	* This structure represents a DRM minor number for device nodes in /dev.
	65	* Entirely opaque to drivers and should never be inspected directly by drivers.
	66	* Drivers instead should only interact with &struct drm_file and of course
	67	* &struct drm_device, which is also where driver-private data and resources can
	68	* be attached to.
a8f8b1d9 DV	69	*/
a8f8b1d9 DV	70	struct drm_minor {
b93658f8 DV	71	/* private: */
	72	int index; /* Minor device number */
	73	int type; /* Control or render */
	74	struct device kdev; / Linux device */
a8f8b1d9 DV	75	struct drm_device *dev;
	76
	77	struct dentry *debugfs_root;
	78
	79	struct list_head debugfs_list;
	80	struct mutex debugfs_lock; /* Protects debugfs_list. */
	81	};
	82
b93658f8 DV	83	/**
	84	* struct drm_pending_event - Event queued up for userspace to read
	85	*
	86	* This represents a DRM event. Drivers can use this as a generic completion
	87	* mechanism, which supports kernel-internal &struct completion, &struct dma_fence
	88	* and also the DRM-specific &struct drm_event delivery mechanism.
	89	*/
a8f8b1d9	90	struct drm_pending_event {
b93658f8 DV	91	/**
	92	* @completion:
	93	*
	94	* Optional pointer to a kernel internal completion signalled when
	95	* drm_send_event() is called, useful to internally synchronize with
	96	* nonblocking operations.
	97	*/
a8f8b1d9	98	struct completion *completion;
b93658f8 DV	99
	100	/**
	101	* @completion_release:
	102	*
	103	* Optional callback currently only used by the atomic modeset helpers
	104	* to clean up the reference count for the structure @completion is
	105	* stored in.
	106	*/
a8f8b1d9	107	void (completion_release)(struct completion completion);
b93658f8 DV	108
	109	/**
	110	* @event:
	111	*
	112	* Pointer to the actual event that should be sent to userspace to be
	113	* read using drm_read(). Can be optional, since nowadays events are
	114	* also used to signal kernel internal threads with @completion or DMA
	115	* transactions using @fence.
	116	*/
a8f8b1d9	117	struct drm_event *event;
b93658f8 DV	118
	119	/**
	120	* @fence:
	121	*
	122	* Optional DMA fence to unblock other hardware transactions which
	123	* depend upon the nonblocking DRM operation this event represents.
	124	*/
a8f8b1d9	125	struct dma_fence *fence;
b93658f8 DV	126
	127	/**
	128	* @file_priv:
	129	*
	130	* &struct drm_file where @event should be delivered to. Only set when
	131	* @event is set.
	132	*/
	133	struct drm_file *file_priv;
	134
	135	/**
	136	* @link:
	137	*
	138	* Double-linked list to keep track of this event. Can be used by the
	139	* driver up to the point when it calls drm_send_event(), after that
	140	* this list entry is owned by the core for its own book-keeping.
	141	*/
a8f8b1d9	142	struct list_head link;
b93658f8 DV	143
	144	/**
	145	* @pending_link:
	146	*
	147	* Entry on &drm_file.pending_event_list, to keep track of all pending
	148	* events for @file_priv, to allow correct unwinding of them when
	149	* userspace closes the file before the event is delivered.
	150	*/
a8f8b1d9	151	struct list_head pending_link;
a8f8b1d9 DV	152	};
a8f8b1d9 DV	153
b93658f8 DV	154	/**
	155	* struct drm_file - DRM file private data
	156	*
	157	* This structure tracks DRM state per open file descriptor.
	158	*/
a8f8b1d9	159	struct drm_file {
b93658f8 DV	160	/**
	161	* @authenticated:
	162	*
	163	* Whether the client is allowed to submit rendering, which for legacy
	164	* nodes means it must be authenticated.
	165	*
	166	* See also the :ref:`section on primary nodes and authentication
	167	* <drm_primary_node>`.
	168	*/
078b7de4	169	bool authenticated;
b93658f8 DV	170
	171	/**
	172	* @stereo_allowed:
	173	*
	174	* True when the client has asked us to expose stereo 3D mode flags.
	175	*/
078b7de4	176	bool stereo_allowed;
b93658f8 DV	177
	178	/**
	179	* @universal_planes:
	180	*
	181	* True if client understands CRTC primary planes and cursor planes
	182	* in the plane list. Automatically set when @atomic is set.
a8f8b1d9	183	*/
078b7de4	184	bool universal_planes;
b93658f8 DV	185
b93658f8 DV	186	/** @atomic: True if client understands atomic properties. */
078b7de4	187	bool atomic;
b93658f8	188
7595bda2 AN	189	/**
	190	* @aspect_ratio_allowed:
	191	*
	192	* True, if client can handle picture aspect ratios, and has requested
	193	* to pass this information along with the mode.
	194	*/
078b7de4	195	bool aspect_ratio_allowed;
7595bda2	196
d67b6a20 LD	197	/**
	198	* @writeback_connectors:
	199	*
	200	* True if client understands writeback connectors
	201	*/
078b7de4	202	bool writeback_connectors;
d67b6a20	203
45bc3d26 EV	204	/**
	205	* @was_master:
	206	*
	207	* This client has or had, master capability. Protected by struct
	208	* &drm_device.master_mutex.
	209	*
	210	* This is used to ensure that CAP_SYS_ADMIN is not enforced, if the
	211	* client is or was master in the past.
	212	*/
	213	bool was_master;
	214
b93658f8 DV	215	/**
	216	* @is_master:
	217	*
	218	* This client is the creator of @master. Protected by struct
	219	* &drm_device.master_mutex.
	220	*
	221	* See also the :ref:`section on primary nodes and authentication
	222	* <drm_primary_node>`.
a8f8b1d9	223	*/
078b7de4	224	bool is_master;
a8f8b1d9	225
b93658f8 DV	226	/**
	227	* @master:
	228	*
0b0860a3 DCZX	229	* Master this node is currently associated with. Protected by struct
	230	* &drm_device.master_mutex, and serialized by @master_lookup_lock.
	231	*
	232	* Only relevant if drm_is_primary_client() returns true. Note that
	233	* this only matches &drm_device.master if the master is the currently
	234	* active one.
b93658f8	235	*
649839d7 DCZX	236	* To update @master, both &drm_device.master_mutex and
	237	* @master_lookup_lock need to be held, therefore holding either of
	238	* them is safe and enough for the read side.
	239	*
56f0729a DCZX	240	* When dereferencing this pointer, either hold struct
	241	* &drm_device.master_mutex for the duration of the pointer's use, or
	242	* use drm_file_get_master() if struct &drm_device.master_mutex is not
	243	* currently held and there is no other need to hold it. This prevents
	244	* @master from being freed during use.
	245	*
b93658f8 DV	246	* See also @authentication and @is_master and the :ref:`section on
	247	* primary nodes and authentication <drm_primary_node>`.
	248	*/
	249	struct drm_master *master;
	250
35352081	251	/** @master_lookup_lock: Serializes @master. */
0b0860a3 DCZX	252	spinlock_t master_lookup_lock;
0b0860a3 DCZX	253
b93658f8	254	/** @pid: Process that opened this file. */
a8f8b1d9	255	struct pid *pid;
b93658f8 DV	256
b93658f8 DV	257	/** @magic: Authentication magic, see @authenticated. */
a8f8b1d9	258	drm_magic_t magic;
b93658f8 DV	259
	260	/**
	261	* @lhead:
	262	*
	263	* List of all open files of a DRM device, linked into
	264	* &drm_device.filelist. Protected by &drm_device.filelist_mutex.
	265	*/
a8f8b1d9	266	struct list_head lhead;
b93658f8 DV	267
b93658f8 DV	268	/** @minor: &struct drm_minor for this file. */
a8f8b1d9	269	struct drm_minor *minor;
a8f8b1d9	270
b93658f8 DV	271	/**
	272	* @object_idr:
	273	*
	274	* Mapping of mm object handles to object pointers. Used by the GEM
	275	* subsystem. Protected by @table_lock.
	276	*/
a8f8b1d9	277	struct idr object_idr;
b93658f8 DV	278
b93658f8 DV	279	/** @table_lock: Protects @object_idr. */
a8f8b1d9 DV	280	spinlock_t table_lock;
a8f8b1d9 DV	281
e9083420 DA	282	/** @syncobj_idr: Mapping of sync object handles to object pointers. */
	283	struct idr syncobj_idr;
	284	/** @syncobj_table_lock: Protects @syncobj_idr. */
	285	spinlock_t syncobj_table_lock;
	286
b93658f8	287	/** @filp: Pointer to the core file structure. */
a8f8b1d9	288	struct file *filp;
b93658f8 DV	289
	290	/**
	291	* @driver_priv:
	292	*
	293	* Optional pointer for driver private data. Can be allocated in
	294	* &drm_driver.open and should be freed in &drm_driver.postclose.
	295	*/
a8f8b1d9 DV	296	void *driver_priv;
a8f8b1d9 DV	297
a8f8b1d9	298	/**
b93658f8 DV	299	* @fbs:
	300	*
	301	* List of &struct drm_framebuffer associated with this file, using the
	302	* &drm_framebuffer.filp_head entry.
a8f8b1d9	303	*
b93658f8 DV	304	* Protected by @fbs_lock. Note that the @fbs list holds a reference on
b93658f8 DV	305	* the framebuffer object to prevent it from untimely disappearing.
a8f8b1d9 DV	306	*/
a8f8b1d9 DV	307	struct list_head fbs;
b93658f8 DV	308
b93658f8 DV	309	/** @fbs_lock: Protects @fbs. */
a8f8b1d9 DV	310	struct mutex fbs_lock;
a8f8b1d9 DV	311
b93658f8 DV	312	/**
	313	* @blobs:
	314	*
	315	* User-created blob properties; this retains a reference on the
	316	* property.
	317	*
	318	* Protected by @drm_mode_config.blob_lock;
	319	*/
a8f8b1d9 DV	320	struct list_head blobs;
a8f8b1d9 DV	321
b93658f8	322	/** @event_wait: Waitqueue for new events added to @event_list. */
a8f8b1d9	323	wait_queue_head_t event_wait;
b93658f8 DV	324
	325	/**
	326	* @pending_event_list:
	327	*
	328	* List of pending &struct drm_pending_event, used to clean up pending
	329	* events in case this file gets closed before the event is signalled.
	330	* Uses the &drm_pending_event.pending_link entry.
	331	*
	332	* Protect by &drm_device.event_lock.
	333	*/
a8f8b1d9	334	struct list_head pending_event_list;
b93658f8 DV	335
	336	/**
	337	* @event_list:
	338	*
	339	* List of &struct drm_pending_event, ready for delivery to userspace
	340	* through drm_read(). Uses the &drm_pending_event.link entry.
	341	*
	342	* Protect by &drm_device.event_lock.
	343	*/
a8f8b1d9	344	struct list_head event_list;
b93658f8 DV	345
	346	/**
	347	* @event_space:
	348	*
	349	* Available event space to prevent userspace from
	350	* exhausting kernel memory. Currently limited to the fairly arbitrary
	351	* value of 4KB.
	352	*/
a8f8b1d9 DV	353	int event_space;
a8f8b1d9 DV	354
b93658f8	355	/** @event_read_lock: Serializes drm_read(). */
a8f8b1d9 DV	356	struct mutex event_read_lock;
a8f8b1d9 DV	357
b93658f8 DV	358	/**
	359	* @prime:
	360	*
	361	* Per-file buffer caches used by the PRIME buffer sharing code.
	362	*/
a8f8b1d9	363	struct drm_prime_file_private prime;
b93658f8 DV	364
b93658f8 DV	365	/* private: */
ee22f763	366	#if IS_ENABLED(CONFIG_DRM_LEGACY)
b93658f8	367	unsigned long lock_count; /* DRI1 legacy lock count */
ee22f763	368	#endif
a8f8b1d9 DV	369	};
a8f8b1d9 DV	370
b93658f8 DV	371	/**
	372	* drm_is_primary_client - is this an open file of the primary node
	373	* @file_priv: DRM file
	374	*
	375	* Returns true if this is an open file of the primary node, i.e.
	376	* &drm_file.minor of @file_priv is a primary minor.
	377	*
	378	* See also the :ref:`section on primary nodes and authentication
	379	* <drm_primary_node>`.
	380	*/
	381	static inline bool drm_is_primary_client(const struct drm_file *file_priv)
	382	{
	383	return file_priv->minor->type == DRM_MINOR_PRIMARY;
	384	}
	385
	386	/**
	387	* drm_is_render_client - is this an open file of the render node
	388	* @file_priv: DRM file
	389	*
	390	* Returns true if this is an open file of the render node, i.e.
	391	* &drm_file.minor of @file_priv is a render minor.
	392	*
	393	* See also the :ref:`section on render nodes <drm_render_node>`.
	394	*/
a8f8b1d9 DV	395	static inline bool drm_is_render_client(const struct drm_file *file_priv)
	396	{
	397	return file_priv->minor->type == DRM_MINOR_RENDER;
	398	}
	399
a8f8b1d9 DV	400	int drm_open(struct inode inode, struct file filp);
	401	ssize_t drm_read(struct file filp, char __user buffer,
	402	size_t count, loff_t *offset);
	403	int drm_release(struct inode inode, struct file filp);
7a2c65dd	404	int drm_release_noglobal(struct inode inode, struct file filp);
afc9a42b	405	__poll_t drm_poll(struct file filp, struct poll_table_struct wait);
a8f8b1d9 DV	406	int drm_event_reserve_init_locked(struct drm_device *dev,
	407	struct drm_file *file_priv,
	408	struct drm_pending_event *p,
	409	struct drm_event *e);
	410	int drm_event_reserve_init(struct drm_device *dev,
	411	struct drm_file *file_priv,
	412	struct drm_pending_event *p,
	413	struct drm_event *e);
	414	void drm_event_cancel_free(struct drm_device *dev,
	415	struct drm_pending_event *p);
	416	void drm_send_event_locked(struct drm_device dev, struct drm_pending_event e);
	417	void drm_send_event(struct drm_device dev, struct drm_pending_event e);
a78e7a51 VSS	418	void drm_send_event_timestamp_locked(struct drm_device *dev,
	419	struct drm_pending_event *e,
	420	ktime_t timestamp);
a8f8b1d9	421
4748aa16 CW	422	struct file mock_drm_getfile(struct drm_minor minor, unsigned int flags);
4748aa16 CW	423
b1823416 THV	424	#ifdef CONFIG_MMU
	425	struct drm_vma_offset_manager;
	426	unsigned long drm_get_unmapped_area(struct file *file,
	427	unsigned long uaddr, unsigned long len,
	428	unsigned long pgoff, unsigned long flags,
	429	struct drm_vma_offset_manager *mgr);
	430	#endif /* CONFIG_MMU */
	431
	432
a8f8b1d9	433	#endif /* _DRM_FILE_H_ */