Branch data Line data Source code
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 : :
35 : : #include <drm/drm.h>
36 : :
37 : : /* Do *not* use outside of drm_print.[ch]! */
38 : : extern unsigned int __drm_debug;
39 : :
40 : : /**
41 : : * DOC: print
42 : : *
43 : : * A simple wrapper for dev_printk(), seq_printf(), etc. Allows same
44 : : * debug code to be used for both debugfs and printk logging.
45 : : *
46 : : * For example::
47 : : *
48 : : * void log_some_info(struct drm_printer *p)
49 : : * {
50 : : * drm_printf(p, "foo=%d\n", foo);
51 : : * drm_printf(p, "bar=%d\n", bar);
52 : : * }
53 : : *
54 : : * #ifdef CONFIG_DEBUG_FS
55 : : * void debugfs_show(struct seq_file *f)
56 : : * {
57 : : * struct drm_printer p = drm_seq_file_printer(f);
58 : : * log_some_info(&p);
59 : : * }
60 : : * #endif
61 : : *
62 : : * void some_other_function(...)
63 : : * {
64 : : * struct drm_printer p = drm_info_printer(drm->dev);
65 : : * log_some_info(&p);
66 : : * }
67 : : */
68 : :
69 : : /**
70 : : * struct drm_printer - drm output "stream"
71 : : *
72 : : * Do not use struct members directly. Use drm_printer_seq_file(),
73 : : * drm_printer_info(), etc to initialize. And drm_printf() for output.
74 : : */
75 : : struct drm_printer {
76 : : /* private: */
77 : : void (*printfn)(struct drm_printer *p, struct va_format *vaf);
78 : : void (*puts)(struct drm_printer *p, const char *str);
79 : : void *arg;
80 : : const char *prefix;
81 : : };
82 : :
83 : : void __drm_printfn_coredump(struct drm_printer *p, struct va_format *vaf);
84 : : void __drm_puts_coredump(struct drm_printer *p, const char *str);
85 : : void __drm_printfn_seq_file(struct drm_printer *p, struct va_format *vaf);
86 : : void __drm_puts_seq_file(struct drm_printer *p, const char *str);
87 : : void __drm_printfn_info(struct drm_printer *p, struct va_format *vaf);
88 : : void __drm_printfn_debug(struct drm_printer *p, struct va_format *vaf);
89 : : void __drm_printfn_err(struct drm_printer *p, struct va_format *vaf);
90 : :
91 : : __printf(2, 3)
92 : : void drm_printf(struct drm_printer *p, const char *f, ...);
93 : : void drm_puts(struct drm_printer *p, const char *str);
94 : : void drm_print_regset32(struct drm_printer *p, struct debugfs_regset32 *regset);
95 : : void drm_print_bits(struct drm_printer *p, unsigned long value,
96 : : const char * const bits[], unsigned int nbits);
97 : :
98 : : __printf(2, 0)
99 : : /**
100 : : * drm_vprintf - print to a &drm_printer stream
101 : : * @p: the &drm_printer
102 : : * @fmt: format string
103 : : * @va: the va_list
104 : : */
105 : : static inline void
106 : 0 : drm_vprintf(struct drm_printer *p, const char *fmt, va_list *va)
107 : : {
108 : 0 : struct va_format vaf = { .fmt = fmt, .va = va };
109 : :
110 : 0 : p->printfn(p, &vaf);
111 : : }
112 : :
113 : : /**
114 : : * drm_printf_indent - Print to a &drm_printer stream with indentation
115 : : * @printer: DRM printer
116 : : * @indent: Tab indentation level (max 5)
117 : : * @fmt: Format string
118 : : */
119 : : #define drm_printf_indent(printer, indent, fmt, ...) \
120 : : drm_printf((printer), "%.*s" fmt, (indent), "\t\t\t\t\tX", ##__VA_ARGS__)
121 : :
122 : : /**
123 : : * struct drm_print_iterator - local struct used with drm_printer_coredump
124 : : * @data: Pointer to the devcoredump output buffer
125 : : * @start: The offset within the buffer to start writing
126 : : * @remain: The number of bytes to write for this iteration
127 : : */
128 : : struct drm_print_iterator {
129 : : void *data;
130 : : ssize_t start;
131 : : ssize_t remain;
132 : : /* private: */
133 : : ssize_t offset;
134 : : };
135 : :
136 : : /**
137 : : * drm_coredump_printer - construct a &drm_printer that can output to a buffer
138 : : * from the read function for devcoredump
139 : : * @iter: A pointer to a struct drm_print_iterator for the read instance
140 : : *
141 : : * This wrapper extends drm_printf() to work with a dev_coredumpm() callback
142 : : * function. The passed in drm_print_iterator struct contains the buffer
143 : : * pointer, size and offset as passed in from devcoredump.
144 : : *
145 : : * For example::
146 : : *
147 : : * void coredump_read(char *buffer, loff_t offset, size_t count,
148 : : * void *data, size_t datalen)
149 : : * {
150 : : * struct drm_print_iterator iter;
151 : : * struct drm_printer p;
152 : : *
153 : : * iter.data = buffer;
154 : : * iter.start = offset;
155 : : * iter.remain = count;
156 : : *
157 : : * p = drm_coredump_printer(&iter);
158 : : *
159 : : * drm_printf(p, "foo=%d\n", foo);
160 : : * }
161 : : *
162 : : * void makecoredump(...)
163 : : * {
164 : : * ...
165 : : * dev_coredumpm(dev, THIS_MODULE, data, 0, GFP_KERNEL,
166 : : * coredump_read, ...)
167 : : * }
168 : : *
169 : : * RETURNS:
170 : : * The &drm_printer object
171 : : */
172 : : static inline struct drm_printer
173 : : drm_coredump_printer(struct drm_print_iterator *iter)
174 : : {
175 : : struct drm_printer p = {
176 : : .printfn = __drm_printfn_coredump,
177 : : .puts = __drm_puts_coredump,
178 : : .arg = iter,
179 : : };
180 : :
181 : : /* Set the internal offset of the iterator to zero */
182 : : iter->offset = 0;
183 : :
184 : : return p;
185 : : }
186 : :
187 : : /**
188 : : * drm_seq_file_printer - construct a &drm_printer that outputs to &seq_file
189 : : * @f: the &struct seq_file to output to
190 : : *
191 : : * RETURNS:
192 : : * The &drm_printer object
193 : : */
194 : 0 : static inline struct drm_printer drm_seq_file_printer(struct seq_file *f)
195 : : {
196 : 0 : struct drm_printer p = {
197 : : .printfn = __drm_printfn_seq_file,
198 : : .puts = __drm_puts_seq_file,
199 : : .arg = f,
200 : : };
201 : 0 : return p;
202 : : }
203 : :
204 : : /**
205 : : * drm_info_printer - construct a &drm_printer that outputs to dev_printk()
206 : : * @dev: the &struct device pointer
207 : : *
208 : : * RETURNS:
209 : : * The &drm_printer object
210 : : */
211 : 0 : static inline struct drm_printer drm_info_printer(struct device *dev)
212 : : {
213 : 0 : struct drm_printer p = {
214 : : .printfn = __drm_printfn_info,
215 : : .arg = dev,
216 : : };
217 : 0 : return p;
218 : : }
219 : :
220 : : /**
221 : : * drm_debug_printer - construct a &drm_printer that outputs to pr_debug()
222 : : * @prefix: debug output prefix
223 : : *
224 : : * RETURNS:
225 : : * The &drm_printer object
226 : : */
227 : 0 : static inline struct drm_printer drm_debug_printer(const char *prefix)
228 : : {
229 : 0 : struct drm_printer p = {
230 : : .printfn = __drm_printfn_debug,
231 : : .prefix = prefix
232 : : };
233 : 0 : return p;
234 : : }
235 : :
236 : : /**
237 : : * drm_err_printer - construct a &drm_printer that outputs to pr_err()
238 : : * @prefix: debug output prefix
239 : : *
240 : : * RETURNS:
241 : : * The &drm_printer object
242 : : */
243 : : static inline struct drm_printer drm_err_printer(const char *prefix)
244 : : {
245 : : struct drm_printer p = {
246 : : .printfn = __drm_printfn_err,
247 : : .prefix = prefix
248 : : };
249 : : return p;
250 : : }
251 : :
252 : : /**
253 : : * enum drm_debug_category - The DRM debug categories
254 : : *
255 : : * Each of the DRM debug logging macros use a specific category, and the logging
256 : : * is filtered by the drm.debug module parameter. This enum specifies the values
257 : : * for the interface.
258 : : *
259 : : * Each DRM_DEBUG_<CATEGORY> macro logs to DRM_UT_<CATEGORY> category, except
260 : : * DRM_DEBUG() logs to DRM_UT_CORE.
261 : : *
262 : : * Enabling verbose debug messages is done through the drm.debug parameter, each
263 : : * category being enabled by a bit:
264 : : *
265 : : * - drm.debug=0x1 will enable CORE messages
266 : : * - drm.debug=0x2 will enable DRIVER messages
267 : : * - drm.debug=0x3 will enable CORE and DRIVER messages
268 : : * - ...
269 : : * - drm.debug=0x1ff will enable all messages
270 : : *
271 : : * An interesting feature is that it's possible to enable verbose logging at
272 : : * run-time by echoing the debug value in its sysfs node::
273 : : *
274 : : * # echo 0xf > /sys/module/drm/parameters/debug
275 : : *
276 : : */
277 : : enum drm_debug_category {
278 : : /**
279 : : * @DRM_UT_CORE: Used in the generic drm code: drm_ioctl.c, drm_mm.c,
280 : : * drm_memory.c, ...
281 : : */
282 : : DRM_UT_CORE = 0x01,
283 : : /**
284 : : * @DRM_UT_DRIVER: Used in the vendor specific part of the driver: i915,
285 : : * radeon, ... macro.
286 : : */
287 : : DRM_UT_DRIVER = 0x02,
288 : : /**
289 : : * @DRM_UT_KMS: Used in the modesetting code.
290 : : */
291 : : DRM_UT_KMS = 0x04,
292 : : /**
293 : : * @DRM_UT_PRIME: Used in the prime code.
294 : : */
295 : : DRM_UT_PRIME = 0x08,
296 : : /**
297 : : * @DRM_UT_ATOMIC: Used in the atomic code.
298 : : */
299 : : DRM_UT_ATOMIC = 0x10,
300 : : /**
301 : : * @DRM_UT_VBL: Used for verbose debug message in the vblank code.
302 : : */
303 : : DRM_UT_VBL = 0x20,
304 : : /**
305 : : * @DRM_UT_STATE: Used for verbose atomic state debugging.
306 : : */
307 : : DRM_UT_STATE = 0x40,
308 : : /**
309 : : * @DRM_UT_LEASE: Used in the lease code.
310 : : */
311 : : DRM_UT_LEASE = 0x80,
312 : : /**
313 : : * @DRM_UT_DP: Used in the DP code.
314 : : */
315 : : DRM_UT_DP = 0x100,
316 : : };
317 : :
318 : 13 : static inline bool drm_debug_enabled(enum drm_debug_category category)
319 : : {
320 [ + - - - : 13 : return unlikely(__drm_debug & category);
# # # # ]
321 : : }
322 : :
323 : : /*
324 : : * struct device based logging
325 : : *
326 : : * Prefer drm_device based logging over device or prink based logging.
327 : : */
328 : :
329 : : __printf(3, 4)
330 : : void drm_dev_printk(const struct device *dev, const char *level,
331 : : const char *format, ...);
332 : : __printf(3, 4)
333 : : void drm_dev_dbg(const struct device *dev, enum drm_debug_category category,
334 : : const char *format, ...);
335 : :
336 : : /**
337 : : * Error output.
338 : : *
339 : : * @dev: device pointer
340 : : * @fmt: printf() like format string.
341 : : */
342 : : #define DRM_DEV_ERROR(dev, fmt, ...) \
343 : : drm_dev_printk(dev, KERN_ERR, "*ERROR* " fmt, ##__VA_ARGS__)
344 : :
345 : : /**
346 : : * Rate limited error output. Like DRM_ERROR() but won't flood the log.
347 : : *
348 : : * @dev: device pointer
349 : : * @fmt: printf() like format string.
350 : : */
351 : : #define DRM_DEV_ERROR_RATELIMITED(dev, fmt, ...) \
352 : : ({ \
353 : : static DEFINE_RATELIMIT_STATE(_rs, \
354 : : DEFAULT_RATELIMIT_INTERVAL, \
355 : : DEFAULT_RATELIMIT_BURST); \
356 : : \
357 : : if (__ratelimit(&_rs)) \
358 : : DRM_DEV_ERROR(dev, fmt, ##__VA_ARGS__); \
359 : : })
360 : :
361 : : #define DRM_DEV_INFO(dev, fmt, ...) \
362 : : drm_dev_printk(dev, KERN_INFO, fmt, ##__VA_ARGS__)
363 : :
364 : : #define DRM_DEV_INFO_ONCE(dev, fmt, ...) \
365 : : ({ \
366 : : static bool __print_once __read_mostly; \
367 : : if (!__print_once) { \
368 : : __print_once = true; \
369 : : DRM_DEV_INFO(dev, fmt, ##__VA_ARGS__); \
370 : : } \
371 : : })
372 : :
373 : : /**
374 : : * Debug output.
375 : : *
376 : : * @dev: device pointer
377 : : * @fmt: printf() like format string.
378 : : */
379 : : #define DRM_DEV_DEBUG(dev, fmt, ...) \
380 : : drm_dev_dbg(dev, DRM_UT_CORE, fmt, ##__VA_ARGS__)
381 : : #define DRM_DEV_DEBUG_DRIVER(dev, fmt, ...) \
382 : : drm_dev_dbg(dev, DRM_UT_DRIVER, fmt, ##__VA_ARGS__)
383 : : #define DRM_DEV_DEBUG_KMS(dev, fmt, ...) \
384 : : drm_dev_dbg(dev, DRM_UT_KMS, fmt, ##__VA_ARGS__)
385 : : #define DRM_DEV_DEBUG_PRIME(dev, fmt, ...) \
386 : : drm_dev_dbg(dev, DRM_UT_PRIME, fmt, ##__VA_ARGS__)
387 : : #define DRM_DEV_DEBUG_ATOMIC(dev, fmt, ...) \
388 : : drm_dev_dbg(dev, DRM_UT_ATOMIC, fmt, ##__VA_ARGS__)
389 : : #define DRM_DEV_DEBUG_VBL(dev, fmt, ...) \
390 : : drm_dev_dbg(dev, DRM_UT_VBL, fmt, ##__VA_ARGS__)
391 : : #define DRM_DEV_DEBUG_DP(dev, fmt, ...) \
392 : : drm_dev_dbg(dev, DRM_UT_DP, fmt, ## __VA_ARGS__)
393 : :
394 : : #define _DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, category, fmt, ...) \
395 : : ({ \
396 : : static DEFINE_RATELIMIT_STATE(_rs, \
397 : : DEFAULT_RATELIMIT_INTERVAL, \
398 : : DEFAULT_RATELIMIT_BURST); \
399 : : if (__ratelimit(&_rs)) \
400 : : drm_dev_dbg(dev, category, fmt, ##__VA_ARGS__); \
401 : : })
402 : :
403 : : /**
404 : : * Rate limited debug output. Like DRM_DEBUG() but won't flood the log.
405 : : *
406 : : * @dev: device pointer
407 : : * @fmt: printf() like format string.
408 : : */
409 : : #define DRM_DEV_DEBUG_RATELIMITED(dev, fmt, ...) \
410 : : _DEV_DRM_DEFINE_DEBUG_RATELIMITED(dev, DRM_UT_CORE, \
411 : : fmt, ##__VA_ARGS__)
412 : : #define DRM_DEV_DEBUG_DRIVER_RATELIMITED(dev, fmt, ...) \
413 : : _DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, DRM_UT_DRIVER, \
414 : : fmt, ##__VA_ARGS__)
415 : : #define DRM_DEV_DEBUG_KMS_RATELIMITED(dev, fmt, ...) \
416 : : _DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, DRM_UT_KMS, \
417 : : fmt, ##__VA_ARGS__)
418 : : #define DRM_DEV_DEBUG_PRIME_RATELIMITED(dev, fmt, ...) \
419 : : _DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, DRM_UT_PRIME, \
420 : : fmt, ##__VA_ARGS__)
421 : :
422 : : /*
423 : : * struct drm_device based logging
424 : : *
425 : : * Prefer drm_device based logging over device or prink based logging.
426 : : */
427 : :
428 : : /* Helper for struct drm_device based logging. */
429 : : #define __drm_printk(drm, level, type, fmt, ...) \
430 : : dev_##level##type((drm)->dev, "[drm] " fmt, ##__VA_ARGS__)
431 : :
432 : :
433 : : #define drm_info(drm, fmt, ...) \
434 : : __drm_printk((drm), info,, fmt, ##__VA_ARGS__)
435 : :
436 : : #define drm_notice(drm, fmt, ...) \
437 : : __drm_printk((drm), notice,, fmt, ##__VA_ARGS__)
438 : :
439 : : #define drm_warn(drm, fmt, ...) \
440 : : __drm_printk((drm), warn,, fmt, ##__VA_ARGS__)
441 : :
442 : : #define drm_err(drm, fmt, ...) \
443 : : __drm_printk((drm), err,, "*ERROR* " fmt, ##__VA_ARGS__)
444 : :
445 : :
446 : : #define drm_info_once(drm, fmt, ...) \
447 : : __drm_printk((drm), info, _once, fmt, ##__VA_ARGS__)
448 : :
449 : : #define drm_notice_once(drm, fmt, ...) \
450 : : __drm_printk((drm), notice, _once, fmt, ##__VA_ARGS__)
451 : :
452 : : #define drm_warn_once(drm, fmt, ...) \
453 : : __drm_printk((drm), warn, _once, fmt, ##__VA_ARGS__)
454 : :
455 : : #define drm_err_once(drm, fmt, ...) \
456 : : __drm_printk((drm), err, _once, "*ERROR* " fmt, ##__VA_ARGS__)
457 : :
458 : :
459 : : #define drm_err_ratelimited(drm, fmt, ...) \
460 : : __drm_printk((drm), err, _ratelimited, "*ERROR* " fmt, ##__VA_ARGS__)
461 : :
462 : :
463 : : #define drm_dbg_core(drm, fmt, ...) \
464 : : drm_dev_dbg((drm)->dev, DRM_UT_CORE, fmt, ##__VA_ARGS__)
465 : : #define drm_dbg(drm, fmt, ...) \
466 : : drm_dev_dbg((drm)->dev, DRM_UT_DRIVER, fmt, ##__VA_ARGS__)
467 : : #define drm_dbg_kms(drm, fmt, ...) \
468 : : drm_dev_dbg((drm)->dev, DRM_UT_KMS, fmt, ##__VA_ARGS__)
469 : : #define drm_dbg_prime(drm, fmt, ...) \
470 : : drm_dev_dbg((drm)->dev, DRM_UT_PRIME, fmt, ##__VA_ARGS__)
471 : : #define drm_dbg_atomic(drm, fmt, ...) \
472 : : drm_dev_dbg((drm)->dev, DRM_UT_ATOMIC, fmt, ##__VA_ARGS__)
473 : : #define drm_dbg_vbl(drm, fmt, ...) \
474 : : drm_dev_dbg((drm)->dev, DRM_UT_VBL, fmt, ##__VA_ARGS__)
475 : : #define drm_dbg_state(drm, fmt, ...) \
476 : : drm_dev_dbg((drm)->dev, DRM_UT_STATE, fmt, ##__VA_ARGS__)
477 : : #define drm_dbg_lease(drm, fmt, ...) \
478 : : drm_dev_dbg((drm)->dev, DRM_UT_LEASE, fmt, ##__VA_ARGS__)
479 : : #define drm_dbg_dp(drm, fmt, ...) \
480 : : drm_dev_dbg((drm)->dev, DRM_UT_DP, fmt, ##__VA_ARGS__)
481 : :
482 : :
483 : : /*
484 : : * printk based logging
485 : : *
486 : : * Prefer drm_device based logging over device or prink based logging.
487 : : */
488 : :
489 : : __printf(2, 3)
490 : : void __drm_dbg(enum drm_debug_category category, const char *format, ...);
491 : : __printf(1, 2)
492 : : void __drm_err(const char *format, ...);
493 : :
494 : : /* Macros to make printk easier */
495 : :
496 : : #define _DRM_PRINTK(once, level, fmt, ...) \
497 : : printk##once(KERN_##level "[" DRM_NAME "] " fmt, ##__VA_ARGS__)
498 : :
499 : : #define DRM_INFO(fmt, ...) \
500 : : _DRM_PRINTK(, INFO, fmt, ##__VA_ARGS__)
501 : : #define DRM_NOTE(fmt, ...) \
502 : : _DRM_PRINTK(, NOTICE, fmt, ##__VA_ARGS__)
503 : : #define DRM_WARN(fmt, ...) \
504 : : _DRM_PRINTK(, WARNING, fmt, ##__VA_ARGS__)
505 : :
506 : : #define DRM_INFO_ONCE(fmt, ...) \
507 : : _DRM_PRINTK(_once, INFO, fmt, ##__VA_ARGS__)
508 : : #define DRM_NOTE_ONCE(fmt, ...) \
509 : : _DRM_PRINTK(_once, NOTICE, fmt, ##__VA_ARGS__)
510 : : #define DRM_WARN_ONCE(fmt, ...) \
511 : : _DRM_PRINTK(_once, WARNING, fmt, ##__VA_ARGS__)
512 : :
513 : : #define DRM_ERROR(fmt, ...) \
514 : : __drm_err(fmt, ##__VA_ARGS__)
515 : :
516 : : #define DRM_ERROR_RATELIMITED(fmt, ...) \
517 : : DRM_DEV_ERROR_RATELIMITED(NULL, fmt, ##__VA_ARGS__)
518 : :
519 : : #define DRM_DEBUG(fmt, ...) \
520 : : __drm_dbg(DRM_UT_CORE, fmt, ##__VA_ARGS__)
521 : :
522 : : #define DRM_DEBUG_DRIVER(fmt, ...) \
523 : : __drm_dbg(DRM_UT_DRIVER, fmt, ##__VA_ARGS__)
524 : :
525 : : #define DRM_DEBUG_KMS(fmt, ...) \
526 : : __drm_dbg(DRM_UT_KMS, fmt, ##__VA_ARGS__)
527 : :
528 : : #define DRM_DEBUG_PRIME(fmt, ...) \
529 : : __drm_dbg(DRM_UT_PRIME, fmt, ##__VA_ARGS__)
530 : :
531 : : #define DRM_DEBUG_ATOMIC(fmt, ...) \
532 : : __drm_dbg(DRM_UT_ATOMIC, fmt, ##__VA_ARGS__)
533 : :
534 : : #define DRM_DEBUG_VBL(fmt, ...) \
535 : : __drm_dbg(DRM_UT_VBL, fmt, ##__VA_ARGS__)
536 : :
537 : : #define DRM_DEBUG_LEASE(fmt, ...) \
538 : : __drm_dbg(DRM_UT_LEASE, fmt, ##__VA_ARGS__)
539 : :
540 : : #define DRM_DEBUG_DP(fmt, ...) \
541 : : __drm_dbg(DRM_UT_DP, fmt, ## __VA_ARGS__)
542 : :
543 : :
544 : : #define DRM_DEBUG_RATELIMITED(fmt, ...) \
545 : : DRM_DEV_DEBUG_RATELIMITED(NULL, fmt, ##__VA_ARGS__)
546 : :
547 : : #define DRM_DEBUG_DRIVER_RATELIMITED(fmt, ...) \
548 : : DRM_DEV_DEBUG_DRIVER_RATELIMITED(NULL, fmt, ##__VA_ARGS__)
549 : :
550 : : #define DRM_DEBUG_KMS_RATELIMITED(fmt, ...) \
551 : : DRM_DEV_DEBUG_KMS_RATELIMITED(NULL, fmt, ##__VA_ARGS__)
552 : :
553 : : #define DRM_DEBUG_PRIME_RATELIMITED(fmt, ...) \
554 : : DRM_DEV_DEBUG_PRIME_RATELIMITED(NULL, fmt, ##__VA_ARGS__)
555 : :
556 : : #endif /* DRM_PRINT_H_ */
|
