1 /* 1 2 * Copyright (C) 2016 Red Hat 3 * 4 * Permission is hereby granted, free of charg 5 * copy of this software and associated docume 6 * to deal in the Software without restriction 7 * the rights to use, copy, modify, merge, pub 8 * and/or sell copies of the Software, and to 9 * Software is furnished to do so, subject to 10 * 11 * The above copyright notice and this permiss 12 * all copies or substantial portions of the S 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT W 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE W 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINF 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIA 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CO 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH 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/device.h> 32 #include <linux/dynamic_debug.h> 33 34 #include <drm/drm.h> 35 36 struct debugfs_regset32; 37 struct drm_device; 38 struct seq_file; 39 40 /* Do *not* use outside of drm_print.[ch]! */ 41 extern unsigned long __drm_debug; 42 43 /** 44 * DOC: print 45 * 46 * A simple wrapper for dev_printk(), seq_prin 47 * debug code to be used for both debugfs and 48 * 49 * For example:: 50 * 51 * void log_some_info(struct drm_printer * 52 * { 53 * drm_printf(p, "foo=%d\n", foo); 54 * drm_printf(p, "bar=%d\n", bar); 55 * } 56 * 57 * #ifdef CONFIG_DEBUG_FS 58 * void debugfs_show(struct seq_file *f) 59 * { 60 * struct drm_printer p = drm_seq_ 61 * log_some_info(&p); 62 * } 63 * #endif 64 * 65 * void some_other_function(...) 66 * { 67 * struct drm_printer p = drm_info 68 * log_some_info(&p); 69 * } 70 */ 71 72 /** 73 * enum drm_debug_category - The DRM debug cat 74 * 75 * Each of the DRM debug logging macros use a 76 * is filtered by the drm.debug module paramet 77 * for the interface. 78 * 79 * Each DRM_DEBUG_<CATEGORY> macro logs to DRM 80 * DRM_DEBUG() logs to DRM_UT_CORE. 81 * 82 * Enabling verbose debug messages is done thr 83 * category being enabled by a bit: 84 * 85 * - drm.debug=0x1 will enable CORE messages 86 * - drm.debug=0x2 will enable DRIVER message 87 * - drm.debug=0x3 will enable CORE and DRIVE 88 * - ... 89 * - drm.debug=0x1ff will enable all messages 90 * 91 * An interesting feature is that it's possibl 92 * run-time by echoing the debug value in its 93 * 94 * # echo 0xf > /sys/module/drm/parameters/d 95 * 96 */ 97 enum drm_debug_category { 98 /* These names must match those in DYN 99 /** 100 * @DRM_UT_CORE: Used in the generic d 101 * drm_memory.c, ... 102 */ 103 DRM_UT_CORE, 104 /** 105 * @DRM_UT_DRIVER: Used in the vendor 106 * radeon, ... macro. 107 */ 108 DRM_UT_DRIVER, 109 /** 110 * @DRM_UT_KMS: Used in the modesettin 111 */ 112 DRM_UT_KMS, 113 /** 114 * @DRM_UT_PRIME: Used in the prime co 115 */ 116 DRM_UT_PRIME, 117 /** 118 * @DRM_UT_ATOMIC: Used in the atomic 119 */ 120 DRM_UT_ATOMIC, 121 /** 122 * @DRM_UT_VBL: Used for verbose debug 123 */ 124 DRM_UT_VBL, 125 /** 126 * @DRM_UT_STATE: Used for verbose ato 127 */ 128 DRM_UT_STATE, 129 /** 130 * @DRM_UT_LEASE: Used in the lease co 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 man 139 */ 140 DRM_UT_DRMRES 141 }; 142 143 static inline bool drm_debug_enabled_raw(enum 144 { 145 return unlikely(__drm_debug & BIT(cate 146 } 147 148 #define drm_debug_enabled_instrumented(categor 149 ({ 150 pr_debug("todo: is this freque 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_ 157 * a descriptor, and only enabled callsites ar 158 * the private macro to avoid re-testing the e 159 */ 160 #define __drm_debug_enabled(category) true 161 #define drm_debug_enabled(category) drm_de 162 #else 163 #define __drm_debug_enabled(category) drm_de 164 #define drm_debug_enabled(category) drm_de 165 #endif 166 167 /** 168 * struct drm_printer - drm output "stream" 169 * 170 * Do not use struct members directly. Use dr 171 * drm_printer_info(), etc to initialize. And 172 */ 173 struct drm_printer { 174 /* private: */ 175 void (*printfn)(struct drm_printer *p, 176 void (*puts)(struct drm_printer *p, co 177 void *arg; 178 const void *origin; 179 const char *prefix; 180 enum drm_debug_category category; 181 }; 182 183 void __drm_printfn_coredump(struct drm_printer 184 void __drm_puts_coredump(struct drm_printer *p 185 void __drm_printfn_seq_file(struct drm_printer 186 void __drm_puts_seq_file(struct drm_printer *p 187 void __drm_printfn_info(struct drm_printer *p, 188 void __drm_printfn_dbg(struct drm_printer *p, 189 void __drm_printfn_err(struct drm_printer *p, 190 191 __printf(2, 3) 192 void drm_printf(struct drm_printer *p, const c 193 void drm_puts(struct drm_printer *p, const cha 194 void drm_print_regset32(struct drm_printer *p, 195 void drm_print_bits(struct drm_printer *p, uns 196 const char * const bits[], 197 198 __printf(2, 0) 199 /** 200 * drm_vprintf - print to a &drm_printer strea 201 * @p: the &drm_printer 202 * @fmt: format string 203 * @va: the va_list 204 */ 205 static inline void 206 drm_vprintf(struct drm_printer *p, const char 207 { 208 struct va_format vaf = { .fmt = fmt, . 209 210 p->printfn(p, &vaf); 211 } 212 213 /** 214 * drm_printf_indent - Print to a &drm_printer 215 * @printer: DRM printer 216 * @indent: Tab indentation level (max 5) 217 * @fmt: Format string 218 */ 219 #define drm_printf_indent(printer, indent, fmt 220 drm_printf((printer), "%.*s" fmt, (ind 221 222 /** 223 * struct drm_print_iterator - local struct us 224 * @data: Pointer to the devcoredump output bu 225 * drm_printer_coredump to determine size of d 226 * @start: The offset within the buffer to sta 227 * @remain: The number of bytes to write for t 228 */ 229 struct 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_pri 239 * from the read function for devcoredump 240 * @iter: A pointer to a struct drm_print_iter 241 * 242 * This wrapper extends drm_printf() to work w 243 * function. The passed in drm_print_iterator 244 * pointer, size and offset as passed in from 245 * 246 * For example:: 247 * 248 * void coredump_read(char *buffer, loff_ 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 267 * coredump_read, ...) 268 * } 269 * 270 * The above example has a time complexity of 271 * devcoredump. This is acceptable for small d 272 * larger ones. 273 * 274 * Another use case for drm_coredump_printer i 275 * a saved buffer before the dev_coredump() ca 276 * one to determine the size of the devcoredum 277 * buffer. Then, in dev_coredump(), copy from 278 * devcoredump read buffer. 279 * 280 * For example:: 281 * 282 * char *devcoredump_saved_buffer; 283 * 284 * ssize_t __coredump_print(char *buffer, 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, 305 * devcoredump_saved_buffer = kvm 306 * __coredump_print(devcoredump_s 307 * } 308 * 309 * void coredump_read(char *buffer, loff_ 310 * void *data, size_t 311 * { 312 * ... 313 * memcpy(buffer, devcoredump_sav 314 * ... 315 * } 316 * 317 * The above example has a time complexity of 318 * devcoredump. This scales better than the pr 319 * devcoredumps. 320 * 321 * RETURNS: 322 * The &drm_printer object 323 */ 324 static inline struct drm_printer 325 drm_coredump_printer(struct drm_print_iterator 326 { 327 struct drm_printer p = { 328 .printfn = __drm_printfn_cored 329 .puts = __drm_puts_coredump, 330 .arg = iter, 331 }; 332 333 /* Set the internal offset of the iter 334 iter->offset = 0; 335 336 return p; 337 } 338 339 /** 340 * drm_seq_file_printer - construct a &drm_pri 341 * @f: the &struct seq_file to output to 342 * 343 * RETURNS: 344 * The &drm_printer object 345 */ 346 static inline struct drm_printer drm_seq_file_ 347 { 348 struct drm_printer p = { 349 .printfn = __drm_printfn_seq_f 350 .puts = __drm_puts_seq_file, 351 .arg = f, 352 }; 353 return p; 354 } 355 356 /** 357 * drm_info_printer - construct a &drm_printer 358 * @dev: the &struct device pointer 359 * 360 * RETURNS: 361 * The &drm_printer object 362 */ 363 static inline struct drm_printer drm_info_prin 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 374 * @drm: the &struct drm_device pointer, or NU 375 * @category: the debug category to use 376 * @prefix: debug output prefix, or NULL for n 377 * 378 * RETURNS: 379 * The &drm_printer object 380 */ 381 static inline struct drm_printer drm_dbg_print 382 383 384 { 385 struct drm_printer p = { 386 .printfn = __drm_printfn_dbg, 387 .arg = drm, 388 .origin = (const void *)_THIS_ 389 .prefix = prefix, 390 .category = category, 391 }; 392 return p; 393 } 394 395 /** 396 * drm_err_printer - construct a &drm_printer 397 * @drm: the &struct drm_device pointer 398 * @prefix: debug output prefix, or NULL for n 399 * 400 * RETURNS: 401 * The &drm_printer object 402 */ 403 static inline struct drm_printer drm_err_print 404 405 { 406 struct drm_printer p = { 407 .printfn = __drm_printfn_err, 408 .arg = drm, 409 .prefix = prefix 410 }; 411 return p; 412 } 413 414 /* 415 * struct device based logging 416 * 417 * Prefer drm_device based logging over device 418 */ 419 420 __printf(3, 4) 421 void drm_dev_printk(const struct device *dev, 422 const char *format, ...); 423 struct _ddebug; 424 __printf(4, 5) 425 void __drm_dev_dbg(struct _ddebug *desc, const 426 enum drm_debug_category cat 427 428 /** 429 * DRM_DEV_ERROR() - Error output. 430 * 431 * NOTE: this is deprecated in favor of drm_er 432 * 433 * @dev: device pointer 434 * @fmt: printf() like format string. 435 */ 436 #define DRM_DEV_ERROR(dev, fmt, ...) 437 drm_dev_printk(dev, KERN_ERR, "*ERROR* 438 439 /** 440 * DRM_DEV_ERROR_RATELIMITED() - Rate limited 441 * 442 * NOTE: this is deprecated in favor of drm_er 443 * dev_err_ratelimited(). 444 * 445 * @dev: device pointer 446 * @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_ 454 DEFAULT_ 455 456 if (__ratelimit(&_rs)) 457 DRM_DEV_ERROR(dev, fmt, ##__VA 458 }) 459 460 /* NOTE: this is deprecated in favor of drm_in 461 #define DRM_DEV_INFO(dev, fmt, ...) 462 drm_dev_printk(dev, KERN_INFO, fmt, ## 463 464 /* NOTE: this is deprecated in favor of drm_in 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_ 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, ##_ 477 #else 478 #define drm_dev_dbg(dev, cat, fmt, ...) 479 _dynamic_func_call_cls(cat, fmt, __drm 480 dev, cat, fmt, 481 #endif 482 483 /** 484 * DRM_DEV_DEBUG() - Debug output for generic 485 * 486 * NOTE: this is deprecated in favor of drm_db 487 * 488 * @dev: device pointer 489 * @fmt: printf() like format string. 490 */ 491 #define DRM_DEV_DEBUG(dev, fmt, ...) 492 drm_dev_dbg(dev, DRM_UT_CORE, fmt, ##_ 493 /** 494 * DRM_DEV_DEBUG_DRIVER() - Debug output for v 495 * 496 * NOTE: this is deprecated in favor of drm_db 497 * 498 * @dev: device pointer 499 * @fmt: printf() like format string. 500 */ 501 #define DRM_DEV_DEBUG_DRIVER(dev, fmt, ...) 502 drm_dev_dbg(dev, DRM_UT_DRIVER, fmt, # 503 /** 504 * DRM_DEV_DEBUG_KMS() - Debug output for mode 505 * 506 * NOTE: this is deprecated in favor of drm_db 507 * 508 * @dev: device pointer 509 * @fmt: printf() like format string. 510 */ 511 #define DRM_DEV_DEBUG_KMS(dev, fmt, ...) 512 drm_dev_dbg(dev, DRM_UT_KMS, fmt, ##__ 513 514 /* 515 * struct drm_device based logging 516 * 517 * Prefer drm_device based logging over device 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 : 523 524 525 #define drm_info(drm, fmt, ...) 526 __drm_printk((drm), info,, fmt, ##__VA 527 528 #define drm_notice(drm, fmt, ...) 529 __drm_printk((drm), notice,, fmt, ##__ 530 531 #define drm_warn(drm, fmt, ...) 532 __drm_printk((drm), warn,, fmt, ##__VA 533 534 #define drm_err(drm, fmt, ...) 535 __drm_printk((drm), err,, "*ERROR* " f 536 537 538 #define drm_info_once(drm, fmt, ...) 539 __drm_printk((drm), info, _once, fmt, 540 541 #define drm_notice_once(drm, fmt, ...) 542 __drm_printk((drm), notice, _once, fmt 543 544 #define drm_warn_once(drm, fmt, ...) 545 __drm_printk((drm), warn, _once, fmt, 546 547 #define drm_err_once(drm, fmt, ...) 548 __drm_printk((drm), err, _once, "*ERRO 549 550 551 #define drm_err_ratelimited(drm, fmt, ...) 552 __drm_printk((drm), err, _ratelimited, 553 554 555 #define drm_dbg_core(drm, fmt, ...) 556 drm_dev_dbg((drm) ? (drm)->dev : NULL, 557 #define drm_dbg_driver(drm, fmt, ...) 558 drm_dev_dbg((drm) ? (drm)->dev : NULL, 559 #define drm_dbg_kms(drm, fmt, ...) 560 drm_dev_dbg((drm) ? (drm)->dev : NULL, 561 #define drm_dbg_prime(drm, fmt, ...) 562 drm_dev_dbg((drm) ? (drm)->dev : NULL, 563 #define drm_dbg_atomic(drm, fmt, ...) 564 drm_dev_dbg((drm) ? (drm)->dev : NULL, 565 #define drm_dbg_vbl(drm, fmt, ...) 566 drm_dev_dbg((drm) ? (drm)->dev : NULL, 567 #define drm_dbg_state(drm, fmt, ...) 568 drm_dev_dbg((drm) ? (drm)->dev : NULL, 569 #define drm_dbg_lease(drm, fmt, ...) 570 drm_dev_dbg((drm) ? (drm)->dev : NULL, 571 #define drm_dbg_dp(drm, fmt, ...) 572 drm_dev_dbg((drm) ? (drm)->dev : NULL, 573 #define drm_dbg_drmres(drm, fmt, ...) 574 drm_dev_dbg((drm) ? (drm)->dev : NULL, 575 576 #define drm_dbg(drm, fmt, ...) drm_dbg_driver 577 578 /* 579 * printk based logging 580 * 581 * Prefer drm_device based logging over device 582 */ 583 584 __printf(1, 2) 585 void __drm_err(const char *format, ...); 586 587 #if !defined(CONFIG_DRM_USE_DYNAMIC_DEBUG) 588 #define __drm_dbg(cat, fmt, ...) __drm_ 589 #else 590 #define __drm_dbg(cat, fmt, ...) 591 _dynamic_func_call_cls(cat, fmt, __drm 592 NULL, cat, fmt, 593 #endif 594 595 /* Macros to make printk easier */ 596 597 #define _DRM_PRINTK(once, level, fmt, ...) 598 printk##once(KERN_##level "[" DRM_NAME 599 600 /* NOTE: this is deprecated in favor of pr_inf 601 #define DRM_INFO(fmt, ...) 602 _DRM_PRINTK(, INFO, fmt, ##__VA_ARGS__ 603 /* NOTE: this is deprecated in favor of pr_not 604 #define DRM_NOTE(fmt, ...) 605 _DRM_PRINTK(, NOTICE, fmt, ##__VA_ARGS 606 /* NOTE: this is deprecated in favor of pr_war 607 #define DRM_WARN(fmt, ...) 608 _DRM_PRINTK(, WARNING, fmt, ##__VA_ARG 609 610 /* NOTE: this is deprecated in favor of pr_inf 611 #define DRM_INFO_ONCE(fmt, ...) 612 _DRM_PRINTK(_once, INFO, fmt, ##__VA_A 613 /* NOTE: this is deprecated in favor of pr_not 614 #define DRM_NOTE_ONCE(fmt, ...) 615 _DRM_PRINTK(_once, NOTICE, fmt, ##__VA 616 /* NOTE: this is deprecated in favor of pr_war 617 #define DRM_WARN_ONCE(fmt, ...) 618 _DRM_PRINTK(_once, WARNING, fmt, ##__V 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 625 #define DRM_ERROR_RATELIMITED(fmt, ...) 626 DRM_DEV_ERROR_RATELIMITED(NULL, fmt, # 627 628 /* NOTE: this is deprecated in favor of drm_db 629 #define DRM_DEBUG(fmt, ...) 630 __drm_dbg(DRM_UT_CORE, fmt, ##__VA_ARG 631 632 /* NOTE: this is deprecated in favor of drm_db 633 #define DRM_DEBUG_DRIVER(fmt, ...) 634 __drm_dbg(DRM_UT_DRIVER, fmt, ##__VA_A 635 636 /* NOTE: this is deprecated in favor of drm_db 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_db 641 #define DRM_DEBUG_PRIME(fmt, ...) 642 __drm_dbg(DRM_UT_PRIME, fmt, ##__VA_AR 643 644 /* NOTE: this is deprecated in favor of drm_db 645 #define DRM_DEBUG_ATOMIC(fmt, ...) 646 __drm_dbg(DRM_UT_ATOMIC, fmt, ##__VA_A 647 648 /* NOTE: this is deprecated in favor of drm_db 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_db 653 #define DRM_DEBUG_LEASE(fmt, ...) 654 __drm_dbg(DRM_UT_LEASE, fmt, ##__VA_AR 655 656 /* NOTE: this is deprecated in favor of drm_db 657 #define DRM_DEBUG_DP(fmt, ...) 658 __drm_dbg(DRM_UT_DP, fmt, ## __VA_ARGS 659 660 #define __DRM_DEFINE_DBG_RATELIMITED(category, 661 ({ 662 static DEFINE_RATELIMIT_STATE(rs_, DEF 663 const struct drm_device *drm_ = (drm); 664 665 if (drm_debug_enabled(DRM_UT_ ## categ 666 drm_dev_printk(drm_ ? drm_->de 667 }) 668 669 #define drm_dbg_ratelimited(drm, fmt, ...) \ 670 __DRM_DEFINE_DBG_RATELIMITED(DRIVER, d 671 672 #define drm_dbg_kms_ratelimited(drm, fmt, ...) 673 __DRM_DEFINE_DBG_RATELIMITED(KMS, drm, 674 675 /* 676 * struct drm_device based WARNs 677 * 678 * drm_WARN*() acts like WARN*(), but with the 679 * using device specific information so that w 680 * warning is originating from. 681 * 682 * Prefer drm_device based drm_WARN* over regu 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 689 dev_name((drm)->dev), 690 691 #define drm_WARN_ONCE(drm, condition, format, 692 WARN_ONCE(condition, "%s %s: [drm] " f 693 dev_driver_string((drm 694 dev_name((drm)->dev), 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(" __st 703 704 #endif /* DRM_PRINT_H_ */ 705
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.