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 13 #include <linux/build_bug.h> 14 #include <linux/dcache.h> 15 #include <linux/sysfs.h> 16 #include <linux/types.h> 17 18 static void 19 tracebuf_ctrl_init(void *cpu_ptr, void *priv) 20 { 21 struct rogue_fwif_tracebuf *tracebuf_ctrl = cpu_ptr; 22 struct pvr_fw_trace *fw_trace = priv; 23 u32 thread_nr; 24 25 tracebuf_ctrl->tracebuf_size_in_dwords = ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS; 26 tracebuf_ctrl->tracebuf_flags = 0; 27 28 if (fw_trace->group_mask) 29 tracebuf_ctrl->log_type = fw_trace->group_mask | ROGUE_FWIF_LOG_TYPE_TRACE; 30 else 31 tracebuf_ctrl->log_type = ROGUE_FWIF_LOG_TYPE_NONE; 32 33 for (thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) { 34 struct rogue_fwif_tracebuf_space *tracebuf_space = 35 &tracebuf_ctrl->tracebuf[thread_nr]; 36 struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr]; 37 38 pvr_fw_object_get_fw_addr(trace_buffer->buf_obj, 39 &tracebuf_space->trace_buffer_fw_addr); 40 41 tracebuf_space->trace_buffer = trace_buffer->buf; 42 tracebuf_space->trace_pointer = 0; 43 } 44 } 45 46 int pvr_fw_trace_init(struct pvr_device *pvr_dev) 47 { 48 struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace; 49 struct drm_device *drm_dev = from_pvr_device(pvr_dev); 50 u32 thread_nr; 51 int err; 52 53 for (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 (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 (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 u32 thread_nr; 115 116 for (thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) { 117 struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr]; 118 119 pvr_fw_object_unmap_and_destroy(trace_buffer->buf_obj); 120 } 121 pvr_fw_object_unmap_and_destroy(fw_trace->tracebuf_ctrl_obj); 122 } 123 124 #if defined(CONFIG_DEBUG_FS) 125 126 /** 127 * update_logtype() - Send KCCB command to trigger FW to update logtype 128 * @pvr_dev: Target PowerVR device 129 * @group_mask: New log group mask. 130 * 131 * Returns: 132 * * 0 on success, 133 * * Any error returned by pvr_kccb_send_cmd(), or 134 * * -%EIO if the device is lost. 135 */ 136 static int 137 update_logtype(struct pvr_device *pvr_dev, u32 group_mask) 138 { 139 struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace; 140 struct rogue_fwif_kccb_cmd cmd; 141 int idx; 142 int err; 143 144 if (group_mask) 145 fw_trace->tracebuf_ctrl->log_type = ROGUE_FWIF_LOG_TYPE_TRACE | group_mask; 146 else 147 fw_trace->tracebuf_ctrl->log_type = ROGUE_FWIF_LOG_TYPE_NONE; 148 149 fw_trace->group_mask = group_mask; 150 151 down_read(&pvr_dev->reset_sem); 152 if (!drm_dev_enter(from_pvr_device(pvr_dev), &idx)) { 153 err = -EIO; 154 goto err_up_read; 155 } 156 157 cmd.cmd_type = ROGUE_FWIF_KCCB_CMD_LOGTYPE_UPDATE; 158 cmd.kccb_flags = 0; 159 160 err = pvr_kccb_send_cmd(pvr_dev, &cmd, NULL); 161 162 drm_dev_exit(idx); 163 164 err_up_read: 165 up_read(&pvr_dev->reset_sem); 166 167 return err; 168 } 169 170 struct pvr_fw_trace_seq_data { 171 /** @buffer: Pointer to copy of trace data. */ 172 u32 *buffer; 173 174 /** @start_offset: Starting offset in trace data, as reported by FW. */ 175 u32 start_offset; 176 177 /** @idx: Current index into trace data. */ 178 u32 idx; 179 180 /** @assert_buf: Trace assert buffer, as reported by FW. */ 181 struct rogue_fwif_file_info_buf assert_buf; 182 }; 183 184 static u32 find_sfid(u32 id) 185 { 186 u32 i; 187 188 for (i = 0; i < ARRAY_SIZE(stid_fmts); i++) { 189 if (stid_fmts[i].id == id) 190 return i; 191 } 192 193 return ROGUE_FW_SF_LAST; 194 } 195 196 static u32 read_fw_trace(struct pvr_fw_trace_seq_data *trace_seq_data, u32 offset) 197 { 198 u32 idx; 199 200 idx = trace_seq_data->idx + offset; 201 if (idx >= ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) 202 return 0; 203 204 idx = (idx + trace_seq_data->start_offset) % ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS; 205 return trace_seq_data->buffer[idx]; 206 } 207 208 /** 209 * fw_trace_get_next() - Advance trace index to next entry 210 * @trace_seq_data: Trace sequence data. 211 * 212 * Returns: 213 * * %true if trace index is now pointing to a valid entry, or 214 * * %false if trace index is pointing to an invalid entry, or has hit the end 215 * of the trace. 216 */ 217 static bool fw_trace_get_next(struct pvr_fw_trace_seq_data *trace_seq_data) 218 { 219 u32 id, sf_id; 220 221 while (trace_seq_data->idx < ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) { 222 id = read_fw_trace(trace_seq_data, 0); 223 trace_seq_data->idx++; 224 if (!ROGUE_FW_LOG_VALIDID(id)) 225 continue; 226 if (id == ROGUE_FW_SF_MAIN_ASSERT_FAILED) { 227 /* Assertion failure marks the end of the trace. */ 228 return false; 229 } 230 231 sf_id = find_sfid(id); 232 if (sf_id == ROGUE_FW_SF_FIRST) 233 continue; 234 if (sf_id == ROGUE_FW_SF_LAST) { 235 /* 236 * Could not match with an ID in the SF table, trace is 237 * most likely corrupt from this point. 238 */ 239 return false; 240 } 241 242 /* Skip over the timestamp, and any parameters. */ 243 trace_seq_data->idx += 2 + ROGUE_FW_SF_PARAMNUM(id); 244 245 /* Ensure index is now pointing to a valid trace entry. */ 246 id = read_fw_trace(trace_seq_data, 0); 247 if (!ROGUE_FW_LOG_VALIDID(id)) 248 continue; 249 250 return true; 251 } 252 253 /* Hit end of trace data. */ 254 return false; 255 } 256 257 /** 258 * fw_trace_get_first() - Find first valid entry in trace 259 * @trace_seq_data: Trace sequence data. 260 * 261 * Skips over invalid (usually zero) and ROGUE_FW_SF_FIRST entries. 262 * 263 * If the trace has no valid entries, this function will exit with the trace 264 * index pointing to the end of the trace. trace_seq_show() will return an error 265 * in this state. 266 */ 267 static void fw_trace_get_first(struct pvr_fw_trace_seq_data *trace_seq_data) 268 { 269 trace_seq_data->idx = 0; 270 271 while (trace_seq_data->idx < ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) { 272 u32 id = read_fw_trace(trace_seq_data, 0); 273 274 if (ROGUE_FW_LOG_VALIDID(id)) { 275 u32 sf_id = find_sfid(id); 276 277 if (sf_id != ROGUE_FW_SF_FIRST) 278 break; 279 } 280 trace_seq_data->idx++; 281 } 282 } 283 284 static void *fw_trace_seq_start(struct seq_file *s, loff_t *pos) 285 { 286 struct pvr_fw_trace_seq_data *trace_seq_data = s->private; 287 u32 i; 288 289 /* Reset trace index, then advance to *pos. */ 290 fw_trace_get_first(trace_seq_data); 291 292 for (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 = read_fw_trace(trace_seq_data, 1) | 336 ((u64)read_fw_trace(trace_seq_data, 2) << 32); 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 (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 u32 thread_nr; 458 459 static_assert(ARRAY_SIZE(fw_trace->buffers) <= 10, 460 "The filename buffer is only large enough for a single-digit thread count"); 461 462 for (thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); ++thread_nr) { 463 char filename[8]; 464 465 snprintf(filename, ARRAY_SIZE(filename), "trace_%u", thread_nr); 466 debugfs_create_file(filename, 0400, dir, 467 &fw_trace->buffers[thread_nr], 468 &pvr_fw_trace_fops); 469 } 470 } 471 #endif 472