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