[mirror_ubuntu-bionic-kernel.git] / include / drm / drmP.h

/*
 * Internal Header for the Direct Rendering Manager
 *
 * 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_P_H_
#define _DRM_P_H_

#include <linux/agp_backend.h>
#include <linux/cdev.h>
#include <linux/dma-mapping.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/highmem.h>
#include <linux/idr.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/jiffies.h>
#include <linux/kernel.h>
#include <linux/kref.h>
#include <linux/miscdevice.h>
#include <linux/mm.h>
#include <linux/mutex.h>
#include <linux/platform_device.h>
#include <linux/poll.h>
#include <linux/ratelimit.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/vmalloc.h>
#include <linux/workqueue.h>
#include <linux/dma-fence.h>
#include <linux/module.h>

#include <asm/mman.h>
#include <asm/pgalloc.h>
#include <linux/uaccess.h>

#include <uapi/drm/drm.h>
#include <uapi/drm/drm_mode.h>

#include <drm/drm_agpsupport.h>
#include <drm/drm_crtc.h>
#include <drm/drm_fourcc.h>
#include <drm/drm_global.h>
#include <drm/drm_hashtab.h>
#include <drm/drm_mm.h>
#include <drm/drm_os_linux.h>
#include <drm/drm_sarea.h>
#include <drm/drm_drv.h>
#include <drm/drm_prime.h>
#include <drm/drm_pci.h>
#include <drm/drm_file.h>
#include <drm/drm_debugfs.h>
#include <drm/drm_ioctl.h>
#include <drm/drm_sysfs.h>
#include <drm/drm_vblank.h>
#include <drm/drm_irq.h>
#include <drm/drm_device.h>

struct module;

struct device_node;
struct videomode;
struct reservation_object;
struct dma_buf_attachment;

struct pci_dev;
struct pci_controller;

/*
 * The following categories are defined:
 *
 * CORE: Used in the generic drm code: drm_ioctl.c, drm_mm.c, drm_memory.c, ...
 *	 This is the category used by the DRM_DEBUG() macro.
 *
 * DRIVER: Used in the vendor specific part of the driver: i915, radeon, ...
 *	   This is the category used by the DRM_DEBUG_DRIVER() macro.
 *
 * KMS: used in the modesetting code.
 *	This is the category used by the DRM_DEBUG_KMS() macro.
 *
 * PRIME: used in the prime code.
 *	  This is the category used by the DRM_DEBUG_PRIME() macro.
 *
 * ATOMIC: used in the atomic code.
 *	  This is the category used by the DRM_DEBUG_ATOMIC() macro.
 *
 * VBL: used for verbose debug message in the vblank code
 *	  This is the category used by the DRM_DEBUG_VBL() macro.
 *
 * Enabling verbose debug messages is done through the drm.debug parameter,
 * each category being enabled by a bit.
 *
 * drm.debug=0x1 will enable CORE messages
 * drm.debug=0x2 will enable DRIVER messages
 * drm.debug=0x3 will enable CORE and DRIVER messages
 * ...
 * drm.debug=0x3f will enable all messages
 *
 * An interesting feature is that it's possible to enable verbose logging at
 * run-time by echoing the debug value in its sysfs node:
 *   # echo 0xf > /sys/module/drm/parameters/debug
 */
#define DRM_UT_NONE		0x00
#define DRM_UT_CORE 		0x01
#define DRM_UT_DRIVER		0x02
#define DRM_UT_KMS		0x04
#define DRM_UT_PRIME		0x08
#define DRM_UT_ATOMIC		0x10
#define DRM_UT_VBL		0x20
#define DRM_UT_STATE		0x40

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

/***********************************************************************/
/** \name Macros to make printk easier */
/*@{*/

#define _DRM_PRINTK(once, level, fmt, ...)				\
	do {								\
		printk##once(KERN_##level "[" DRM_NAME "] " fmt,	\
			     ##__VA_ARGS__);				\
	} while (0)

