drivers/gpu/drm/i915/gt/uc/intel_guc_log.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright © 2014-2019 Intel Corporation
   4  */
   5
   6 #include <linux/debugfs.h>
   7 #include <linux/string_helpers.h>
   8
   9 #include "gt/intel_gt.h"
  10 #include "i915_drv.h"
  11 #include "i915_irq.h"
  12 #include "i915_memcpy.h"
  13 #include "intel_guc_capture.h"
  14 #include "intel_guc_log.h"
  15 #include "intel_guc_print.h"
  16
  17 #if defined(CONFIG_DRM_I915_DEBUG_GUC)
  18 #define GUC_LOG_DEFAULT_CRASH_BUFFER_SIZE       SZ_2M
  19 #define GUC_LOG_DEFAULT_DEBUG_BUFFER_SIZE       SZ_16M
  20 #define GUC_LOG_DEFAULT_CAPTURE_BUFFER_SIZE     SZ_1M
  21 #elif defined(CONFIG_DRM_I915_DEBUG_GEM)
  22 #define GUC_LOG_DEFAULT_CRASH_BUFFER_SIZE       SZ_1M
  23 #define GUC_LOG_DEFAULT_DEBUG_BUFFER_SIZE       SZ_2M
  24 #define GUC_LOG_DEFAULT_CAPTURE_BUFFER_SIZE     SZ_1M
  25 #else
  26 #define GUC_LOG_DEFAULT_CRASH_BUFFER_SIZE       SZ_8K
  27 #define GUC_LOG_DEFAULT_DEBUG_BUFFER_SIZE       SZ_64K
  28 #define GUC_LOG_DEFAULT_CAPTURE_BUFFER_SIZE     SZ_1M
  29 #endif
  30
  31 static void guc_log_copy_debuglogs_for_relay(struct intel_guc_log *log);
  32
  33 struct guc_log_section {
  34         u32 max;
  35         u32 flag;
  36         u32 default_val;
  37         const char *name;
  38 };
  39
  40 static void _guc_log_init_sizes(struct intel_guc_log *log)
  41 {
  42         struct intel_guc *guc = log_to_guc(log);
  43         static const struct guc_log_section sections[GUC_LOG_SECTIONS_LIMIT] = {
  44                 {
  45                         GUC_LOG_CRASH_MASK >> GUC_LOG_CRASH_SHIFT,
  46                         GUC_LOG_LOG_ALLOC_UNITS,
  47                         GUC_LOG_DEFAULT_CRASH_BUFFER_SIZE,
  48                         "crash dump"
  49                 },
  50                 {
  51                         GUC_LOG_DEBUG_MASK >> GUC_LOG_DEBUG_SHIFT,
  52                         GUC_LOG_LOG_ALLOC_UNITS,
  53                         GUC_LOG_DEFAULT_DEBUG_BUFFER_SIZE,
  54                         "debug",
  55                 },
  56                 {
  57                         GUC_LOG_CAPTURE_MASK >> GUC_LOG_CAPTURE_SHIFT,
  58                         GUC_LOG_CAPTURE_ALLOC_UNITS,
  59                         GUC_LOG_DEFAULT_CAPTURE_BUFFER_SIZE,
  60                         "capture",
  61                 }
  62         };
  63         int i;
  64
  65         for (i = 0; i < GUC_LOG_SECTIONS_LIMIT; i++)
  66                 log->sizes[i].bytes = sections[i].default_val;
  67
  68         /* If debug size > 1MB then bump default crash size to keep the same units */
  69         if (log->sizes[GUC_LOG_SECTIONS_DEBUG].bytes >= SZ_1M &&
  70             GUC_LOG_DEFAULT_CRASH_BUFFER_SIZE < SZ_1M)
  71                 log->sizes[GUC_LOG_SECTIONS_CRASH].bytes = SZ_1M;
  72
  73         /* Prepare the GuC API structure fields: */
  74         for (i = 0; i < GUC_LOG_SECTIONS_LIMIT; i++) {
  75                 /* Convert to correct units */
  76                 if ((log->sizes[i].bytes % SZ_1M) == 0) {
  77                         log->sizes[i].units = SZ_1M;
  78                         log->sizes[i].flag = sections[i].flag;
  79                 } else {
  80                         log->sizes[i].units = SZ_4K;
  81                         log->sizes[i].flag = 0;
  82                 }
  83
  84                 if (!IS_ALIGNED(log->sizes[i].bytes, log->sizes[i].units))
  85                         guc_err(guc, "Mis-aligned log %s size: 0x%X vs 0x%X!\n",
  86                                 sections[i].name, log->sizes[i].bytes, log->sizes[i].units);
  87                 log->sizes[i].count = log->sizes[i].bytes / log->sizes[i].units;
  88
  89                 if (!log->sizes[i].count) {
  90                         guc_err(guc, "Zero log %s size!\n", sections[i].name);
  91                 } else {
  92                         /* Size is +1 unit */
  93                         log->sizes[i].count--;
  94                 }
  95
  96                 /* Clip to field size */
  97                 if (log->sizes[i].count > sections[i].max) {
  98                         guc_err(guc, "log %s size too large: %d vs %d!\n",
  99                                 sections[i].name, log->sizes[i].count + 1, sections[i].max + 1);
 100                         log->sizes[i].count = sections[i].max;
 101                 }
 102         }
 103
 104         if (log->sizes[GUC_LOG_SECTIONS_CRASH].units != log->sizes[GUC_LOG_SECTIONS_DEBUG].units) {
 105                 guc_err(guc, "Unit mismatch for crash and debug sections: %d vs %d!\n",
 106                         log->sizes[GUC_LOG_SECTIONS_CRASH].units,
 107                         log->sizes[GUC_LOG_SECTIONS_DEBUG].units);
 108                 log->sizes[GUC_LOG_SECTIONS_CRASH].units = log->sizes[GUC_LOG_SECTIONS_DEBUG].units;
 109                 log->sizes[GUC_LOG_SECTIONS_CRASH].count = 0;
 110         }
 111
 112         log->sizes_initialised = true;
 113 }
 114
 115 static void guc_log_init_sizes(struct intel_guc_log *log)
 116 {
 117         if (log->sizes_initialised)
 118                 return;
 119
 120         _guc_log_init_sizes(log);
 121 }
 122
 123 static u32 intel_guc_log_section_size_crash(struct intel_guc_log *log)
 124 {
 125         guc_log_init_sizes(log);
 126
 127         return log->sizes[GUC_LOG_SECTIONS_CRASH].bytes;
 128 }
 129
 130 static u32 intel_guc_log_section_size_debug(struct intel_guc_log *log)
 131 {
 132         guc_log_init_sizes(log);
 133
 134         return log->sizes[GUC_LOG_SECTIONS_DEBUG].bytes;
 135 }
 136
 137 u32 intel_guc_log_section_size_capture(struct intel_guc_log *log)
 138 {
 139         guc_log_init_sizes(log);
 140
 141         return log->sizes[GUC_LOG_SECTIONS_CAPTURE].bytes;
 142 }
 143
 144 static u32 intel_guc_log_size(struct intel_guc_log *log)
 145 {
 146         /*
 147          *  GuC Log buffer Layout:
 148          *
 149          *  NB: Ordering must follow "enum guc_log_buffer_type".
 150          *
 151          *  +===============================+ 00B
 152          *  |      Debug state header       |
 153          *  +-------------------------------+ 32B
 154          *  |    Crash dump state header    |
 155          *  +-------------------------------+ 64B
 156          *  |     Capture state header      |
 157          *  +-------------------------------+ 96B
 158          *  |                               |
 159          *  +===============================+ PAGE_SIZE (4KB)
 160          *  |          Debug logs           |
 161          *  +===============================+ + DEBUG_SIZE
 162          *  |        Crash Dump logs        |
 163          *  +===============================+ + CRASH_SIZE
 164          *  |         Capture logs          |
 165          *  +===============================+ + CAPTURE_SIZE
 166          */
 167         return PAGE_SIZE +
 168                 intel_guc_log_section_size_crash(log) +
 169                 intel_guc_log_section_size_debug(log) +
 170                 intel_guc_log_section_size_capture(log);
 171 }
 172
 173 /**
 174  * DOC: GuC firmware log
 175  *
 176  * Firmware log is enabled by setting i915.guc_log_level to the positive level.
 177  * Log data is printed out via reading debugfs i915_guc_log_dump. Reading from
 178  * i915_guc_load_status will print out firmware loading status and scratch
 179  * registers value.
 180  */
 181
 182 static int guc_action_flush_log_complete(struct intel_guc *guc)
 183 {
 184         u32 action[] = {
 185                 INTEL_GUC_ACTION_LOG_BUFFER_FILE_FLUSH_COMPLETE,
 186                 GUC_DEBUG_LOG_BUFFER
 187         };
 188
 189         return intel_guc_send_nb(guc, action, ARRAY_SIZE(action), 0);
 190 }
 191
 192 static int guc_action_flush_log(struct intel_guc *guc)
 193 {
 194         u32 action[] = {
 195                 INTEL_GUC_ACTION_FORCE_LOG_BUFFER_FLUSH,
 196                 0
 197         };
 198
 199         return intel_guc_send(guc, action, ARRAY_SIZE(action));
 200 }
 201
 202 static int guc_action_control_log(struct intel_guc *guc, bool enable,
 203                                   bool default_logging, u32 verbosity)
 204 {
 205         u32 action[] = {
 206                 INTEL_GUC_ACTION_UK_LOG_ENABLE_LOGGING,
 207                 (enable ? GUC_LOG_CONTROL_LOGGING_ENABLED : 0) |
 208                 (verbosity << GUC_LOG_CONTROL_VERBOSITY_SHIFT) |
 209                 (default_logging ? GUC_LOG_CONTROL_DEFAULT_LOGGING : 0)
 210         };
 211
 212         GEM_BUG_ON(verbosity > GUC_LOG_VERBOSITY_MAX);
 213
 214         return intel_guc_send(guc, action, ARRAY_SIZE(action));
 215 }
 216
 217 /*
 218  * Sub buffer switch callback. Called whenever relay has to switch to a new
 219  * sub buffer, relay stays on the same sub buffer if 0 is returned.
 220  */
 221 static int subbuf_start_callback(struct rchan_buf *buf,
 222                                  void *subbuf,
 223                                  void *prev_subbuf,
 224                                  size_t prev_padding)
 225 {
 226         /*
 227          * Use no-overwrite mode by default, where relay will stop accepting
 228          * new data if there are no empty sub buffers left.
 229          * There is no strict synchronization enforced by relay between Consumer
 230          * and Producer. In overwrite mode, there is a possibility of getting
 231          * inconsistent/garbled data, the producer could be writing on to the
 232          * same sub buffer from which Consumer is reading. This can't be avoided
 233          * unless Consumer is fast enough and can always run in tandem with
 234          * Producer.
 235          */
 236         if (relay_buf_full(buf))
 237                 return 0;
 238
 239         return 1;
 240 }
 241
 242 /*
 243  * file_create() callback. Creates relay file in debugfs.
 244  */
 245 static struct dentry *create_buf_file_callback(const char *filename,
 246                                                struct dentry *parent,
 247                                                umode_t mode,
 248                                                struct rchan_buf *buf,
 249                                                int *is_global)
 250 {
 251         struct dentry *buf_file;
 252
 253         /*
 254          * This to enable the use of a single buffer for the relay channel and
 255          * correspondingly have a single file exposed to User, through which
 256          * it can collect the logs in order without any post-processing.
 257          * Need to set 'is_global' even if parent is NULL for early logging.
 258          */
 259         *is_global = 1;
 260
 261         if (!parent)
 262                 return NULL;
 263
 264         buf_file = debugfs_create_file(filename, mode,
 265                                        parent, buf, &relay_file_operations);
 266         if (IS_ERR(buf_file))
 267                 return NULL;
 268
 269         return buf_file;
 270 }
 271
 272 /*
 273  * file_remove() default callback. Removes relay file in debugfs.
 274  */
 275 static int remove_buf_file_callback(struct dentry *dentry)
 276 {
 277         debugfs_remove(dentry);
 278         return 0;
 279 }
 280
 281 /* relay channel callbacks */
 282 static const struct rchan_callbacks relay_callbacks = {
 283         .subbuf_start = subbuf_start_callback,
 284         .create_buf_file = create_buf_file_callback,
 285         .remove_buf_file = remove_buf_file_callback,
 286 };
 287
 288 static void guc_move_to_next_buf(struct intel_guc_log *log)
 289 {
 290         /*
 291          * Make sure the updates made in the sub buffer are visible when
 292          * Consumer sees the following update to offset inside the sub buffer.
 293          */
 294         smp_wmb();
 295
 296         /* All data has been written, so now move the offset of sub buffer. */
 297         relay_reserve(log->relay.channel, log->vma->obj->base.size -
 298                                           intel_guc_log_section_size_capture(log));
 299
 300         /* Switch to the next sub buffer */
 301         relay_flush(log->relay.channel);
 302 }
 303
 304 static void *guc_get_write_buffer(struct intel_guc_log *log)
 305 {
 306         /*
 307          * Just get the base address of a new sub buffer and copy data into it
 308          * ourselves. NULL will be returned in no-overwrite mode, if all sub
 309          * buffers are full. Could have used the relay_write() to indirectly
 310          * copy the data, but that would have been bit convoluted, as we need to
 311          * write to only certain locations inside a sub buffer which cannot be
 312          * done without using relay_reserve() along with relay_write(). So its
 313          * better to use relay_reserve() alone.
 314          */
 315         return relay_reserve(log->relay.channel, 0);
 316 }
 317
 318 bool intel_guc_check_log_buf_overflow(struct intel_guc_log *log,
 319                                       enum guc_log_buffer_type type,
 320                                       unsigned int full_cnt)
 321 {
 322         unsigned int prev_full_cnt = log->stats[type].sampled_overflow;
 323         bool overflow = false;
 324
 325         if (full_cnt != prev_full_cnt) {
 326                 overflow = true;
 327
 328                 log->stats[type].overflow = full_cnt;
 329                 log->stats[type].sampled_overflow += full_cnt - prev_full_cnt;
 330
 331                 if (full_cnt < prev_full_cnt) {
 332                         /* buffer_full_cnt is a 4 bit counter */
 333                         log->stats[type].sampled_overflow += 16;
 334                 }
 335
 336                 guc_notice_ratelimited(log_to_guc(log), "log buffer overflow\n");
 337         }
 338
 339         return overflow;
 340 }
 341
 342 unsigned int intel_guc_get_log_buffer_size(struct intel_guc_log *log,
 343                                            enum guc_log_buffer_type type)
 344 {
 345         switch (type) {
 346         case GUC_DEBUG_LOG_BUFFER:
 347                 return intel_guc_log_section_size_debug(log);
 348         case GUC_CRASH_DUMP_LOG_BUFFER:
 349                 return intel_guc_log_section_size_crash(log);
 350         case GUC_CAPTURE_LOG_BUFFER:
 351                 return intel_guc_log_section_size_capture(log);
 352         default:
 353                 MISSING_CASE(type);
 354         }
 355
 356         return 0;
 357 }
 358
 359 size_t intel_guc_get_log_buffer_offset(struct intel_guc_log *log,
 360                                        enum guc_log_buffer_type type)
 361 {
 362         enum guc_log_buffer_type i;
 363         size_t offset = PAGE_SIZE;/* for the log_buffer_states */
 364
 365         for (i = GUC_DEBUG_LOG_BUFFER; i < GUC_MAX_LOG_BUFFER; ++i) {
 366                 if (i == type)
 367                         break;
 368                 offset += intel_guc_get_log_buffer_size(log, i);
 369         }
 370
 371         return offset;
 372 }
 373
 374 static void _guc_log_copy_debuglogs_for_relay(struct intel_guc_log *log)
 375 {
 376         struct intel_guc *guc = log_to_guc(log);
 377         unsigned int buffer_size, read_offset, write_offset, bytes_to_copy, full_cnt;
 378         struct guc_log_buffer_state *log_buf_state, *log_buf_snapshot_state;
 379         struct guc_log_buffer_state log_buf_state_local;
 380         enum guc_log_buffer_type type;
 381         void *src_data, *dst_data;
 382         bool new_overflow;
 383
 384         mutex_lock(&log->relay.lock);
 385
 386         if (guc_WARN_ON(guc, !intel_guc_log_relay_created(log)))
 387                 goto out_unlock;
 388
 389         /* Get the pointer to shared GuC log buffer */
 390         src_data = log->buf_addr;
 391         log_buf_state = src_data;
 392
 393         /* Get the pointer to local buffer to store the logs */
 394         log_buf_snapshot_state = dst_data = guc_get_write_buffer(log);
 395
 396         if (unlikely(!log_buf_snapshot_state)) {
 397                 /*
 398                  * Used rate limited to avoid deluge of messages, logs might be
 399                  * getting consumed by User at a slow rate.
 400                  */
 401                 guc_err_ratelimited(guc, "no sub-buffer to copy general logs\n");
 402                 log->relay.full_count++;
 403
 404                 goto out_unlock;
 405         }
 406
 407         /* Actual logs are present from the 2nd page */
 408         src_data += PAGE_SIZE;
 409         dst_data += PAGE_SIZE;
 410
 411         /* For relay logging, we exclude error state capture */
 412         for (type = GUC_DEBUG_LOG_BUFFER; type <= GUC_CRASH_DUMP_LOG_BUFFER; type++) {
 413                 /*
 414                  * Make a copy of the state structure, inside GuC log buffer
 415                  * (which is uncached mapped), on the stack to avoid reading
 416                  * from it multiple times.
 417                  */
 418                 memcpy(&log_buf_state_local, log_buf_state,
 419                        sizeof(struct guc_log_buffer_state));
 420                 buffer_size = intel_guc_get_log_buffer_size(log, type);
 421                 read_offset = log_buf_state_local.read_ptr;
 422                 write_offset = log_buf_state_local.sampled_write_ptr;
 423                 full_cnt = log_buf_state_local.buffer_full_cnt;
 424
 425                 /* Bookkeeping stuff */
 426                 log->stats[type].flush += log_buf_state_local.flush_to_file;
 427                 new_overflow = intel_guc_check_log_buf_overflow(log, type, full_cnt);
 428
 429                 /* Update the state of shared log buffer */
 430                 log_buf_state->read_ptr = write_offset;
 431                 log_buf_state->flush_to_file = 0;
 432                 log_buf_state++;
 433
 434                 /* First copy the state structure in snapshot buffer */
 435                 memcpy(log_buf_snapshot_state, &log_buf_state_local,
 436                        sizeof(struct guc_log_buffer_state));
 437
 438                 /*
 439                  * The write pointer could have been updated by GuC firmware,
 440                  * after sending the flush interrupt to Host, for consistency
 441                  * set write pointer value to same value of sampled_write_ptr
 442                  * in the snapshot buffer.
 443                  */
 444                 log_buf_snapshot_state->write_ptr = write_offset;
 445                 log_buf_snapshot_state++;
 446
 447                 /* Now copy the actual logs. */
 448                 if (unlikely(new_overflow)) {
 449                         /* copy the whole buffer in case of overflow */
 450                         read_offset = 0;
 451                         write_offset = buffer_size;
 452                 } else if (unlikely((read_offset > buffer_size) ||
 453                                     (write_offset > buffer_size))) {
 454                         guc_err(guc, "invalid log buffer state\n");
 455                         /* copy whole buffer as offsets are unreliable */
 456                         read_offset = 0;
 457                         write_offset = buffer_size;
 458                 }
 459
 460                 /* Just copy the newly written data */
 461                 if (read_offset > write_offset) {
 462                         i915_memcpy_from_wc(dst_data, src_data, write_offset);
 463                         bytes_to_copy = buffer_size - read_offset;
 464                 } else {
 465                         bytes_to_copy = write_offset - read_offset;
 466                 }
 467                 i915_memcpy_from_wc(dst_data + read_offset,
 468                                     src_data + read_offset, bytes_to_copy);
 469
 470                 src_data += buffer_size;
 471                 dst_data += buffer_size;
 472         }
 473
 474         guc_move_to_next_buf(log);
 475
 476 out_unlock:
 477         mutex_unlock(&log->relay.lock);
 478 }
 479
 480 static void copy_debug_logs_work(struct work_struct *work)
 481 {
 482         struct intel_guc_log *log =
 483                 container_of(work, struct intel_guc_log, relay.flush_work);
 484
 485         guc_log_copy_debuglogs_for_relay(log);
 486 }
 487
 488 static int guc_log_relay_map(struct intel_guc_log *log)
 489 {
 490         lockdep_assert_held(&log->relay.lock);
 491
 492         if (!log->vma || !log->buf_addr)
 493                 return -ENODEV;
 494
 495         /*
 496          * WC vmalloc mapping of log buffer pages was done at
 497          * GuC Log Init time, but lets keep a ref for book-keeping
 498          */
 499         i915_gem_object_get(log->vma->obj);
 500         log->relay.buf_in_use = true;
 501
 502         return 0;
 503 }
 504
 505 static void guc_log_relay_unmap(struct intel_guc_log *log)
 506 {
 507         lockdep_assert_held(&log->relay.lock);
 508
 509         i915_gem_object_put(log->vma->obj);
 510         log->relay.buf_in_use = false;
 511 }
 512
 513 void intel_guc_log_init_early(struct intel_guc_log *log)
 514 {
 515         mutex_init(&log->relay.lock);
 516         INIT_WORK(&log->relay.flush_work, copy_debug_logs_work);
 517         log->relay.started = false;
 518 }
 519
 520 static int guc_log_relay_create(struct intel_guc_log *log)
 521 {
 522         struct intel_guc *guc = log_to_guc(log);
 523         struct drm_i915_private *i915 = guc_to_gt(guc)->i915;
 524         struct rchan *guc_log_relay_chan;
 525         size_t n_subbufs, subbuf_size;
 526         int ret;
 527
 528         lockdep_assert_held(&log->relay.lock);
 529         GEM_BUG_ON(!log->vma);
 530
 531          /*
 532           * Keep the size of sub buffers same as shared log buffer
 533           * but GuC log-events excludes the error-state-capture logs
 534           */
 535         subbuf_size = log->vma->size - intel_guc_log_section_size_capture(log);
 536
 537         /*
 538          * Store up to 8 snapshots, which is large enough to buffer sufficient
 539          * boot time logs and provides enough leeway to User, in terms of
 540          * latency, for consuming the logs from relay. Also doesn't take
 541          * up too much memory.
 542          */
 543         n_subbufs = 8;
 544
 545         if (!guc->dbgfs_node)
 546                 return -ENOENT;
 547
 548         guc_log_relay_chan = relay_open("guc_log",
 549                                         guc->dbgfs_node,
 550                                         subbuf_size, n_subbufs,
 551                                         &relay_callbacks, i915);
 552         if (!guc_log_relay_chan) {
 553                 guc_err(guc, "Couldn't create relay channel for logging\n");
 554
 555                 ret = -ENOMEM;
 556                 return ret;
 557         }
 558
 559         GEM_BUG_ON(guc_log_relay_chan->subbuf_size < subbuf_size);
 560         log->relay.channel = guc_log_relay_chan;
 561
 562         return 0;
 563 }
 564
 565 static void guc_log_relay_destroy(struct intel_guc_log *log)
 566 {
 567         lockdep_assert_held(&log->relay.lock);
 568
 569         relay_close(log->relay.channel);
 570         log->relay.channel = NULL;
 571 }
 572
 573 static void guc_log_copy_debuglogs_for_relay(struct intel_guc_log *log)
 574 {
 575         struct intel_guc *guc = log_to_guc(log);
 576         struct drm_i915_private *i915 = guc_to_gt(guc)->i915;
 577         intel_wakeref_t wakeref;
 578
 579         _guc_log_copy_debuglogs_for_relay(log);
 580
 581         /*
 582          * Generally device is expected to be active only at this
 583          * time, so get/put should be really quick.
 584          */
 585         with_intel_runtime_pm(&i915->runtime_pm, wakeref)
 586                 guc_action_flush_log_complete(guc);
 587 }
 588
 589 static u32 __get_default_log_level(struct intel_guc_log *log)
 590 {
 591         struct intel_guc *guc = log_to_guc(log);
 592         struct drm_i915_private *i915 = guc_to_gt(guc)->i915;
 593
 594         /* A negative value means "use platform/config default" */
 595         if (i915->params.guc_log_level < 0) {
 596                 return (IS_ENABLED(CONFIG_DRM_I915_DEBUG) ||
 597                         IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)) ?
 598                         GUC_LOG_LEVEL_MAX : GUC_LOG_LEVEL_NON_VERBOSE;
 599         }
 600
 601         if (i915->params.guc_log_level > GUC_LOG_LEVEL_MAX) {
 602                 guc_warn(guc, "Log verbosity param out of range: %d > %d!\n",
 603                          i915->params.guc_log_level, GUC_LOG_LEVEL_MAX);
 604                 return (IS_ENABLED(CONFIG_DRM_I915_DEBUG) ||
 605                         IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)) ?
 606                         GUC_LOG_LEVEL_MAX : GUC_LOG_LEVEL_DISABLED;
 607         }
 608
 609         GEM_BUG_ON(i915->params.guc_log_level < GUC_LOG_LEVEL_DISABLED);
 610         GEM_BUG_ON(i915->params.guc_log_level > GUC_LOG_LEVEL_MAX);
 611         return i915->params.guc_log_level;
 612 }
 613
 614 int intel_guc_log_create(struct intel_guc_log *log)
 615 {
 616         struct intel_guc *guc = log_to_guc(log);
 617         struct i915_vma *vma;
 618         void *vaddr;
 619         u32 guc_log_size;
 620         int ret;
 621
 622         GEM_BUG_ON(log->vma);
 623
 624         guc_log_size = intel_guc_log_size(log);
 625
 626         vma = intel_guc_allocate_vma(guc, guc_log_size);
 627         if (IS_ERR(vma)) {
 628                 ret = PTR_ERR(vma);
 629                 goto err;
 630         }
 631
 632         log->vma = vma;
 633         /*
 634          * Create a WC (Uncached for read) vmalloc mapping up front immediate access to
 635          * data from memory during  critical events such as error capture
 636          */
 637         vaddr = i915_gem_object_pin_map_unlocked(log->vma->obj, I915_MAP_WC);
 638         if (IS_ERR(vaddr)) {
 639                 ret = PTR_ERR(vaddr);
 640                 i915_vma_unpin_and_release(&log->vma, 0);
 641                 goto err;
 642         }
 643         log->buf_addr = vaddr;
 644
 645         log->level = __get_default_log_level(log);
 646         guc_dbg(guc, "guc_log_level=%d (%s, verbose:%s, verbosity:%d)\n",
 647                 log->level, str_enabled_disabled(log->level),
 648                 str_yes_no(GUC_LOG_LEVEL_IS_VERBOSE(log->level)),
 649                 GUC_LOG_LEVEL_TO_VERBOSITY(log->level));
 650
 651         return 0;
 652
 653 err:
 654         guc_err(guc, "Failed to allocate or map log buffer %pe\n", ERR_PTR(ret));
 655         return ret;
 656 }
 657
 658 void intel_guc_log_destroy(struct intel_guc_log *log)
 659 {
 660         log->buf_addr = NULL;
 661         i915_vma_unpin_and_release(&log->vma, I915_VMA_RELEASE_MAP);
 662 }
 663
 664 int intel_guc_log_set_level(struct intel_guc_log *log, u32 level)
 665 {
 666         struct intel_guc *guc = log_to_guc(log);
 667         struct drm_i915_private *i915 = guc_to_gt(guc)->i915;
 668         intel_wakeref_t wakeref;
 669         int ret = 0;
 670
 671         BUILD_BUG_ON(GUC_LOG_VERBOSITY_MIN != 0);
 672         GEM_BUG_ON(!log->vma);
 673
 674         /*
 675          * GuC is recognizing log levels starting from 0 to max, we're using 0
 676          * as indication that logging should be disabled.
 677          */
 678         if (level < GUC_LOG_LEVEL_DISABLED || level > GUC_LOG_LEVEL_MAX)
 679                 return -EINVAL;
 680
 681         mutex_lock(&i915->drm.struct_mutex);
 682
 683         if (log->level == level)
 684                 goto out_unlock;
 685
 686         with_intel_runtime_pm(&i915->runtime_pm, wakeref)
 687                 ret = guc_action_control_log(guc,
 688                                              GUC_LOG_LEVEL_IS_VERBOSE(level),
 689                                              GUC_LOG_LEVEL_IS_ENABLED(level),
 690                                              GUC_LOG_LEVEL_TO_VERBOSITY(level));
 691         if (ret) {
 692                 guc_dbg(guc, "guc_log_control action failed %pe\n", ERR_PTR(ret));
 693                 goto out_unlock;
 694         }
 695
 696         log->level = level;
 697
 698 out_unlock:
 699         mutex_unlock(&i915->drm.struct_mutex);
 700
 701         return ret;
 702 }
 703
 704 bool intel_guc_log_relay_created(const struct intel_guc_log *log)
 705 {
 706         return log->buf_addr;
 707 }
 708
 709 int intel_guc_log_relay_open(struct intel_guc_log *log)
 710 {
 711         int ret;
 712
 713         if (!log->vma)
 714                 return -ENODEV;
 715
 716         mutex_lock(&log->relay.lock);
 717
 718         if (intel_guc_log_relay_created(log)) {
 719                 ret = -EEXIST;
 720                 goto out_unlock;
 721         }
 722
 723         /*
 724          * We require SSE 4.1 for fast reads from the GuC log buffer and
 725          * it should be present on the chipsets supporting GuC based
 726          * submissions.
 727          */
 728         if (!i915_has_memcpy_from_wc()) {
 729                 ret = -ENXIO;
 730                 goto out_unlock;
 731         }
 732
 733         ret = guc_log_relay_create(log);
 734         if (ret)
 735                 goto out_unlock;
 736
 737         ret = guc_log_relay_map(log);
 738         if (ret)
 739                 goto out_relay;
 740
 741         mutex_unlock(&log->relay.lock);
 742
 743         return 0;
 744
 745 out_relay:
 746         guc_log_relay_destroy(log);
 747 out_unlock:
 748         mutex_unlock(&log->relay.lock);
 749
 750         return ret;
 751 }
 752
 753 int intel_guc_log_relay_start(struct intel_guc_log *log)
 754 {
 755         if (log->relay.started)
 756                 return -EEXIST;
 757
 758         /*
 759          * When GuC is logging without us relaying to userspace, we're ignoring
 760          * the flush notification. This means that we need to unconditionally
 761          * flush on relay enabling, since GuC only notifies us once.
 762          */
 763         queue_work(system_highpri_wq, &log->relay.flush_work);
 764
 765         log->relay.started = true;
 766
 767         return 0;
 768 }
 769
 770 void intel_guc_log_relay_flush(struct intel_guc_log *log)
 771 {
 772         struct intel_guc *guc = log_to_guc(log);
 773         intel_wakeref_t wakeref;
 774
 775         if (!log->relay.started)
 776                 return;
 777
 778         /*
 779          * Before initiating the forceful flush, wait for any pending/ongoing
 780          * flush to complete otherwise forceful flush may not actually happen.
 781          */
 782         flush_work(&log->relay.flush_work);
 783
 784         with_intel_runtime_pm(guc_to_gt(guc)->uncore->rpm, wakeref)
 785                 guc_action_flush_log(guc);
 786
 787         /* GuC would have updated log buffer by now, so copy it */
 788         guc_log_copy_debuglogs_for_relay(log);
 789 }
 790
 791 /*
 792  * Stops the relay log. Called from intel_guc_log_relay_close(), so no
 793  * possibility of race with start/flush since relay_write cannot race
 794  * relay_close.
 795  */
 796 static void guc_log_relay_stop(struct intel_guc_log *log)
 797 {
 798         struct intel_guc *guc = log_to_guc(log);
 799         struct drm_i915_private *i915 = guc_to_gt(guc)->i915;
 800
 801         if (!log->relay.started)
 802                 return;
 803
 804         intel_synchronize_irq(i915);
 805
 806         flush_work(&log->relay.flush_work);
 807
 808         log->relay.started = false;
 809 }
 810
 811 void intel_guc_log_relay_close(struct intel_guc_log *log)
 812 {
 813         guc_log_relay_stop(log);
 814
 815         mutex_lock(&log->relay.lock);
 816         GEM_BUG_ON(!intel_guc_log_relay_created(log));
 817         guc_log_relay_unmap(log);
 818         guc_log_relay_destroy(log);
 819         mutex_unlock(&log->relay.lock);
 820 }
 821
 822 void intel_guc_log_handle_flush_event(struct intel_guc_log *log)
 823 {
 824         if (log->relay.started)
 825                 queue_work(system_highpri_wq, &log->relay.flush_work);
 826 }
 827
 828 static const char *
 829 stringify_guc_log_type(enum guc_log_buffer_type type)
 830 {
 831         switch (type) {
 832         case GUC_DEBUG_LOG_BUFFER:
 833                 return "DEBUG";
 834         case GUC_CRASH_DUMP_LOG_BUFFER:
 835                 return "CRASH";
 836         case GUC_CAPTURE_LOG_BUFFER:
 837                 return "CAPTURE";
 838         default:
 839                 MISSING_CASE(type);
 840         }
 841
 842         return "";
 843 }
 844
 845 /**
 846  * intel_guc_log_info - dump information about GuC log relay
 847  * @log: the GuC log
 848  * @p: the &drm_printer
 849  *
 850  * Pretty printer for GuC log info
 851  */
 852 void intel_guc_log_info(struct intel_guc_log *log, struct drm_printer *p)
 853 {
 854         enum guc_log_buffer_type type;
 855
 856         if (!intel_guc_log_relay_created(log)) {
 857                 drm_puts(p, "GuC log relay not created\n");
 858                 return;
 859         }
 860
 861         drm_puts(p, "GuC logging stats:\n");
 862
 863         drm_printf(p, "\tRelay full count: %u\n", log->relay.full_count);
 864
 865         for (type = GUC_DEBUG_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; type++) {
 866                 drm_printf(p, "\t%s:\tflush count %10u, overflow count %10u\n",
 867                            stringify_guc_log_type(type),
 868                            log->stats[type].flush,
 869                            log->stats[type].sampled_overflow);
 870         }
 871 }
 872
 873 /**
 874  * intel_guc_log_dump - dump the contents of the GuC log
 875  * @log: the GuC log
 876  * @p: the &drm_printer
 877  * @dump_load_err: dump the log saved on GuC load error
 878  *
 879  * Pretty printer for the GuC log
 880  */
 881 int intel_guc_log_dump(struct intel_guc_log *log, struct drm_printer *p,
 882                        bool dump_load_err)
 883 {
 884         struct intel_guc *guc = log_to_guc(log);
 885         struct intel_uc *uc = container_of(guc, struct intel_uc, guc);
 886         struct drm_i915_gem_object *obj = NULL;
 887         void *map;
 888         u32 *page;
 889         int i, j;
 890
 891         if (!intel_guc_is_supported(guc))
 892                 return -ENODEV;
 893
 894         if (dump_load_err)
 895                 obj = uc->load_err_log;
 896         else if (guc->log.vma)
 897                 obj = guc->log.vma->obj;
 898
 899         if (!obj)
 900                 return 0;
 901
 902         page = (u32 *)__get_free_page(GFP_KERNEL);
 903         if (!page)
 904                 return -ENOMEM;
 905
 906         intel_guc_dump_time_info(guc, p);
 907
 908         map = i915_gem_object_pin_map_unlocked(obj, I915_MAP_WC);
 909         if (IS_ERR(map)) {
 910                 guc_dbg(guc, "Failed to pin log object: %pe\n", map);
 911                 drm_puts(p, "(log data unaccessible)\n");
 912                 free_page((unsigned long)page);
 913                 return PTR_ERR(map);
 914         }
 915
 916         for (i = 0; i < obj->base.size; i += PAGE_SIZE) {
 917                 if (!i915_memcpy_from_wc(page, map + i, PAGE_SIZE))
 918                         memcpy(page, map + i, PAGE_SIZE);
 919
 920                 for (j = 0; j < PAGE_SIZE / sizeof(u32); j += 4)
 921                         drm_printf(p, "0x%08x 0x%08x 0x%08x 0x%08x\n",
 922                                    *(page + j + 0), *(page + j + 1),
 923                                    *(page + j + 2), *(page + j + 3));
 924         }
 925
 926         drm_puts(p, "\n");
 927
 928         i915_gem_object_unpin_map(obj);
 929         free_page((unsigned long)page);
 930
 931         return 0;
 932 }