1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2 /* Copyright (C) 2017-2018 Netronome Systems, Inc. */ 3 4 #include <linux/ethtool.h> 5 #include <linux/vmalloc.h> 6 7 #include "nfp_asm.h" 8 #include "nfp_main.h" 9 #include "nfpcore/nfp.h" 10 #include "nfpcore/nfp_nffw.h" 11 #include "nfpcore/nfp6000/nfp6000.h" 12 13 #define NFP_DUMP_SPEC_RTSYM "_abi_dump_spec" 14 15 #define ALIGN8(x) ALIGN(x, 8) 16 17 enum nfp_dumpspec_type { 18 NFP_DUMPSPEC_TYPE_CPP_CSR = 0, 19 NFP_DUMPSPEC_TYPE_XPB_CSR = 1, 20 NFP_DUMPSPEC_TYPE_ME_CSR = 2, 21 NFP_DUMPSPEC_TYPE_INDIRECT_ME_CSR = 3, 22 NFP_DUMPSPEC_TYPE_RTSYM = 4, 23 NFP_DUMPSPEC_TYPE_HWINFO = 5, 24 NFP_DUMPSPEC_TYPE_FWNAME = 6, 25 NFP_DUMPSPEC_TYPE_HWINFO_FIELD = 7, 26 NFP_DUMPSPEC_TYPE_PROLOG = 10000, 27 NFP_DUMPSPEC_TYPE_ERROR = 10001, 28 }; 29 30 /* The following structs must be carefully aligned so that they can be used to 31 * interpret the binary dumpspec and populate the dump data in a deterministic 32 * way. 33 */ 34 35 /* generic type plus length */ 36 struct nfp_dump_tl { 37 __be32 type; 38 __be32 length; /* chunk length to follow, aligned to 8 bytes */ 39 char data[0]; 40 }; 41 42 /* NFP CPP parameters */ 43 struct nfp_dumpspec_cpp_isl_id { 44 u8 target; 45 u8 action; 46 u8 token; 47 u8 island; 48 }; 49 50 struct nfp_dump_common_cpp { 51 struct nfp_dumpspec_cpp_isl_id cpp_id; 52 __be32 offset; /* address to start dump */ 53 __be32 dump_length; /* total bytes to dump, aligned to reg size */ 54 }; 55 56 /* CSR dumpables */ 57 struct nfp_dumpspec_csr { 58 struct nfp_dump_tl tl; 59 struct nfp_dump_common_cpp cpp; 60 __be32 register_width; /* in bits */ 61 }; 62 63 struct nfp_dumpspec_rtsym { 64 struct nfp_dump_tl tl; 65 char rtsym[0]; 66 }; 67 68 /* header for register dumpable */ 69 struct nfp_dump_csr { 70 struct nfp_dump_tl tl; 71 struct nfp_dump_common_cpp cpp; 72 __be32 register_width; /* in bits */ 73 __be32 error; /* error code encountered while reading */ 74 __be32 error_offset; /* offset being read when error occurred */ 75 }; 76 77 struct nfp_dump_rtsym { 78 struct nfp_dump_tl tl; 79 struct nfp_dump_common_cpp cpp; 80 __be32 error; /* error code encountered while reading */ 81 u8 padded_name_length; /* pad so data starts at 8 byte boundary */ 82 char rtsym[0]; 83 /* after padded_name_length, there is dump_length data */ 84 }; 85 86 struct nfp_dump_prolog { 87 struct nfp_dump_tl tl; 88 __be32 dump_level; 89 }; 90 91 struct nfp_dump_error { 92 struct nfp_dump_tl tl; 93 __be32 error; 94 char padding[4]; 95 char spec[0]; 96 }; 97 98 /* to track state through debug size calculation TLV traversal */ 99 struct nfp_level_size { 100 __be32 requested_level; /* input */ 101 u32 total_size; /* output */ 102 }; 103 104 /* to track state during debug dump creation TLV traversal */ 105 struct nfp_dump_state { 106 __be32 requested_level; /* input param */ 107 u32 dumped_size; /* adds up to size of dumped data */ 108 u32 buf_size; /* size of buffer pointer to by p */ 109 void *p; /* current point in dump buffer */ 110 }; 111 112 typedef int (*nfp_tlv_visit)(struct nfp_pf *pf, struct nfp_dump_tl *tl, 113 void *param); 114 115 static int 116 nfp_traverse_tlvs(struct nfp_pf *pf, void *data, u32 data_length, void *param, 117 nfp_tlv_visit tlv_visit) 118 { 119 long long remaining = data_length; 120 struct nfp_dump_tl *tl; 121 u32 total_tlv_size; 122 void *p = data; 123 int err; 124 125 while (remaining >= sizeof(*tl)) { 126 tl = p; 127 if (!tl->type && !tl->length) 128 break; 129 130 if (be32_to_cpu(tl->length) > remaining - sizeof(*tl)) 131 return -EINVAL; 132 133 total_tlv_size = sizeof(*tl) + be32_to_cpu(tl->length); 134 135 /* Spec TLVs should be aligned to 4 bytes. */ 136 if (total_tlv_size % 4 != 0) 137 return -EINVAL; 138 139 p += total_tlv_size; 140 remaining -= total_tlv_size; 141 err = tlv_visit(pf, tl, param); 142 if (err) 143 return err; 144 } 145 146 return 0; 147 } 148 149 static u32 nfp_get_numeric_cpp_id(struct nfp_dumpspec_cpp_isl_id *cpp_id) 150 { 151 return NFP_CPP_ISLAND_ID(cpp_id->target, cpp_id->action, cpp_id->token, 152 cpp_id->island); 153 } 154 155 struct nfp_dumpspec * 156 nfp_net_dump_load_dumpspec(struct nfp_cpp *cpp, struct nfp_rtsym_table *rtbl) 157 { 158 const struct nfp_rtsym *specsym; 159 struct nfp_dumpspec *dumpspec; 160 int bytes_read; 161 u64 sym_size; 162 163 specsym = nfp_rtsym_lookup(rtbl, NFP_DUMP_SPEC_RTSYM); 164 if (!specsym) 165 return NULL; 166 sym_size = nfp_rtsym_size(specsym); 167 168 /* expected size of this buffer is in the order of tens of kilobytes */ 169 dumpspec = vmalloc(sizeof(*dumpspec) + sym_size); 170 if (!dumpspec) 171 return NULL; 172 dumpspec->size = sym_size; 173 174 bytes_read = nfp_rtsym_read(cpp, specsym, 0, dumpspec->data, sym_size); 175 if (bytes_read != sym_size) { 176 vfree(dumpspec); 177 nfp_warn(cpp, "Debug dump specification read failed.\n"); 178 return NULL; 179 } 180 181 return dumpspec; 182 } 183 184 static int nfp_dump_error_tlv_size(struct nfp_dump_tl *spec) 185 { 186 return ALIGN8(sizeof(struct nfp_dump_error) + sizeof(*spec) + 187 be32_to_cpu(spec->length)); 188 } 189 190 static int nfp_calc_fwname_tlv_size(struct nfp_pf *pf) 191 { 192 u32 fwname_len = strlen(nfp_mip_name(pf->mip)); 193 194 return sizeof(struct nfp_dump_tl) + ALIGN8(fwname_len + 1); 195 } 196 197 static int nfp_calc_hwinfo_field_sz(struct nfp_pf *pf, struct nfp_dump_tl *spec) 198 { 199 u32 tl_len, key_len; 200 const char *value; 201 202 tl_len = be32_to_cpu(spec->length); 203 key_len = strnlen(spec->data, tl_len); 204 if (key_len == tl_len) 205 return nfp_dump_error_tlv_size(spec); 206 207 value = nfp_hwinfo_lookup(pf->hwinfo, spec->data); 208 if (!value) 209 return nfp_dump_error_tlv_size(spec); 210 211 return sizeof(struct nfp_dump_tl) + ALIGN8(key_len + strlen(value) + 2); 212 } 213 214 static bool nfp_csr_spec_valid(struct nfp_dumpspec_csr *spec_csr) 215 { 216 u32 required_read_sz = sizeof(*spec_csr) - sizeof(spec_csr->tl); 217 u32 available_sz = be32_to_cpu(spec_csr->tl.length); 218 u32 reg_width; 219 220 if (available_sz < required_read_sz) 221 return false; 222 223 reg_width = be32_to_cpu(spec_csr->register_width); 224 225 return reg_width == 32 || reg_width == 64; 226 } 227 228 static int 229 nfp_calc_rtsym_dump_sz(struct nfp_pf *pf, struct nfp_dump_tl *spec) 230 { 231 struct nfp_rtsym_table *rtbl = pf->rtbl; 232 struct nfp_dumpspec_rtsym *spec_rtsym; 233 const struct nfp_rtsym *sym; 234 u32 tl_len, key_len; 235 236 spec_rtsym = (struct nfp_dumpspec_rtsym *)spec; 237 tl_len = be32_to_cpu(spec->length); 238 key_len = strnlen(spec_rtsym->rtsym, tl_len); 239 if (key_len == tl_len) 240 return nfp_dump_error_tlv_size(spec); 241 242 sym = nfp_rtsym_lookup(rtbl, spec_rtsym->rtsym); 243 if (!sym) 244 return nfp_dump_error_tlv_size(spec); 245 246 return ALIGN8(offsetof(struct nfp_dump_rtsym, rtsym) + key_len + 1) + 247 ALIGN8(nfp_rtsym_size(sym)); 248 } 249 250 static int 251 nfp_add_tlv_size(struct nfp_pf *pf, struct nfp_dump_tl *tl, void *param) 252 { 253 struct nfp_dumpspec_csr *spec_csr; 254 u32 *size = param; 255 u32 hwinfo_size; 256 257 switch (be32_to_cpu(tl->type)) { 258 case NFP_DUMPSPEC_TYPE_FWNAME: 259 *size += nfp_calc_fwname_tlv_size(pf); 260 break; 261 case NFP_DUMPSPEC_TYPE_CPP_CSR: 262 case NFP_DUMPSPEC_TYPE_XPB_CSR: 263 case NFP_DUMPSPEC_TYPE_ME_CSR: 264 spec_csr = (struct nfp_dumpspec_csr *)tl; 265 if (!nfp_csr_spec_valid(spec_csr)) 266 *size += nfp_dump_error_tlv_size(tl); 267 else 268 *size += ALIGN8(sizeof(struct nfp_dump_csr)) + 269 ALIGN8(be32_to_cpu(spec_csr->cpp.dump_length)); 270 break; 271 case NFP_DUMPSPEC_TYPE_INDIRECT_ME_CSR: 272 spec_csr = (struct nfp_dumpspec_csr *)tl; 273 if (!nfp_csr_spec_valid(spec_csr)) 274 *size += nfp_dump_error_tlv_size(tl); 275 else 276 *size += ALIGN8(sizeof(struct nfp_dump_csr)) + 277 ALIGN8(be32_to_cpu(spec_csr->cpp.dump_length) * 278 NFP_IND_NUM_CONTEXTS); 279 break; 280 case NFP_DUMPSPEC_TYPE_RTSYM: 281 *size += nfp_calc_rtsym_dump_sz(pf, tl); 282 break; 283 case NFP_DUMPSPEC_TYPE_HWINFO: 284 hwinfo_size = nfp_hwinfo_get_packed_str_size(pf->hwinfo); 285 *size += sizeof(struct nfp_dump_tl) + ALIGN8(hwinfo_size); 286 break; 287 case NFP_DUMPSPEC_TYPE_HWINFO_FIELD: 288 *size += nfp_calc_hwinfo_field_sz(pf, tl); 289 break; 290 default: 291 *size += nfp_dump_error_tlv_size(tl); 292 break; 293 } 294 295 return 0; 296 } 297 298 static int 299 nfp_calc_specific_level_size(struct nfp_pf *pf, struct nfp_dump_tl *dump_level, 300 void *param) 301 { 302 struct nfp_level_size *lev_sz = param; 303 304 if (dump_level->type != lev_sz->requested_level) 305 return 0; 306 307 return nfp_traverse_tlvs(pf, dump_level->data, 308 be32_to_cpu(dump_level->length), 309 &lev_sz->total_size, nfp_add_tlv_size); 310 } 311 312 s64 nfp_net_dump_calculate_size(struct nfp_pf *pf, struct nfp_dumpspec *spec, 313 u32 flag) 314 { 315 struct nfp_level_size lev_sz; 316 int err; 317 318 lev_sz.requested_level = cpu_to_be32(flag); 319 lev_sz.total_size = ALIGN8(sizeof(struct nfp_dump_prolog)); 320 321 err = nfp_traverse_tlvs(pf, spec->data, spec->size, &lev_sz, 322 nfp_calc_specific_level_size); 323 if (err) 324 return err; 325 326 return lev_sz.total_size; 327 } 328 329 static int nfp_add_tlv(u32 type, u32 total_tlv_sz, struct nfp_dump_state *dump) 330 { 331 struct nfp_dump_tl *tl = dump->p; 332 333 if (total_tlv_sz > dump->buf_size) 334 return -ENOSPC; 335 336 if (dump->buf_size - total_tlv_sz < dump->dumped_size) 337 return -ENOSPC; 338 339 tl->type = cpu_to_be32(type); 340 tl->length = cpu_to_be32(total_tlv_sz - sizeof(*tl)); 341 342 dump->dumped_size += total_tlv_sz; 343 dump->p += total_tlv_sz; 344 345 return 0; 346 } 347 348 static int 349 nfp_dump_error_tlv(struct nfp_dump_tl *spec, int error, 350 struct nfp_dump_state *dump) 351 { 352 struct nfp_dump_error *dump_header = dump->p; 353 u32 total_spec_size, total_size; 354 int err; 355 356 total_spec_size = sizeof(*spec) + be32_to_cpu(spec->length); 357 total_size = ALIGN8(sizeof(*dump_header) + total_spec_size); 358 359 err = nfp_add_tlv(NFP_DUMPSPEC_TYPE_ERROR, total_size, dump); 360 if (err) 361 return err; 362 363 dump_header->error = cpu_to_be32(error); 364 memcpy(dump_header->spec, spec, total_spec_size); 365 366 return 0; 367 } 368 369 static int nfp_dump_fwname(struct nfp_pf *pf, struct nfp_dump_state *dump) 370 { 371 struct nfp_dump_tl *dump_header = dump->p; 372 u32 fwname_len, total_size; 373 const char *fwname; 374 int err; 375 376 fwname = nfp_mip_name(pf->mip); 377 fwname_len = strlen(fwname); 378 total_size = sizeof(*dump_header) + ALIGN8(fwname_len + 1); 379 380 err = nfp_add_tlv(NFP_DUMPSPEC_TYPE_FWNAME, total_size, dump); 381 if (err) 382 return err; 383 384 memcpy(dump_header->data, fwname, fwname_len); 385 386 return 0; 387 } 388 389 static int 390 nfp_dump_hwinfo(struct nfp_pf *pf, struct nfp_dump_tl *spec, 391 struct nfp_dump_state *dump) 392 { 393 struct nfp_dump_tl *dump_header = dump->p; 394 u32 hwinfo_size, total_size; 395 char *hwinfo; 396 int err; 397 398 hwinfo = nfp_hwinfo_get_packed_strings(pf->hwinfo); 399 hwinfo_size = nfp_hwinfo_get_packed_str_size(pf->hwinfo); 400 total_size = sizeof(*dump_header) + ALIGN8(hwinfo_size); 401 402 err = nfp_add_tlv(NFP_DUMPSPEC_TYPE_HWINFO, total_size, dump); 403 if (err) 404 return err; 405 406 memcpy(dump_header->data, hwinfo, hwinfo_size); 407 408 return 0; 409 } 410 411 static int nfp_dump_hwinfo_field(struct nfp_pf *pf, struct nfp_dump_tl *spec, 412 struct nfp_dump_state *dump) 413 { 414 struct nfp_dump_tl *dump_header = dump->p; 415 u32 tl_len, key_len, val_len; 416 const char *key, *value; 417 u32 total_size; 418 int err; 419 420 tl_len = be32_to_cpu(spec->length); 421 key_len = strnlen(spec->data, tl_len); 422 if (key_len == tl_len) 423 return nfp_dump_error_tlv(spec, -EINVAL, dump); 424 425 key = spec->data; 426 value = nfp_hwinfo_lookup(pf->hwinfo, key); 427 if (!value) 428 return nfp_dump_error_tlv(spec, -ENOENT, dump); 429 430 val_len = strlen(value); 431 total_size = sizeof(*dump_header) + ALIGN8(key_len + val_len + 2); 432 err = nfp_add_tlv(NFP_DUMPSPEC_TYPE_HWINFO_FIELD, total_size, dump); 433 if (err) 434 return err; 435 436 memcpy(dump_header->data, key, key_len + 1); 437 memcpy(dump_header->data + key_len + 1, value, val_len + 1); 438 439 return 0; 440 } 441 442 static bool is_xpb_read(struct nfp_dumpspec_cpp_isl_id *cpp_id) 443 { 444 return cpp_id->target == NFP_CPP_TARGET_ISLAND_XPB && 445 cpp_id->action == 0 && cpp_id->token == 0; 446 } 447 448 static int 449 nfp_dump_csr_range(struct nfp_pf *pf, struct nfp_dumpspec_csr *spec_csr, 450 struct nfp_dump_state *dump) 451 { 452 struct nfp_dump_csr *dump_header = dump->p; 453 u32 reg_sz, header_size, total_size; 454 u32 cpp_rd_addr, max_rd_addr; 455 int bytes_read; 456 void *dest; 457 u32 cpp_id; 458 int err; 459 460 if (!nfp_csr_spec_valid(spec_csr)) 461 return nfp_dump_error_tlv(&spec_csr->tl, -EINVAL, dump); 462 463 reg_sz = be32_to_cpu(spec_csr->register_width) / BITS_PER_BYTE; 464 header_size = ALIGN8(sizeof(*dump_header)); 465 total_size = header_size + 466 ALIGN8(be32_to_cpu(spec_csr->cpp.dump_length)); 467 dest = dump->p + header_size; 468 469 err = nfp_add_tlv(be32_to_cpu(spec_csr->tl.type), total_size, dump); 470 if (err) 471 return err; 472 473 dump_header->cpp = spec_csr->cpp; 474 dump_header->register_width = spec_csr->register_width; 475 476 cpp_id = nfp_get_numeric_cpp_id(&spec_csr->cpp.cpp_id); 477 cpp_rd_addr = be32_to_cpu(spec_csr->cpp.offset); 478 max_rd_addr = cpp_rd_addr + be32_to_cpu(spec_csr->cpp.dump_length); 479 480 while (cpp_rd_addr < max_rd_addr) { 481 if (is_xpb_read(&spec_csr->cpp.cpp_id)) { 482 err = nfp_xpb_readl(pf->cpp, cpp_rd_addr, (u32 *)dest); 483 } else { 484 bytes_read = nfp_cpp_read(pf->cpp, cpp_id, cpp_rd_addr, 485 dest, reg_sz); 486 err = bytes_read == reg_sz ? 0 : -EIO; 487 } 488 if (err) { 489 dump_header->error = cpu_to_be32(err); 490 dump_header->error_offset = cpu_to_be32(cpp_rd_addr); 491 break; 492 } 493 cpp_rd_addr += reg_sz; 494 dest += reg_sz; 495 } 496 497 return 0; 498 } 499 500 /* Write context to CSRCtxPtr, then read from it. Then the value can be read 501 * from IndCtxStatus. 502 */ 503 static int 504 nfp_read_indirect_csr(struct nfp_cpp *cpp, 505 struct nfp_dumpspec_cpp_isl_id cpp_params, u32 offset, 506 u32 reg_sz, u32 context, void *dest) 507 { 508 u32 csr_ctx_ptr_offs; 509 u32 cpp_id; 510 int result; 511 512 csr_ctx_ptr_offs = nfp_get_ind_csr_ctx_ptr_offs(offset); 513 cpp_id = NFP_CPP_ISLAND_ID(cpp_params.target, 514 NFP_IND_ME_REFL_WR_SIG_INIT, 515 cpp_params.token, cpp_params.island); 516 result = nfp_cpp_writel(cpp, cpp_id, csr_ctx_ptr_offs, context); 517 if (result) 518 return result; 519 520 cpp_id = nfp_get_numeric_cpp_id(&cpp_params); 521 result = nfp_cpp_read(cpp, cpp_id, csr_ctx_ptr_offs, dest, reg_sz); 522 if (result != reg_sz) 523 return result < 0 ? result : -EIO; 524 525 result = nfp_cpp_read(cpp, cpp_id, offset, dest, reg_sz); 526 if (result != reg_sz) 527 return result < 0 ? result : -EIO; 528 529 return 0; 530 } 531 532 static int 533 nfp_read_all_indirect_csr_ctx(struct nfp_cpp *cpp, 534 struct nfp_dumpspec_csr *spec_csr, u32 address, 535 u32 reg_sz, void *dest) 536 { 537 u32 ctx; 538 int err; 539 540 for (ctx = 0; ctx < NFP_IND_NUM_CONTEXTS; ctx++) { 541 err = nfp_read_indirect_csr(cpp, spec_csr->cpp.cpp_id, address, 542 reg_sz, ctx, dest + ctx * reg_sz); 543 if (err) 544 return err; 545 } 546 547 return 0; 548 } 549 550 static int 551 nfp_dump_indirect_csr_range(struct nfp_pf *pf, 552 struct nfp_dumpspec_csr *spec_csr, 553 struct nfp_dump_state *dump) 554 { 555 struct nfp_dump_csr *dump_header = dump->p; 556 u32 reg_sz, header_size, total_size; 557 u32 cpp_rd_addr, max_rd_addr; 558 u32 reg_data_length; 559 void *dest; 560 int err; 561 562 if (!nfp_csr_spec_valid(spec_csr)) 563 return nfp_dump_error_tlv(&spec_csr->tl, -EINVAL, dump); 564 565 reg_sz = be32_to_cpu(spec_csr->register_width) / BITS_PER_BYTE; 566 header_size = ALIGN8(sizeof(*dump_header)); 567 reg_data_length = be32_to_cpu(spec_csr->cpp.dump_length) * 568 NFP_IND_NUM_CONTEXTS; 569 total_size = header_size + ALIGN8(reg_data_length); 570 dest = dump->p + header_size; 571 572 err = nfp_add_tlv(be32_to_cpu(spec_csr->tl.type), total_size, dump); 573 if (err) 574 return err; 575 576 dump_header->cpp = spec_csr->cpp; 577 dump_header->register_width = spec_csr->register_width; 578 579 cpp_rd_addr = be32_to_cpu(spec_csr->cpp.offset); 580 max_rd_addr = cpp_rd_addr + be32_to_cpu(spec_csr->cpp.dump_length); 581 while (cpp_rd_addr < max_rd_addr) { 582 err = nfp_read_all_indirect_csr_ctx(pf->cpp, spec_csr, 583 cpp_rd_addr, reg_sz, dest); 584 if (err) { 585 dump_header->error = cpu_to_be32(err); 586 dump_header->error_offset = cpu_to_be32(cpp_rd_addr); 587 break; 588 } 589 cpp_rd_addr += reg_sz; 590 dest += reg_sz * NFP_IND_NUM_CONTEXTS; 591 } 592 593 return 0; 594 } 595 596 static int 597 nfp_dump_single_rtsym(struct nfp_pf *pf, struct nfp_dumpspec_rtsym *spec, 598 struct nfp_dump_state *dump) 599 { 600 struct nfp_dump_rtsym *dump_header = dump->p; 601 struct nfp_dumpspec_cpp_isl_id cpp_params; 602 struct nfp_rtsym_table *rtbl = pf->rtbl; 603 u32 header_size, total_size, sym_size; 604 const struct nfp_rtsym *sym; 605 u32 tl_len, key_len; 606 int bytes_read; 607 void *dest; 608 int err; 609 610 tl_len = be32_to_cpu(spec->tl.length); 611 key_len = strnlen(spec->rtsym, tl_len); 612 if (key_len == tl_len) 613 return nfp_dump_error_tlv(&spec->tl, -EINVAL, dump); 614 615 sym = nfp_rtsym_lookup(rtbl, spec->rtsym); 616 if (!sym) 617 return nfp_dump_error_tlv(&spec->tl, -ENOENT, dump); 618 619 sym_size = nfp_rtsym_size(sym); 620 header_size = 621 ALIGN8(offsetof(struct nfp_dump_rtsym, rtsym) + key_len + 1); 622 total_size = header_size + ALIGN8(sym_size); 623 dest = dump->p + header_size; 624 625 err = nfp_add_tlv(be32_to_cpu(spec->tl.type), total_size, dump); 626 if (err) 627 return err; 628 629 dump_header->padded_name_length = 630 header_size - offsetof(struct nfp_dump_rtsym, rtsym); 631 memcpy(dump_header->rtsym, spec->rtsym, key_len + 1); 632 dump_header->cpp.dump_length = cpu_to_be32(sym_size); 633 634 if (sym->type != NFP_RTSYM_TYPE_ABS) { 635 cpp_params.target = sym->target; 636 cpp_params.action = NFP_CPP_ACTION_RW; 637 cpp_params.token = 0; 638 cpp_params.island = sym->domain; 639 dump_header->cpp.cpp_id = cpp_params; 640 dump_header->cpp.offset = cpu_to_be32(sym->addr); 641 } 642 643 bytes_read = nfp_rtsym_read(pf->cpp, sym, 0, dest, sym_size); 644 if (bytes_read != sym_size) { 645 if (bytes_read >= 0) 646 bytes_read = -EIO; 647 dump_header->error = cpu_to_be32(bytes_read); 648 } 649 650 return 0; 651 } 652 653 static int 654 nfp_dump_for_tlv(struct nfp_pf *pf, struct nfp_dump_tl *tl, void *param) 655 { 656 struct nfp_dumpspec_rtsym *spec_rtsym; 657 struct nfp_dump_state *dump = param; 658 struct nfp_dumpspec_csr *spec_csr; 659 int err; 660 661 switch (be32_to_cpu(tl->type)) { 662 case NFP_DUMPSPEC_TYPE_FWNAME: 663 err = nfp_dump_fwname(pf, dump); 664 if (err) 665 return err; 666 break; 667 case NFP_DUMPSPEC_TYPE_CPP_CSR: 668 case NFP_DUMPSPEC_TYPE_XPB_CSR: 669 case NFP_DUMPSPEC_TYPE_ME_CSR: 670 spec_csr = (struct nfp_dumpspec_csr *)tl; 671 err = nfp_dump_csr_range(pf, spec_csr, dump); 672 if (err) 673 return err; 674 break; 675 case NFP_DUMPSPEC_TYPE_INDIRECT_ME_CSR: 676 spec_csr = (struct nfp_dumpspec_csr *)tl; 677 err = nfp_dump_indirect_csr_range(pf, spec_csr, dump); 678 if (err) 679 return err; 680 break; 681 case NFP_DUMPSPEC_TYPE_RTSYM: 682 spec_rtsym = (struct nfp_dumpspec_rtsym *)tl; 683 err = nfp_dump_single_rtsym(pf, spec_rtsym, dump); 684 if (err) 685 return err; 686 break; 687 case NFP_DUMPSPEC_TYPE_HWINFO: 688 err = nfp_dump_hwinfo(pf, tl, dump); 689 if (err) 690 return err; 691 break; 692 case NFP_DUMPSPEC_TYPE_HWINFO_FIELD: 693 err = nfp_dump_hwinfo_field(pf, tl, dump); 694 if (err) 695 return err; 696 break; 697 default: 698 err = nfp_dump_error_tlv(tl, -EOPNOTSUPP, dump); 699 if (err) 700 return err; 701 } 702 703 return 0; 704 } 705 706 static int 707 nfp_dump_specific_level(struct nfp_pf *pf, struct nfp_dump_tl *dump_level, 708 void *param) 709 { 710 struct nfp_dump_state *dump = param; 711 712 if (dump_level->type != dump->requested_level) 713 return 0; 714 715 return nfp_traverse_tlvs(pf, dump_level->data, 716 be32_to_cpu(dump_level->length), dump, 717 nfp_dump_for_tlv); 718 } 719 720 static int nfp_dump_populate_prolog(struct nfp_dump_state *dump) 721 { 722 struct nfp_dump_prolog *prolog = dump->p; 723 u32 total_size; 724 int err; 725 726 total_size = ALIGN8(sizeof(*prolog)); 727 728 err = nfp_add_tlv(NFP_DUMPSPEC_TYPE_PROLOG, total_size, dump); 729 if (err) 730 return err; 731 732 prolog->dump_level = dump->requested_level; 733 734 return 0; 735 } 736 737 int nfp_net_dump_populate_buffer(struct nfp_pf *pf, struct nfp_dumpspec *spec, 738 struct ethtool_dump *dump_param, void *dest) 739 { 740 struct nfp_dump_state dump; 741 int err; 742 743 dump.requested_level = cpu_to_be32(dump_param->flag); 744 dump.dumped_size = 0; 745 dump.p = dest; 746 dump.buf_size = dump_param->len; 747 748 err = nfp_dump_populate_prolog(&dump); 749 if (err) 750 return err; 751 752 err = nfp_traverse_tlvs(pf, spec->data, spec->size, &dump, 753 nfp_dump_specific_level); 754 if (err) 755 return err; 756 757 /* Set size of actual dump, to trigger warning if different from 758 * calculated size. 759 */ 760 dump_param->len = dump.dumped_size; 761 762 return 0; 763 } 764