1 /*
2  * Copyright (C) 2016 Red Hat
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20  * OTHER DEALINGS IN THE SOFTWARE.
21  *
22  * Authors:
23  * Rob Clark <robdclark@gmail.com>
24  */
25 
26 #ifndef DRM_PRINT_H_
27 #define DRM_PRINT_H_
28 
29 #include <linux/compiler.h>
30 #include <linux/printk.h>
31 #include <linux/seq_file.h>
32 #include <linux/device.h>
33 #include <linux/debugfs.h>
34 #include <linux/dynamic_debug.h>
35 
36 #include <drm/drm.h>
37 
38 /* Do *not* use outside of drm_print.[ch]! */
39 extern unsigned long __drm_debug;
40 
41 /**
42  * DOC: print
43  *
44  * A simple wrapper for dev_printk(), seq_printf(), etc.  Allows same
45  * debug code to be used for both debugfs and printk logging.
46  *
47  * For example::
48  *
49  *     void log_some_info(struct drm_printer *p)
50  *     {
51  *             drm_printf(p, "foo=%d\n", foo);
52  *             drm_printf(p, "bar=%d\n", bar);
53  *     }
54  *
55  *     #ifdef CONFIG_DEBUG_FS
56  *     void debugfs_show(struct seq_file *f)
57  *     {
58  *             struct drm_printer p = drm_seq_file_printer(f);
59  *             log_some_info(&p);
60  *     }
61  *     #endif
62  *
63  *     void some_other_function(...)
64  *     {
65  *             struct drm_printer p = drm_info_printer(drm->dev);
66  *             log_some_info(&p);
67  *     }
68  */
69 
70 /**
71  * struct drm_printer - drm output "stream"
72  *
73  * Do not use struct members directly.  Use drm_printer_seq_file(),
74  * drm_printer_info(), etc to initialize.  And drm_printf() for output.
75  */
76 struct drm_printer {
77 	/* private: */
78 	void (*printfn)(struct drm_printer *p, struct va_format *vaf);
79 	void (*puts)(struct drm_printer *p, const char *str);
80 	void *arg;
81 	const char *prefix;
82 };
83 
84 void __drm_printfn_coredump(struct drm_printer *p, struct va_format *vaf);
85 void __drm_puts_coredump(struct drm_printer *p, const char *str);
86 void __drm_printfn_seq_file(struct drm_printer *p, struct va_format *vaf);
87 void __drm_puts_seq_file(struct drm_printer *p, const char *str);
88 void __drm_printfn_info(struct drm_printer *p, struct va_format *vaf);
89 void __drm_printfn_debug(struct drm_printer *p, struct va_format *vaf);
90 void __drm_printfn_err(struct drm_printer *p, struct va_format *vaf);
91 
92 __printf(2, 3)
93 void drm_printf(struct drm_printer *p, const char *f, ...);
94 void drm_puts(struct drm_printer *p, const char *str);
95 void drm_print_regset32(struct drm_printer *p, struct debugfs_regset32 *regset);
96 void drm_print_bits(struct drm_printer *p, unsigned long value,
97 		    const char * const bits[], unsigned int nbits);
98 
99 __printf(2, 0)
100 /**
101  * drm_vprintf - print to a &drm_printer stream
102  * @p: the &drm_printer
103  * @fmt: format string
104  * @va: the va_list
105  */
106 static inline void
drm_vprintf(struct drm_printer * p,const char * fmt,va_list * va)107 drm_vprintf(struct drm_printer *p, const char *fmt, va_list *va)
108 {
109 	struct va_format vaf = { .fmt = fmt, .va = va };
110 
111 	p->printfn(p, &vaf);
112 }
113 
114 /**
115  * drm_printf_indent - Print to a &drm_printer stream with indentation
116  * @printer: DRM printer
117  * @indent: Tab indentation level (max 5)
118  * @fmt: Format string
119  */
120 #define drm_printf_indent(printer, indent, fmt, ...) \
121 	drm_printf((printer), "%.*s" fmt, (indent), "\t\t\t\t\tX", ##__VA_ARGS__)
122 
123 /**
124  * struct drm_print_iterator - local struct used with drm_printer_coredump
125  * @data: Pointer to the devcoredump output buffer
126  * @start: The offset within the buffer to start writing
127  * @remain: The number of bytes to write for this iteration
128  */
129 struct drm_print_iterator {
130 	void *data;
131 	ssize_t start;
132 	ssize_t remain;
133 	/* private: */
134 	ssize_t offset;
135 };
136 
137 /**
138  * drm_coredump_printer - construct a &drm_printer that can output to a buffer
139  * from the read function for devcoredump
140  * @iter: A pointer to a struct drm_print_iterator for the read instance
141  *
142  * This wrapper extends drm_printf() to work with a dev_coredumpm() callback
143  * function. The passed in drm_print_iterator struct contains the buffer
144  * pointer, size and offset as passed in from devcoredump.
145  *
146  * For example::
147  *
148  *	void coredump_read(char *buffer, loff_t offset, size_t count,
149  *		void *data, size_t datalen)
150  *	{
151  *		struct drm_print_iterator iter;
152  *		struct drm_printer p;
153  *
154  *		iter.data = buffer;
155  *		iter.start = offset;
156  *		iter.remain = count;
157  *
158  *		p = drm_coredump_printer(&iter);
159  *
160  *		drm_printf(p, "foo=%d\n", foo);
161  *	}
162  *
163  *	void makecoredump(...)
164  *	{
165  *		...
166  *		dev_coredumpm(dev, THIS_MODULE, data, 0, GFP_KERNEL,
167  *			coredump_read, ...)
168  *	}
169  *
170  * RETURNS:
171  * The &drm_printer object
172  */
173 static inline struct drm_printer
drm_coredump_printer(struct drm_print_iterator * iter)174 drm_coredump_printer(struct drm_print_iterator *iter)
175 {
176 	struct drm_printer p = {
177 		.printfn = __drm_printfn_coredump,
178 		.puts = __drm_puts_coredump,
179 		.arg = iter,
180 	};
181 
182 	/* Set the internal offset of the iterator to zero */
183 	iter->offset = 0;
184 
185 	return p;
186 }
187 
188 /**
189  * drm_seq_file_printer - construct a &drm_printer that outputs to &seq_file
190  * @f:  the &struct seq_file to output to
191  *
192  * RETURNS:
193  * The &drm_printer object
194  */
drm_seq_file_printer(struct seq_file * f)195 static inline struct drm_printer drm_seq_file_printer(struct seq_file *f)
196 {
197 	struct drm_printer p = {
198 		.printfn = __drm_printfn_seq_file,
199 		.puts = __drm_puts_seq_file,
200 		.arg = f,
201 	};
202 	return p;
203 }
204 
205 /**
206  * drm_info_printer - construct a &drm_printer that outputs to dev_printk()
207  * @dev: the &struct device pointer
208  *
209  * RETURNS:
210  * The &drm_printer object
211  */
drm_info_printer(struct device * dev)212 static inline struct drm_printer drm_info_printer(struct device *dev)
213 {
214 	struct drm_printer p = {
215 		.printfn = __drm_printfn_info,
216 		.arg = dev,
217 	};
218 	return p;
219 }
220 
221 /**
222  * drm_debug_printer - construct a &drm_printer that outputs to pr_debug()
223  * @prefix: debug output prefix
224  *
225  * RETURNS:
226  * The &drm_printer object
227  */
drm_debug_printer(const char * prefix)228 static inline struct drm_printer drm_debug_printer(const char *prefix)
229 {
230 	struct drm_printer p = {
231 		.printfn = __drm_printfn_debug,
232 		.prefix = prefix
233 	};
234 	return p;
235 }
236 
237 /**
238  * drm_err_printer - construct a &drm_printer that outputs to pr_err()
239  * @prefix: debug output prefix
240  *
241  * RETURNS:
242  * The &drm_printer object
243  */
drm_err_printer(const char * prefix)244 static inline struct drm_printer drm_err_printer(const char *prefix)
245 {
246 	struct drm_printer p = {
247 		.printfn = __drm_printfn_err,
248 		.prefix = prefix
249 	};
250 	return p;
251 }
252 
253 /**
254  * enum drm_debug_category - The DRM debug categories
255  *
256  * Each of the DRM debug logging macros use a specific category, and the logging
257  * is filtered by the drm.debug module parameter. This enum specifies the values
258  * for the interface.
259  *
260  * Each DRM_DEBUG_<CATEGORY> macro logs to DRM_UT_<CATEGORY> category, except
261  * DRM_DEBUG() logs to DRM_UT_CORE.
262  *
263  * Enabling verbose debug messages is done through the drm.debug parameter, each
264  * category being enabled by a bit:
265  *
266  *  - drm.debug=0x1 will enable CORE messages
267  *  - drm.debug=0x2 will enable DRIVER messages
268  *  - drm.debug=0x3 will enable CORE and DRIVER messages
269  *  - ...
270  *  - drm.debug=0x1ff will enable all messages
271  *
272  * An interesting feature is that it's possible to enable verbose logging at
273  * run-time by echoing the debug value in its sysfs node::
274  *
275  *   # echo 0xf > /sys/module/drm/parameters/debug
276  *
277  */
278 enum drm_debug_category {
279 	/* These names must match those in DYNAMIC_DEBUG_CLASSBITS */
280 	/**
281 	 * @DRM_UT_CORE: Used in the generic drm code: drm_ioctl.c, drm_mm.c,
282 	 * drm_memory.c, ...
283 	 */
284 	DRM_UT_CORE,
285 	/**
286 	 * @DRM_UT_DRIVER: Used in the vendor specific part of the driver: i915,
287 	 * radeon, ... macro.
288 	 */
289 	DRM_UT_DRIVER,
290 	/**
291 	 * @DRM_UT_KMS: Used in the modesetting code.
292 	 */
293 	DRM_UT_KMS,
294 	/**
295 	 * @DRM_UT_PRIME: Used in the prime code.
296 	 */
297 	DRM_UT_PRIME,
298 	/**
299 	 * @DRM_UT_ATOMIC: Used in the atomic code.
300 	 */
301 	DRM_UT_ATOMIC,
302 	/**
303 	 * @DRM_UT_VBL: Used for verbose debug message in the vblank code.
304 	 */
305 	DRM_UT_VBL,
306 	/**
307 	 * @DRM_UT_STATE: Used for verbose atomic state debugging.
308 	 */
309 	DRM_UT_STATE,
310 	/**
311 	 * @DRM_UT_LEASE: Used in the lease code.
312 	 */
313 	DRM_UT_LEASE,
314 	/**
315 	 * @DRM_UT_DP: Used in the DP code.
316 	 */
317 	DRM_UT_DP,
318 	/**
319 	 * @DRM_UT_DRMRES: Used in the drm managed resources code.
320 	 */
321 	DRM_UT_DRMRES
322 };
323 
drm_debug_enabled_raw(enum drm_debug_category category)324 static inline bool drm_debug_enabled_raw(enum drm_debug_category category)
325 {
326 	return unlikely(__drm_debug & BIT(category));
327 }
328 
329 #define drm_debug_enabled_instrumented(category)			\
330 	({								\
331 		pr_debug("todo: is this frequent enough to optimize ?\n"); \
332 		drm_debug_enabled_raw(category);			\
333 	})
334 
335 #if defined(CONFIG_DRM_USE_DYNAMIC_DEBUG)
336 /*
337  * the drm.debug API uses dyndbg, so each drm_*dbg macro/callsite gets
338  * a descriptor, and only enabled callsites are reachable.  They use
339  * the private macro to avoid re-testing the enable-bit.
340  */
341 #define __drm_debug_enabled(category)	true
342 #define drm_debug_enabled(category)	drm_debug_enabled_instrumented(category)
343 #else
344 #define __drm_debug_enabled(category)	drm_debug_enabled_raw(category)
345 #define drm_debug_enabled(category)	drm_debug_enabled_raw(category)
346 #endif
347 
348 /*
349  * struct device based logging
350  *
351  * Prefer drm_device based logging over device or printk based logging.
352  */
353 
354 __printf(3, 4)
355 void drm_dev_printk(const struct device *dev, const char *level,
356 		    const char *format, ...);
357 struct _ddebug;
358 __printf(4, 5)
359 void __drm_dev_dbg(struct _ddebug *desc, const struct device *dev,
360 		   enum drm_debug_category category, const char *format, ...);
361 
362 /**
363  * DRM_DEV_ERROR() - Error output.
364  *
365  * NOTE: this is deprecated in favor of drm_err() or dev_err().
366  *
367  * @dev: device pointer
368  * @fmt: printf() like format string.
369  */
370 #define DRM_DEV_ERROR(dev, fmt, ...)					\
371 	drm_dev_printk(dev, KERN_ERR, "*ERROR* " fmt, ##__VA_ARGS__)
372 
373 /**
374  * DRM_DEV_ERROR_RATELIMITED() - Rate limited error output.
375  *
376  * NOTE: this is deprecated in favor of drm_err_ratelimited() or
377  * dev_err_ratelimited().
378  *
379  * @dev: device pointer
380  * @fmt: printf() like format string.
381  *
382  * Like DRM_ERROR() but won't flood the log.
383  */
384 #define DRM_DEV_ERROR_RATELIMITED(dev, fmt, ...)			\
385 ({									\
386 	static DEFINE_RATELIMIT_STATE(_rs,				\
387 				      DEFAULT_RATELIMIT_INTERVAL,	\
388 				      DEFAULT_RATELIMIT_BURST);		\
389 									\
390 	if (__ratelimit(&_rs))						\
391 		DRM_DEV_ERROR(dev, fmt, ##__VA_ARGS__);			\
392 })
393 
394 /* NOTE: this is deprecated in favor of drm_info() or dev_info(). */
395 #define DRM_DEV_INFO(dev, fmt, ...)				\
396 	drm_dev_printk(dev, KERN_INFO, fmt, ##__VA_ARGS__)
397 
398 /* NOTE: this is deprecated in favor of drm_info_once() or dev_info_once(). */
399 #define DRM_DEV_INFO_ONCE(dev, fmt, ...)				\
400 ({									\
401 	static bool __print_once __read_mostly;				\
402 	if (!__print_once) {						\
403 		__print_once = true;					\
404 		DRM_DEV_INFO(dev, fmt, ##__VA_ARGS__);			\
405 	}								\
406 })
407 
408 #if !defined(CONFIG_DRM_USE_DYNAMIC_DEBUG)
409 #define drm_dev_dbg(dev, cat, fmt, ...)				\
410 	__drm_dev_dbg(NULL, dev, cat, fmt, ##__VA_ARGS__)
411 #else
412 #define drm_dev_dbg(dev, cat, fmt, ...)				\
413 	_dynamic_func_call_cls(cat, fmt, __drm_dev_dbg,		\
414 			       dev, cat, fmt, ##__VA_ARGS__)
415 #endif
416 
417 /**
418  * DRM_DEV_DEBUG() - Debug output for generic drm code
419  *
420  * NOTE: this is deprecated in favor of drm_dbg_core().
421  *
422  * @dev: device pointer
423  * @fmt: printf() like format string.
424  */
425 #define DRM_DEV_DEBUG(dev, fmt, ...)					\
426 	drm_dev_dbg(dev, DRM_UT_CORE, fmt, ##__VA_ARGS__)
427 /**
428  * DRM_DEV_DEBUG_DRIVER() - Debug output for vendor specific part of the driver
429  *
430  * NOTE: this is deprecated in favor of drm_dbg() or dev_dbg().
431  *
432  * @dev: device pointer
433  * @fmt: printf() like format string.
434  */
435 #define DRM_DEV_DEBUG_DRIVER(dev, fmt, ...)				\
436 	drm_dev_dbg(dev, DRM_UT_DRIVER,	fmt, ##__VA_ARGS__)
437 /**
438  * DRM_DEV_DEBUG_KMS() - Debug output for modesetting code
439  *
440  * NOTE: this is deprecated in favor of drm_dbg_kms().
441  *
442  * @dev: device pointer
443  * @fmt: printf() like format string.
444  */
445 #define DRM_DEV_DEBUG_KMS(dev, fmt, ...)				\
446 	drm_dev_dbg(dev, DRM_UT_KMS, fmt, ##__VA_ARGS__)
447 
448 /*
449  * struct drm_device based logging
450  *
451  * Prefer drm_device based logging over device or prink based logging.
452  */
453 
454 /* Helper for struct drm_device based logging. */
455 #define __drm_printk(drm, level, type, fmt, ...)			\
456 	dev_##level##type((drm)->dev, "[drm] " fmt, ##__VA_ARGS__)
457 
458 
459 #define drm_info(drm, fmt, ...)					\
460 	__drm_printk((drm), info,, fmt, ##__VA_ARGS__)
461 
462 #define drm_notice(drm, fmt, ...)				\
463 	__drm_printk((drm), notice,, fmt, ##__VA_ARGS__)
464 
465 #define drm_warn(drm, fmt, ...)					\
466 	__drm_printk((drm), warn,, fmt, ##__VA_ARGS__)
467 
468 #define drm_err(drm, fmt, ...)					\
469 	__drm_printk((drm), err,, "*ERROR* " fmt, ##__VA_ARGS__)
470 
471 
472 #define drm_info_once(drm, fmt, ...)				\
473 	__drm_printk((drm), info, _once, fmt, ##__VA_ARGS__)
474 
475 #define drm_notice_once(drm, fmt, ...)				\
476 	__drm_printk((drm), notice, _once, fmt, ##__VA_ARGS__)
477 
478 #define drm_warn_once(drm, fmt, ...)				\
479 	__drm_printk((drm), warn, _once, fmt, ##__VA_ARGS__)
480 
481 #define drm_err_once(drm, fmt, ...)				\
482 	__drm_printk((drm), err, _once, "*ERROR* " fmt, ##__VA_ARGS__)
483 
484 
485 #define drm_err_ratelimited(drm, fmt, ...)				\
486 	__drm_printk((drm), err, _ratelimited, "*ERROR* " fmt, ##__VA_ARGS__)
487 
488 
489 #define drm_dbg_core(drm, fmt, ...)					\
490 	drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_CORE, fmt, ##__VA_ARGS__)
491 #define drm_dbg_driver(drm, fmt, ...)						\
492 	drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_DRIVER, fmt, ##__VA_ARGS__)
493 #define drm_dbg_kms(drm, fmt, ...)					\
494 	drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_KMS, fmt, ##__VA_ARGS__)
495 #define drm_dbg_prime(drm, fmt, ...)					\
496 	drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_PRIME, fmt, ##__VA_ARGS__)
497 #define drm_dbg_atomic(drm, fmt, ...)					\
498 	drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_ATOMIC, fmt, ##__VA_ARGS__)
499 #define drm_dbg_vbl(drm, fmt, ...)					\
500 	drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_VBL, fmt, ##__VA_ARGS__)
501 #define drm_dbg_state(drm, fmt, ...)					\
502 	drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_STATE, fmt, ##__VA_ARGS__)
503 #define drm_dbg_lease(drm, fmt, ...)					\
504 	drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_LEASE, fmt, ##__VA_ARGS__)
505 #define drm_dbg_dp(drm, fmt, ...)					\
506 	drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_DP, fmt, ##__VA_ARGS__)
507 #define drm_dbg_drmres(drm, fmt, ...)					\
508 	drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_DRMRES, fmt, ##__VA_ARGS__)
509 
510 #define drm_dbg(drm, fmt, ...)	drm_dbg_driver(drm, fmt, ##__VA_ARGS__)
511 
512 /*
513  * printk based logging
514  *
515  * Prefer drm_device based logging over device or prink based logging.
516  */
517 
518 __printf(3, 4)
519 void ___drm_dbg(struct _ddebug *desc, enum drm_debug_category category, const char *format, ...);
520 __printf(1, 2)
521 void __drm_err(const char *format, ...);
522 
523 #if !defined(CONFIG_DRM_USE_DYNAMIC_DEBUG)
524 #define __drm_dbg(cat, fmt, ...)		___drm_dbg(NULL, cat, fmt, ##__VA_ARGS__)
525 #else
526 #define __drm_dbg(cat, fmt, ...)					\
527 	_dynamic_func_call_cls(cat, fmt, ___drm_dbg,			\
528 			       cat, fmt, ##__VA_ARGS__)
529 #endif
530 
531 /* Macros to make printk easier */
532 
533 #define _DRM_PRINTK(once, level, fmt, ...)				\
534 	printk##once(KERN_##level "[" DRM_NAME "] " fmt, ##__VA_ARGS__)
535 
536 /* NOTE: this is deprecated in favor of pr_info(). */
537 #define DRM_INFO(fmt, ...)						\
538 	_DRM_PRINTK(, INFO, fmt, ##__VA_ARGS__)
539 /* NOTE: this is deprecated in favor of pr_notice(). */
540 #define DRM_NOTE(fmt, ...)						\
541 	_DRM_PRINTK(, NOTICE, fmt, ##__VA_ARGS__)
542 /* NOTE: this is deprecated in favor of pr_warn(). */
543 #define DRM_WARN(fmt, ...)						\
544 	_DRM_PRINTK(, WARNING, fmt, ##__VA_ARGS__)
545 
546 /* NOTE: this is deprecated in favor of pr_info_once(). */
547 #define DRM_INFO_ONCE(fmt, ...)						\
548 	_DRM_PRINTK(_once, INFO, fmt, ##__VA_ARGS__)
549 /* NOTE: this is deprecated in favor of pr_notice_once(). */
550 #define DRM_NOTE_ONCE(fmt, ...)						\
551 	_DRM_PRINTK(_once, NOTICE, fmt, ##__VA_ARGS__)
552 /* NOTE: this is deprecated in favor of pr_warn_once(). */
553 #define DRM_WARN_ONCE(fmt, ...)						\
554 	_DRM_PRINTK(_once, WARNING, fmt, ##__VA_ARGS__)
555 
556 /* NOTE: this is deprecated in favor of pr_err(). */
557 #define DRM_ERROR(fmt, ...)						\
558 	__drm_err(fmt, ##__VA_ARGS__)
559 
560 /* NOTE: this is deprecated in favor of pr_err_ratelimited(). */
561 #define DRM_ERROR_RATELIMITED(fmt, ...)					\
562 	DRM_DEV_ERROR_RATELIMITED(NULL, fmt, ##__VA_ARGS__)
563 
564 /* NOTE: this is deprecated in favor of drm_dbg_core(NULL, ...). */
565 #define DRM_DEBUG(fmt, ...)						\
566 	__drm_dbg(DRM_UT_CORE, fmt, ##__VA_ARGS__)
567 
568 /* NOTE: this is deprecated in favor of drm_dbg(NULL, ...). */
569 #define DRM_DEBUG_DRIVER(fmt, ...)					\
570 	__drm_dbg(DRM_UT_DRIVER, fmt, ##__VA_ARGS__)
571 
572 /* NOTE: this is deprecated in favor of drm_dbg_kms(NULL, ...). */
573 #define DRM_DEBUG_KMS(fmt, ...)						\
574 	__drm_dbg(DRM_UT_KMS, fmt, ##__VA_ARGS__)
575 
576 /* NOTE: this is deprecated in favor of drm_dbg_prime(NULL, ...). */
577 #define DRM_DEBUG_PRIME(fmt, ...)					\
578 	__drm_dbg(DRM_UT_PRIME, fmt, ##__VA_ARGS__)
579 
580 /* NOTE: this is deprecated in favor of drm_dbg_atomic(NULL, ...). */
581 #define DRM_DEBUG_ATOMIC(fmt, ...)					\
582 	__drm_dbg(DRM_UT_ATOMIC, fmt, ##__VA_ARGS__)
583 
584 /* NOTE: this is deprecated in favor of drm_dbg_vbl(NULL, ...). */
585 #define DRM_DEBUG_VBL(fmt, ...)						\
586 	__drm_dbg(DRM_UT_VBL, fmt, ##__VA_ARGS__)
587 
588 /* NOTE: this is deprecated in favor of drm_dbg_lease(NULL, ...). */
589 #define DRM_DEBUG_LEASE(fmt, ...)					\
590 	__drm_dbg(DRM_UT_LEASE, fmt, ##__VA_ARGS__)
591 
592 /* NOTE: this is deprecated in favor of drm_dbg_dp(NULL, ...). */
593 #define DRM_DEBUG_DP(fmt, ...)						\
594 	__drm_dbg(DRM_UT_DP, fmt, ## __VA_ARGS__)
595 
596 #define __DRM_DEFINE_DBG_RATELIMITED(category, drm, fmt, ...)					\
597 ({												\
598 	static DEFINE_RATELIMIT_STATE(rs_, DEFAULT_RATELIMIT_INTERVAL, DEFAULT_RATELIMIT_BURST);\
599 	const struct drm_device *drm_ = (drm);							\
600 												\
601 	if (drm_debug_enabled(DRM_UT_ ## category) && __ratelimit(&rs_))			\
602 		drm_dev_printk(drm_ ? drm_->dev : NULL, KERN_DEBUG, fmt, ## __VA_ARGS__);	\
603 })
604 
605 #define drm_dbg_kms_ratelimited(drm, fmt, ...) \
606 	__DRM_DEFINE_DBG_RATELIMITED(KMS, drm, fmt, ## __VA_ARGS__)
607 
608 /*
609  * struct drm_device based WARNs
610  *
611  * drm_WARN*() acts like WARN*(), but with the key difference of
612  * using device specific information so that we know from which device
613  * warning is originating from.
614  *
615  * Prefer drm_device based drm_WARN* over regular WARN*
616  */
617 
618 /* Helper for struct drm_device based WARNs */
619 #define drm_WARN(drm, condition, format, arg...)			\
620 	WARN(condition, "%s %s: " format,				\
621 			dev_driver_string((drm)->dev),			\
622 			dev_name((drm)->dev), ## arg)
623 
624 #define drm_WARN_ONCE(drm, condition, format, arg...)			\
625 	WARN_ONCE(condition, "%s %s: " format,				\
626 			dev_driver_string((drm)->dev),			\
627 			dev_name((drm)->dev), ## arg)
628 
629 #define drm_WARN_ON(drm, x)						\
630 	drm_WARN((drm), (x), "%s",					\
631 		 "drm_WARN_ON(" __stringify(x) ")")
632 
633 #define drm_WARN_ON_ONCE(drm, x)					\
634 	drm_WARN_ONCE((drm), (x), "%s",					\
635 		      "drm_WARN_ON_ONCE(" __stringify(x) ")")
636 
637 #endif /* DRM_PRINT_H_ */
638