drm: Extract drm_drv.h (85e634bc) · Commits · e / devices / android_kernel_oneplus_sm8150

drivers/gpu/drm/drm_drv.c

+4 −14

Original line number	Original line	Diff line number	Diff line
	@@ -32,7 +32,10 @@
	#include <linux/moduleparam.h>		#include <linux/moduleparam.h>
	#include <linux/mount.h>		#include <linux/mount.h>
	#include <linux/slab.h>		#include <linux/slab.h>

			#include <drm/drm_drv.h>
	#include <drm/drmP.h>		#include <drm/drmP.h>

	#include "drm_crtc_internal.h"		#include "drm_crtc_internal.h"
	#include "drm_legacy.h"		#include "drm_legacy.h"
	#include "drm_internal.h"		#include "drm_internal.h"
	@@ -257,10 +260,7 @@ static void drm_minor_unregister(struct drm_device *dev, unsigned int type)
	drm_debugfs_cleanup(minor);		drm_debugfs_cleanup(minor);
	}		}

	/**		/*
	* drm_minor_acquire - Acquire a DRM minor
	* @minor_id: Minor ID of the DRM-minor
	*
	* Looks up the given minor-ID and returns the respective DRM-minor object. The		* Looks up the given minor-ID and returns the respective DRM-minor object. The
	* refence-count of the underlying device is increased so you must release this		* refence-count of the underlying device is increased so you must release this
	* object with drm_minor_release().		* object with drm_minor_release().
	@@ -268,10 +268,6 @@ static void drm_minor_unregister(struct drm_device *dev, unsigned int type)
	* As long as you hold this minor, it is guaranteed that the object and the		* As long as you hold this minor, it is guaranteed that the object and the
	* minor->dev pointer will stay valid! However, the device may get unplugged and		* minor->dev pointer will stay valid! However, the device may get unplugged and
	* unregistered while you hold the minor.		* unregistered while you hold the minor.
	*
	* Returns:
	* Pointer to minor-object with increased device-refcount, or PTR_ERR on
	* failure.
	*/		*/
	struct drm_minor *drm_minor_acquire(unsigned int minor_id)		struct drm_minor *drm_minor_acquire(unsigned int minor_id)
	{		{
	@@ -294,12 +290,6 @@ struct drm_minor *drm_minor_acquire(unsigned int minor_id)
	return minor;		return minor;
	}		}

	/**
	* drm_minor_release - Release DRM minor
	* @minor: Pointer to DRM minor object
	*
	* Release a minor that was previously acquired via drm_minor_acquire().
	*/
	void drm_minor_release(struct drm_minor *minor)		void drm_minor_release(struct drm_minor *minor)
	{		{
	drm_dev_unref(minor->dev);		drm_dev_unref(minor->dev);

drivers/gpu/drm/drm_internal.h

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -46,6 +46,10 @@ void drm_prime_destroy_file_private(struct drm_prime_file_private *prime_fpriv);
	void drm_prime_remove_buf_handle_locked(struct drm_prime_file_private *prime_fpriv,		void drm_prime_remove_buf_handle_locked(struct drm_prime_file_private *prime_fpriv,
	struct dma_buf *dma_buf);		struct dma_buf *dma_buf);

			/* drm_drv.c */
			struct drm_minor *drm_minor_acquire(unsigned int minor_id);
			void drm_minor_release(struct drm_minor *minor);

	/* drm_info.c */		/* drm_info.c */
	int drm_name_info(struct seq_file m, void data);		int drm_name_info(struct seq_file m, void data);
	int drm_clients_info(struct seq_file m, void data);		int drm_clients_info(struct seq_file m, void data);

include/drm/drmP.h

+1 −298

Original line number	Original line	Diff line number	Diff line
	@@ -76,6 +76,7 @@
	#include <drm/drm_os_linux.h>		#include <drm/drm_os_linux.h>
	#include <drm/drm_sarea.h>		#include <drm/drm_sarea.h>
	#include <drm/drm_vma_manager.h>		#include <drm/drm_vma_manager.h>
			#include <drm/drm_drv.h>

	struct module;		struct module;

	@@ -137,34 +138,10 @@ struct dma_buf_attachment;
	#define DRM_UT_VBL 0x20		#define DRM_UT_VBL 0x20
	#define DRM_UT_STATE 0x40		#define DRM_UT_STATE 0x40

	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, ...);

	/***********************************************************************/		/***********************************************************************/
	/** \name DRM template customization defaults */		/** \name DRM template customization defaults */
	/@{/		/@{/

	/* 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

	/***********************************************************************/		/***********************************************************************/
	/** \name Macros to make printk easier */		/** \name Macros to make printk easier */
	/@{/		/@{/
	@@ -480,263 +457,6 @@ struct drm_lock_data {
	#define DRM_SCANOUTPOS_IN_VBLANK (1 << 1)		#define DRM_SCANOUTPOS_IN_VBLANK (1 << 1)
	#define DRM_SCANOUTPOS_ACCURATE (1 << 2)		#define DRM_SCANOUTPOS_ACCURATE (1 << 2)

	/**
	* 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
	*/
	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 - get raw hardware vblank counter
	* @dev: DRM device
	* @pipe: counter to fetch
	*
	* Driver callback for fetching a raw hardware vblank counter for @crtc.
	* 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.
	*
	* RETURNS
	* Raw vblank counter value.
	*/
	u32 (get_vblank_counter) (struct drm_device dev, unsigned int pipe);

	/**
	* enable_vblank - enable vblank interrupt events
	* @dev: DRM device
	* @pipe: which irq to enable
	*
	* Enable vblank interrupts for @crtc. If the device doesn't have
	* a hardware vblank counter, the driver should use the
	* drm_vblank_no_hw_counter() function that keeps a virtual counter.
	*
	* 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 interrupt events
	* @dev: DRM device
	* @pipe: which irq to enable
	*
	* Disable vblank interrupts for @crtc. If the device doesn't have
	* a hardware vblank counter, the driver should use the
	* drm_vblank_no_hw_counter() function that keeps a virtual counter.
	*/
	void (disable_vblank) (struct drm_device dev, unsigned int pipe);

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

	/**
	* Called by vblank timestamping code.
	*
	* Return the current display scanout position from a crtc, and an
	* optional accurate ktime_get timestamp of when position was measured.
	*
	* \param dev DRM device.
	* \param pipe Id of the crtc to query.
	* \param flags Flags from the caller (DRM_CALLED_FROM_VBLIRQ or 0).
	* \param *vpos Target location for current vertical scanout position.
	* \param *hpos Target location for current horizontal scanout position.
	* \param *stime Target location for timestamp taken immediately before
	* scanout position query. Can be NULL to skip timestamp.
	* \param *etime Target location for timestamp taken immediately after
	* scanout position query. Can be NULL to skip timestamp.
	* \param 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."
	*
	* \return 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);

	/**
	* Called by \c 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.
	*
	* \param dev dev DRM device handle.
	* \param pipe crtc for which timestamp should be returned.
	* \param *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.
	* \param *vblank_time Target location for returned vblank timestamp.
	* \param flags 0 = Defaults, no special treatment needed.
	* \param 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 routines */
	int (master_create)(struct drm_device dev, struct drm_master *master);
	void (master_destroy)(struct drm_device dev, struct drm_master *master);
	/**
	* master_set is called whenever the minor master is set.
	* master_drop is called whenever the minor master is dropped.
	*/

	int (master_set)(struct drm_device dev, struct drm_file *file_priv,
	bool from_open);
	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 alloc support */
	int (dumb_create)(struct drm_file file_priv,
	struct drm_device *dev,
	struct drm_mode_create_dumb *args);
	int (dumb_map_offset)(struct drm_file file_priv,
	struct drm_device *dev, uint32_t handle,
	uint64_t *offset);
	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;
	};

	enum drm_minor_type {		enum drm_minor_type {
	DRM_MINOR_PRIMARY,		DRM_MINOR_PRIMARY,
	DRM_MINOR_CONTROL,		DRM_MINOR_CONTROL,
	@@ -1011,11 +731,6 @@ void drm_clflush_virt_range(void *addr, unsigned long length);
	extern void drm_vblank_pre_modeset(struct drm_device *dev, unsigned int pipe);		extern void drm_vblank_pre_modeset(struct drm_device *dev, unsigned int pipe);
	extern void drm_vblank_post_modeset(struct drm_device *dev, unsigned int pipe);		extern void drm_vblank_post_modeset(struct drm_device *dev, unsigned int pipe);

	/* drm_drv.c */
	void drm_put_dev(struct drm_device *dev);
	void drm_unplug_dev(struct drm_device *dev);
	extern unsigned int drm_debug;

	/* Debugfs support */		/* Debugfs support */
	#if defined(CONFIG_DEBUG_FS)		#if defined(CONFIG_DEBUG_FS)
	extern int drm_debugfs_create_files(const struct drm_info_list *files,		extern int drm_debugfs_create_files(const struct drm_info_list *files,
	@@ -1068,18 +783,6 @@ extern void drm_pci_free(struct drm_device dev, struct drm_dma_handle dmah);
	extern void drm_sysfs_hotplug_event(struct drm_device *dev);		extern void drm_sysfs_hotplug_event(struct drm_device *dev);


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

	struct drm_minor *drm_minor_acquire(unsigned int minor_id);
	void drm_minor_release(struct drm_minor *minor);

	/@}/		/@}/

include/drm/drm_drv.h

0 → 100644

+340 −0

File added.

Preview size limit exceeded, changes collapsed.