705 lines · c
1/*2 * Copyright (C) 2016 Red Hat3 *4 * Permission is hereby granted, free of charge, to any person obtaining a5 * copy of this software and associated documentation files (the "Software"),6 * to deal in the Software without restriction, including without limitation7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,8 * and/or sell copies of the Software, and to permit persons to whom the9 * Software is furnished to do so, subject to the following conditions:10 *11 * The above copyright notice and this permission notice shall be included in12 * all copies or substantial portions of the Software.13 *14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR18 * 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 OR20 * 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/device.h>32#include <linux/dynamic_debug.h>33 34#include <drm/drm.h>35 36struct debugfs_regset32;37struct drm_device;38struct seq_file;39 40/* Do *not* use outside of drm_print.[ch]! */41extern unsigned long __drm_debug;42 43/**44 * DOC: print45 *46 * A simple wrapper for dev_printk(), seq_printf(), etc. Allows same47 * debug code to be used for both debugfs and printk logging.48 *49 * For example::50 *51 * void log_some_info(struct drm_printer *p)52 * {53 * drm_printf(p, "foo=%d\n", foo);54 * drm_printf(p, "bar=%d\n", bar);55 * }56 *57 * #ifdef CONFIG_DEBUG_FS58 * void debugfs_show(struct seq_file *f)59 * {60 * struct drm_printer p = drm_seq_file_printer(f);61 * log_some_info(&p);62 * }63 * #endif64 *65 * void some_other_function(...)66 * {67 * struct drm_printer p = drm_info_printer(drm->dev);68 * log_some_info(&p);69 * }70 */71 72/**73 * enum drm_debug_category - The DRM debug categories74 *75 * Each of the DRM debug logging macros use a specific category, and the logging76 * is filtered by the drm.debug module parameter. This enum specifies the values77 * for the interface.78 *79 * Each DRM_DEBUG_<CATEGORY> macro logs to DRM_UT_<CATEGORY> category, except80 * DRM_DEBUG() logs to DRM_UT_CORE.81 *82 * Enabling verbose debug messages is done through the drm.debug parameter, each83 * category being enabled by a bit:84 *85 * - drm.debug=0x1 will enable CORE messages86 * - drm.debug=0x2 will enable DRIVER messages87 * - drm.debug=0x3 will enable CORE and DRIVER messages88 * - ...89 * - drm.debug=0x1ff will enable all messages90 *91 * An interesting feature is that it's possible to enable verbose logging at92 * run-time by echoing the debug value in its sysfs node::93 *94 * # echo 0xf > /sys/module/drm/parameters/debug95 *96 */97enum drm_debug_category {98 /* These names must match those in DYNAMIC_DEBUG_CLASSBITS */99 /**100 * @DRM_UT_CORE: Used in the generic drm code: drm_ioctl.c, drm_mm.c,101 * drm_memory.c, ...102 */103 DRM_UT_CORE,104 /**105 * @DRM_UT_DRIVER: Used in the vendor specific part of the driver: i915,106 * radeon, ... macro.107 */108 DRM_UT_DRIVER,109 /**110 * @DRM_UT_KMS: Used in the modesetting code.111 */112 DRM_UT_KMS,113 /**114 * @DRM_UT_PRIME: Used in the prime code.115 */116 DRM_UT_PRIME,117 /**118 * @DRM_UT_ATOMIC: Used in the atomic code.119 */120 DRM_UT_ATOMIC,121 /**122 * @DRM_UT_VBL: Used for verbose debug message in the vblank code.123 */124 DRM_UT_VBL,125 /**126 * @DRM_UT_STATE: Used for verbose atomic state debugging.127 */128 DRM_UT_STATE,129 /**130 * @DRM_UT_LEASE: Used in the lease code.131 */132 DRM_UT_LEASE,133 /**134 * @DRM_UT_DP: Used in the DP code.135 */136 DRM_UT_DP,137 /**138 * @DRM_UT_DRMRES: Used in the drm managed resources code.139 */140 DRM_UT_DRMRES141};142 143static inline bool drm_debug_enabled_raw(enum drm_debug_category category)144{145 return unlikely(__drm_debug & BIT(category));146}147 148#define drm_debug_enabled_instrumented(category) \149 ({ \150 pr_debug("todo: is this frequent enough to optimize ?\n"); \151 drm_debug_enabled_raw(category); \152 })153 154#if defined(CONFIG_DRM_USE_DYNAMIC_DEBUG)155/*156 * the drm.debug API uses dyndbg, so each drm_*dbg macro/callsite gets157 * a descriptor, and only enabled callsites are reachable. They use158 * the private macro to avoid re-testing the enable-bit.159 */160#define __drm_debug_enabled(category) true161#define drm_debug_enabled(category) drm_debug_enabled_instrumented(category)162#else163#define __drm_debug_enabled(category) drm_debug_enabled_raw(category)164#define drm_debug_enabled(category) drm_debug_enabled_raw(category)165#endif166 167/**168 * struct drm_printer - drm output "stream"169 *170 * Do not use struct members directly. Use drm_printer_seq_file(),171 * drm_printer_info(), etc to initialize. And drm_printf() for output.172 */173struct drm_printer {174 /* private: */175 void (*printfn)(struct drm_printer *p, struct va_format *vaf);176 void (*puts)(struct drm_printer *p, const char *str);177 void *arg;178 const void *origin;179 const char *prefix;180 enum drm_debug_category category;181};182 183void __drm_printfn_coredump(struct drm_printer *p, struct va_format *vaf);184void __drm_puts_coredump(struct drm_printer *p, const char *str);185void __drm_printfn_seq_file(struct drm_printer *p, struct va_format *vaf);186void __drm_puts_seq_file(struct drm_printer *p, const char *str);187void __drm_printfn_info(struct drm_printer *p, struct va_format *vaf);188void __drm_printfn_dbg(struct drm_printer *p, struct va_format *vaf);189void __drm_printfn_err(struct drm_printer *p, struct va_format *vaf);190 191__printf(2, 3)192void drm_printf(struct drm_printer *p, const char *f, ...);193void drm_puts(struct drm_printer *p, const char *str);194void drm_print_regset32(struct drm_printer *p, struct debugfs_regset32 *regset);195void drm_print_bits(struct drm_printer *p, unsigned long value,196 const char * const bits[], unsigned int nbits);197 198__printf(2, 0)199/**200 * drm_vprintf - print to a &drm_printer stream201 * @p: the &drm_printer202 * @fmt: format string203 * @va: the va_list204 */205static inline void206drm_vprintf(struct drm_printer *p, const char *fmt, va_list *va)207{208 struct va_format vaf = { .fmt = fmt, .va = va };209 210 p->printfn(p, &vaf);211}212 213/**214 * drm_printf_indent - Print to a &drm_printer stream with indentation215 * @printer: DRM printer216 * @indent: Tab indentation level (max 5)217 * @fmt: Format string218 */219#define drm_printf_indent(printer, indent, fmt, ...) \220 drm_printf((printer), "%.*s" fmt, (indent), "\t\t\t\t\tX", ##__VA_ARGS__)221 222/**223 * struct drm_print_iterator - local struct used with drm_printer_coredump224 * @data: Pointer to the devcoredump output buffer, can be NULL if using225 * drm_printer_coredump to determine size of devcoredump226 * @start: The offset within the buffer to start writing227 * @remain: The number of bytes to write for this iteration228 */229struct drm_print_iterator {230 void *data;231 ssize_t start;232 ssize_t remain;233 /* private: */234 ssize_t offset;235};236 237/**238 * drm_coredump_printer - construct a &drm_printer that can output to a buffer239 * from the read function for devcoredump240 * @iter: A pointer to a struct drm_print_iterator for the read instance241 *242 * This wrapper extends drm_printf() to work with a dev_coredumpm() callback243 * function. The passed in drm_print_iterator struct contains the buffer244 * pointer, size and offset as passed in from devcoredump.245 *246 * For example::247 *248 * void coredump_read(char *buffer, loff_t offset, size_t count,249 * void *data, size_t datalen)250 * {251 * struct drm_print_iterator iter;252 * struct drm_printer p;253 *254 * iter.data = buffer;255 * iter.start = offset;256 * iter.remain = count;257 *258 * p = drm_coredump_printer(&iter);259 *260 * drm_printf(p, "foo=%d\n", foo);261 * }262 *263 * void makecoredump(...)264 * {265 * ...266 * dev_coredumpm(dev, THIS_MODULE, data, 0, GFP_KERNEL,267 * coredump_read, ...)268 * }269 *270 * The above example has a time complexity of O(N^2), where N is the size of the271 * devcoredump. This is acceptable for small devcoredumps but scales poorly for272 * larger ones.273 *274 * Another use case for drm_coredump_printer is to capture the devcoredump into275 * a saved buffer before the dev_coredump() callback. This involves two passes:276 * one to determine the size of the devcoredump and another to print it to a277 * buffer. Then, in dev_coredump(), copy from the saved buffer into the278 * devcoredump read buffer.279 *280 * For example::281 *282 * char *devcoredump_saved_buffer;283 *284 * ssize_t __coredump_print(char *buffer, ssize_t count, ...)285 * {286 * struct drm_print_iterator iter;287 * struct drm_printer p;288 *289 * iter.data = buffer;290 * iter.start = 0;291 * iter.remain = count;292 *293 * p = drm_coredump_printer(&iter);294 *295 * drm_printf(p, "foo=%d\n", foo);296 * ...297 * return count - iter.remain;298 * }299 *300 * void coredump_print(...)301 * {302 * ssize_t count;303 *304 * count = __coredump_print(NULL, INT_MAX, ...);305 * devcoredump_saved_buffer = kvmalloc(count, GFP_KERNEL);306 * __coredump_print(devcoredump_saved_buffer, count, ...);307 * }308 *309 * void coredump_read(char *buffer, loff_t offset, size_t count,310 * void *data, size_t datalen)311 * {312 * ...313 * memcpy(buffer, devcoredump_saved_buffer + offset, count);314 * ...315 * }316 *317 * The above example has a time complexity of O(N*2), where N is the size of the318 * devcoredump. This scales better than the previous example for larger319 * devcoredumps.320 *321 * RETURNS:322 * The &drm_printer object323 */324static inline struct drm_printer325drm_coredump_printer(struct drm_print_iterator *iter)326{327 struct drm_printer p = {328 .printfn = __drm_printfn_coredump,329 .puts = __drm_puts_coredump,330 .arg = iter,331 };332 333 /* Set the internal offset of the iterator to zero */334 iter->offset = 0;335 336 return p;337}338 339/**340 * drm_seq_file_printer - construct a &drm_printer that outputs to &seq_file341 * @f: the &struct seq_file to output to342 *343 * RETURNS:344 * The &drm_printer object345 */346static inline struct drm_printer drm_seq_file_printer(struct seq_file *f)347{348 struct drm_printer p = {349 .printfn = __drm_printfn_seq_file,350 .puts = __drm_puts_seq_file,351 .arg = f,352 };353 return p;354}355 356/**357 * drm_info_printer - construct a &drm_printer that outputs to dev_printk()358 * @dev: the &struct device pointer359 *360 * RETURNS:361 * The &drm_printer object362 */363static inline struct drm_printer drm_info_printer(struct device *dev)364{365 struct drm_printer p = {366 .printfn = __drm_printfn_info,367 .arg = dev,368 };369 return p;370}371 372/**373 * drm_dbg_printer - construct a &drm_printer for drm device specific output374 * @drm: the &struct drm_device pointer, or NULL375 * @category: the debug category to use376 * @prefix: debug output prefix, or NULL for no prefix377 *378 * RETURNS:379 * The &drm_printer object380 */381static inline struct drm_printer drm_dbg_printer(struct drm_device *drm,382 enum drm_debug_category category,383 const char *prefix)384{385 struct drm_printer p = {386 .printfn = __drm_printfn_dbg,387 .arg = drm,388 .origin = (const void *)_THIS_IP_, /* it's fine as we will be inlined */389 .prefix = prefix,390 .category = category,391 };392 return p;393}394 395/**396 * drm_err_printer - construct a &drm_printer that outputs to drm_err()397 * @drm: the &struct drm_device pointer398 * @prefix: debug output prefix, or NULL for no prefix399 *400 * RETURNS:401 * The &drm_printer object402 */403static inline struct drm_printer drm_err_printer(struct drm_device *drm,404 const char *prefix)405{406 struct drm_printer p = {407 .printfn = __drm_printfn_err,408 .arg = drm,409 .prefix = prefix410 };411 return p;412}413 414/*415 * struct device based logging416 *417 * Prefer drm_device based logging over device or printk based logging.418 */419 420__printf(3, 4)421void drm_dev_printk(const struct device *dev, const char *level,422 const char *format, ...);423struct _ddebug;424__printf(4, 5)425void __drm_dev_dbg(struct _ddebug *desc, const struct device *dev,426 enum drm_debug_category category, const char *format, ...);427 428/**429 * DRM_DEV_ERROR() - Error output.430 *431 * NOTE: this is deprecated in favor of drm_err() or dev_err().432 *433 * @dev: device pointer434 * @fmt: printf() like format string.435 */436#define DRM_DEV_ERROR(dev, fmt, ...) \437 drm_dev_printk(dev, KERN_ERR, "*ERROR* " fmt, ##__VA_ARGS__)438 439/**440 * DRM_DEV_ERROR_RATELIMITED() - Rate limited error output.441 *442 * NOTE: this is deprecated in favor of drm_err_ratelimited() or443 * dev_err_ratelimited().444 *445 * @dev: device pointer446 * @fmt: printf() like format string.447 *448 * Like DRM_ERROR() but won't flood the log.449 */450#define DRM_DEV_ERROR_RATELIMITED(dev, fmt, ...) \451({ \452 static DEFINE_RATELIMIT_STATE(_rs, \453 DEFAULT_RATELIMIT_INTERVAL, \454 DEFAULT_RATELIMIT_BURST); \455 \456 if (__ratelimit(&_rs)) \457 DRM_DEV_ERROR(dev, fmt, ##__VA_ARGS__); \458})459 460/* NOTE: this is deprecated in favor of drm_info() or dev_info(). */461#define DRM_DEV_INFO(dev, fmt, ...) \462 drm_dev_printk(dev, KERN_INFO, fmt, ##__VA_ARGS__)463 464/* NOTE: this is deprecated in favor of drm_info_once() or dev_info_once(). */465#define DRM_DEV_INFO_ONCE(dev, fmt, ...) \466({ \467 static bool __print_once __read_mostly; \468 if (!__print_once) { \469 __print_once = true; \470 DRM_DEV_INFO(dev, fmt, ##__VA_ARGS__); \471 } \472})473 474#if !defined(CONFIG_DRM_USE_DYNAMIC_DEBUG)475#define drm_dev_dbg(dev, cat, fmt, ...) \476 __drm_dev_dbg(NULL, dev, cat, fmt, ##__VA_ARGS__)477#else478#define drm_dev_dbg(dev, cat, fmt, ...) \479 _dynamic_func_call_cls(cat, fmt, __drm_dev_dbg, \480 dev, cat, fmt, ##__VA_ARGS__)481#endif482 483/**484 * DRM_DEV_DEBUG() - Debug output for generic drm code485 *486 * NOTE: this is deprecated in favor of drm_dbg_core().487 *488 * @dev: device pointer489 * @fmt: printf() like format string.490 */491#define DRM_DEV_DEBUG(dev, fmt, ...) \492 drm_dev_dbg(dev, DRM_UT_CORE, fmt, ##__VA_ARGS__)493/**494 * DRM_DEV_DEBUG_DRIVER() - Debug output for vendor specific part of the driver495 *496 * NOTE: this is deprecated in favor of drm_dbg() or dev_dbg().497 *498 * @dev: device pointer499 * @fmt: printf() like format string.500 */501#define DRM_DEV_DEBUG_DRIVER(dev, fmt, ...) \502 drm_dev_dbg(dev, DRM_UT_DRIVER, fmt, ##__VA_ARGS__)503/**504 * DRM_DEV_DEBUG_KMS() - Debug output for modesetting code505 *506 * NOTE: this is deprecated in favor of drm_dbg_kms().507 *508 * @dev: device pointer509 * @fmt: printf() like format string.510 */511#define DRM_DEV_DEBUG_KMS(dev, fmt, ...) \512 drm_dev_dbg(dev, DRM_UT_KMS, fmt, ##__VA_ARGS__)513 514/*515 * struct drm_device based logging516 *517 * Prefer drm_device based logging over device or prink based logging.518 */519 520/* Helper for struct drm_device based logging. */521#define __drm_printk(drm, level, type, fmt, ...) \522 dev_##level##type((drm) ? (drm)->dev : NULL, "[drm] " fmt, ##__VA_ARGS__)523 524 525#define drm_info(drm, fmt, ...) \526 __drm_printk((drm), info,, fmt, ##__VA_ARGS__)527 528#define drm_notice(drm, fmt, ...) \529 __drm_printk((drm), notice,, fmt, ##__VA_ARGS__)530 531#define drm_warn(drm, fmt, ...) \532 __drm_printk((drm), warn,, fmt, ##__VA_ARGS__)533 534#define drm_err(drm, fmt, ...) \535 __drm_printk((drm), err,, "*ERROR* " fmt, ##__VA_ARGS__)536 537 538#define drm_info_once(drm, fmt, ...) \539 __drm_printk((drm), info, _once, fmt, ##__VA_ARGS__)540 541#define drm_notice_once(drm, fmt, ...) \542 __drm_printk((drm), notice, _once, fmt, ##__VA_ARGS__)543 544#define drm_warn_once(drm, fmt, ...) \545 __drm_printk((drm), warn, _once, fmt, ##__VA_ARGS__)546 547#define drm_err_once(drm, fmt, ...) \548 __drm_printk((drm), err, _once, "*ERROR* " fmt, ##__VA_ARGS__)549 550 551#define drm_err_ratelimited(drm, fmt, ...) \552 __drm_printk((drm), err, _ratelimited, "*ERROR* " fmt, ##__VA_ARGS__)553 554 555#define drm_dbg_core(drm, fmt, ...) \556 drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_CORE, fmt, ##__VA_ARGS__)557#define drm_dbg_driver(drm, fmt, ...) \558 drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_DRIVER, fmt, ##__VA_ARGS__)559#define drm_dbg_kms(drm, fmt, ...) \560 drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_KMS, fmt, ##__VA_ARGS__)561#define drm_dbg_prime(drm, fmt, ...) \562 drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_PRIME, fmt, ##__VA_ARGS__)563#define drm_dbg_atomic(drm, fmt, ...) \564 drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_ATOMIC, fmt, ##__VA_ARGS__)565#define drm_dbg_vbl(drm, fmt, ...) \566 drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_VBL, fmt, ##__VA_ARGS__)567#define drm_dbg_state(drm, fmt, ...) \568 drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_STATE, fmt, ##__VA_ARGS__)569#define drm_dbg_lease(drm, fmt, ...) \570 drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_LEASE, fmt, ##__VA_ARGS__)571#define drm_dbg_dp(drm, fmt, ...) \572 drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_DP, fmt, ##__VA_ARGS__)573#define drm_dbg_drmres(drm, fmt, ...) \574 drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_DRMRES, fmt, ##__VA_ARGS__)575 576#define drm_dbg(drm, fmt, ...) drm_dbg_driver(drm, fmt, ##__VA_ARGS__)577 578/*579 * printk based logging580 *581 * Prefer drm_device based logging over device or prink based logging.582 */583 584__printf(1, 2)585void __drm_err(const char *format, ...);586 587#if !defined(CONFIG_DRM_USE_DYNAMIC_DEBUG)588#define __drm_dbg(cat, fmt, ...) __drm_dev_dbg(NULL, NULL, cat, fmt, ##__VA_ARGS__)589#else590#define __drm_dbg(cat, fmt, ...) \591 _dynamic_func_call_cls(cat, fmt, __drm_dev_dbg, \592 NULL, cat, fmt, ##__VA_ARGS__)593#endif594 595/* Macros to make printk easier */596 597#define _DRM_PRINTK(once, level, fmt, ...) \598 printk##once(KERN_##level "[" DRM_NAME "] " fmt, ##__VA_ARGS__)599 600/* NOTE: this is deprecated in favor of pr_info(). */601#define DRM_INFO(fmt, ...) \602 _DRM_PRINTK(, INFO, fmt, ##__VA_ARGS__)603/* NOTE: this is deprecated in favor of pr_notice(). */604#define DRM_NOTE(fmt, ...) \605 _DRM_PRINTK(, NOTICE, fmt, ##__VA_ARGS__)606/* NOTE: this is deprecated in favor of pr_warn(). */607#define DRM_WARN(fmt, ...) \608 _DRM_PRINTK(, WARNING, fmt, ##__VA_ARGS__)609 610/* NOTE: this is deprecated in favor of pr_info_once(). */611#define DRM_INFO_ONCE(fmt, ...) \612 _DRM_PRINTK(_once, INFO, fmt, ##__VA_ARGS__)613/* NOTE: this is deprecated in favor of pr_notice_once(). */614#define DRM_NOTE_ONCE(fmt, ...) \615 _DRM_PRINTK(_once, NOTICE, fmt, ##__VA_ARGS__)616/* NOTE: this is deprecated in favor of pr_warn_once(). */617#define DRM_WARN_ONCE(fmt, ...) \618 _DRM_PRINTK(_once, WARNING, fmt, ##__VA_ARGS__)619 620/* NOTE: this is deprecated in favor of pr_err(). */621#define DRM_ERROR(fmt, ...) \622 __drm_err(fmt, ##__VA_ARGS__)623 624/* NOTE: this is deprecated in favor of pr_err_ratelimited(). */625#define DRM_ERROR_RATELIMITED(fmt, ...) \626 DRM_DEV_ERROR_RATELIMITED(NULL, fmt, ##__VA_ARGS__)627 628/* NOTE: this is deprecated in favor of drm_dbg_core(NULL, ...). */629#define DRM_DEBUG(fmt, ...) \630 __drm_dbg(DRM_UT_CORE, fmt, ##__VA_ARGS__)631 632/* NOTE: this is deprecated in favor of drm_dbg(NULL, ...). */633#define DRM_DEBUG_DRIVER(fmt, ...) \634 __drm_dbg(DRM_UT_DRIVER, fmt, ##__VA_ARGS__)635 636/* NOTE: this is deprecated in favor of drm_dbg_kms(NULL, ...). */637#define DRM_DEBUG_KMS(fmt, ...) \638 __drm_dbg(DRM_UT_KMS, fmt, ##__VA_ARGS__)639 640/* NOTE: this is deprecated in favor of drm_dbg_prime(NULL, ...). */641#define DRM_DEBUG_PRIME(fmt, ...) \642 __drm_dbg(DRM_UT_PRIME, fmt, ##__VA_ARGS__)643 644/* NOTE: this is deprecated in favor of drm_dbg_atomic(NULL, ...). */645#define DRM_DEBUG_ATOMIC(fmt, ...) \646 __drm_dbg(DRM_UT_ATOMIC, fmt, ##__VA_ARGS__)647 648/* NOTE: this is deprecated in favor of drm_dbg_vbl(NULL, ...). */649#define DRM_DEBUG_VBL(fmt, ...) \650 __drm_dbg(DRM_UT_VBL, fmt, ##__VA_ARGS__)651 652/* NOTE: this is deprecated in favor of drm_dbg_lease(NULL, ...). */653#define DRM_DEBUG_LEASE(fmt, ...) \654 __drm_dbg(DRM_UT_LEASE, fmt, ##__VA_ARGS__)655 656/* NOTE: this is deprecated in favor of drm_dbg_dp(NULL, ...). */657#define DRM_DEBUG_DP(fmt, ...) \658 __drm_dbg(DRM_UT_DP, fmt, ## __VA_ARGS__)659 660#define __DRM_DEFINE_DBG_RATELIMITED(category, drm, fmt, ...) \661({ \662 static DEFINE_RATELIMIT_STATE(rs_, DEFAULT_RATELIMIT_INTERVAL, DEFAULT_RATELIMIT_BURST);\663 const struct drm_device *drm_ = (drm); \664 \665 if (drm_debug_enabled(DRM_UT_ ## category) && __ratelimit(&rs_)) \666 drm_dev_printk(drm_ ? drm_->dev : NULL, KERN_DEBUG, fmt, ## __VA_ARGS__); \667})668 669#define drm_dbg_ratelimited(drm, fmt, ...) \670 __DRM_DEFINE_DBG_RATELIMITED(DRIVER, drm, fmt, ## __VA_ARGS__)671 672#define drm_dbg_kms_ratelimited(drm, fmt, ...) \673 __DRM_DEFINE_DBG_RATELIMITED(KMS, drm, fmt, ## __VA_ARGS__)674 675/*676 * struct drm_device based WARNs677 *678 * drm_WARN*() acts like WARN*(), but with the key difference of679 * using device specific information so that we know from which device680 * warning is originating from.681 *682 * Prefer drm_device based drm_WARN* over regular WARN*683 */684 685/* Helper for struct drm_device based WARNs */686#define drm_WARN(drm, condition, format, arg...) \687 WARN(condition, "%s %s: [drm] " format, \688 dev_driver_string((drm)->dev), \689 dev_name((drm)->dev), ## arg)690 691#define drm_WARN_ONCE(drm, condition, format, arg...) \692 WARN_ONCE(condition, "%s %s: [drm] " format, \693 dev_driver_string((drm)->dev), \694 dev_name((drm)->dev), ## arg)695 696#define drm_WARN_ON(drm, x) \697 drm_WARN((drm), (x), "%s", \698 "drm_WARN_ON(" __stringify(x) ")")699 700#define drm_WARN_ON_ONCE(drm, x) \701 drm_WARN_ONCE((drm), (x), "%s", \702 "drm_WARN_ON_ONCE(" __stringify(x) ")")703 704#endif /* DRM_PRINT_H_ */705