1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (c) 2020 Marvell Semiconductor Inc. 3 * All rights reserved. 4 * www.marvell.com 5 */ 6 7 #ifndef _QED_DEBUG_H 8 #define _QED_DEBUG_H 9 10 /* Forward Declaration */ 11 struct ecore_dev; 12 enum ecore_dbg_features; 13 14 int qed_dbg_grc(struct ecore_dev *edev, void *buffer, u32 *num_dumped_bytes); 15 int qed_dbg_grc_size(struct ecore_dev *edev); 16 int qed_dbg_idle_chk(struct ecore_dev *edev, void *buffer, 17 u32 *num_dumped_bytes); 18 int qed_dbg_idle_chk_size(struct ecore_dev *edev); 19 int qed_dbg_reg_fifo(struct ecore_dev *edev, void *buffer, 20 u32 *num_dumped_bytes); 21 int qed_dbg_reg_fifo_size(struct ecore_dev *edev); 22 int qed_dbg_igu_fifo(struct ecore_dev *edev, void *buffer, 23 u32 *num_dumped_bytes); 24 int qed_dbg_igu_fifo_size(struct ecore_dev *edev); 25 int qed_dbg_protection_override(struct ecore_dev *edev, void *buffer, 26 u32 *num_dumped_bytes); 27 int qed_dbg_protection_override_size(struct ecore_dev *edev); 28 int qed_dbg_fw_asserts(struct ecore_dev *edev, void *buffer, 29 u32 *num_dumped_bytes); 30 int qed_dbg_fw_asserts_size(struct ecore_dev *edev); 31 int qed_dbg_ilt(struct ecore_dev *edev, void *buffer, u32 *num_dumped_bytes); 32 int qed_dbg_ilt_size(struct ecore_dev *edev); 33 int qed_dbg_mcp_trace(struct ecore_dev *edev, void *buffer, 34 u32 *num_dumped_bytes); 35 int qed_dbg_mcp_trace_size(struct ecore_dev *edev); 36 int qed_dbg_all_data(struct ecore_dev *edev, void *buffer); 37 int qed_dbg_all_data_size(struct ecore_dev *edev); 38 u8 qed_get_debug_engine(struct ecore_dev *edev); 39 void qed_set_debug_engine(struct ecore_dev *edev, int engine_number); 40 int qed_dbg_feature(struct ecore_dev *edev, void *buffer, 41 enum ecore_dbg_features feature, u32 *num_dumped_bytes); 42 int 43 qed_dbg_feature_size(struct ecore_dev *edev, enum ecore_dbg_features feature); 44 45 void qed_dbg_pf_init(struct ecore_dev *edev); 46 void qed_dbg_pf_exit(struct ecore_dev *edev); 47 48 /***************************** Public Functions *******************************/ 49 50 /** 51 * @brief qed_dbg_set_bin_ptr - Sets a pointer to the binary data with debug 52 * arrays. 53 * 54 * @param p_hwfn - HW device data 55 * @param bin_ptr - a pointer to the binary data with debug arrays. 56 */ 57 enum dbg_status qed_dbg_set_bin_ptr(struct ecore_hwfn *p_hwfn, 58 const u8 * const bin_ptr); 59 60 /** 61 * @brief qed_dbg_set_app_ver - Sets the version of the calling app. 62 * 63 * The application should call this function with the TOOLS_VERSION 64 * it compiles with. Must be called before all other debug functions. 65 * 66 * @return error if one of the following holds: 67 * - the specified app version is not supported 68 * Otherwise, returns ok. 69 */ 70 enum dbg_status qed_dbg_set_app_ver(u32 ver); 71 72 /** 73 * @brief qed_read_regs - Reads registers into a buffer (using GRC). 74 * 75 * @param p_hwfn - HW device data 76 * @param p_ptt - Ptt window used for writing the registers. 77 * @param buf - Destination buffer. 78 * @param addr - Source GRC address in dwords. 79 * @param len - Number of registers to read. 80 */ 81 void qed_read_regs(struct ecore_hwfn *p_hwfn, 82 struct ecore_ptt *p_ptt, u32 *buf, u32 addr, u32 len); 83 84 /** 85 * @brief qed_read_fw_info - Reads FW info from the chip. 86 * 87 * The FW info contains FW-related information, such as the FW version, 88 * FW image (main/L2B/kuku), FW timestamp, etc. 89 * The FW info is read from the internal RAM of the first Storm that is not in 90 * reset. 91 * 92 * @param p_hwfn - HW device data 93 * @param p_ptt - Ptt window used for writing the registers. 94 * @param fw_info - Out: a pointer to write the FW info into. 95 * 96 * @return true if the FW info was read successfully from one of the Storms, 97 * or false if all Storms are in reset. 98 */ 99 bool qed_read_fw_info(struct ecore_hwfn *p_hwfn, 100 struct ecore_ptt *p_ptt, struct fw_info *fw_info); 101 /** 102 * @brief qed_dbg_grc_config - Sets the value of a GRC parameter. 103 * 104 * @param p_hwfn - HW device data 105 * @param grc_param - GRC parameter 106 * @param val - Value to set. 107 * 108 * @return error if one of the following holds: 109 * - the version wasn't set 110 * - grc_param is invalid 111 * - val is outside the allowed boundaries 112 */ 113 enum dbg_status qed_dbg_grc_config(struct ecore_hwfn *p_hwfn, 114 enum dbg_grc_params grc_param, u32 val); 115 116 /** 117 * @brief qed_dbg_grc_set_params_default - Reverts all GRC parameters to their 118 * default value. 119 * 120 * @param p_hwfn - HW device data 121 */ 122 void qed_dbg_grc_set_params_default(struct ecore_hwfn *p_hwfn); 123 /** 124 * @brief qed_dbg_grc_get_dump_buf_size - Returns the required buffer size for 125 * GRC Dump. 126 * 127 * @param p_hwfn - HW device data 128 * @param p_ptt - Ptt window used for writing the registers. 129 * @param buf_size - OUT: required buffer size (in dwords) for the GRC Dump 130 * data. 131 * 132 * @return error if one of the following holds: 133 * - the version wasn't set 134 * Otherwise, returns ok. 135 */ 136 enum dbg_status qed_dbg_grc_get_dump_buf_size(struct ecore_hwfn *p_hwfn, 137 struct ecore_ptt *p_ptt, 138 u32 *buf_size); 139 140 /** 141 * @brief qed_dbg_grc_dump - Dumps GRC data into the specified buffer. 142 * 143 * @param p_hwfn - HW device data 144 * @param p_ptt - Ptt window used for writing the registers. 145 * @param dump_buf - Pointer to write the collected GRC data into. 146 * @param buf_size_in_dwords - Size of the specified buffer in dwords. 147 * @param num_dumped_dwords - OUT: number of dumped dwords. 148 * 149 * @return error if one of the following holds: 150 * - the version wasn't set 151 * - the specified dump buffer is too small 152 * Otherwise, returns ok. 153 */ 154 enum dbg_status qed_dbg_grc_dump(struct ecore_hwfn *p_hwfn, 155 struct ecore_ptt *p_ptt, 156 u32 *dump_buf, 157 u32 buf_size_in_dwords, 158 u32 *num_dumped_dwords); 159 /** 160 * @brief qed_dbg_idle_chk_get_dump_buf_size - Returns the required buffer size 161 * for idle check results. 162 * 163 * @param p_hwfn - HW device data 164 * @param p_ptt - Ptt window used for writing the registers. 165 * @param buf_size - OUT: required buffer size (in dwords) for the idle check 166 * data. 167 * 168 * @return error if one of the following holds: 169 * - the version wasn't set 170 * Otherwise, returns ok. 171 */ 172 enum dbg_status qed_dbg_idle_chk_get_dump_buf_size(struct ecore_hwfn *p_hwfn, 173 struct ecore_ptt *p_ptt, 174 u32 *buf_size); 175 176 /** 177 * @brief qed_dbg_idle_chk_dump - Performs idle check and writes the results 178 * into the specified buffer. 179 * 180 * @param p_hwfn - HW device data 181 * @param p_ptt - Ptt window used for writing the registers. 182 * @param dump_buf - Pointer to write the idle check data into. 183 * @param buf_size_in_dwords - Size of the specified buffer in dwords. 184 * @param num_dumped_dwords - OUT: number of dumped dwords. 185 * 186 * @return error if one of the following holds: 187 * - the version wasn't set 188 * - the specified buffer is too small 189 * Otherwise, returns ok. 190 */ 191 enum dbg_status qed_dbg_idle_chk_dump(struct ecore_hwfn *p_hwfn, 192 struct ecore_ptt *p_ptt, 193 u32 *dump_buf, 194 u32 buf_size_in_dwords, 195 u32 *num_dumped_dwords); 196 197 /** 198 * @brief qed_dbg_mcp_trace_get_dump_buf_size - Returns the required buffer size 199 * for mcp trace results. 200 * 201 * @param p_hwfn - HW device data 202 * @param p_ptt - Ptt window used for writing the registers. 203 * @param buf_size - OUT: required buffer size (in dwords) for mcp trace data. 204 * 205 * @return error if one of the following holds: 206 * - the version wasn't set 207 * - the trace data in MCP scratchpad contain an invalid signature 208 * - the bundle ID in NVRAM is invalid 209 * - the trace meta data cannot be found (in NVRAM or image file) 210 * Otherwise, returns ok. 211 */ 212 enum dbg_status qed_dbg_mcp_trace_get_dump_buf_size(struct ecore_hwfn *p_hwfn, 213 struct ecore_ptt *p_ptt, 214 u32 *buf_size); 215 216 /** 217 * @brief qed_dbg_mcp_trace_dump - Performs mcp trace and writes the results 218 * into the specified buffer. 219 * 220 * @param p_hwfn - HW device data 221 * @param p_ptt - Ptt window used for writing the registers. 222 * @param dump_buf - Pointer to write the mcp trace data into. 223 * @param buf_size_in_dwords - Size of the specified buffer in dwords. 224 * @param num_dumped_dwords - OUT: number of dumped dwords. 225 * 226 * @return error if one of the following holds: 227 * - the version wasn't set 228 * - the specified buffer is too small 229 * - the trace data in MCP scratchpad contain an invalid signature 230 * - the bundle ID in NVRAM is invalid 231 * - the trace meta data cannot be found (in NVRAM or image file) 232 * - the trace meta data cannot be read (from NVRAM or image file) 233 * Otherwise, returns ok. 234 */ 235 enum dbg_status qed_dbg_mcp_trace_dump(struct ecore_hwfn *p_hwfn, 236 struct ecore_ptt *p_ptt, 237 u32 *dump_buf, 238 u32 buf_size_in_dwords, 239 u32 *num_dumped_dwords); 240 241 /** 242 * @brief qed_dbg_reg_fifo_get_dump_buf_size - Returns the required buffer size 243 * for grc trace fifo results. 244 * 245 * @param p_hwfn - HW device data 246 * @param p_ptt - Ptt window used for writing the registers. 247 * @param buf_size - OUT: required buffer size (in dwords) for reg fifo data. 248 * 249 * @return error if one of the following holds: 250 * - the version wasn't set 251 * Otherwise, returns ok. 252 */ 253 enum dbg_status qed_dbg_reg_fifo_get_dump_buf_size(struct ecore_hwfn *p_hwfn, 254 struct ecore_ptt *p_ptt, 255 u32 *buf_size); 256 257 /** 258 * @brief qed_dbg_reg_fifo_dump - Reads the reg fifo and writes the results into 259 * the specified buffer. 260 * 261 * @param p_hwfn - HW device data 262 * @param p_ptt - Ptt window used for writing the registers. 263 * @param dump_buf - Pointer to write the reg fifo data into. 264 * @param buf_size_in_dwords - Size of the specified buffer in dwords. 265 * @param num_dumped_dwords - OUT: number of dumped dwords. 266 * 267 * @return error if one of the following holds: 268 * - the version wasn't set 269 * - the specified buffer is too small 270 * - DMAE transaction failed 271 * Otherwise, returns ok. 272 */ 273 enum dbg_status qed_dbg_reg_fifo_dump(struct ecore_hwfn *p_hwfn, 274 struct ecore_ptt *p_ptt, 275 u32 *dump_buf, 276 u32 buf_size_in_dwords, 277 u32 *num_dumped_dwords); 278 279 /** 280 * @brief qed_dbg_igu_fifo_get_dump_buf_size - Returns the required buffer size 281 * for the IGU fifo results. 282 * 283 * @param p_hwfn - HW device data 284 * @param p_ptt - Ptt window used for writing the registers. 285 * @param buf_size - OUT: required buffer size (in dwords) for the IGU fifo 286 * data. 287 * 288 * @return error if one of the following holds: 289 * - the version wasn't set 290 * Otherwise, returns ok. 291 */ 292 enum dbg_status qed_dbg_igu_fifo_get_dump_buf_size(struct ecore_hwfn *p_hwfn, 293 struct ecore_ptt *p_ptt, 294 u32 *buf_size); 295 296 /** 297 * @brief qed_dbg_igu_fifo_dump - Reads the IGU fifo and writes the results into 298 * the specified buffer. 299 * 300 * @param p_hwfn - HW device data 301 * @param p_ptt - Ptt window used for writing the registers. 302 * @param dump_buf - Pointer to write the IGU fifo data into. 303 * @param buf_size_in_dwords - Size of the specified buffer in dwords. 304 * @param num_dumped_dwords - OUT: number of dumped dwords. 305 * 306 * @return error if one of the following holds: 307 * - the version wasn't set 308 * - the specified buffer is too small 309 * - DMAE transaction failed 310 * Otherwise, returns ok. 311 */ 312 enum dbg_status qed_dbg_igu_fifo_dump(struct ecore_hwfn *p_hwfn, 313 struct ecore_ptt *p_ptt, 314 u32 *dump_buf, 315 u32 buf_size_in_dwords, 316 u32 *num_dumped_dwords); 317 318 /** 319 * @brief qed_dbg_protection_override_get_dump_buf_size - Returns the required 320 * buffer size for protection override window results. 321 * 322 * @param p_hwfn - HW device data 323 * @param p_ptt - Ptt window used for writing the registers. 324 * @param buf_size - OUT: required buffer size (in dwords) for protection 325 * override data. 326 * 327 * @return error if one of the following holds: 328 * - the version wasn't set 329 * Otherwise, returns ok. 330 */ 331 enum dbg_status 332 qed_dbg_protection_override_get_dump_buf_size(struct ecore_hwfn *p_hwfn, 333 struct ecore_ptt *p_ptt, 334 u32 *buf_size); 335 /** 336 * @brief qed_dbg_protection_override_dump - Reads protection override window 337 * entries and writes the results into the specified buffer. 338 * 339 * @param p_hwfn - HW device data 340 * @param p_ptt - Ptt window used for writing the registers. 341 * @param dump_buf - Pointer to write the protection override data into. 342 * @param buf_size_in_dwords - Size of the specified buffer in dwords. 343 * @param num_dumped_dwords - OUT: number of dumped dwords. 344 * 345 * @return error if one of the following holds: 346 * - the version wasn't set 347 * - the specified buffer is too small 348 * - DMAE transaction failed 349 * Otherwise, returns ok. 350 */ 351 enum dbg_status qed_dbg_protection_override_dump(struct ecore_hwfn *p_hwfn, 352 struct ecore_ptt *p_ptt, 353 u32 *dump_buf, 354 u32 buf_size_in_dwords, 355 u32 *num_dumped_dwords); 356 /** 357 * @brief qed_dbg_fw_asserts_get_dump_buf_size - Returns the required buffer 358 * size for FW Asserts results. 359 * 360 * @param p_hwfn - HW device data 361 * @param p_ptt - Ptt window used for writing the registers. 362 * @param buf_size - OUT: required buffer size (in dwords) for FW Asserts data. 363 * 364 * @return error if one of the following holds: 365 * - the version wasn't set 366 * Otherwise, returns ok. 367 */ 368 enum dbg_status qed_dbg_fw_asserts_get_dump_buf_size(struct ecore_hwfn *p_hwfn, 369 struct ecore_ptt *p_ptt, 370 u32 *buf_size); 371 /** 372 * @brief qed_dbg_fw_asserts_dump - Reads the FW Asserts and writes the results 373 * into the specified buffer. 374 * 375 * @param p_hwfn - HW device data 376 * @param p_ptt - Ptt window used for writing the registers. 377 * @param dump_buf - Pointer to write the FW Asserts data into. 378 * @param buf_size_in_dwords - Size of the specified buffer in dwords. 379 * @param num_dumped_dwords - OUT: number of dumped dwords. 380 * 381 * @return error if one of the following holds: 382 * - the version wasn't set 383 * - the specified buffer is too small 384 * Otherwise, returns ok. 385 */ 386 enum dbg_status qed_dbg_fw_asserts_dump(struct ecore_hwfn *p_hwfn, 387 struct ecore_ptt *p_ptt, 388 u32 *dump_buf, 389 u32 buf_size_in_dwords, 390 u32 *num_dumped_dwords); 391 392 /** 393 * @brief qed_dbg_read_attn - Reads the attention registers of the specified 394 * block and type, and writes the results into the specified buffer. 395 * 396 * @param p_hwfn - HW device data 397 * @param p_ptt - Ptt window used for writing the registers. 398 * @param block - Block ID. 399 * @param attn_type - Attention type. 400 * @param clear_status - Indicates if the attention status should be cleared. 401 * @param results - OUT: Pointer to write the read results into 402 * 403 * @return error if one of the following holds: 404 * - the version wasn't set 405 * Otherwise, returns ok. 406 */ 407 enum dbg_status qed_dbg_read_attn(struct ecore_hwfn *p_hwfn, 408 struct ecore_ptt *p_ptt, 409 enum block_id block, 410 enum dbg_attn_type attn_type, 411 bool clear_status, 412 struct dbg_attn_block_result *results); 413 414 /** 415 * @brief qed_dbg_print_attn - Prints attention registers values in the 416 * specified results struct. 417 * 418 * @param p_hwfn 419 * @param results - Pointer to the attention read results 420 * 421 * @return error if one of the following holds: 422 * - the version wasn't set 423 * Otherwise, returns ok. 424 */ 425 enum dbg_status qed_dbg_print_attn(struct ecore_hwfn *p_hwfn, 426 struct dbg_attn_block_result *results); 427 428 /******************************* Data Types **********************************/ 429 430 struct mcp_trace_format { 431 u32 data; 432 #define MCP_TRACE_FORMAT_MODULE_MASK 0x0000ffff 433 #define MCP_TRACE_FORMAT_MODULE_OFFSET 0 434 #define MCP_TRACE_FORMAT_LEVEL_MASK 0x00030000 435 #define MCP_TRACE_FORMAT_LEVEL_OFFSET 16 436 #define MCP_TRACE_FORMAT_P1_SIZE_MASK 0x000c0000 437 #define MCP_TRACE_FORMAT_P1_SIZE_OFFSET 18 438 #define MCP_TRACE_FORMAT_P2_SIZE_MASK 0x00300000 439 #define MCP_TRACE_FORMAT_P2_SIZE_OFFSET 20 440 #define MCP_TRACE_FORMAT_P3_SIZE_MASK 0x00c00000 441 #define MCP_TRACE_FORMAT_P3_SIZE_OFFSET 22 442 #define MCP_TRACE_FORMAT_LEN_MASK 0xff000000 443 #define MCP_TRACE_FORMAT_LEN_OFFSET 24 444 445 char *format_str; 446 }; 447 448 /* MCP Trace Meta data structure */ 449 struct mcp_trace_meta { 450 u32 modules_num; 451 char **modules; 452 u32 formats_num; 453 struct mcp_trace_format *formats; 454 bool is_allocated; 455 }; 456 457 /* Debug Tools user data */ 458 struct dbg_tools_user_data { 459 struct mcp_trace_meta mcp_trace_meta; 460 const u32 *mcp_trace_user_meta_buf; 461 }; 462 463 /******************************** Constants **********************************/ 464 465 #define MAX_NAME_LEN 16 466 467 /***************************** Public Functions *******************************/ 468 469 /** 470 * @brief qed_dbg_user_set_bin_ptr - Sets a pointer to the binary data with 471 * debug arrays. 472 * 473 * @param p_hwfn - HW device data 474 * @param bin_ptr - a pointer to the binary data with debug arrays. 475 */ 476 enum dbg_status qed_dbg_user_set_bin_ptr(struct ecore_hwfn *p_hwfn, 477 const u8 * const bin_ptr); 478 479 /** 480 * @brief qed_dbg_alloc_user_data - Allocates user debug data. 481 * 482 * @param p_hwfn - HW device data 483 * @param user_data_ptr - OUT: a pointer to the allocated memory. 484 */ 485 enum dbg_status qed_dbg_alloc_user_data(struct ecore_hwfn *p_hwfn, 486 void **user_data_ptr); 487 488 /** 489 * @brief qed_dbg_get_status_str - Returns a string for the specified status. 490 * 491 * @param status - a debug status code. 492 * 493 * @return a string for the specified status 494 */ 495 const char *qed_dbg_get_status_str(enum dbg_status status); 496 497 /** 498 * @brief qed_get_idle_chk_results_buf_size - Returns the required buffer size 499 * for idle check results (in bytes). 500 * 501 * @param p_hwfn - HW device data 502 * @param dump_buf - idle check dump buffer. 503 * @param num_dumped_dwords - number of dwords that were dumped. 504 * @param results_buf_size - OUT: required buffer size (in bytes) for the parsed 505 * results. 506 * 507 * @return error if the parsing fails, ok otherwise. 508 */ 509 enum dbg_status qed_get_idle_chk_results_buf_size(struct ecore_hwfn *p_hwfn, 510 u32 *dump_buf, 511 u32 num_dumped_dwords, 512 u32 *results_buf_size); 513 /** 514 * @brief qed_print_idle_chk_results - Prints idle check results 515 * 516 * @param p_hwfn - HW device data 517 * @param dump_buf - idle check dump buffer. 518 * @param num_dumped_dwords - number of dwords that were dumped. 519 * @param results_buf - buffer for printing the idle check results. 520 * @param num_errors - OUT: number of errors found in idle check. 521 * @param num_warnings - OUT: number of warnings found in idle check. 522 * 523 * @return error if the parsing fails, ok otherwise. 524 */ 525 enum dbg_status qed_print_idle_chk_results(struct ecore_hwfn *p_hwfn, 526 u32 *dump_buf, 527 u32 num_dumped_dwords, 528 char *results_buf, 529 u32 *num_errors, 530 u32 *num_warnings); 531 532 /** 533 * @brief qed_dbg_mcp_trace_set_meta_data - Sets the MCP Trace meta data. 534 * 535 * Needed in case the MCP Trace dump doesn't contain the meta data (e.g. due to 536 * no NVRAM access). 537 * 538 * @param data - pointer to MCP Trace meta data 539 * @param size - size of MCP Trace meta data in dwords 540 */ 541 void qed_dbg_mcp_trace_set_meta_data(struct ecore_hwfn *p_hwfn, 542 const u32 *meta_buf); 543 544 /** 545 * @brief qed_get_mcp_trace_results_buf_size - Returns the required buffer size 546 * for MCP Trace results (in bytes). 547 * 548 * @param p_hwfn - HW device data 549 * @param dump_buf - MCP Trace dump buffer. 550 * @param num_dumped_dwords - number of dwords that were dumped. 551 * @param results_buf_size - OUT: required buffer size (in bytes) for the parsed 552 * results. 553 * 554 * @return error if the parsing fails, ok otherwise. 555 */ 556 enum dbg_status qed_get_mcp_trace_results_buf_size(struct ecore_hwfn *p_hwfn, 557 u32 *dump_buf, 558 u32 num_dumped_dwords, 559 u32 *results_buf_size); 560 561 /** 562 * @brief qed_print_mcp_trace_results - Prints MCP Trace results 563 * 564 * @param p_hwfn - HW device data 565 * @param dump_buf - mcp trace dump buffer, starting from the header. 566 * @param num_dumped_dwords - number of dwords that were dumped. 567 * @param results_buf - buffer for printing the mcp trace results. 568 * 569 * @return error if the parsing fails, ok otherwise. 570 */ 571 enum dbg_status qed_print_mcp_trace_results(struct ecore_hwfn *p_hwfn, 572 u32 *dump_buf, 573 u32 num_dumped_dwords, 574 char *results_buf); 575 576 /** 577 * @brief qed_print_mcp_trace_results_cont - Prints MCP Trace results, and 578 * keeps the MCP trace meta data allocated, to support continuous MCP Trace 579 * parsing. After the continuous parsing ends, mcp_trace_free_meta_data should 580 * be called to free the meta data. 581 * 582 * @param p_hwfn - HW device data 583 * @param dump_buf - mcp trace dump buffer, starting from the header. 584 * @param results_buf - buffer for printing the mcp trace results. 585 * 586 * @return error if the parsing fails, ok otherwise. 587 */ 588 enum dbg_status qed_print_mcp_trace_results_cont(struct ecore_hwfn *p_hwfn, 589 u32 *dump_buf, 590 char *results_buf); 591 592 /** 593 * @brief print_mcp_trace_line - Prints MCP Trace results for a single line 594 * 595 * @param p_hwfn - HW device data 596 * @param dump_buf - mcp trace dump buffer, starting from the header. 597 * @param num_dumped_bytes - number of bytes that were dumped. 598 * @param results_buf - buffer for printing the mcp trace results. 599 * 600 * @return error if the parsing fails, ok otherwise. 601 */ 602 enum dbg_status qed_print_mcp_trace_line(struct ecore_hwfn *p_hwfn, 603 u8 *dump_buf, 604 u32 num_dumped_bytes, 605 char *results_buf); 606 607 /** 608 * @brief mcp_trace_free_meta_data - Frees the MCP Trace meta data. 609 * Should be called after continuous MCP Trace parsing. 610 * 611 * @param p_hwfn - HW device data 612 */ 613 void qed_mcp_trace_free_meta_data(struct ecore_hwfn *p_hwfn); 614 615 /** 616 * @brief qed_get_reg_fifo_results_buf_size - Returns the required buffer size 617 * for reg_fifo results (in bytes). 618 * 619 * @param p_hwfn - HW device data 620 * @param dump_buf - reg fifo dump buffer. 621 * @param num_dumped_dwords - number of dwords that were dumped. 622 * @param results_buf_size - OUT: required buffer size (in bytes) for the parsed 623 * results. 624 * 625 * @return error if the parsing fails, ok otherwise. 626 */ 627 enum dbg_status qed_get_reg_fifo_results_buf_size(struct ecore_hwfn *p_hwfn, 628 u32 *dump_buf, 629 u32 num_dumped_dwords, 630 u32 *results_buf_size); 631 632 /** 633 * @brief qed_print_reg_fifo_results - Prints reg fifo results 634 * 635 * @param p_hwfn - HW device data 636 * @param dump_buf - reg fifo dump buffer, starting from the header. 637 * @param num_dumped_dwords - number of dwords that were dumped. 638 * @param results_buf - buffer for printing the reg fifo results. 639 * 640 * @return error if the parsing fails, ok otherwise. 641 */ 642 enum dbg_status qed_print_reg_fifo_results(struct ecore_hwfn *p_hwfn, 643 u32 *dump_buf, 644 u32 num_dumped_dwords, 645 char *results_buf); 646 647 /** 648 * @brief qed_get_igu_fifo_results_buf_size - Returns the required buffer size 649 * for igu_fifo results (in bytes). 650 * 651 * @param p_hwfn - HW device data 652 * @param dump_buf - IGU fifo dump buffer. 653 * @param num_dumped_dwords - number of dwords that were dumped. 654 * @param results_buf_size - OUT: required buffer size (in bytes) for the parsed 655 * results. 656 * 657 * @return error if the parsing fails, ok otherwise. 658 */ 659 enum dbg_status qed_get_igu_fifo_results_buf_size(struct ecore_hwfn *p_hwfn, 660 u32 *dump_buf, 661 u32 num_dumped_dwords, 662 u32 *results_buf_size); 663 664 /** 665 * @brief qed_print_igu_fifo_results - Prints IGU fifo results 666 * 667 * @param p_hwfn - HW device data 668 * @param dump_buf - IGU fifo dump buffer, starting from the header. 669 * @param num_dumped_dwords - number of dwords that were dumped. 670 * @param results_buf - buffer for printing the IGU fifo results. 671 * 672 * @return error if the parsing fails, ok otherwise. 673 */ 674 enum dbg_status qed_print_igu_fifo_results(struct ecore_hwfn *p_hwfn, 675 u32 *dump_buf, 676 u32 num_dumped_dwords, 677 char *results_buf); 678 679 /** 680 * @brief qed_get_protection_override_results_buf_size - Returns the required 681 * buffer size for protection override results (in bytes). 682 * 683 * @param p_hwfn - HW device data 684 * @param dump_buf - protection override dump buffer. 685 * @param num_dumped_dwords - number of dwords that were dumped. 686 * @param results_buf_size - OUT: required buffer size (in bytes) for the parsed 687 * results. 688 * 689 * @return error if the parsing fails, ok otherwise. 690 */ 691 enum dbg_status 692 qed_get_protection_override_results_buf_size(struct ecore_hwfn *p_hwfn, 693 u32 *dump_buf, 694 u32 num_dumped_dwords, 695 u32 *results_buf_size); 696 697 /** 698 * @brief qed_print_protection_override_results - Prints protection override 699 * results. 700 * 701 * @param p_hwfn - HW device data 702 * @param dump_buf - protection override dump buffer, starting from the header. 703 * @param num_dumped_dwords - number of dwords that were dumped. 704 * @param results_buf - buffer for printing the reg fifo results. 705 * 706 * @return error if the parsing fails, ok otherwise. 707 */ 708 enum dbg_status qed_print_protection_override_results(struct ecore_hwfn *p_hwfn, 709 u32 *dump_buf, 710 u32 num_dumped_dwords, 711 char *results_buf); 712 713 /** 714 * @brief qed_get_fw_asserts_results_buf_size - Returns the required buffer size 715 * for FW Asserts results (in bytes). 716 * 717 * @param p_hwfn - HW device data 718 * @param dump_buf - FW Asserts dump buffer. 719 * @param num_dumped_dwords - number of dwords that were dumped. 720 * @param results_buf_size - OUT: required buffer size (in bytes) for the parsed 721 * results. 722 * 723 * @return error if the parsing fails, ok otherwise. 724 */ 725 enum dbg_status qed_get_fw_asserts_results_buf_size(struct ecore_hwfn *p_hwfn, 726 u32 *dump_buf, 727 u32 num_dumped_dwords, 728 u32 *results_buf_size); 729 730 /** 731 * @brief qed_print_fw_asserts_results - Prints FW Asserts results 732 * 733 * @param p_hwfn - HW device data 734 * @param dump_buf - FW Asserts dump buffer, starting from the header. 735 * @param num_dumped_dwords - number of dwords that were dumped. 736 * @param results_buf - buffer for printing the FW Asserts results. 737 * 738 * @return error if the parsing fails, ok otherwise. 739 */ 740 enum dbg_status qed_print_fw_asserts_results(struct ecore_hwfn *p_hwfn, 741 u32 *dump_buf, 742 u32 num_dumped_dwords, 743 char *results_buf); 744 745 /** 746 * @brief qed_dbg_parse_attn - Parses and prints attention registers values in 747 * the specified results struct. 748 * 749 * @param p_hwfn - HW device data 750 * @param results - Pointer to the attention read results 751 * 752 * @return error if one of the following holds: 753 * - the version wasn't set 754 * Otherwise, returns ok. 755 */ 756 enum dbg_status qed_dbg_parse_attn(struct ecore_hwfn *p_hwfn, 757 struct dbg_attn_block_result *results); 758 759 #endif 760