#define DRM_INFO(fmt, ...)						\
	_DRM_PRINTK(, INFO, fmt, ##__VA_ARGS__)
#define DRM_NOTE(fmt, ...)						\
	_DRM_PRINTK(, NOTICE, fmt, ##__VA_ARGS__)
#define DRM_WARN(fmt, ...)						\
	_DRM_PRINTK(, WARNING, fmt, ##__VA_ARGS__)

#define DRM_INFO_ONCE(fmt, ...)						\
	_DRM_PRINTK(_once, INFO, fmt, ##__VA_ARGS__)
#define DRM_NOTE_ONCE(fmt, ...)						\
	_DRM_PRINTK(_once, NOTICE, fmt, ##__VA_ARGS__)
#define DRM_WARN_ONCE(fmt, ...)						\
	_DRM_PRINTK(_once, WARNING, fmt, ##__VA_ARGS__)

/**
 * Error output.
 *
 * \param fmt printf() like format string.
 * \param arg arguments
 */
#define DRM_DEV_ERROR(dev, fmt, ...)					\
	drm_dev_printk(dev, KERN_ERR, DRM_UT_NONE, __func__, " *ERROR*",\
		       fmt, ##__VA_ARGS__)
#define DRM_ERROR(fmt, ...)						\
	drm_printk(KERN_ERR, DRM_UT_NONE, fmt,	##__VA_ARGS__)

/**
 * Rate limited error output.  Like DRM_ERROR() but won't flood the log.
 *
 * \param fmt printf() like format string.
 * \param arg arguments
 */
#define DRM_DEV_ERROR_RATELIMITED(dev, fmt, ...)			\
({									\
	static DEFINE_RATELIMIT_STATE(_rs,				\
				      DEFAULT_RATELIMIT_INTERVAL,	\
				      DEFAULT_RATELIMIT_BURST);		\
									\
	if (__ratelimit(&_rs))						\
		DRM_DEV_ERROR(dev, fmt, ##__VA_ARGS__);			\
})
#define DRM_ERROR_RATELIMITED(fmt, ...)					\
	DRM_DEV_ERROR_RATELIMITED(NULL, fmt, ##__VA_ARGS__)

#define DRM_DEV_INFO(dev, fmt, ...)					\
	drm_dev_printk(dev, KERN_INFO, DRM_UT_NONE, __func__, "", fmt,	\
		       ##__VA_ARGS__)

#define DRM_DEV_INFO_ONCE(dev, fmt, ...)				\
({									\
	static bool __print_once __read_mostly;				\
	if (!__print_once) {						\
		__print_once = true;					\
		DRM_DEV_INFO(dev, fmt, ##__VA_ARGS__);			\
	}								\
})

/**
 * Debug output.
 *
 * \param fmt printf() like format string.
 * \param arg arguments
 */
#define DRM_DEV_DEBUG(dev, fmt, args...)				\
	drm_dev_printk(dev, KERN_DEBUG, DRM_UT_CORE, __func__, "", fmt,	\
		       ##args)
#define DRM_DEBUG(fmt, ...)						\
	drm_printk(KERN_DEBUG, DRM_UT_CORE, fmt, ##__VA_ARGS__)

#define DRM_DEV_DEBUG_DRIVER(dev, fmt, args...)				\
	drm_dev_printk(dev, KERN_DEBUG, DRM_UT_DRIVER, __func__, "",	\
		       fmt, ##args)
#define DRM_DEBUG_DRIVER(fmt, ...)					\
	drm_printk(KERN_DEBUG, DRM_UT_DRIVER, fmt, ##__VA_ARGS__)

#define DRM_DEV_DEBUG_KMS(dev, fmt, args...)				\
	drm_dev_printk(dev, KERN_DEBUG, DRM_UT_KMS, __func__, "", fmt,	\
		       ##args)
#define DRM_DEBUG_KMS(fmt, ...)					\
	drm_printk(KERN_DEBUG, DRM_UT_KMS, fmt, ##__VA_ARGS__)

#define DRM_DEV_DEBUG_PRIME(dev, fmt, args...)				\
	drm_dev_printk(dev, KERN_DEBUG, DRM_UT_PRIME, __func__, "",	\
		       fmt, ##args)
#define DRM_DEBUG_PRIME(fmt, ...)					\
	drm_printk(KERN_DEBUG, DRM_UT_PRIME, fmt, ##__VA_ARGS__)

#define DRM_DEV_DEBUG_ATOMIC(dev, fmt, args...)				\
	drm_dev_printk(dev, KERN_DEBUG, DRM_UT_ATOMIC, __func__, "",	\
		       fmt, ##args)
#define DRM_DEBUG_ATOMIC(fmt, ...)					\
	drm_printk(KERN_DEBUG, DRM_UT_ATOMIC, fmt, ##__VA_ARGS__)

#define DRM_DEV_DEBUG_VBL(dev, fmt, args...)				\
	drm_dev_printk(dev, KERN_DEBUG, DRM_UT_VBL, __func__, "", fmt,	\
		       ##args)
#define DRM_DEBUG_VBL(fmt, ...)					\
	drm_printk(KERN_DEBUG, DRM_UT_VBL, fmt, ##__VA_ARGS__)

#define _DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, level, fmt, args...)	\
({									\
	static DEFINE_RATELIMIT_STATE(_rs,				\
				      DEFAULT_RATELIMIT_INTERVAL,	\
				      DEFAULT_RATELIMIT_BURST);		\
	if (__ratelimit(&_rs))						\
		drm_dev_printk(dev, KERN_DEBUG, DRM_UT_ ## level,	\
			       __func__, "", fmt, ##args);		\
})

/**
 * Rate limited debug output. Like DRM_DEBUG() but won't flood the log.
 *
 * \param fmt printf() like format string.
 * \param arg arguments
 */
#define DRM_DEV_DEBUG_RATELIMITED(dev, fmt, args...)			\
	DEV__DRM_DEFINE_DEBUG_RATELIMITED(dev, CORE, fmt, ##args)
#define DRM_DEBUG_RATELIMITED(fmt, args...)				\
	DRM_DEV_DEBUG_RATELIMITED(NULL, fmt, ##args)
#define DRM_DEV_DEBUG_DRIVER_RATELIMITED(dev, fmt, args...)		\
	_DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, DRIVER, fmt, ##args)
#define DRM_DEBUG_DRIVER_RATELIMITED(fmt, args...)			\
	DRM_DEV_DEBUG_DRIVER_RATELIMITED(NULL, fmt, ##args)
#define DRM_DEV_DEBUG_KMS_RATELIMITED(dev, fmt, args...)		\
	_DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, KMS, fmt, ##args)
#define DRM_DEBUG_KMS_RATELIMITED(fmt, args...)				\
	DRM_DEV_DEBUG_KMS_RATELIMITED(NULL, fmt, ##args)
#define DRM_DEV_DEBUG_PRIME_RATELIMITED(dev, fmt, args...)		\
	_DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, PRIME, fmt, ##args)
#define DRM_DEBUG_PRIME_RATELIMITED(fmt, args...)			\
	DRM_DEV_DEBUG_PRIME_RATELIMITED(NULL, fmt, ##args)

/* Format strings and argument splitters to simplify printing
 * various "complex" objects
 */

/*@}*/

/***********************************************************************/
/** \name Internal types and structures */
/*@{*/

#define DRM_IF_VERSION(maj, min) (maj << 16 | min)


/**
 * drm_drv_uses_atomic_modeset - check if the driver implements
 * atomic_commit()
 * @dev: DRM device
 *
 * This check is useful if drivers do not have DRIVER_ATOMIC set but
 * have atomic modesetting internally implemented.
 */
static inline bool drm_drv_uses_atomic_modeset(struct drm_device *dev)
{
	return dev->mode_config.funcs->atomic_commit != NULL;
}

#define DRM_SWITCH_POWER_ON 0
#define DRM_SWITCH_POWER_OFF 1
#define DRM_SWITCH_POWER_CHANGING 2
#define DRM_SWITCH_POWER_DYNAMIC_OFF 3

static __inline__ int drm_core_check_feature(struct drm_device *dev,
					     int feature)
{
	return ((dev->driver->driver_features & feature) ? 1 : 0);
}

/******************************************************************/
/** \name Internal function definitions */
/*@{*/

				/* Driver support (drm_drv.h) */

/*
 * These are exported to drivers so that they can implement fencing using
 * DMA quiscent + idle. DMA quiescent usually requires the hardware lock.
 */

/*@}*/

/* returns true if currently okay to sleep */
static __inline__ bool drm_can_sleep(void)
{
	if (in_atomic() || in_dbg_master() || irqs_disabled())
		return false;
	return true;
}

/* helper for handling conditionals in various for_each macros */
#define for_each_if(condition) if (!(condition)) {} else

#endif
Commit	Line	Data
1da177e4	1	/*
d7d2c48e DH	2	* Internal Header for the Direct Rendering Manager
d7d2c48e DH	3	*
1da177e4 LT	4	* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
1da177e4 LT	5	* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
dcdb1674	6	* Copyright (c) 2009-2010, Code Aurora Forum.
1da177e4 LT	7	* All rights reserved.
1da177e4 LT	8	*
d7d2c48e DH	9	* Author: Rickard E. (Rik) Faith <faith@valinux.com>
	10	* Author: Gareth Hughes <gareth@valinux.com>
	11	*
1da177e4 LT	12	* Permission is hereby granted, free of charge, to any person obtaining a
	13	* copy of this software and associated documentation files (the "Software"),
	14	* to deal in the Software without restriction, including without limitation
	15	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	16	* and/or sell copies of the Software, and to permit persons to whom the
	17	* Software is furnished to do so, subject to the following conditions:
	18	*
	19	* The above copyright notice and this permission notice (including the next
	20	* paragraph) shall be included in all copies or substantial portions of the
	21	* Software.
	22	*
	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	24	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	25	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	26	* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
	27	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	28	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	29	* OTHER DEALINGS IN THE SOFTWARE.
	30	*/
	31
	32	#ifndef _DRM_P_H_
	33	#define _DRM_P_H_
	34
96993908 DH	35	#include <linux/agp_backend.h>
	36	#include <linux/cdev.h>
	37	#include <linux/dma-mapping.h>
	38	#include <linux/file.h>
1da177e4	39	#include <linux/fs.h>
96993908 DH	40	#include <linux/highmem.h>
96993908 DH	41	#include <linux/idr.h>
1da177e4	42	#include <linux/init.h>
96993908	43	#include <linux/io.h>
1da177e4	44	#include <linux/jiffies.h>
96993908 DH	45	#include <linux/kernel.h>
	46	#include <linux/kref.h>
	47	#include <linux/miscdevice.h>
1da177e4	48	#include <linux/mm.h>
30e2fb18	49	#include <linux/mutex.h>
96993908 DH	50	#include <linux/platform_device.h>
96993908 DH	51	#include <linux/poll.h>
5d13d425	52	#include <linux/ratelimit.h>
96993908 DH	53	#include <linux/sched.h>
96993908 DH	54	#include <linux/slab.h>
1da177e4	55	#include <linux/types.h>
d6db6564	56	#include <linux/vmalloc.h>
96993908	57	#include <linux/workqueue.h>
f54d1867	58	#include <linux/dma-fence.h>
c6bb9baa	59	#include <linux/module.h>
96993908 DH	60
96993908 DH	61	#include <asm/mman.h>
1da177e4	62	#include <asm/pgalloc.h>
7c0f6ba6	63	#include <linux/uaccess.h>
96993908	64
d7d2c48e DH	65	#include <uapi/drm/drm.h>
	66	#include <uapi/drm/drm_mode.h>
	67
	68	#include <drm/drm_agpsupport.h>
	69	#include <drm/drm_crtc.h>
ae4df11a	70	#include <drm/drm_fourcc.h>
d7d2c48e	71	#include <drm/drm_global.h>
96993908 DH	72	#include <drm/drm_hashtab.h>
	73	#include <drm/drm_mm.h>
	74	#include <drm/drm_os_linux.h>
19218e48	75	#include <drm/drm_sarea.h>
85e634bc	76	#include <drm/drm_drv.h>
c6bb9baa	77	#include <drm/drm_prime.h>
23ef59ef	78	#include <drm/drm_pci.h>
a8f8b1d9	79	#include <drm/drm_file.h>
4834442d	80	#include <drm/drm_debugfs.h>
7cfdf711	81	#include <drm/drm_ioctl.h>
e2271704	82	#include <drm/drm_sysfs.h>
3ed4351a DV	83	#include <drm/drm_vblank.h>
3ed4351a DV	84	#include <drm/drm_irq.h>
e4672e55	85	#include <drm/drm_device.h>
1da177e4	86
de477254 PG	87	struct module;
de477254 PG	88
edb37a95	89	struct device_node;
ebc64e45	90	struct videomode;
3aac4502	91	struct reservation_object;
b5e9c1a2	92	struct dma_buf_attachment;
ebc64e45	93
23ef59ef DV	94	struct pci_dev;
	95	struct pci_controller;
	96
87fdff81	97	/*
346fea63	98	* The following categories are defined:
1414b76c LD	99	*
	100	* CORE: Used in the generic drm code: drm_ioctl.c, drm_mm.c, drm_memory.c, ...
	101	* This is the category used by the DRM_DEBUG() macro.
	102	*
	103	* DRIVER: Used in the vendor specific part of the driver: i915, radeon, ...
	104	* This is the category used by the DRM_DEBUG_DRIVER() macro.
87fdff81	105	*
1414b76c LD	106	* KMS: used in the modesetting code.
1414b76c LD	107	* This is the category used by the DRM_DEBUG_KMS() macro.
87fdff81	108	*
1414b76c LD	109	* PRIME: used in the prime code.
1414b76c LD	110	* This is the category used by the DRM_DEBUG_PRIME() macro.
87fdff81	111	*
17a38d9c DV	112	* ATOMIC: used in the atomic code.
	113	* This is the category used by the DRM_DEBUG_ATOMIC() macro.
	114	*
235fabe0 VS	115	* VBL: used for verbose debug message in the vblank code
	116	* This is the category used by the DRM_DEBUG_VBL() macro.
	117	*
1414b76c LD	118	* Enabling verbose debug messages is done through the drm.debug parameter,
	119	* each category being enabled by a bit.
	120	*
	121	* drm.debug=0x1 will enable CORE messages
	122	* drm.debug=0x2 will enable DRIVER messages
	123	* drm.debug=0x3 will enable CORE and DRIVER messages
	124	* ...
235fabe0	125	* drm.debug=0x3f will enable all messages
1414b76c LD	126	*
	127	* An interesting feature is that it's possible to enable verbose logging at
	128	* run-time by echoing the debug value in its sysfs node:
	129	* # echo 0xf > /sys/module/drm/parameters/debug
87fdff81	130	*/
c4e68a58	131	#define DRM_UT_NONE 0x00
1414b76c LD	132	#define DRM_UT_CORE 0x01
	133	#define DRM_UT_DRIVER 0x02
	134	#define DRM_UT_KMS 0x04
	135	#define DRM_UT_PRIME 0x08
17a38d9c	136	#define DRM_UT_ATOMIC 0x10
235fabe0	137	#define DRM_UT_VBL 0x20
fceffb32	138	#define DRM_UT_STATE 0x40
4fefcb27	139
1da177e4 LT	140	/***********************************************************************/
	141	/** \name DRM template customization defaults */
	142	/@{/
	143
1da177e4	144	/***********************************************************************/
1da177e4 LT	145	/** \name Macros to make printk easier */
	146	/@{/
	147
30b0da8d DG	148	#define _DRM_PRINTK(once, level, fmt, ...) \
	149	do { \
	150	printk##once(KERN_##level "[" DRM_NAME "] " fmt, \
	151	##__VA_ARGS__); \
	152	} while (0)
	153
	154	#define DRM_INFO(fmt, ...) \
	155	_DRM_PRINTK(, INFO, fmt, ##__VA_ARGS__)
	156	#define DRM_NOTE(fmt, ...) \
	157	_DRM_PRINTK(, NOTICE, fmt, ##__VA_ARGS__)
	158	#define DRM_WARN(fmt, ...) \
	159	_DRM_PRINTK(, WARNING, fmt, ##__VA_ARGS__)
	160
	161	#define DRM_INFO_ONCE(fmt, ...) \
	162	_DRM_PRINTK(_once, INFO, fmt, ##__VA_ARGS__)
	163	#define DRM_NOTE_ONCE(fmt, ...) \
	164	_DRM_PRINTK(_once, NOTICE, fmt, ##__VA_ARGS__)
	165	#define DRM_WARN_ONCE(fmt, ...) \
	166	_DRM_PRINTK(_once, WARNING, fmt, ##__VA_ARGS__)
	167
1da177e4 LT	168	/**
	169	* Error output.
	170	*
	171	* \param fmt printf() like format string.
	172	* \param arg arguments
	173	*/
c4e68a58 SP	174	#define DRM_DEV_ERROR(dev, fmt, ...) \
	175	drm_dev_printk(dev, KERN_ERR, DRM_UT_NONE, __func__, " ERROR",\
	176	fmt, ##__VA_ARGS__)
	177	#define DRM_ERROR(fmt, ...) \
6bd488db	178	drm_printk(KERN_ERR, DRM_UT_NONE, fmt, ##__VA_ARGS__)
1da177e4	179
5d13d425 RC	180	/**
	181	* Rate limited error output. Like DRM_ERROR() but won't flood the log.
	182	*
	183	* \param fmt printf() like format string.
	184	* \param arg arguments
	185	*/
c4e68a58	186	#define DRM_DEV_ERROR_RATELIMITED(dev, fmt, ...) \
5d13d425 RC	187	({ \
	188	static DEFINE_RATELIMIT_STATE(_rs, \
	189	DEFAULT_RATELIMIT_INTERVAL, \
	190	DEFAULT_RATELIMIT_BURST); \
	191	\
	192	if (__ratelimit(&_rs)) \
c4e68a58	193	DRM_DEV_ERROR(dev, fmt, ##__VA_ARGS__); \
5d13d425	194	})
c4e68a58 SP	195	#define DRM_ERROR_RATELIMITED(fmt, ...) \
c4e68a58 SP	196	DRM_DEV_ERROR_RATELIMITED(NULL, fmt, ##__VA_ARGS__)
5d13d425	197
c4e68a58 SP	198	#define DRM_DEV_INFO(dev, fmt, ...) \
	199	drm_dev_printk(dev, KERN_INFO, DRM_UT_NONE, __func__, "", fmt, \
	200	##__VA_ARGS__)
1da177e4	201
c4e68a58 SP	202	#define DRM_DEV_INFO_ONCE(dev, fmt, ...) \
	203	({ \
	204	static bool __print_once __read_mostly; \
	205	if (!__print_once) { \
	206	__print_once = true; \
	207	DRM_DEV_INFO(dev, fmt, ##__VA_ARGS__); \
	208	} \
	209	})
48b8f631	210
1da177e4 LT	211	/**
1da177e4 LT	212	* Debug output.
b5e89ed5	213	*
1da177e4 LT	214	* \param fmt printf() like format string.
	215	* \param arg arguments
	216	*/
c4e68a58 SP	217	#define DRM_DEV_DEBUG(dev, fmt, args...) \
	218	drm_dev_printk(dev, KERN_DEBUG, DRM_UT_CORE, __func__, "", fmt, \
	219	##args)
6bd488db JP	220	#define DRM_DEBUG(fmt, ...) \
6bd488db JP	221	drm_printk(KERN_DEBUG, DRM_UT_CORE, fmt, ##__VA_ARGS__)
4fefcb27	222
c4e68a58 SP	223	#define DRM_DEV_DEBUG_DRIVER(dev, fmt, args...) \
	224	drm_dev_printk(dev, KERN_DEBUG, DRM_UT_DRIVER, __func__, "", \
	225	fmt, ##args)
6bd488db JP	226	#define DRM_DEBUG_DRIVER(fmt, ...) \
6bd488db JP	227	drm_printk(KERN_DEBUG, DRM_UT_DRIVER, fmt, ##__VA_ARGS__)
c4e68a58 SP	228
	229	#define DRM_DEV_DEBUG_KMS(dev, fmt, args...) \
	230	drm_dev_printk(dev, KERN_DEBUG, DRM_UT_KMS, __func__, "", fmt, \
	231	##args)
6bd488db JP	232	#define DRM_DEBUG_KMS(fmt, ...) \
6bd488db JP	233	drm_printk(KERN_DEBUG, DRM_UT_KMS, fmt, ##__VA_ARGS__)
c4e68a58 SP	234
	235	#define DRM_DEV_DEBUG_PRIME(dev, fmt, args...) \
	236	drm_dev_printk(dev, KERN_DEBUG, DRM_UT_PRIME, __func__, "", \
	237	fmt, ##args)
6bd488db JP	238	#define DRM_DEBUG_PRIME(fmt, ...) \
6bd488db JP	239	drm_printk(KERN_DEBUG, DRM_UT_PRIME, fmt, ##__VA_ARGS__)
c4e68a58 SP	240
	241	#define DRM_DEV_DEBUG_ATOMIC(dev, fmt, args...) \
	242	drm_dev_printk(dev, KERN_DEBUG, DRM_UT_ATOMIC, __func__, "", \
	243	fmt, ##args)
6bd488db JP	244	#define DRM_DEBUG_ATOMIC(fmt, ...) \
6bd488db JP	245	drm_printk(KERN_DEBUG, DRM_UT_ATOMIC, fmt, ##__VA_ARGS__)
c4e68a58 SP	246
	247	#define DRM_DEV_DEBUG_VBL(dev, fmt, args...) \
	248	drm_dev_printk(dev, KERN_DEBUG, DRM_UT_VBL, __func__, "", fmt, \
	249	##args)
6bd488db JP	250	#define DRM_DEBUG_VBL(fmt, ...) \
6bd488db JP	251	drm_printk(KERN_DEBUG, DRM_UT_VBL, fmt, ##__VA_ARGS__)
1da177e4	252
c4e68a58 SP	253	#define _DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, level, fmt, args...) \
	254	({ \
	255	static DEFINE_RATELIMIT_STATE(_rs, \
	256	DEFAULT_RATELIMIT_INTERVAL, \
	257	DEFAULT_RATELIMIT_BURST); \
	258	if (__ratelimit(&_rs)) \
	259	drm_dev_printk(dev, KERN_DEBUG, DRM_UT_ ## level, \
	260	__func__, "", fmt, ##args); \
	261	})
27528c66 L	262
	263	/**
	264	* Rate limited debug output. Like DRM_DEBUG() but won't flood the log.
	265	*
	266	* \param fmt printf() like format string.
	267	* \param arg arguments
	268	*/
c4e68a58 SP	269	#define DRM_DEV_DEBUG_RATELIMITED(dev, fmt, args...) \
c4e68a58 SP	270	DEV__DRM_DEFINE_DEBUG_RATELIMITED(dev, CORE, fmt, ##args)
27528c66	271	#define DRM_DEBUG_RATELIMITED(fmt, args...) \
c4e68a58 SP	272	DRM_DEV_DEBUG_RATELIMITED(NULL, fmt, ##args)
	273	#define DRM_DEV_DEBUG_DRIVER_RATELIMITED(dev, fmt, args...) \
	274	_DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, DRIVER, fmt, ##args)
27528c66	275	#define DRM_DEBUG_DRIVER_RATELIMITED(fmt, args...) \
c4e68a58 SP	276	DRM_DEV_DEBUG_DRIVER_RATELIMITED(NULL, fmt, ##args)
	277	#define DRM_DEV_DEBUG_KMS_RATELIMITED(dev, fmt, args...) \
	278	_DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, KMS, fmt, ##args)
27528c66	279	#define DRM_DEBUG_KMS_RATELIMITED(fmt, args...) \
c4e68a58 SP	280	DRM_DEV_DEBUG_KMS_RATELIMITED(NULL, fmt, ##args)
	281	#define DRM_DEV_DEBUG_PRIME_RATELIMITED(dev, fmt, args...) \
	282	_DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, PRIME, fmt, ##args)
27528c66	283	#define DRM_DEBUG_PRIME_RATELIMITED(fmt, args...) \
c4e68a58	284	DRM_DEV_DEBUG_PRIME_RATELIMITED(NULL, fmt, ##args)
27528c66	285
65c7dc18 RC	286	/* Format strings and argument splitters to simplify printing
	287	* various "complex" objects
	288	*/
65c7dc18	289
1da177e4 LT	290	/@}/
1da177e4 LT	291
1da177e4 LT	292	/***********************************************************************/
	293	/** \name Internal types and structures */
	294	/@{/
	295
1da177e4	296	#define DRM_IF_VERSION(maj, min) (maj << 16 \| min)
1da177e4	297
1da177e4	298
a743d758 DP	299	/**
	300	* drm_drv_uses_atomic_modeset - check if the driver implements
	301	* atomic_commit()
	302	* @dev: DRM device
	303	*
	304	* This check is useful if drivers do not have DRIVER_ATOMIC set but
	305	* have atomic modesetting internally implemented.
	306	*/
	307	static inline bool drm_drv_uses_atomic_modeset(struct drm_device *dev)
	308	{
	309	return dev->mode_config.funcs->atomic_commit != NULL;
	310	}
	311
5bcf719b DA	312	#define DRM_SWITCH_POWER_ON 0
	313	#define DRM_SWITCH_POWER_OFF 1
	314	#define DRM_SWITCH_POWER_CHANGING 2
13bb9cc8	315	#define DRM_SWITCH_POWER_DYNAMIC_OFF 3
5bcf719b	316
b5e89ed5 DA	317	static __inline__ int drm_core_check_feature(struct drm_device *dev,
b5e89ed5 DA	318	int feature)
1da177e4 LT	319	{
	320	return ((dev->driver->driver_features & feature) ? 1 : 0);
	321	}
	322
1da177e4 LT	323	/******************************************************************/
	324	/** \name Internal function definitions */
	325	/@{/
	326
1da177e4	327	/* Driver support (drm_drv.h) */
1da177e4	328
040ac320 TH	329	/*
	330	* These are exported to drivers so that they can implement fencing using
	331	* DMA quiscent + idle. DMA quiescent usually requires the hardware lock.
	332	*/
	333
8410ea3b DA	334	/@}/
8410ea3b DA	335
cc1f7194 DA	336	/* returns true if currently okay to sleep */
	337	static __inline__ bool drm_can_sleep(void)
	338	{
	339	if (in_atomic() \|\| in_dbg_master() \|\| irqs_disabled())
	340	return false;
	341	return true;
	342	}
	343
373701b1 JN	344	/* helper for handling conditionals in various for_each macros */
	345	#define for_each_if(condition) if (!(condition)) {} else
	346
1da177e4	347	#endif