1 // SPDX-License-Identifier: GPL-2.0-only OR MIT 2 /* Copyright (c) 2023 Imagination Technologies Ltd. */ 3 4 #include "pvr_device.h" 5 #include "pvr_gem.h" 6 #include "pvr_rogue_fwif.h" 7 #include "pvr_rogue_fwif_sf.h" 8 #include "pvr_fw_trace.h" 9 10 #include <drm/drm_drv.h> 11 #include <drm/drm_file.h> 12 #include <drm/drm_print.h> 13 14 #include <linux/build_bug.h> 15 #include <linux/dcache.h> 16 #include <linux/debugfs.h> 17 #include <linux/sysfs.h> 18 #include <linux/types.h> 19 20 static void 21 tracebuf_ctrl_init(void *cpu_ptr, void *priv) 22 { 23 struct rogue_fwif_tracebuf *tracebuf_ctrl = cpu_ptr; 24 struct pvr_fw_trace *fw_trace = priv; 25 26 tracebuf_ctrl->tracebuf_size_in_dwords = ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS; 27 tracebuf_ctrl->tracebuf_flags = 0; 28 29 if (fw_trace->group_mask) 30 tracebuf_ctrl->log_type = fw_trace->group_mask | ROGUE_FWIF_LOG_TYPE_TRACE; 31 else 32 tracebuf_ctrl->log_type = ROGUE_FWIF_LOG_TYPE_NONE; 33 34 for (u32 thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) { 35 struct rogue_fwif_tracebuf_space *tracebuf_space = 36 &tracebuf_ctrl->tracebuf[thread_nr]; 37 struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr]; 38 39 pvr_fw_object_get_fw_addr(trace_buffer->buf_obj, 40 &tracebuf_space->trace_buffer_fw_addr); 41 42 tracebuf_space->trace_buffer = trace_buffer->buf; 43 tracebuf_space->trace_pointer = 0; 44 } 45 } 46 47 int pvr_fw_trace_init(struct pvr_device *pvr_dev) 48 { 49 struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace; 50 struct drm_device *drm_dev = from_pvr_device(pvr_dev); 51 int err; 52 53 for (u32 thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) { 54 struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr]; 55 56 trace_buffer->buf = 57 pvr_fw_object_create_and_map(pvr_dev, 58 ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS * 59 sizeof(*trace_buffer->buf), 60 PVR_BO_FW_FLAGS_DEVICE_UNCACHED | 61 PVR_BO_FW_NO_CLEAR_ON_RESET, 62 NULL, NULL, &trace_buffer->buf_obj); 63 if (IS_ERR(trace_buffer->buf)) { 64 drm_err(drm_dev, "Unable to allocate trace buffer\n"); 65 err = PTR_ERR(trace_buffer->buf); 66 trace_buffer->buf = NULL; 67 goto err_free_buf; 68 } 69 } 70 71 /* TODO: Provide control of group mask. */ 72 fw_trace->group_mask = 0; 73 74 fw_trace->tracebuf_ctrl = 75 pvr_fw_object_create_and_map(pvr_dev, 76 sizeof(*fw_trace->tracebuf_ctrl), 77 PVR_BO_FW_FLAGS_DEVICE_UNCACHED | 78 PVR_BO_FW_NO_CLEAR_ON_RESET, 79 tracebuf_ctrl_init, fw_trace, 80 &fw_trace->tracebuf_ctrl_obj); 81 if (IS_ERR(fw_trace->tracebuf_ctrl)) { 82 drm_err(drm_dev, "Unable to allocate trace buffer control structure\n"); 83 err = PTR_ERR(fw_trace->tracebuf_ctrl); 84 goto err_free_buf; 85 } 86 87 BUILD_BUG_ON(ARRAY_SIZE(fw_trace->tracebuf_ctrl->tracebuf) != 88 ARRAY_SIZE(fw_trace->buffers)); 89 90 for (u32 thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) { 91 struct rogue_fwif_tracebuf_space *tracebuf_space = 92 &fw_trace->tracebuf_ctrl->tracebuf[thread_nr]; 93 struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr]; 94 95 trace_buffer->tracebuf_space = tracebuf_space; 96 } 97 98 return 0; 99 100 err_free_buf: 101 for (u32 thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) { 102 struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr]; 103 104 if (trace_buffer->buf) 105 pvr_fw_object_unmap_and_destroy(trace_buffer->buf_obj); 106 } 107 108 return err; 109 } 110 111 void pvr_fw_trace_fini(struct pvr_device *pvr_dev) 112 { 113 struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace; 114 115 for (u32 thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) { 116 struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr]; 117 118 pvr_fw_object_unmap_and_destroy(trace_buffer->buf_obj); 119 } 120 pvr_fw_object_unmap_and_destroy(fw_trace->tracebuf_ctrl_obj); 121 } 122 123 /** 124 * update_logtype() - Send KCCB command to trigger FW to update logtype 125 * @pvr_dev: Target PowerVR device 126 * @group_mask: New log group mask. 127 * 128 * Returns: 129 * * 0 on success, 130 * * Any error returned by pvr_kccb_send_cmd(), or 131 * * -%EIO if the device is lost. 132 */ 133 static int 134 update_logtype(struct pvr_device *pvr_dev, u32 group_mask) 135 { 136 struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace; 137 struct rogue_fwif_kccb_cmd cmd; 138 int idx; 139 int err; 140 int slot; 141 142 if (group_mask) 143 fw_trace->tracebuf_ctrl->log_type = ROGUE_FWIF_LOG_TYPE_TRACE | group_mask; 144 else 145 fw_trace->tracebuf_ctrl->log_type = ROGUE_FWIF_LOG_TYPE_NONE; 146 147 fw_trace->group_mask = group_mask; 148 149 down_read(&pvr_dev->reset_sem); 150 if (!drm_dev_enter(from_pvr_device(pvr_dev), &idx)) { 151 err = -EIO; 152 goto err_up_read; 153 } 154 155 cmd.cmd_type = ROGUE_FWIF_KCCB_CMD_LOGTYPE_UPDATE; 156 cmd.kccb_flags = 0; 157 158 err = pvr_kccb_send_cmd(pvr_dev, &cmd, &slot); 159 if (err) 160 goto err_drm_dev_exit; 161 162 err = pvr_kccb_wait_for_completion(pvr_dev, slot, HZ, NULL); 163 164 err_drm_dev_exit: 165 drm_dev_exit(idx); 166 167 err_up_read: 168 up_read(&pvr_dev->reset_sem); 169 170 return err; 171 } 172 173 struct pvr_fw_trace_seq_data { 174 /** @buffer: Pointer to copy of trace data. */ 175 u32 *buffer; 176 177 /** @start_offset: Starting offset in trace data, as reported by FW. */ 178 u32 start_offset; 179 180 /** @idx: Current index into trace data. */ 181 u32 idx; 182 183 /** @assert_buf: Trace assert buffer, as reported by FW. */ 184 struct rogue_fwif_file_info_buf assert_buf; 185 }; 186 187 static u32 find_sfid(u32 id) 188 { 189 for (u32 i = 0; i < ARRAY_SIZE(stid_fmts); i++) { 190 if (stid_fmts[i].id == id) 191 return i; 192 } 193 194 return ROGUE_FW_SF_LAST; 195 } 196 197 static u32 read_fw_trace(struct pvr_fw_trace_seq_data *trace_seq_data, u32 offset) 198 { 199 u32 idx; 200 201 idx = trace_seq_data->idx + offset; 202 if (idx >= ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) 203 return 0; 204 205 idx = (idx + trace_seq_data->start_offset) % ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS; 206 return trace_seq_data->buffer[idx]; 207 } 208 209 /** 210 * fw_trace_get_next() - Advance trace index to next entry 211 * @trace_seq_data: Trace sequence data. 212 * 213 * Returns: 214 * * %true if trace index is now pointing to a valid entry, or 215 * * %false if trace index is pointing to an invalid entry, or has hit the end 216 * of the trace. 217 */ 218 static bool fw_trace_get_next(struct pvr_fw_trace_seq_data *trace_seq_data) 219 { 220 u32 id, sf_id; 221 222 while (trace_seq_data->idx < ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) { 223 id = read_fw_trace(trace_seq_data, 0); 224 trace_seq_data->idx++; 225 if (!ROGUE_FW_LOG_VALIDID(id)) 226 continue; 227 if (id == ROGUE_FW_SF_MAIN_ASSERT_FAILED) { 228 /* Assertion failure marks the end of the trace. */ 229 return false; 230 } 231 232 sf_id = find_sfid(id); 233 if (sf_id == ROGUE_FW_SF_FIRST) 234 continue; 235 if (sf_id == ROGUE_FW_SF_LAST) { 236 /* 237 * Could not match with an ID in the SF table, trace is 238 * most likely corrupt from this point. 239 */ 240 return false; 241 } 242 243 /* Skip over the timestamp, and any parameters. */ 244 trace_seq_data->idx += 2 + ROGUE_FW_SF_PARAMNUM(id); 245 246 /* Ensure index is now pointing to a valid trace entry. */ 247 id = read_fw_trace(trace_seq_data, 0); 248 if (!ROGUE_FW_LOG_VALIDID(id)) 249 continue; 250 251 return true; 252 } 253 254 /* Hit end of trace data. */ 255 return false; 256 } 257 258 /** 259 * fw_trace_get_first() - Find first valid entry in trace 260 * @trace_seq_data: Trace sequence data. 261 * 262 * Skips over invalid (usually zero) and ROGUE_FW_SF_FIRST entries. 263 * 264 * If the trace has no valid entries, this function will exit with the trace 265 * index pointing to the end of the trace. trace_seq_show() will return an error 266 * in this state. 267 */ 268 static void fw_trace_get_first(struct pvr_fw_trace_seq_data *trace_seq_data) 269 { 270 trace_seq_data->idx = 0; 271 272 while (trace_seq_data->idx < ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) { 273 u32 id = read_fw_trace(trace_seq_data, 0); 274 275 if (ROGUE_FW_LOG_VALIDID(id)) { 276 u32 sf_id = find_sfid(id); 277 278 if (sf_id != ROGUE_FW_SF_FIRST) 279 break; 280 } 281 trace_seq_data->idx++; 282 } 283 } 284 285 static void *fw_trace_seq_start(struct seq_file *s, loff_t *pos) 286 { 287 struct pvr_fw_trace_seq_data *trace_seq_data = s->private; 288 289 /* Reset trace index, then advance to *pos. */ 290 fw_trace_get_first(trace_seq_data); 291 292 for (u32 i = 0; i < *pos; i++) { 293 if (!fw_trace_get_next(trace_seq_data)) 294 return NULL; 295 } 296 297 return (trace_seq_data->idx < ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) ? pos : NULL; 298 } 299 300 static void *fw_trace_seq_next(struct seq_file *s, void *v, loff_t *pos) 301 { 302 struct pvr_fw_trace_seq_data *trace_seq_data = s->private; 303 304 (*pos)++; 305 if (!fw_trace_get_next(trace_seq_data)) 306 return NULL; 307 308 return (trace_seq_data->idx < ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) ? pos : NULL; 309 } 310 311 static void fw_trace_seq_stop(struct seq_file *s, void *v) 312 { 313 } 314 315 static int fw_trace_seq_show(struct seq_file *s, void *v) 316 { 317 struct pvr_fw_trace_seq_data *trace_seq_data = s->private; 318 u64 timestamp; 319 u32 id; 320 u32 sf_id; 321 322 if (trace_seq_data->idx >= ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) 323 return -EINVAL; 324 325 id = read_fw_trace(trace_seq_data, 0); 326 /* Index is not pointing at a valid entry. */ 327 if (!ROGUE_FW_LOG_VALIDID(id)) 328 return -EINVAL; 329 330 sf_id = find_sfid(id); 331 /* Index is not pointing at a valid entry. */ 332 if (sf_id == ROGUE_FW_SF_LAST) 333 return -EINVAL; 334 335 timestamp = ((u64)read_fw_trace(trace_seq_data, 1) << 32) | 336 read_fw_trace(trace_seq_data, 2); 337 timestamp = (timestamp & ~ROGUE_FWT_TIMESTAMP_TIME_CLRMSK) >> 338 ROGUE_FWT_TIMESTAMP_TIME_SHIFT; 339 340 seq_printf(s, "[%llu] : ", timestamp); 341 if (id == ROGUE_FW_SF_MAIN_ASSERT_FAILED) { 342 seq_printf(s, "ASSERTION %s failed at %s:%u", 343 trace_seq_data->assert_buf.info, 344 trace_seq_data->assert_buf.path, 345 trace_seq_data->assert_buf.line_num); 346 } else { 347 seq_printf(s, stid_fmts[sf_id].name, 348 read_fw_trace(trace_seq_data, 3), 349 read_fw_trace(trace_seq_data, 4), 350 read_fw_trace(trace_seq_data, 5), 351 read_fw_trace(trace_seq_data, 6), 352 read_fw_trace(trace_seq_data, 7), 353 read_fw_trace(trace_seq_data, 8), 354 read_fw_trace(trace_seq_data, 9), 355 read_fw_trace(trace_seq_data, 10), 356 read_fw_trace(trace_seq_data, 11), 357 read_fw_trace(trace_seq_data, 12), 358 read_fw_trace(trace_seq_data, 13), 359 read_fw_trace(trace_seq_data, 14), 360 read_fw_trace(trace_seq_data, 15), 361 read_fw_trace(trace_seq_data, 16), 362 read_fw_trace(trace_seq_data, 17), 363 read_fw_trace(trace_seq_data, 18), 364 read_fw_trace(trace_seq_data, 19), 365 read_fw_trace(trace_seq_data, 20), 366 read_fw_trace(trace_seq_data, 21), 367 read_fw_trace(trace_seq_data, 22)); 368 } 369 seq_puts(s, "\n"); 370 return 0; 371 } 372 373 static const struct seq_operations pvr_fw_trace_seq_ops = { 374 .start = fw_trace_seq_start, 375 .next = fw_trace_seq_next, 376 .stop = fw_trace_seq_stop, 377 .show = fw_trace_seq_show 378 }; 379 380 static int fw_trace_open(struct inode *inode, struct file *file) 381 { 382 struct pvr_fw_trace_buffer *trace_buffer = inode->i_private; 383 struct rogue_fwif_tracebuf_space *tracebuf_space = 384 trace_buffer->tracebuf_space; 385 struct pvr_fw_trace_seq_data *trace_seq_data; 386 int err; 387 388 trace_seq_data = kzalloc(sizeof(*trace_seq_data), GFP_KERNEL); 389 if (!trace_seq_data) 390 return -ENOMEM; 391 392 trace_seq_data->buffer = kcalloc(ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS, 393 sizeof(*trace_seq_data->buffer), GFP_KERNEL); 394 if (!trace_seq_data->buffer) { 395 err = -ENOMEM; 396 goto err_free_data; 397 } 398 399 /* 400 * Take a local copy of the trace buffer, as firmware may still be 401 * writing to it. This will exist as long as this file is open. 402 */ 403 memcpy(trace_seq_data->buffer, trace_buffer->buf, 404 ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS * sizeof(u32)); 405 trace_seq_data->start_offset = READ_ONCE(tracebuf_space->trace_pointer); 406 trace_seq_data->assert_buf = tracebuf_space->assert_buf; 407 fw_trace_get_first(trace_seq_data); 408 409 err = seq_open(file, &pvr_fw_trace_seq_ops); 410 if (err) 411 goto err_free_buffer; 412 413 ((struct seq_file *)file->private_data)->private = trace_seq_data; 414 415 return 0; 416 417 err_free_buffer: 418 kfree(trace_seq_data->buffer); 419 420 err_free_data: 421 kfree(trace_seq_data); 422 423 return err; 424 } 425 426 static int fw_trace_release(struct inode *inode, struct file *file) 427 { 428 struct pvr_fw_trace_seq_data *trace_seq_data = 429 ((struct seq_file *)file->private_data)->private; 430 431 seq_release(inode, file); 432 kfree(trace_seq_data->buffer); 433 kfree(trace_seq_data); 434 435 return 0; 436 } 437 438 static const struct file_operations pvr_fw_trace_fops = { 439 .owner = THIS_MODULE, 440 .open = fw_trace_open, 441 .read = seq_read, 442 .llseek = seq_lseek, 443 .release = fw_trace_release, 444 }; 445 446 void 447 pvr_fw_trace_mask_update(struct pvr_device *pvr_dev, u32 old_mask, u32 new_mask) 448 { 449 if (IS_ENABLED(CONFIG_DEBUG_FS) && old_mask != new_mask) 450 update_logtype(pvr_dev, new_mask); 451 } 452 453 void 454 pvr_fw_trace_debugfs_init(struct pvr_device *pvr_dev, struct dentry *dir) 455 { 456 struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace; 457 458 if (!IS_ENABLED(CONFIG_DEBUG_FS)) 459 return; 460 461 static_assert(ARRAY_SIZE(fw_trace->buffers) <= 10, 462 "The filename buffer is only large enough for a single-digit thread count"); 463 464 for (u32 thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); ++thread_nr) { 465 char filename[8]; 466 467 snprintf(filename, ARRAY_SIZE(filename), "trace_%u", thread_nr); 468 debugfs_create_file(filename, 0400, dir, 469 &fw_trace->buffers[thread_nr], 470 &pvr_fw_trace_fops); 471 } 472 } 473