diag.c (31566B)
1 /* 2 * 3 * 4 * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file. 5 * 6 * Copyright 2007-2019 Broadcom Inc. All rights reserved. 7 * 8 * Purpose: Common device register/mem diagnostic functions. 9 */ 10 #if defined(BCM_SAND_SUPPORT) || defined(BCM_ESW_SUPPORT) 11 #include <appl/diag/system.h> 12 #include <appl/diag/diag.h> 13 14 #include <shared/bsl.h> 15 #include <sdk_config.h> 16 17 #include <soc/cm.h> 18 #include <soc/drv.h> 19 #include <soc/error.h> 20 #include <soc/register.h> 21 #include <soc/mem.h> 22 #include <soc/mcm/memregs.h> 23 #include <soc/defs.h> 24 #ifdef BCM_IPROC_SUPPORT 25 #include <soc/iproc.h> 26 #endif 27 28 29 int diag_reg_bits(int unit, char* reg_name) 30 { 31 int reg_bits = 0; 32 soc_regaddrlist_t alist; 33 soc_regaddrinfo_t* ainfo; 34 35 if (!SOC_UNIT_VALID(unit)) 36 { 37 cli_out("Invalid unit.\n"); 38 return reg_bits; 39 } 40 41 if (reg_name == NULL) 42 { 43 return reg_bits; 44 } 45 46 if (soc_regaddrlist_alloc(&alist) < 0) 47 { 48 cli_out("Could not allocate address list. Memory error.\n"); 49 return reg_bits; 50 } 51 52 if (*reg_name == '$') 53 { 54 reg_name++; 55 } 56 /* Symbolic name given, print all or some values ... */ 57 if (parse_symbolic_reference(unit, &alist, reg_name) < 0) 58 { 59 cli_out("Syntax error parsing \"%s\"\n", reg_name); 60 } 61 else 62 { 63 if (alist.count > 1) 64 { 65 /* a list is not supported, only a single address */ 66 cli_out("Only a single address can be get bits %s.\n", reg_name); 67 } 68 else 69 { 70 ainfo = &alist.ainfo[0]; 71 reg_bits = soc_reg_bits(unit, ainfo->reg); 72 } 73 } 74 75 soc_regaddrlist_free(&alist); 76 return reg_bits; 77 } 78 79 80 int diag_reg_field_bits(int unit, char *reg_name, char* field_name) 81 { 82 int field_bits = 0; 83 soc_regaddrlist_t alist; 84 soc_regaddrinfo_t* ainfo; 85 soc_reg_info_t* reginfo; 86 int f; 87 88 if (!SOC_UNIT_VALID(unit)) 89 { 90 cli_out("Invalid unit.\n"); 91 return field_bits; 92 } 93 if (reg_name == NULL) 94 { 95 return field_bits; 96 } 97 98 if (soc_regaddrlist_alloc(&alist) < 0) 99 { 100 cli_out("Could not allocate address list. Memory error.\n"); 101 return field_bits; 102 } 103 104 if (*reg_name == '$') 105 { 106 reg_name++; 107 } 108 109 /* Symbolic name given, print all or some values ... */ 110 if (parse_symbolic_reference(unit, &alist, reg_name) < 0) 111 { 112 cli_out("Syntax error parsing \"%s\"\n", reg_name); 113 } 114 else 115 { 116 if (alist.count >1) 117 { 118 /* a list is not supported, only a single address */ 119 cli_out("Only a single address can be get field bits %s.\n", reg_name); 120 } 121 else 122 { 123 ainfo = &alist.ainfo[0]; 124 reginfo = &SOC_REG_INFO(unit, ainfo->reg); 125 126 /*search field by name*/ 127 for (f = reginfo->nFields - 1; f >= 0; f--) 128 { 129 soc_field_info_t *fld = ®info->fields[f]; 130 if (sal_strcasecmp(SOC_FIELD_NAME(unit, fld->field), field_name)) 131 { 132 continue; 133 } 134 field_bits = soc_reg_field_length(unit, ainfo->reg, fld->field); 135 break; 136 } 137 } 138 } 139 140 soc_regaddrlist_free(&alist); 141 return field_bits; 142 } 143 144 145 int diag_reg_get(int unit, char *name, reg_val value) 146 { 147 int rv = SOC_E_NONE; 148 soc_regaddrlist_t alist; 149 soc_regaddrinfo_t *ainfo; 150 151 if (!SOC_UNIT_VALID(unit)) { 152 cli_out("Invalid unit.\n"); 153 return SOC_E_UNIT; 154 } 155 156 if (name == NULL) { 157 return SOC_E_PARAM; 158 } 159 160 if (soc_regaddrlist_alloc(&alist) < 0) { 161 cli_out("Could not allocate address list. Memory error.\n"); 162 return SOC_E_PARAM; 163 } 164 165 if (*name == '$') { 166 name++; 167 } 168 /* Symbolic name given, print all or some values ... */ 169 if (parse_symbolic_reference(unit, &alist, name) < 0) { 170 cli_out("Syntax error parsing \"%s\"\n", name); 171 rv = SOC_E_PARAM; 172 } else { 173 if (alist.count > 1) { 174 /* a list is not supported, only a single address */ 175 cli_out("Only a single address can be read %s.\n", name); 176 rv = SOC_E_PARAM; 177 } else { 178 ainfo = &alist.ainfo[0]; 179 if (soc_cpureg == SOC_REG_INFO(unit, ainfo->reg).regtype) { 180 SOC_REG_ABOVE_64_CLEAR(value); 181 value[0] = soc_pci_read(unit, SOC_REG_INFO(unit, ainfo->reg).offset); 182 rv = BCM_E_NONE; 183 #ifdef BCM_IPROC_SUPPORT 184 } else if (soc_iprocreg == SOC_REG_INFO(unit,ainfo->reg).regtype) { 185 SOC_REG_ABOVE_64_CLEAR(value); 186 rv = soc_iproc_getreg(unit, SOC_REG_INFO(unit, ainfo->reg).offset, &(value[0])); 187 #endif 188 } else if (soc_customreg == SOC_REG_INFO(unit, ainfo->reg).regtype) { 189 rv = soc_custom_reg_above_64_get(unit, ainfo->reg, ainfo->port, ainfo->idx, value); 190 if (rv) { 191 char buf[80]; 192 soc_reg_sprint_addr(unit, buf, ainfo); 193 cli_out("ERROR: read from register %s failed: %s\n", buf, soc_errmsg(rv)); 194 } 195 } else if ((rv = soc_reg_above_64_get(unit, ainfo->reg, ainfo->port, ainfo->idx, value)) < 0) { 196 char buf[80]; 197 soc_reg_sprint_addr(unit, buf, ainfo); 198 cli_out("ERROR: read from register %s failed: %s\n", 199 buf, soc_errmsg(rv)); 200 } 201 } 202 } 203 soc_regaddrlist_free(&alist); 204 return rv; 205 } 206 207 /* Get a register field value by reading the register, and extracting the field from the read register. */ 208 int diag_reg_field_get(int unit, char *name, char* field_name, reg_val value) 209 { 210 int rv = SOC_E_NONE; 211 soc_regaddrlist_t alist; 212 soc_regaddrinfo_t *ainfo; 213 soc_reg_info_t *reginfo; 214 int f; 215 reg_val value_all; 216 int field_found = 0; 217 218 if (!SOC_UNIT_VALID(unit)) { 219 cli_out("Invalid unit.\n"); 220 return SOC_E_UNIT; 221 } 222 223 if (name == NULL) { 224 return SOC_E_PARAM; 225 } 226 227 if (soc_regaddrlist_alloc(&alist) < 0) { 228 cli_out("Could not allocate address list. Memory error.\n"); 229 return SOC_E_PARAM; 230 } 231 232 if (*name == '$') { 233 name++; 234 } 235 236 /* Symbolic name given, print all or some values ... */ 237 if (parse_symbolic_reference(unit, &alist, name) < 0) { 238 cli_out("Syntax error parsing \"%s\"\n", name); 239 rv = SOC_E_PARAM; 240 } else { 241 if (alist.count >1) { 242 /* a list is not supported, only a single address */ 243 cli_out("Only a single address can be read %s.\n", name); 244 rv = SOC_E_PARAM; 245 } 246 else { 247 ainfo = &alist.ainfo[0]; 248 reginfo = &SOC_REG_INFO(unit, ainfo->reg); 249 rv = BCM_E_NONE; 250 if (soc_cpureg == SOC_REG_INFO(unit,ainfo->reg).regtype) { 251 SOC_REG_ABOVE_64_CLEAR(value); 252 value_all[0] = soc_pci_read(unit, SOC_REG_INFO(unit,ainfo->reg).offset); 253 #ifdef BCM_IPROC_SUPPORT 254 } else if (soc_iprocreg == SOC_REG_INFO(unit,ainfo->reg).regtype) { 255 SOC_REG_ABOVE_64_CLEAR(value); 256 rv = soc_iproc_getreg(unit, SOC_REG_INFO(unit, ainfo->reg).offset, value_all); 257 #endif 258 } else { 259 rv = soc_reg_above_64_get(unit, ainfo->reg, ainfo->port, ainfo->idx, value_all); 260 } 261 if (rv < 0) { 262 char buf[80]; 263 soc_reg_sprint_addr(unit, buf, ainfo); 264 cli_out("ERROR: read from register %s failed: %s\n", 265 buf, soc_errmsg(rv)); 266 } 267 268 /*search field by name*/ 269 for (f = reginfo->nFields - 1; f >= 0; f--) { 270 soc_field_info_t *fld = ®info->fields[f]; 271 if (sal_strcasecmp(SOC_FIELD_NAME(unit, fld->field),field_name)) { 272 continue; 273 } 274 field_found = 1; 275 soc_reg_above_64_field_get(unit, ainfo->reg, value_all, fld->field, value); 276 break; 277 } 278 if (field_found == 0) { 279 rv = SOC_E_NOT_FOUND; 280 } 281 282 283 } 284 } 285 soc_regaddrlist_free(&alist); 286 return rv; 287 } 288 289 /* Get a register field from a register value in memory. The register is not read. */ 290 int diag_reg_field_only_get(int unit, char *name, reg_val reg_value, char* field_name, reg_val field_value) 291 { 292 int rv = SOC_E_NONE; 293 soc_regaddrlist_t alist; 294 soc_regaddrinfo_t *ainfo; 295 soc_reg_info_t *reginfo; 296 int f; 297 int field_found = 0; 298 299 if (!SOC_UNIT_VALID(unit)) { 300 cli_out("Invalid unit.\n"); 301 return SOC_E_UNIT; 302 } 303 304 if (name == NULL) { 305 return SOC_E_PARAM; 306 } 307 308 if (soc_regaddrlist_alloc(&alist) < 0) { 309 cli_out("Could not allocate address list. Memory error.\n"); 310 return SOC_E_PARAM; 311 } 312 313 if (*name == '$') { 314 name++; 315 } 316 317 /* Symbolic name given, print all or some values ... */ 318 if (parse_symbolic_reference(unit, &alist, name) < 0) { 319 cli_out("Syntax error parsing \"%s\"\n", name); 320 rv = SOC_E_PARAM; 321 } else { 322 if (alist.count >1) { 323 /* a list is not supported, only a single address */ 324 cli_out("Only a single address can be read %s.\n", name); 325 rv = SOC_E_PARAM; 326 } 327 else { 328 ainfo = &alist.ainfo[0]; 329 reginfo = &SOC_REG_INFO(unit, ainfo->reg); 330 rv = BCM_E_NONE; 331 /*search field by name*/ 332 for (f = reginfo->nFields - 1; f >= 0; f--) { 333 soc_field_info_t *fld = ®info->fields[f]; 334 if (sal_strcasecmp(SOC_FIELD_NAME(unit, fld->field),field_name)) { 335 continue; 336 } 337 field_found = 1; 338 soc_reg_above_64_field_get(unit, ainfo->reg, reg_value, fld->field, field_value); 339 break; 340 } 341 if (field_found == 0) { 342 rv = SOC_E_NOT_FOUND; 343 } 344 345 346 } 347 } 348 soc_regaddrlist_free(&alist); 349 return rv; 350 } 351 352 int diag_reg_set(int unit, char *name, reg_val value) 353 { 354 int rv = SOC_E_NONE, i; 355 soc_regaddrlist_t alist; 356 soc_regaddrinfo_t *ainfo; 357 358 if (!SOC_UNIT_VALID(unit)) { 359 cli_out("Invalid unit.\n"); 360 return SOC_E_UNIT; 361 } 362 363 if (name == NULL) { 364 return SOC_E_PARAM; 365 } 366 367 if (soc_regaddrlist_alloc(&alist) < 0) { 368 cli_out("Could not allocate address list. Memory error.\n"); 369 return SOC_E_PARAM; 370 } 371 372 if (*name == '$') { 373 name++; 374 } 375 376 /* Symbolic name given, print all or some values ... */ 377 if (parse_symbolic_reference(unit, &alist, name) < 0) { 378 cli_out("Syntax error parsing \"%s\"\n", name); 379 rv = SOC_E_PARAM; 380 } else { 381 for(i=0 ; i<alist.count && SOC_E_NONE == rv ; i++) { 382 ainfo = &alist.ainfo[0]; 383 if (soc_cpureg == SOC_REG_INFO(unit,ainfo->reg).regtype) { 384 soc_pci_write(unit, SOC_REG_INFO(unit,ainfo->reg).offset, value[0]); 385 rv = BCM_E_NONE; 386 #ifdef BCM_IPROC_SUPPORT 387 } else if (soc_iprocreg == SOC_REG_INFO(unit,ainfo->reg).regtype) { 388 rv = soc_iproc_setreg(unit, SOC_REG_INFO(unit,ainfo->reg).offset, value[0]); 389 #endif 390 } else if (( rv = soc_reg_above_64_set(unit, ainfo->reg, ainfo->port, ainfo->idx, value)) < 0) { 391 char buf[80]; 392 soc_reg_sprint_addr(unit, buf, ainfo); 393 cli_out("ERROR: write to register %s failed: %s\n", 394 buf, soc_errmsg(rv)); 395 } 396 } 397 } 398 soc_regaddrlist_free(&alist); 399 return rv; 400 } 401 402 /* Set a register field by reading the register, changing the field value in memory, and writing back the register. */ 403 int diag_reg_field_set(int unit, char *name, char* field_name,reg_val value) 404 { 405 int rv = SOC_E_NONE, i; 406 soc_regaddrlist_t alist; 407 soc_regaddrinfo_t *ainfo; 408 soc_reg_info_t *reginfo; 409 int f; 410 reg_val value_all; 411 int field_found = 0; 412 413 if (!SOC_UNIT_VALID(unit)) { 414 cli_out("Invalid unit.\n"); 415 return SOC_E_UNIT; 416 } 417 418 if (name == NULL) { 419 return SOC_E_PARAM; 420 } 421 422 if (soc_regaddrlist_alloc(&alist) < 0) { 423 cli_out("Could not allocate address list. Memory error.\n"); 424 return SOC_E_PARAM; 425 } 426 427 if (*name == '$') { 428 name++; 429 } 430 431 /* Symbolic name given, print all or some values ... */ 432 if (parse_symbolic_reference(unit, &alist, name) < 0) { 433 cli_out("Syntax error parsing \"%s\"\n", name); 434 rv = SOC_E_PARAM; 435 } else { 436 for(i=0 ; i<alist.count && SOC_E_NONE == rv ; i++) { 437 ainfo = &alist.ainfo[0]; 438 reginfo = &SOC_REG_INFO(unit, ainfo->reg); 439 rv = BCM_E_NONE; 440 if (soc_cpureg == SOC_REG_INFO(unit,ainfo->reg).regtype) { 441 SOC_REG_ABOVE_64_CLEAR(value_all); 442 value_all[0] = soc_pci_read(unit, SOC_REG_INFO(unit,ainfo->reg).offset); 443 #ifdef BCM_IPROC_SUPPORT 444 } else if (soc_iprocreg == SOC_REG_INFO(unit, ainfo->reg).regtype) { 445 rv = soc_iproc_getreg(unit, SOC_REG_INFO(unit, ainfo->reg).offset, value_all); 446 447 #endif 448 } else { 449 rv = soc_reg_above_64_get(unit, ainfo->reg, ainfo->port, ainfo->idx, value_all); 450 } 451 if (rv < 0) { 452 char buf[80]; 453 soc_reg_sprint_addr(unit, buf, ainfo); 454 cli_out("ERROR: read from register %s failed: %s\n", 455 buf, soc_errmsg(rv)); 456 } 457 458 /*search field by name*/ 459 for (f = reginfo->nFields - 1; f >= 0; f--) { 460 soc_field_info_t *fld = ®info->fields[f]; 461 if (sal_strcasecmp(SOC_FIELD_NAME(unit, fld->field),field_name)) { 462 continue; 463 } 464 field_found = 1; 465 soc_reg_above_64_field_set(unit, ainfo->reg, value_all, fld->field, value); 466 break; 467 } 468 if (field_found == 0) { 469 rv = SOC_E_NOT_FOUND; 470 } else { 471 rv = BCM_E_NONE; 472 if (soc_cpureg == SOC_REG_INFO(unit,ainfo->reg).regtype) { 473 soc_pci_write(unit, SOC_REG_INFO(unit,ainfo->reg).offset, value_all[0]); 474 #ifdef BCM_IPROC_SUPPORT 475 } else if (soc_iprocreg == SOC_REG_INFO(unit,ainfo->reg).regtype) { 476 rv = soc_iproc_setreg(unit, SOC_REG_INFO(unit,ainfo->reg).offset, value_all[0]); 477 #endif 478 } else { 479 rv = soc_reg_above_64_set(unit, ainfo->reg, ainfo->port, ainfo->idx, value_all); 480 } 481 if (rv < 0) { 482 char buf[80]; 483 soc_reg_sprint_addr(unit, buf, ainfo); 484 cli_out("ERROR: write to register %s failed: %s\n", 485 buf, soc_errmsg(rv)); 486 } 487 488 } 489 } 490 } 491 soc_regaddrlist_free(&alist); 492 return rv; 493 } 494 495 /* Set a register field in a register value in memory. The register is not read or written */ 496 int diag_reg_field_only_set(int unit, char *name, reg_val reg_value, char* field_name,reg_val field_value) 497 { 498 int rv = SOC_E_NONE, i; 499 soc_regaddrlist_t alist; 500 soc_regaddrinfo_t *ainfo; 501 soc_reg_info_t *reginfo; 502 int f; 503 int field_found = 0; 504 505 if (!SOC_UNIT_VALID(unit)) { 506 cli_out("Invalid unit.\n"); 507 return SOC_E_UNIT; 508 } 509 510 if (name == NULL) { 511 return SOC_E_PARAM; 512 } 513 514 if (soc_regaddrlist_alloc(&alist) < 0) { 515 cli_out("Could not allocate address list. Memory error.\n"); 516 return SOC_E_PARAM; 517 } 518 519 if (*name == '$') { 520 name++; 521 } 522 523 /* Symbolic name given, print all or some values ... */ 524 if (parse_symbolic_reference(unit, &alist, name) < 0) { 525 cli_out("Syntax error parsing \"%s\"\n", name); 526 rv = SOC_E_PARAM; 527 } else { 528 for(i=0 ; i<alist.count && SOC_E_NONE == rv ; i++) { 529 ainfo = &alist.ainfo[0]; 530 reginfo = &SOC_REG_INFO(unit, ainfo->reg); 531 rv = BCM_E_NONE; 532 /*search field by name*/ 533 for (f = reginfo->nFields - 1; f >= 0; f--) { 534 soc_field_info_t *fld = ®info->fields[f]; 535 if (sal_strcasecmp(SOC_FIELD_NAME(unit, fld->field),field_name)) { 536 continue; 537 } 538 field_found = 1; 539 soc_reg_above_64_field_set(unit, ainfo->reg, reg_value, fld->field, field_value); 540 break; 541 } 542 if (field_found == 0) { 543 rv = SOC_E_NOT_FOUND; 544 } else { 545 rv = BCM_E_NONE; 546 if (soc_cpureg == SOC_REG_INFO(unit,ainfo->reg).regtype) { 547 soc_pci_write(unit, SOC_REG_INFO(unit,ainfo->reg).offset, reg_value[0]); 548 #ifdef BCM_IPROC_SUPPORT 549 } else if (soc_iprocreg == SOC_REG_INFO(unit,ainfo->reg).regtype) { 550 rv = soc_iproc_setreg(unit, SOC_REG_INFO(unit,ainfo->reg).offset, reg_value[0]); 551 #endif 552 } else { 553 rv = soc_reg_above_64_set(unit, ainfo->reg, ainfo->port, ainfo->idx, reg_value); 554 } 555 if (rv < 0) { 556 char buf[80]; 557 soc_reg_sprint_addr(unit, buf, ainfo); 558 cli_out("ERROR: write to register %s failed: %s\n", 559 buf, soc_errmsg(rv)); 560 } 561 562 } 563 } 564 } 565 soc_regaddrlist_free(&alist); 566 return rv; 567 } 568 569 int diag_mem_get(int unit, char *name, int index, mem_val value) 570 { 571 int copyno; 572 soc_mem_t mem; 573 int rv = SOC_E_NONE; 574 unsigned array_index; 575 576 if (!SOC_UNIT_VALID(unit)) { 577 cli_out("Invalid unit.\n"); 578 return SOC_E_UNIT; 579 } 580 581 if (name == NULL) { 582 return SOC_E_PARAM; 583 } 584 585 if (parse_memory_name(unit, &mem, name, ©no, &array_index) < 0) { 586 cli_out("ERROR: unknown table \"%s\"\n",name); 587 return SOC_E_PARAM; 588 } 589 590 if (!SOC_MEM_IS_VALID(unit, mem)) { 591 cli_out("Error: Memory %s not valid for chip %s.\n", 592 SOC_MEM_UFNAME(unit, mem), SOC_UNIT_NAME(unit)); 593 return SOC_E_PARAM; 594 } 595 596 /* Created entry, now write it */ 597 if ((rv = soc_mem_array_read(unit, mem, array_index, copyno, index, value)) < 0) { 598 cli_out("Read ERROR: table %s.%d[%d]: %s\n", 599 SOC_MEM_UFNAME(unit, mem), copyno==COPYNO_ALL ? 600 0 : copyno, index, 601 soc_errmsg(rv)); 602 } 603 604 605 return rv; 606 } 607 608 609 /* Set a memory field in a memory value stored in memory. The device memory is not read or written */ 610 int diag_mem_field_get(int unit, char *name, char* field_name, int index, mem_val value) 611 { 612 int copyno; 613 soc_field_info_t *fieldp; 614 soc_mem_t mem; 615 soc_mem_info_t *memp; 616 int f; 617 uint32 fval[SOC_MAX_MEM_FIELD_WORDS]; 618 char tmp[(SOC_MAX_MEM_FIELD_WORDS * 8) + 3]; 619 int rv = SOC_E_NONE; 620 unsigned array_index; 621 622 if (!SOC_UNIT_VALID(unit)) { 623 cli_out("Invalid unit.\n"); 624 return SOC_E_UNIT; 625 } 626 627 if (name == NULL) { 628 return SOC_E_PARAM; 629 } 630 631 if (parse_memory_name(unit, &mem, name, ©no, &array_index) < 0) { 632 cli_out("ERROR: unknown table \"%s\"\n",name); 633 return SOC_E_PARAM; 634 } 635 636 memp = &SOC_MEM_INFO(unit, mem); 637 638 if (!SOC_MEM_IS_VALID(unit, mem)) { 639 cli_out("Error: Memory %s not valid for chip %s.\n", 640 SOC_MEM_UFNAME(unit, mem), SOC_UNIT_NAME(unit)); 641 return SOC_E_PARAM; 642 } 643 644 sal_memset(fval, 0, (sizeof(uint32)) * SOC_MAX_MEM_FIELD_WORDS); 645 sal_memset(value, 0, sizeof (mem_val)); 646 sal_memset(tmp, 0, sizeof(char) * ((SOC_MAX_MEM_FIELD_WORDS * 8) + 3) ); 647 648 if ((rv = soc_mem_array_read(unit, mem, array_index, copyno, index, fval)) < 0) { 649 cli_out("Read ERROR: table %s.%d[%d]: %s\n", 650 SOC_MEM_UFNAME(unit, mem), copyno==COPYNO_ALL ? 651 0 : copyno, index, 652 soc_errmsg(rv)); 653 } 654 for (f = memp->nFields - 1; f >= 0; f--) { 655 fieldp = &memp->fields[f]; 656 if (!(sal_strcasecmp(SOC_FIELD_NAME(unit, fieldp->field),field_name))) { 657 soc_mem_field_get(unit, mem, fval, fieldp->field, value); 658 _shr_format_long_integer(tmp, value, SOC_MAX_MEM_FIELD_WORDS); 659 #if !defined(SOC_NO_NAMES) 660 LOG_VERBOSE(BSL_LS_APPL_COMMON, 661 (BSL_META_U(unit, 662 "%s="), 663 soc_fieldnames[fieldp->field])); 664 #endif 665 LOG_VERBOSE(BSL_LS_APPL_COMMON, 666 (BSL_META_U(unit, 667 "%s\n"), 668 tmp)); 669 break; 670 } 671 } 672 return rv; 673 } 674 675 /* The funciton diag_mem_field_only_get is getting only the field without first getting the memory value */ 676 int diag_mem_field_only_get(int unit, char *name, char* field_name, int index, mem_val value) 677 { 678 int copyno; 679 soc_field_info_t *fieldp; 680 soc_mem_t mem; 681 soc_mem_info_t *memp; 682 int f; 683 uint32 fval[SOC_MAX_MEM_FIELD_WORDS]; 684 char tmp[(SOC_MAX_MEM_FIELD_WORDS * 8) + 3]; 685 int rv = SOC_E_NONE; 686 unsigned array_index; 687 688 if (!SOC_UNIT_VALID(unit)) { 689 cli_out("Invalid unit.\n"); 690 return SOC_E_UNIT; 691 } 692 693 if (name == NULL) { 694 return SOC_E_PARAM; 695 } 696 697 if (parse_memory_name(unit, &mem, name, ©no, &array_index) < 0) { 698 cli_out("ERROR: unknown table \"%s\"\n",name); 699 return SOC_E_PARAM; 700 } 701 702 memp = &SOC_MEM_INFO(unit, mem); 703 704 if (!SOC_MEM_IS_VALID(unit, mem)) { 705 cli_out("Error: Memory %s not valid for chip %s.\n", 706 SOC_MEM_UFNAME(unit, mem), SOC_UNIT_NAME(unit)); 707 return SOC_E_PARAM; 708 } 709 710 sal_memset(fval, 0, (sizeof(uint32)) * SOC_MAX_MEM_FIELD_WORDS); 711 sal_memset(value, 0, sizeof (mem_val)); 712 sal_memset(tmp, 0, sizeof(char) * ((SOC_MAX_MEM_FIELD_WORDS * 8) + 3) ); 713 714 if ((rv = soc_mem_array_read(unit, mem, array_index, copyno, index, fval)) < 0) { 715 cli_out("Read ERROR: table %s.%d[%d]: %s\n", 716 SOC_MEM_UFNAME(unit, mem), copyno==COPYNO_ALL ? 717 0 : copyno, index, 718 soc_errmsg(rv)); 719 } 720 for (f = memp->nFields - 1; f >= 0; f--) { 721 fieldp = &memp->fields[f]; 722 if (!(sal_strcasecmp(SOC_FIELD_NAME(unit, fieldp->field),field_name))) { 723 soc_mem_field_get(unit, mem, fval, fieldp->field, value); 724 _shr_format_long_integer(tmp, value, SOC_MAX_MEM_FIELD_WORDS); 725 #if !defined(SOC_NO_NAMES) 726 LOG_VERBOSE(BSL_LS_APPL_COMMON, 727 (BSL_META_U(unit, 728 "%s="), 729 soc_fieldnames[fieldp->field])); 730 #endif 731 LOG_VERBOSE(BSL_LS_APPL_COMMON, 732 (BSL_META_U(unit, 733 "%s\n"), 734 tmp)); 735 break; 736 } 737 } 738 return rv; 739 } 740 741 int diag_soc_mem_read_range(int unit, char *name, int index1, int index2, void *buffer) 742 { 743 int copyno; 744 soc_mem_t mem; 745 int rv = SOC_E_NONE; 746 unsigned array_index; 747 748 if (!SOC_UNIT_VALID(unit)) { 749 cli_out("Invalid unit.\n"); 750 return SOC_E_UNIT; 751 } 752 753 if (name == NULL) { 754 return SOC_E_PARAM; 755 } 756 757 if (parse_memory_name(unit, &mem, name, ©no, &array_index) < 0) { 758 cli_out("ERROR: unknown table \"%s\"\n",name); 759 return SOC_E_PARAM; 760 } 761 762 if (!SOC_MEM_IS_VALID(unit, mem)) { 763 cli_out("Error: Memory %s not valid for chip %s.\n", 764 SOC_MEM_UFNAME(unit, mem), SOC_UNIT_NAME(unit)); 765 return SOC_E_PARAM; 766 } 767 768 /* Created entry, now write it */ 769 if ((rv = soc_mem_array_read_range(unit, mem, array_index, copyno, index1, index2, buffer)) < 0) { 770 cli_out("Read ERROR: table %s.%d[%d-%d]: %s\n", 771 SOC_MEM_UFNAME(unit, mem), copyno==COPYNO_ALL ? 772 0 : copyno, index1, index2, 773 soc_errmsg(rv)); 774 } 775 776 return rv; 777 } 778 779 int diag_mem_set(int unit, char *name, int start, int count, mem_val value) 780 { 781 int index, copyno; 782 soc_mem_t mem; 783 int rv = SOC_E_NONE; 784 unsigned array_index; 785 786 if (!SOC_UNIT_VALID(unit)) { 787 cli_out("Invalid unit.\n"); 788 return SOC_E_UNIT; 789 } 790 791 if (name == NULL) { 792 return SOC_E_PARAM; 793 } 794 795 if (parse_memory_name(unit, &mem, name, ©no, &array_index) < 0) { 796 cli_out("ERROR: unknown table \"%s\"\n",name); 797 return SOC_E_PARAM; 798 } 799 800 if (!SOC_MEM_IS_VALID(unit, mem)) { 801 cli_out("Error: Memory %s not valid for chip %s.\n", 802 SOC_MEM_UFNAME(unit, mem), SOC_UNIT_NAME(unit)); 803 return SOC_E_PARAM; 804 } 805 806 if (soc_mem_is_readonly(unit, mem)) { 807 cli_out("ERROR: Table %s is read-only\n", 808 SOC_MEM_UFNAME(unit, mem)); 809 return SOC_E_PARAM; 810 } 811 812 /* Created entry, now write it */ 813 for (index = start; index < start + count && SOC_E_NONE == rv; index++) 814 { 815 if ((rv = soc_mem_array_write(unit, mem, array_index, copyno, index, value)) < 0) { 816 cli_out("Write ERROR: table %s.%d[%d]: %s\n", 817 SOC_MEM_UFNAME(unit, mem), copyno==COPYNO_ALL ? 818 0 : copyno, index, 819 soc_errmsg(rv)); 820 } 821 } 822 823 return rv; 824 } 825 826 int diag_mem_field_set(int unit, char *name, char* field_name, int start, int count, mem_val value) 827 { 828 int index, copyno; 829 soc_mem_t mem; 830 int rv = SOC_E_NONE; 831 soc_field_info_t *fieldp; 832 soc_mem_info_t *memp; 833 int f; 834 uint32 fval[SOC_MAX_MEM_FIELD_WORDS]; 835 unsigned array_index; 836 837 838 839 if (!SOC_UNIT_VALID(unit)) { 840 cli_out("Invalid unit.\n"); 841 return SOC_E_UNIT; 842 } 843 844 if (name == NULL) { 845 return SOC_E_PARAM; 846 } 847 848 if (parse_memory_name(unit, &mem, name, ©no, &array_index) < 0) { 849 cli_out("ERROR: unknown table \"%s\"\n",name); 850 return SOC_E_PARAM; 851 } 852 853 if (!SOC_MEM_IS_VALID(unit, mem)) { 854 cli_out("Error: Memory %s not valid for chip %s.\n", 855 SOC_MEM_UFNAME(unit, mem), SOC_UNIT_NAME(unit)); 856 return SOC_E_PARAM; 857 } 858 859 if (soc_mem_is_readonly(unit, mem)) { 860 cli_out("ERROR: Table %s is read-only\n", 861 SOC_MEM_UFNAME(unit, mem)); 862 return SOC_E_PARAM; 863 } 864 memp = &SOC_MEM_INFO(unit, mem); 865 /* Created entry, now write it */ 866 for (index = start; index < start + count && SOC_E_NONE == rv; index++) 867 { 868 sal_memset(fval, 0, sizeof (fval)); 869 870 if ((rv = soc_mem_array_read(unit, mem, array_index, copyno, index, fval)) < 0) { 871 cli_out("Read ERROR: table %s.%d[%d]: %s\n", 872 SOC_MEM_UFNAME(unit, mem), copyno==COPYNO_ALL ? 873 0 : copyno, index, 874 soc_errmsg(rv)); 875 } 876 for (f = memp->nFields - 1; f >= 0; f--) { 877 fieldp = &memp->fields[f]; 878 if (sal_strcasecmp(SOC_FIELD_NAME(unit, fieldp->field),field_name)) { 879 continue; 880 } 881 soc_mem_field_set(unit, mem, fval, fieldp->field, value); 882 } 883 884 if ((rv = soc_mem_array_write(unit, mem, array_index, copyno, index, fval)) < 0) { 885 cli_out("Write ERROR: table %s.%d[%d]: %s\n", 886 SOC_MEM_UFNAME(unit, mem), copyno==COPYNO_ALL ? 887 0 : copyno, index, 888 soc_errmsg(rv)); 889 } 890 } 891 892 return rv; 893 } 894 895 /* Get a memory field from a memory value stored in memory. The device memory is not read. */ 896 int diag_mem_field_only_set(int unit, char *name, char* field_name, int start, int count, mem_val value) 897 { 898 int index, copyno; 899 soc_mem_t mem; 900 int rv = SOC_E_NONE; 901 soc_field_info_t *fieldp; 902 soc_mem_info_t *memp; 903 int f; 904 uint32 fval[SOC_MAX_MEM_FIELD_WORDS]; 905 unsigned array_index; 906 907 908 909 if (!SOC_UNIT_VALID(unit)) { 910 cli_out("Invalid unit.\n"); 911 return SOC_E_UNIT; 912 } 913 914 if (name == NULL) { 915 return SOC_E_PARAM; 916 } 917 918 if (parse_memory_name(unit, &mem, name, ©no, &array_index) < 0) { 919 cli_out("ERROR: unknown table \"%s\"\n",name); 920 return SOC_E_PARAM; 921 } 922 923 if (!SOC_MEM_IS_VALID(unit, mem)) { 924 cli_out("Error: Memory %s not valid for chip %s.\n", 925 SOC_MEM_UFNAME(unit, mem), SOC_UNIT_NAME(unit)); 926 return SOC_E_PARAM; 927 } 928 929 if (soc_mem_is_readonly(unit, mem)) { 930 cli_out("ERROR: Table %s is read-only\n", 931 SOC_MEM_UFNAME(unit, mem)); 932 return SOC_E_PARAM; 933 } 934 memp = &SOC_MEM_INFO(unit, mem); 935 /* Created entry, now write it */ 936 for (index = start; index < start + count && SOC_E_NONE == rv; index++) 937 { 938 sal_memset(fval, 0, sizeof (fval)); 939 for (f = memp->nFields - 1; f >= 0; f--) { 940 fieldp = &memp->fields[f]; 941 if (sal_strcasecmp(SOC_FIELD_NAME(unit, fieldp->field),field_name)) { 942 continue; 943 } 944 soc_mem_field_set(unit, mem, fval, fieldp->field, value); 945 } 946 947 if ((rv = soc_mem_array_write(unit, mem, array_index, copyno, index, fval)) < 0) { 948 cli_out("Write ERROR: table %s.%d[%d]: %s\n", 949 SOC_MEM_UFNAME(unit, mem), copyno==COPYNO_ALL ? 950 0 : copyno, index, 951 soc_errmsg(rv)); 952 } 953 } 954 955 return rv; 956 } 957 958 959 int diag_soc_mem_write_range(int unit, char *name, int index1, int index2, void *buffer) 960 { 961 int copyno; 962 soc_mem_t mem; 963 int rv = SOC_E_NONE; 964 unsigned array_index; 965 966 if (!SOC_UNIT_VALID(unit)) { 967 cli_out("Invalid unit.\n"); 968 return SOC_E_UNIT; 969 } 970 971 if (name == NULL) { 972 return SOC_E_PARAM; 973 } 974 975 if (parse_memory_name(unit, &mem, name, ©no, &array_index) < 0) { 976 cli_out("ERROR: unknown table \"%s\"\n",name); 977 return SOC_E_PARAM; 978 } 979 980 if (!SOC_MEM_IS_VALID(unit, mem)) { 981 cli_out("Error: Memory %s not valid for chip %s.\n", 982 SOC_MEM_UFNAME(unit, mem), SOC_UNIT_NAME(unit)); 983 return SOC_E_PARAM; 984 } 985 986 if (soc_mem_is_readonly(unit, mem)) { 987 cli_out("ERROR: Table %s is read-only\n", 988 SOC_MEM_UFNAME(unit, mem)); 989 return SOC_E_PARAM; 990 } 991 992 /* Created entry, now write it */ 993 if ((rv = soc_mem_array_write_range(unit, 0, mem, array_index, copyno, index1, index2, buffer)) < 0) { 994 cli_out("Write ERROR: table %s.%d[%d-%d]: %s\n", 995 SOC_MEM_UFNAME(unit, mem), copyno==COPYNO_ALL ? 996 0 : copyno, index1, index2, 997 soc_errmsg(rv)); 998 } 999 1000 return rv; 1001 } 1002 #else 1003 /* To avoid empty file warning in not supported architectures */ 1004 int appl_diag_diag_anchor; 1005 #endif /* #if defined(BCM_SAND_SUPPORT) || defined(BCM_ESW_SUPPORT) */