ui_rom_defi_fmf.h (50594B)
1 /* 2 * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file. 3 * 4 * Copyright 2007-2020 Broadcom Inc. All rights reserved. 5 */ 6 #ifndef UI_ROM_DEFI_FMF_INCLUDED 7 /* { */ 8 #define UI_ROM_DEFI_FMF_INCLUDED 9 /* 10 * General include file for reference design. 11 */ 12 #include <appl/diag/dpp/ref_sys.h> 13 14 #include <appl/diag/dpp/ui_defx.h> 15 #include <appl/diag/dpp/utils_defx.h> 16 /* 17 * FMF include file. 18 */ 19 #include <soc/dpp/fmfDriver/fmf_sys_wide_defs.h> 20 /* 21 * SOC_SAND include files. 22 */ 23 #include <soc/dpp/SAND/SAND_FM/sand_chip_defines.h> 24 25 #include <soc/dpp/SOC_SAND_FE200/fe200_chip_defines.h> 26 27 /******************************************************** 28 *NAME 29 * Fmf_general_on_off_vals 30 *TYPE: BUFFER 31 *DATE: 31/DEC/2003 32 *FUNCTION: 33 * ARRAY CONTAINING THE INITIAL LIST OF VALUES 34 * RELATED TO PARAMETERS WHICH ARE ANSWERED BY EITHER 35 * "ON" OR "OFF" (FOR EXAMPLE "USE_FLOW" IN THE 36 * CONTEXT OF SUBJECT 'CONNECT_PP_TO_PP'). 37 *ORGANIZATION: 38 * ARRAY OF STRUCTURES OF TYPE 'PARAM_VAL': 39 * int val_type - 40 * Type of value. Can be: 41 * VAL_END_OF_LIST 0 42 * VAL_NUMERIC 1 43 * VAL_SYMBOL 2 44 * VAL_TEXT 3 45 * VAL_IP 4 46 * The first one is only to indicate the end of 47 * this array. The others indicate what kind of 48 * value this is. 49 * char *symb_val - 50 * ASCII presentation of the symbolic value. 51 * Note: Must be small letters only! 52 * For numeric variables: 53 * This is a dummy variable. Enables searching 54 * array of 'PARAM_VAL_RULES' for name (string) 55 * matching without special case for numeric 56 * variable. 57 * VAL_DESCRIPTOR val_descriptor - 58 * Union of structures (of types VAL_NUM_DESCRIPTOR, 59 * VAL_TEXT_DESCRIPTOR, VAL_IP_DESCRIPTOR and 60 * VAL_SYMB_DESCRIPTOR). Descriptor of value. 61 * See details in file of definition. Note: Symbols 62 * must be small letters only! 63 *USAGE: 64 * SEE ORGANIZATION. 65 *REMARKS: 66 * NONE. 67 *SEE ALSO: 68 */ 69 EXTERN CONST 70 PARAM_VAL_RULES 71 Fmf_general_on_off_vals[] 72 #ifdef INIT 73 = 74 { 75 { 76 VAL_SYMBOL, 77 "on", 78 { 79 { 80 ON_EQUIVALENT, 81 /* 82 * Casting added here just to keep the compiler silent. 83 */ 84 (long)" Positive response. Activate.", 85 /* 86 * Pointer to a function to call after symbolic value 87 * has been accepted. Casting should be 'VAL_PROC_PTR'. 88 * Casting to 'long' added here just to keep the 89 * compiler silent. 90 */ 91 (long)NULL 92 } 93 } 94 }, 95 { 96 VAL_SYMBOL, 97 "off", 98 { 99 { 100 OFF_EQUIVALENT, 101 /* 102 * Casting added here just to keep the compiler silent. 103 */ 104 (long)" Negative response. Do not activate.", 105 /* 106 * Pointer to a function to call after symbolic value 107 * has been accepted. Casting should be 'VAL_PROC_PTR'. 108 * Casting to 'long' added here just to keep the 109 * compiler silent. 110 */ 111 (long)NULL 112 } 113 } 114 }, 115 /* 116 * Last element. Do not remove. 117 */ 118 { 119 VAL_END_OF_LIST 120 } 121 } 122 #endif 123 ; 124 /******************************************************** 125 *NAME 126 * Fmf_ip_address_vals 127 *TYPE: BUFFER 128 *DATE: 05/OCT/2003 129 *FUNCTION: 130 * ARRAY CONTAINING THE INITIAL LIST OF VALUES 131 * RELATED TO AN INDEFINITE IP-ADDRESS PARAMETER. 132 * FOR EXAMPLE, THE PARAMETER "UNIT_IP_ADDRESS" WITHIN 133 * 'ADD_DEVICE'. 134 *ORGANIZATION: 135 * ARRAY OF STRUCTURES OF TYPE 'PARAM_VAL': 136 * int val_type - 137 * Type of value. Can be: 138 * VAL_END_OF_LIST 0 139 * VAL_NUMERIC 1 140 * VAL_SYMBOL 2 141 * VAL_TEXT 3 142 * VAL_IP 4 143 * The first one is only to indicate the end of 144 * this array. The others indicate what kind of 145 * value this is. 146 * char *symb_val - 147 * ASCII presentation of the symbolic value. 148 * Note: Must be small letters only! 149 * For numeric variables: 150 * This is a dummy variable. Enables searching 151 * array of 'PARAM_VAL_RULES' for name (string) 152 * matching without special case for numeric 153 * variable. 154 * VAL_DESCRIPTOR val_descriptor - 155 * Union of structures (of types VAL_NUM_DESCRIPTOR, 156 * VAL_TEXT_DESCRIPTOR, VAL_IP_DESCRIPTOR and 157 * VAL_SYMB_DESCRIPTOR). Descriptor of value. 158 * See details in file of definition. Note: Symbols 159 * must be small letters only! 160 *USAGE: 161 * SEE ORGANIZATION. 162 *REMARKS: 163 * NONE. 164 *SEE ALSO: 165 */ 166 EXTERN CONST 167 PARAM_VAL_RULES 168 Fmf_ip_address_vals[] 169 #ifdef INIT 170 = 171 { 172 { 173 VAL_IP, 174 SYMB_NAME_IP, 175 { 176 { 177 } 178 } 179 }, 180 /* 181 * Last element. Do not remove. 182 */ 183 { 184 VAL_END_OF_LIST 185 } 186 } 187 #endif 188 ; 189 /******************************************************** 190 *NAME 191 * Fmf_indefinite_num_vals 192 *TYPE: BUFFER 193 *DATE: 01/OCT/2003 194 *FUNCTION: 195 * ARRAY CONTAINING THE INITIAL LIST OF VALUES 196 * RELATED TO AN INDEFINITE SINGLE NUMBER. 197 *ORGANIZATION: 198 * ARRAY OF STRUCTURES OF TYPE 'PARAM_VAL': 199 * int val_type - 200 * Type of value. Can be: 201 * VAL_END_OF_LIST 0 202 * VAL_NUMERIC 1 203 * VAL_SYMBOL 2 204 * VAL_TEXT 3 205 * VAL_IP 4 206 * The first one is only to indicate the end of 207 * this array. The others indicate what kind of 208 * value this is. 209 * char *symb_val - 210 * ASCII presentation of the symbolic value. 211 * Note: Must be small letters only! 212 * For numeric variables: 213 * This is a dummy variable. Enables searching 214 * array of 'PARAM_VAL_RULES' for name (string) 215 * matching without special case for numeric 216 * variable. 217 * VAL_DESCRIPTOR val_descriptor - 218 * Union of structures (of types VAL_NUM_DESCRIPTOR, 219 * VAL_TEXT_DESCRIPTOR, VAL_IP_DESCRIPTOR and 220 * VAL_SYMB_DESCRIPTOR). Descriptor of value. 221 * See details in file of definition. Note: Symbols 222 * must be small letters only! 223 *USAGE: 224 * SEE ORGANIZATION. 225 *REMARKS: 226 * NONE. 227 *SEE ALSO: 228 */ 229 EXTERN CONST 230 PARAM_VAL_RULES 231 Fmf_indefinite_num_vals[] 232 #ifdef INIT 233 = 234 { 235 { 236 VAL_NUMERIC,SYMB_NAME_NUMERIC, 237 { 238 { 239 0, 240 0,0, 241 /* 242 * Number of times this value can be repeated (i.e., 243 * value is an array). Must be at least 1! 244 */ 245 1, 246 (VAL_PROC_PTR)NULL 247 } 248 } 249 }, 250 /* 251 * Last element. Do not remove. 252 */ 253 { 254 VAL_END_OF_LIST 255 } 256 } 257 #endif 258 ; 259 /******************************************************** 260 *NAME 261 * Fmf_chip_id_vals 262 *TYPE: BUFFER 263 *DATE: 09/DEC/2003 264 *FUNCTION: 265 * ARRAY CONTAINING THE INITIAL LIST OF VALUES 266 * RELATED TO "CHIP_ID" FIELD WITHIN "ADD_DEVICE". 267 *ORGANIZATION: 268 * ARRAY OF STRUCTURES OF TYPE 'PARAM_VAL': 269 * int val_type - 270 * Type of value. Can be: 271 * VAL_END_OF_LIST 0 272 * VAL_NUMERIC 1 273 * VAL_SYMBOL 2 274 * VAL_TEXT 3 275 * VAL_IP 4 276 * The first one is only to indicate the end of 277 * this array. The others indicate what kind of 278 * value this is. 279 * char *symb_val - 280 * ASCII presentation of the symbolic value. 281 * Note: Must be small letters only! 282 * For numeric variables: 283 * This is a dummy variable. Enables searching 284 * array of 'PARAM_VAL_RULES' for name (string) 285 * matching without special case for numeric 286 * variable. 287 * VAL_DESCRIPTOR val_descriptor - 288 * Union of structures (of types VAL_NUM_DESCRIPTOR, 289 * VAL_TEXT_DESCRIPTOR, VAL_IP_DESCRIPTOR and 290 * VAL_SYMB_DESCRIPTOR). Descriptor of value. 291 * See details in file of definition. Note: Symbols 292 * must be small letters only! 293 *USAGE: 294 * SEE ORGANIZATION. 295 *REMARKS: 296 * NONE. 297 *SEE ALSO: 298 */ 299 EXTERN CONST 300 PARAM_VAL_RULES 301 Fmf_chip_id_vals[] 302 #ifdef INIT 303 = 304 { 305 { 306 VAL_NUMERIC,SYMB_NAME_NUMERIC, 307 { 308 { 309 HAS_MIN_VALUE | HAS_MAX_VALUE, 310 BIT(CHIP_ID_NUM_BITS) - 1,0, 311 /* 312 * Number of times this value can be repeated (i.e., 313 * value is an array). Must be at least 1! 314 */ 315 1, 316 (VAL_PROC_PTR)NULL 317 } 318 } 319 }, 320 /* 321 * Last element. Do not remove. 322 */ 323 { 324 VAL_END_OF_LIST 325 } 326 } 327 #endif 328 ; 329 /******************************************************** 330 *NAME 331 * Fmf_unit_vals 332 *TYPE: BUFFER 333 *DATE: 09/DEC/2003 334 *FUNCTION: 335 * ARRAY CONTAINING THE INITIAL LIST OF VALUES 336 * RELATED TO "DEVICE_ID" FIELD WITHIN "ADD_DEVICE". 337 *ORGANIZATION: 338 * ARRAY OF STRUCTURES OF TYPE 'PARAM_VAL': 339 * int val_type - 340 * Type of value. Can be: 341 * VAL_END_OF_LIST 0 342 * VAL_NUMERIC 1 343 * VAL_SYMBOL 2 344 * VAL_TEXT 3 345 * VAL_IP 4 346 * The first one is only to indicate the end of 347 * this array. The others indicate what kind of 348 * value this is. 349 * char *symb_val - 350 * ASCII presentation of the symbolic value. 351 * Note: Must be small letters only! 352 * For numeric variables: 353 * This is a dummy variable. Enables searching 354 * array of 'PARAM_VAL_RULES' for name (string) 355 * matching without special case for numeric 356 * variable. 357 * VAL_DESCRIPTOR val_descriptor - 358 * Union of structures (of types VAL_NUM_DESCRIPTOR, 359 * VAL_TEXT_DESCRIPTOR, VAL_IP_DESCRIPTOR and 360 * VAL_SYMB_DESCRIPTOR). Descriptor of value. 361 * See details in file of definition. Note: Symbols 362 * must be small letters only! 363 *USAGE: 364 * SEE ORGANIZATION. 365 *REMARKS: 366 * NONE. 367 *SEE ALSO: 368 */ 369 EXTERN CONST 370 PARAM_VAL_RULES 371 Fmf_unit_vals[] 372 #ifdef INIT 373 = 374 { 375 { 376 VAL_NUMERIC,SYMB_NAME_NUMERIC, 377 { 378 { 379 HAS_MIN_VALUE | HAS_MAX_VALUE, 380 (SOC_SAND_MAX_DEVICE_TYPE * BIT(CHIP_ID_NUM_BITS)) - 1,0, 381 /* 382 * Number of times this value can be repeated (i.e., 383 * value is an array). Must be at least 1! 384 */ 385 1, 386 (VAL_PROC_PTR)NULL 387 } 388 } 389 }, 390 /* 391 * Last element. Do not remove. 392 */ 393 { 394 VAL_END_OF_LIST 395 } 396 } 397 #endif 398 ; 399 /******************************************************** 400 *NAME 401 * Fmf_pp_id_vals 402 *TYPE: BUFFER 403 *DATE: 09/DEC/2003 404 *FUNCTION: 405 * ARRAY CONTAINING THE INITIAL LIST OF VALUES 406 * RELATED TO "PP_ID" FIELD WITHIN any subject specifying 407 * PP (such as "CONNECT_PP_TO_PP"). 408 *ORGANIZATION: 409 * ARRAY OF STRUCTURES OF TYPE 'PARAM_VAL': 410 * int val_type - 411 * Type of value. Can be: 412 * VAL_END_OF_LIST 0 413 * VAL_NUMERIC 1 414 * VAL_SYMBOL 2 415 * VAL_TEXT 3 416 * VAL_IP 4 417 * The first one is only to indicate the end of 418 * this array. The others indicate what kind of 419 * value this is. 420 * char *symb_val - 421 * ASCII presentation of the symbolic value. 422 * Note: Must be small letters only! 423 * For numeric variables: 424 * This is a dummy variable. Enables searching 425 * array of 'PARAM_VAL_RULES' for name (string) 426 * matching without special case for numeric 427 * variable. 428 * VAL_DESCRIPTOR val_descriptor - 429 * Union of structures (of types VAL_NUM_DESCRIPTOR, 430 * VAL_TEXT_DESCRIPTOR, VAL_IP_DESCRIPTOR and 431 * VAL_SYMB_DESCRIPTOR). Descriptor of value. 432 * See details in file of definition. Note: Symbols 433 * must be small letters only! 434 *USAGE: 435 * SEE ORGANIZATION. 436 *REMARKS: 437 * NONE. 438 *SEE ALSO: 439 */ 440 EXTERN CONST 441 PARAM_VAL_RULES 442 Fmf_pp_id_vals[] 443 #ifdef INIT 444 = 445 { 446 { 447 VAL_NUMERIC,SYMB_NAME_NUMERIC, 448 { 449 { 450 HAS_NO_MIN_VALUE | HAS_NO_MAX_VALUE, 451 0,0, 452 /* 453 * Number of times this value can be repeated (i.e., 454 * value is an array). Must be at least 1! 455 */ 456 1, 457 (VAL_PROC_PTR)NULL 458 } 459 } 460 }, 461 /* 462 * Last element. Do not remove. 463 */ 464 { 465 VAL_END_OF_LIST 466 } 467 } 468 #endif 469 ; 470 /******************************************************** 471 *NAME 472 * Fmf_unit_vals 473 *TYPE: BUFFER 474 *DATE: 16/OCT/2003 475 *FUNCTION: 476 * ARRAY CONTAINING THE INITIAL LIST OF VALUES 477 * RELATED TO "UNIT" FIELD WITHIN "FMF DEBUG" 478 * CONTEXT. 479 *ORGANIZATION: 480 * ARRAY OF STRUCTURES OF TYPE 'PARAM_VAL': 481 * int val_type - 482 * Type of value. Can be: 483 * VAL_END_OF_LIST 0 484 * VAL_NUMERIC 1 485 * VAL_SYMBOL 2 486 * VAL_TEXT 3 487 * VAL_IP 4 488 * The first one is only to indicate the end of 489 * this array. The others indicate what kind of 490 * value this is. 491 * char *symb_val - 492 * ASCII presentation of the symbolic value. 493 * Note: Must be small letters only! 494 * For numeric variables: 495 * This is a dummy variable. Enables searching 496 * array of 'PARAM_VAL_RULES' for name (string) 497 * matching without special case for numeric 498 * variable. 499 * VAL_DESCRIPTOR val_descriptor - 500 * Union of structures (of types VAL_NUM_DESCRIPTOR, 501 * VAL_TEXT_DESCRIPTOR, VAL_IP_DESCRIPTOR and 502 * VAL_SYMB_DESCRIPTOR). Descriptor of value. 503 * See details in file of definition. Note: Symbols 504 * must be small letters only! 505 *USAGE: 506 * SEE ORGANIZATION. 507 *REMARKS: 508 * NONE. 509 *SEE ALSO: 510 */ 511 EXTERN CONST 512 PARAM_VAL_RULES 513 Fmf_unit_vals[] 514 #ifdef INIT 515 = 516 { 517 { 518 VAL_NUMERIC,SYMB_NAME_NUMERIC, 519 { 520 { 521 HAS_MIN_VALUE | HAS_MAX_VALUE, 522 FMF_MAX_NUM_UNITS - 1,0, 523 /* 524 * Number of times this value can be repeated (i.e., 525 * value is an array). Must be at least 1! 526 */ 527 1, 528 (VAL_PROC_PTR)NULL 529 } 530 } 531 }, 532 /* 533 * Last element. Do not remove. 534 */ 535 { 536 VAL_END_OF_LIST 537 } 538 } 539 #endif 540 ; 541 /******************************************************** 542 *NAME 543 * Fmf_format_vals 544 *TYPE: BUFFER 545 *DATE: 16/OCT/2003 546 *FUNCTION: 547 * ARRAY CONTAINING THE INITIAL LIST OF VALUES 548 * RELATED TO THE PARAMETER "FORMAT" IN THE CONTEXT 549 * OF 'FMF DEBUG' SUBJECT. 550 *ORGANIZATION: 551 * ARRAY OF STRUCTURES OF TYPE 'PARAM_VAL': 552 * int val_type - 553 * Type of value. Can be: 554 * VAL_END_OF_LIST 0 555 * VAL_NUMERIC 1 556 * VAL_SYMBOL 2 557 * VAL_TEXT 3 558 * VAL_IP 4 559 * The first one is only to indicate the end of 560 * this array. The others indicate what kind of 561 * value this is. 562 * char *symb_val - 563 * ASCII presentation of the symbolic value. 564 * Note: Must be small letters only! 565 * For numeric variables: 566 * This is a dummy variable. Enables searching 567 * array of 'PARAM_VAL_RULES' for name (string) 568 * matching without special case for numeric 569 * variable. 570 * VAL_DESCRIPTOR val_descriptor - 571 * Union of structures (of types VAL_NUM_DESCRIPTOR, 572 * VAL_TEXT_DESCRIPTOR, VAL_IP_DESCRIPTOR and 573 * VAL_SYMB_DESCRIPTOR). Descriptor of value. 574 * See details in file of definition. Note: Symbols 575 * must be small letters only! 576 *USAGE: 577 * SEE ORGANIZATION. 578 *REMARKS: 579 * NONE. 580 *SEE ALSO: 581 */ 582 EXTERN CONST 583 PARAM_VAL_RULES 584 Fmf_format_vals[] 585 #ifdef INIT 586 = 587 { 588 { 589 VAL_SYMBOL, 590 "long", 591 { 592 { 593 FORMAT_LONG_EQUIVALENT, 594 /* 595 * Casting added here just to keep the compiler silent. 596 */ 597 (long)" Detailed display format.", 598 /* 599 * Pointer to a function to call after symbolic value 600 * has been accepted. Casting should be 'VAL_PROC_PTR'. 601 * Casting to 'long' added here just to keep the 602 * compiler silent. 603 */ 604 (long)NULL 605 } 606 } 607 }, 608 { 609 VAL_SYMBOL, 610 "short", 611 { 612 { 613 FORMAT_SHORT_EQUIVALENT, 614 /* 615 * Casting added here just to keep the compiler silent. 616 */ 617 (long)" Short, brief display format.", 618 /* 619 * Pointer to a function to call after symbolic value 620 * has been accepted. Casting should be 'VAL_PROC_PTR'. 621 * Casting to 'long' added here just to keep the 622 * compiler silent. 623 */ 624 (long)NULL 625 } 626 } 627 }, 628 /* 629 * Last element. Do not remove. 630 */ 631 { 632 VAL_END_OF_LIST 633 } 634 } 635 #endif 636 ; 637 /******************************************************** 638 *NAME 639 * Fmf_device_type_vals 640 *TYPE: BUFFER 641 *DATE: 21/DEC/2003 642 *FUNCTION: 643 * ARRAY CONTAINING THE INITIAL LIST OF VALUES 644 * RELATED TO THE PARAMETER "DEVICE_TYPE" IN THE CONTEXT 645 * OF 'FMF DEBUG' SUBJECT. 646 *ORGANIZATION: 647 * ARRAY OF STRUCTURES OF TYPE 'PARAM_VAL': 648 * int val_type - 649 * Type of value. Can be: 650 * VAL_END_OF_LIST 0 651 * VAL_NUMERIC 1 652 * VAL_SYMBOL 2 653 * VAL_TEXT 3 654 * VAL_IP 4 655 * The first one is only to indicate the end of 656 * this array. The others indicate what kind of 657 * value this is. 658 * char *symb_val - 659 * ASCII presentation of the symbolic value. 660 * Note: Must be small letters only! 661 * For numeric variables: 662 * This is a dummy variable. Enables searching 663 * array of 'PARAM_VAL_RULES' for name (string) 664 * matching without special case for numeric 665 * variable. 666 * VAL_DESCRIPTOR val_descriptor - 667 * Union of structures (of types VAL_NUM_DESCRIPTOR, 668 * VAL_TEXT_DESCRIPTOR, VAL_IP_DESCRIPTOR and 669 * VAL_SYMB_DESCRIPTOR). Descriptor of value. 670 * See details in file of definition. Note: Symbols 671 * must be small letters only! 672 *USAGE: 673 * SEE ORGANIZATION. 674 *REMARKS: 675 * NONE. 676 *SEE ALSO: 677 */ 678 EXTERN CONST 679 PARAM_VAL_RULES 680 Fmf_device_type_vals[] 681 #ifdef INIT 682 = 683 { 684 { 685 VAL_SYMBOL, 686 "fe2_type", 687 { 688 { 689 FE2_DEVICE_TYPE_EQUIVALENT, 690 /* 691 * Casting added here just to keep the compiler silent. 692 */ 693 (long)" Operate on \'Fabric Element 2\' device.", 694 /* 695 * Pointer to a function to call after symbolic value 696 * has been accepted. Casting should be 'VAL_PROC_PTR'. 697 * Casting to 'long' added here just to keep the 698 * compiler silent. 699 */ 700 (long)NULL 701 } 702 } 703 }, 704 { 705 VAL_SYMBOL, 706 "fe13_type", 707 { 708 { 709 FE13_DEVICE_TYPE_EQUIVALENT, 710 /* 711 * Casting added here just to keep the compiler silent. 712 */ 713 (long)" Operate on \'Fabric Element 1 & 3\' device.", 714 /* 715 * Pointer to a function to call after symbolic value 716 * has been accepted. Casting should be 'VAL_PROC_PTR'. 717 * Casting to 'long' added here just to keep the 718 * compiler silent. 719 */ 720 (long)NULL 721 } 722 } 723 }, 724 { 725 VAL_SYMBOL, 726 "fap_type", 727 { 728 { 729 FAP_DEVICE_TYPE_EQUIVALENT, 730 /* 731 * Casting added here just to keep the compiler silent. 732 */ 733 (long)" Operate on \'Fabric Access\' device.", 734 /* 735 * Pointer to a function to call after symbolic value 736 * has been accepted. Casting should be 'VAL_PROC_PTR'. 737 * Casting to 'long' added here just to keep the 738 * compiler silent. 739 */ 740 (long)NULL 741 } 742 } 743 }, 744 { 745 VAL_SYMBOL, 746 "any_device_type", 747 { 748 { 749 ANY_DEVICE_TYPE_EQUIVALENT, 750 /* 751 * Casting added here just to keep the compiler silent. 752 */ 753 (long)" Operate on \'any\' device (all devices that match).", 754 /* 755 * Pointer to a function to call after symbolic value 756 * has been accepted. Casting should be 'VAL_PROC_PTR'. 757 * Casting to 'long' added here just to keep the 758 * compiler silent. 759 */ 760 (long)NULL 761 } 762 } 763 }, 764 /* 765 * Allow also any numeric value for debug purposes. 766 */ 767 { 768 VAL_NUMERIC,SYMB_NAME_NUMERIC, 769 { 770 { 771 0, 772 0,0, 773 /* 774 * Number of times this value can be repeated (i.e., 775 * value is an array). Must be at least 1! 776 */ 777 1, 778 (VAL_PROC_PTR)NULL 779 } 780 } 781 }, 782 /* 783 * Last element. Do not remove. 784 */ 785 { 786 VAL_END_OF_LIST 787 } 788 } 789 #endif 790 ; 791 /******************************************************** 792 *NAME 793 * Fmf_device_subtype_vals 794 *TYPE: BUFFER 795 *DATE: 21/DEC/2003 796 *FUNCTION: 797 * ARRAY CONTAINING THE INITIAL LIST OF VALUES 798 * RELATED TO THE PARAMETER "DEVICE_SUB_TYPE" IN THE CONTEXT 799 * OF 'FMF DEBUG' SUBJECT. 800 *ORGANIZATION: 801 * ARRAY OF STRUCTURES OF TYPE 'PARAM_VAL': 802 * int val_type - 803 * Type of value. Can be: 804 * VAL_END_OF_LIST 0 805 * VAL_NUMERIC 1 806 * VAL_SYMBOL 2 807 * VAL_TEXT 3 808 * VAL_IP 4 809 * The first one is only to indicate the end of 810 * this array. The others indicate what kind of 811 * value this is. 812 * char *symb_val - 813 * ASCII presentation of the symbolic value. 814 * Note: Must be small letters only! 815 * For numeric variables: 816 * This is a dummy variable. Enables searching 817 * array of 'PARAM_VAL_RULES' for name (string) 818 * matching without special case for numeric 819 * variable. 820 * VAL_DESCRIPTOR val_descriptor - 821 * Union of structures (of types VAL_NUM_DESCRIPTOR, 822 * VAL_TEXT_DESCRIPTOR, VAL_IP_DESCRIPTOR and 823 * VAL_SYMB_DESCRIPTOR). Descriptor of value. 824 * See details in file of definition. Note: Symbols 825 * must be small letters only! 826 *USAGE: 827 * SEE ORGANIZATION. 828 *REMARKS: 829 * NONE. 830 *SEE ALSO: 831 */ 832 EXTERN CONST 833 PARAM_VAL_RULES 834 Fmf_device_subtype_vals[] 835 #ifdef INIT 836 = 837 { 838 { 839 VAL_SYMBOL, 840 FE200_DEVICE_SUBTYPE_STRING, 841 { 842 { 843 FE200_DEVICE_SUBTYPE_EQUIVALENT, 844 /* 845 * Casting added here just to keep the compiler silent. 846 */ 847 (long)" Operate on \'SOC_SAND_FE200\' device.", 848 /* 849 * Pointer to a function to call after symbolic value 850 * has been accepted. Casting should be 'VAL_PROC_PTR'. 851 * Casting to 'long' added here just to keep the 852 * compiler silent. 853 */ 854 (long)NULL 855 } 856 } 857 }, 858 { 859 VAL_SYMBOL, 860 FAP10M_DEVICE_SUBTYPE_STRING, 861 { 862 { 863 FAP10M_DEVICE_SUBTYPE_EQUIVALENT, 864 /* 865 * Casting added here just to keep the compiler silent. 866 */ 867 (long)" Operate on \'SOC_SAND_FAP10M\' device.", 868 /* 869 * Pointer to a function to call after symbolic value 870 * has been accepted. Casting should be 'VAL_PROC_PTR'. 871 * Casting to 'long' added here just to keep the 872 * compiler silent. 873 */ 874 (long)NULL 875 } 876 } 877 }, 878 { 879 VAL_SYMBOL, 880 "any_device_subtype", 881 { 882 { 883 ANY_DEVICE_SUBTYPE_EQUIVALENT, 884 /* 885 * Casting added here just to keep the compiler silent. 886 */ 887 (long)" Operate on \'any\' device subtype (all subtypes that match).", 888 /* 889 * Pointer to a function to call after symbolic value 890 * has been accepted. Casting should be 'VAL_PROC_PTR'. 891 * Casting to 'long' added here just to keep the 892 * compiler silent. 893 */ 894 (long)NULL 895 } 896 } 897 }, 898 /* 899 * Allow also any numeric value for debug purposes. 900 */ 901 { 902 VAL_NUMERIC,SYMB_NAME_NUMERIC, 903 { 904 { 905 0, 906 0,0, 907 /* 908 * Number of times this value can be repeated (i.e., 909 * value is an array). Must be at least 1! 910 */ 911 1, 912 (VAL_PROC_PTR)NULL 913 } 914 } 915 }, 916 /* 917 * Last element. Do not remove. 918 */ 919 { 920 VAL_END_OF_LIST 921 } 922 } 923 #endif 924 ; 925 /******************************************************** 926 *NAME 927 * Fmf_debug_flags_vals 928 *TYPE: BUFFER 929 *DATE: 11/DEC/2003 930 *FUNCTION: 931 * ARRAY CONTAINING THE INITIAL LIST OF VALUES 932 * RELATED TO THE PARAMETER "DEBUG_FLAGS" IN THE CONTEXT 933 * OF 'FMF DEBUG' SUBJECT. 934 *ORGANIZATION: 935 * ARRAY OF STRUCTURES OF TYPE 'PARAM_VAL': 936 * int val_type - 937 * Type of value. Can be: 938 * VAL_END_OF_LIST 0 939 * VAL_NUMERIC 1 940 * VAL_SYMBOL 2 941 * VAL_TEXT 3 942 * VAL_IP 4 943 * The first one is only to indicate the end of 944 * this array. The others indicate what kind of 945 * value this is. 946 * char *symb_val - 947 * ASCII presentation of the symbolic value. 948 * Note: Must be small letters only! 949 * For numeric variables: 950 * This is a dummy variable. Enables searching 951 * array of 'PARAM_VAL_RULES' for name (string) 952 * matching without special case for numeric 953 * variable. 954 * VAL_DESCRIPTOR val_descriptor - 955 * Union of structures (of types VAL_NUM_DESCRIPTOR, 956 * VAL_TEXT_DESCRIPTOR, VAL_IP_DESCRIPTOR and 957 * VAL_SYMB_DESCRIPTOR). Descriptor of value. 958 * See details in file of definition. Note: Symbols 959 * must be small letters only! 960 *USAGE: 961 * SEE ORGANIZATION. 962 *REMARKS: 963 * NONE. 964 *SEE ALSO: 965 */ 966 EXTERN CONST 967 PARAM_VAL_RULES 968 Fmf_debug_flags_vals[] 969 #ifdef INIT 970 = 971 { 972 { 973 VAL_SYMBOL, 974 "fmf_debug_on", 975 { 976 { 977 FMF_DEBUG_ON_EQUIVALENT, 978 /* 979 * Casting added here just to keep the compiler silent. 980 */ 981 (long)" Activate FMF debug flag (debug mode on -> debug printouts).", 982 /* 983 * Pointer to a function to call after symbolic value 984 * has been accepted. Casting should be 'VAL_PROC_PTR'. 985 * Casting to 'long' added here just to keep the 986 * compiler silent. 987 */ 988 (long)NULL 989 } 990 } 991 }, 992 { 993 VAL_SYMBOL, 994 "fmf_debug_off", 995 { 996 { 997 FMF_DEBUG_OFF_EQUIVALENT, 998 /* 999 * Casting added here just to keep the compiler silent. 1000 */ 1001 (long)" Deactivate FMF debug flag (debug mode off -> NO debug printouts).", 1002 /* 1003 * Pointer to a function to call after symbolic value 1004 * has been accepted. Casting should be 'VAL_PROC_PTR'. 1005 * Casting to 'long' added here just to keep the 1006 * compiler silent. 1007 */ 1008 (long)NULL 1009 } 1010 } 1011 }, 1012 { 1013 VAL_SYMBOL, 1014 "fmc_n_debug_on", 1015 { 1016 { 1017 FMC_N_DEBUG_ON_EQUIVALENT, 1018 /* 1019 * Casting added here just to keep the compiler silent. 1020 */ 1021 (long)" Activate FMC_N debug flag (debug mode on -> debug printouts).", 1022 /* 1023 * Pointer to a function to call after symbolic value 1024 * has been accepted. Casting should be 'VAL_PROC_PTR'. 1025 * Casting to 'long' added here just to keep the 1026 * compiler silent. 1027 */ 1028 (long)NULL 1029 } 1030 } 1031 }, 1032 { 1033 VAL_SYMBOL, 1034 "fmc_n_debug_off", 1035 { 1036 { 1037 FMC_N_DEBUG_OFF_EQUIVALENT, 1038 /* 1039 * Casting added here just to keep the compiler silent. 1040 */ 1041 (long)" Deactivate FMC_N debug flag (debug mode off -> NO debug printouts).", 1042 /* 1043 * Pointer to a function to call after symbolic value 1044 * has been accepted. Casting should be 'VAL_PROC_PTR'. 1045 * Casting to 'long' added here just to keep the 1046 * compiler silent. 1047 */ 1048 (long)NULL 1049 } 1050 } 1051 }, 1052 { 1053 VAL_SYMBOL, 1054 "dcl_debug_on", 1055 { 1056 { 1057 DCL_DEBUG_ON_EQUIVALENT, 1058 /* 1059 * Casting added here just to keep the compiler silent. 1060 */ 1061 (long)" Activate DCL debug flag (debug mode on -> debug printouts).", 1062 /* 1063 * Pointer to a function to call after symbolic value 1064 * has been accepted. Casting should be 'VAL_PROC_PTR'. 1065 * Casting to 'long' added here just to keep the 1066 * compiler silent. 1067 */ 1068 (long)NULL 1069 } 1070 } 1071 }, 1072 { 1073 VAL_SYMBOL, 1074 "dcl_debug_off", 1075 { 1076 { 1077 DCL_DEBUG_OFF_EQUIVALENT, 1078 /* 1079 * Casting added here just to keep the compiler silent. 1080 */ 1081 (long)" Deactivate DCL debug flag (debug mode off -> NO debug printouts).", 1082 /* 1083 * Pointer to a function to call after symbolic value 1084 * has been accepted. Casting should be 'VAL_PROC_PTR'. 1085 * Casting to 'long' added here just to keep the 1086 * compiler silent. 1087 */ 1088 (long)NULL 1089 } 1090 } 1091 }, 1092 { 1093 VAL_SYMBOL, 1094 "show_all_debug_flags", 1095 { 1096 { 1097 SHOW_ALL_DEBUG_FLAGS_EQUIVALENT, 1098 /* 1099 * Casting added here just to keep the compiler silent. 1100 */ 1101 (long)" Display all debug flags (DCL, FMC_N, FMF).", 1102 /* 1103 * Pointer to a function to call after symbolic value 1104 * has been accepted. Casting should be 'VAL_PROC_PTR'. 1105 * Casting to 'long' added here just to keep the 1106 * compiler silent. 1107 */ 1108 (long)NULL 1109 } 1110 } 1111 }, 1112 /* 1113 * Last element. Do not remove. 1114 */ 1115 { 1116 VAL_END_OF_LIST 1117 } 1118 } 1119 #endif 1120 ; 1121 /******************************************************** 1122 *NAME 1123 * Fmf_format_default 1124 *TYPE: BUFFER 1125 *DATE: 16/OCT/2003 1126 *FUNCTION: 1127 * ARRAY CONTAINING THE DEFAULT VALUE 1128 * RELATED TO THE PARAMETER "FORMAT" IN THE CONTEXT 1129 * OF 'FMF DEBUG' SUBJECT. 1130 *ORGANIZATION: 1131 * ARRAY OF STRUCTURES OF TYPE 'PARAM_VAL': 1132 * int val_type - 1133 * Type of variable (VAL_NUMERIC, VAL_TEXT, 1134 * VAL_IP OR VAL_SYMBOL) 1135 * int numeric_equivalent - 1136 * Numeric value related to (identifier of) 1137 * 'string_value' in 'value' below.. Only relevant 1138 * for val_type = VAL_SYMBOL 1139 * union value - 1140 * Union of one of 1141 * int int_value 1142 * char *string_value 1143 * char val_text[MAX_SIZE_OF_TEXT_VAR] ; 1144 * unsigned long ip_value ; 1145 * Value of default variable. 1146 *USAGE: 1147 * SEE ORGANIZATION. 1148 *REMARKS: 1149 * NONE. 1150 *SEE ALSO: 1151 */ 1152 EXTERN CONST 1153 PARAM_VAL 1154 Fmf_format_default 1155 #ifdef INIT 1156 = 1157 { 1158 VAL_SYMBOL, 1159 FORMAT_SHORT_EQUIVALENT, 1160 { 1161 /* 1162 * Casting required here only to keep the compiler silent. 1163 */ 1164 (int)"short" 1165 } 1166 } 1167 #endif 1168 ; 1169 /******************************************************** 1170 *NAME 1171 * Fmf_empty_vals 1172 *TYPE: BUFFER 1173 *DATE: 18/SEP/2003 1174 *FUNCTION: 1175 * ARRAY CONTAINING EMPTY LIST OF VALUES 1176 * RELATED TO ANY PARAMETER OF ANY SUBJECT. 1177 *ORGANIZATION: 1178 * ARRAY OF STRUCTURES OF TYPE 'PARAM_VAL': 1179 * int val_type - 1180 * Type of value. Can be: 1181 * VAL_END_OF_LIST 0 1182 * VAL_NUMERIC 1 1183 * VAL_SYMBOL 2 1184 * VAL_TEXT 3 1185 * VAL_IP 4 1186 * The first one is only to indicate the end of 1187 * this array. The others indicate what kind of 1188 * value this is. 1189 * char *symb_val - 1190 * ASCII presentation of the symbolic value. 1191 * Note: Must be small letters only! 1192 * For numeric variables: 1193 * This is a dummy variable. Enables searching 1194 * array of 'PARAM_VAL_RULES' for name (string) 1195 * matching without special case for numeric 1196 * variable. 1197 * VAL_DESCRIPTOR val_descriptor - 1198 * Union of structures (of types VAL_NUM_DESCRIPTOR, 1199 * VAL_TEXT_DESCRIPTOR, VAL_IP_DESCRIPTOR and 1200 * VAL_SYMB_DESCRIPTOR). Descriptor of value. 1201 * See details in file of definition. Note: Symbols 1202 * must be small letters only! 1203 *USAGE: 1204 * SEE ORGANIZATION. 1205 *REMARKS: 1206 * None 1207 *SEE ALSO: 1208 */ 1209 EXTERN CONST 1210 PARAM_VAL_RULES 1211 Fmf_empty_vals[] 1212 #ifdef INIT 1213 = 1214 { 1215 /* 1216 * Last element. Do not remove. 1217 */ 1218 { 1219 VAL_END_OF_LIST 1220 } 1221 } 1222 #endif 1223 ; 1224 /******************************************************** 1225 *NAME 1226 * Fmf_params 1227 *TYPE: BUFFER 1228 *DATE: 18/SEP/2003 1229 *FUNCTION: 1230 * ARRAY CONTAINING THE INITIAL LIST OF PARAMETERS 1231 * RELATED TO THE SUBJECT "FMF". 1232 *ORGANIZATION: 1233 * ARRAY OF STRUCTURES OF TYPE 'PARAM': 1234 * int subject_id - 1235 * Identifier of this parameter. 1236 * char *par_name - 1237 * Ascii presentation of parameter. Must be small 1238 * letters only! Must contain at least one character. 1239 * PARAM_VAL *allowed_vals - 1240 * Array of structures of type PARAM_VAL. This is 1241 * the list of values allowed for that 1242 * parameter. 1243 * int default_care - 1244 * Flags bitmap. 1245 * Bit(0) indicates whether there is a default 1246 * value for this parameter (i.e. 'default_val' 1247 * is meaningful). '0' indicates 'no default val'. 1248 * Bit(1) indicates whether this parameter must 1249 * or may not appear on command line (within its 1250 * context). '0' indicates 'may not appear'. 1251 * PARAM_VAL *default_val - 1252 * Default value for this parameter. 1253 * unsigned int num_numeric_vals ; 1254 * Number of numeric values in array 'allowed_vals'. 1255 * unsigned int num_symbolic_vals ; 1256 * Number of symbolic values in array 'allowed_vals'. 1257 * unsigned int num_text_vals ; 1258 * Number of free text values in array 'allowed_vals'. 1259 * unsigned int num_ip_vals ; 1260 * Number of IP address values in array 'allowed_vals'. 1261 * unsigned int numeric_index ; 1262 * Index of numeric value (if there is any) in 1263 * array 'allowed_vals'. 1264 * unsigned int text_index ; 1265 * Index of free text value (if there is any) in 1266 * array 'allowed_vals'. 1267 * unsigned int ip_index ; 1268 * Index of IP address value (if there is any) in 1269 * array 'allowed_vals'. 1270 * char *param_short_help - 1271 * Short help for this parameter. 1272 * char *param_detailed_help - 1273 * Detailed help for this parameter. 1274 * char *vals_detailed_help ; 1275 * Detailed help for all values attached to this parameter. 1276 * THIS FIELD IS AUTOMATICALLY FILLED IN BY THE SYSTEM 1277 * and does NOT need to be filled in by the user. 1278 * unsigned long mutex_control ; 1279 * Mutual exclusion syntax control. Up to 32*4 groups 1280 * specified by bits. If a parameter has specific 1281 * bits set then other parameters, with any of 1282 * these bits set, may not be on the same line. 1283 *USAGE: 1284 * SEE ORGANIZATION. 1285 *REMARKS: 1286 * NONE. 1287 *SEE ALSO: 1288 */ 1289 EXTERN CONST 1290 PARAM 1291 Fmf_params[] 1292 #ifdef INIT 1293 = 1294 { 1295 { 1296 PARAM_FMF_USE_FLOW_ID, 1297 "use_flow", 1298 (PARAM_VAL_RULES *)&Fmf_general_on_off_vals[0], 1299 (sizeof(Fmf_general_on_off_vals) / sizeof(Fmf_general_on_off_vals[0])) - 1, 1300 HAS_NO_DEFAULT | MAY_NOT_APPEAR,(PARAM_VAL *)0, 1301 0,0,0,0,0,0,0, 1302 "Indicate whether to use \'flow labeling\' (\'on\') or\r\n" 1303 " \'destination labeling (\'off\').", 1304 "Example:\r\n" 1305 " fmf debug connect_pp_to_pp from_one_pp pp_id 11 to_one_pp pp_id 17\r\n" 1306 " use_flow off\r\n" 1307 "Results in connecting the PP with id \'11\' to the PP with id \'17\'\r\n" 1308 "using \'destination labeling\'.\r\n", 1309 "", 1310 { 1311 BIT(7) | BIT(8) | BIT(9) | BIT(10), 1312 0 1313 }, 1314 7, 1315 /* 1316 * Pointer to a function to call after symbolic parameter 1317 * has been accepted. 1318 */ 1319 (VAL_PROC_PTR)NULL 1320 }, 1321 { 1322 PARAM_FMF_DST_PP_ID_ID, 1323 "dst_pp_id", 1324 (PARAM_VAL_RULES *)&Fmf_pp_id_vals[0], 1325 (sizeof(Fmf_pp_id_vals) / sizeof(Fmf_pp_id_vals[0])) - 1, 1326 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1327 0,0,0,0,0,0,0, 1328 "Id of destination Packet Processor to operate on.", 1329 "Example:\r\n" 1330 " fmf debug connect_pp_to_pp from_one_pp pp_id 11 to_one_pp dst_pp_id 17\r\n" 1331 " use_flow off\r\n" 1332 "Results in connecting the PP with id \'11\' to the PP with id \'17\'\r\n" 1333 "using \'destination labeling\'.\r\n", 1334 "", 1335 { 1336 BIT(9), 1337 0 1338 }, 1339 6, 1340 /* 1341 * Pointer to a function to call after symbolic parameter 1342 * has been accepted. 1343 */ 1344 (VAL_PROC_PTR)NULL 1345 }, 1346 { 1347 PARAM_FMF_TO_ALL_PPS_ID, 1348 "to_all_pps", 1349 (PARAM_VAL_RULES *)&Fmf_empty_vals[0], 1350 (sizeof(Fmf_empty_vals) / sizeof(Fmf_empty_vals[0])) - 1, 1351 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1352 0,0,0,0,0,0,0, 1353 "Indicate that all PPs are to be operated on.", 1354 "Example:\r\n" 1355 " fmf debug connect_pp_to_pp from_all_pps to_all_pps use_flow off\r\n" 1356 "Results in connecting all registered PPs to all registered PPs\r\n" 1357 "using \'destination labeling\'.\r\n", 1358 "", 1359 { 1360 BIT(10), 1361 0 1362 }, 1363 5, 1364 (VAL_PROC_PTR)NULL 1365 }, 1366 { 1367 PARAM_FMF_TO_ONE_PP_ID, 1368 "to_one_pp", 1369 (PARAM_VAL_RULES *)&Fmf_empty_vals[0], 1370 (sizeof(Fmf_empty_vals) / sizeof(Fmf_empty_vals[0])) - 1, 1371 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1372 0,0,0,0,0,0,0, 1373 "Indicate destination PP, to operate on, follows.", 1374 "Example:\r\n" 1375 " fmf debug connect_pp_to_pp from_one_pp pp_id 11 to_one_pp pp_id 17\r\n" 1376 " use_flow off\r\n" 1377 "Results in connecting the PP with id \'11\' to the PP with id \'17\'\r\n" 1378 "using \'destination labeling\'.\r\n", 1379 "", 1380 { 1381 BIT(9), 1382 0 1383 }, 1384 5, 1385 (VAL_PROC_PTR)NULL 1386 }, 1387 { 1388 PARAM_FMF_PP_ID_ID, 1389 "pp_id", 1390 (PARAM_VAL_RULES *)&Fmf_pp_id_vals[0], 1391 (sizeof(Fmf_pp_id_vals) / sizeof(Fmf_pp_id_vals[0])) - 1, 1392 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1393 0,0,0,0,0,0,0, 1394 "Id of Packet Processor to operate on.", 1395 "Example:\r\n" 1396 " fmf debug activate_device one_specific_device unit 35\r\n" 1397 "Results in activating FAP device with chip id 11\r\n", 1398 "", 1399 { 1400 BIT(7) | BIT(9) | BIT(10), 1401 0 1402 }, 1403 4, 1404 /* 1405 * Pointer to a function to call after symbolic parameter 1406 * has been accepted. 1407 */ 1408 (VAL_PROC_PTR)NULL 1409 }, 1410 { 1411 PARAM_FMF_FROM_ALL_PPS_ID, 1412 "from_all_pps", 1413 (PARAM_VAL_RULES *)&Fmf_empty_vals[0], 1414 (sizeof(Fmf_empty_vals) / sizeof(Fmf_empty_vals[0])) - 1, 1415 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1416 0,0,0,0,0,0,0, 1417 "Indicate that all PPs are to be operated on.", 1418 "Example:\r\n" 1419 " fmf debug connect_pp_to_pp from_all_pps to_all_pps use_flow off\r\n" 1420 "Results in connecting all registered PPs to all registered PPs\r\n" 1421 "using \'destination labeling\'.\r\n", 1422 "", 1423 { 1424 BIT(8) | BIT(9) | BIT(10), 1425 0 1426 }, 1427 3, 1428 (VAL_PROC_PTR)NULL 1429 }, 1430 { 1431 PARAM_FMF_FROM_ONE_PP_ID, 1432 "from_one_pp", 1433 (PARAM_VAL_RULES *)&Fmf_empty_vals[0], 1434 (sizeof(Fmf_empty_vals) / sizeof(Fmf_empty_vals[0])) - 1, 1435 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1436 0,0,0,0,0,0,0, 1437 "Indicate source PP, to operate on, follows.", 1438 "Example:\r\n" 1439 " fmf debug connect_pp_to_pp from_one_pp pp_id 11 to_all_pps use_flow off\r\n" 1440 "Results in connecting the PP with id \'11\' to all other registered PPs\r\n" 1441 "using \'destination labeling\'.\r\n", 1442 "", 1443 { 1444 BIT(7) | BIT(9) | BIT(10), 1445 0 1446 }, 1447 3, 1448 (VAL_PROC_PTR)NULL 1449 }, 1450 { 1451 PARAM_FMF_CONNECT_PP_TO_PP_ID, 1452 "connect_pp_to_pp", 1453 (PARAM_VAL_RULES *)&Fmf_empty_vals[0], 1454 (sizeof(Fmf_empty_vals) / sizeof(Fmf_empty_vals[0])) - 1, 1455 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1456 0,0,0,0,0,0,0, 1457 "Set user flows from a group of PPs to a group of PPs.", 1458 "Example:\r\n" 1459 " fmf debug connect_pp_to_pp from_one_pp pp_id 11 to_all_pps use_flow off\r\n" 1460 "Results in connecting the PP with id \'11\' to all other registered PPs\r\n" 1461 "using \'destination labeling\'.\r\n", 1462 "", 1463 { 1464 BIT(7) | BIT(8) | BIT(9) | BIT(10), 1465 0 1466 }, 1467 2, 1468 (VAL_PROC_PTR)NULL 1469 }, 1470 { 1471 PARAM_FMF_ALL_SPECIFIED_DEVICES_ID, 1472 "all_specified_devices", 1473 (PARAM_VAL_RULES *)&Fmf_empty_vals[0], 1474 (sizeof(Fmf_empty_vals) / sizeof(Fmf_empty_vals[0])) - 1, 1475 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1476 0,0,0,0,0,0,0, 1477 "Indicate that all registered devices, of specified type, are to be operated on.", 1478 "Example:\r\n" 1479 " fmf debug activate_device all_specified_devices device_type fap_type\r\n" 1480 " device_sub_type fap10m_type\r\n" 1481 "Results in activating all registered SOC_SAND_FAP10M devices\r\n", 1482 "", 1483 { 1484 BIT(6), 1485 0 1486 }, 1487 3, 1488 (VAL_PROC_PTR)NULL 1489 }, 1490 { 1491 PARAM_FMF_ONE_SPECIFIC_DEVICE_ID, 1492 "one_specific_device", 1493 (PARAM_VAL_RULES *)&Fmf_empty_vals[0], 1494 (sizeof(Fmf_empty_vals) / sizeof(Fmf_empty_vals[0])) - 1, 1495 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1496 0,0,0,0,0,0,0, 1497 "Specify one registered device to operate on.", 1498 "Example:\r\n" 1499 " fmf debug init_base_params one_specific_device unit 35\r\n" 1500 "Results in loading default base parameters (See \'FAP10M_BASE_PARAMS\')\r\n" 1501 "into FAP device with chip id 11\r\n", 1502 "", 1503 { 1504 BIT(5), 1505 0 1506 }, 1507 3, 1508 (VAL_PROC_PTR)NULL 1509 }, 1510 { 1511 PARAM_FMF_INIT_BASE_PARAMS_ID, 1512 "init_base_params", 1513 (PARAM_VAL_RULES *)&Fmf_empty_vals[0], 1514 (sizeof(Fmf_empty_vals) / sizeof(Fmf_empty_vals[0])) - 1, 1515 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1516 0,0,0,0,0,0,0, 1517 "Initialize base parameters on a specific registered device or on all registered.", 1518 "Example:\r\n" 1519 " fmf debug init_base_params one_specific_device unit 35\r\n" 1520 "Results in loading default base parameters (See \'FAP10M_BASE_PARAMS\'\r\n" 1521 "into FAP device with chip id 11\r\n", 1522 "", 1523 { 1524 BIT(5) | BIT(6), 1525 0 1526 }, 1527 2, 1528 (VAL_PROC_PTR)NULL 1529 }, 1530 { 1531 PARAM_FMF_DEBUG_FLAGS_ID, 1532 "debug_flags", 1533 (PARAM_VAL_RULES *)&Fmf_debug_flags_vals[0], 1534 (sizeof(Fmf_debug_flags_vals) / sizeof(Fmf_debug_flags_vals[0])) - 1, 1535 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1536 0,0,0,0,0,0,0, 1537 "Control (activate/deactivate) debug flags within FMF system.", 1538 "Example:\r\n" 1539 " fmf debug debug_flags fmf_debug_on\r\n" 1540 "Results in activating debug flag within FMF (will produce\r\n" 1541 "debug printouts)\r\n", 1542 "", 1543 { 1544 BIT(4), 1545 0 1546 }, 1547 2, 1548 (VAL_PROC_PTR)NULL 1549 }, 1550 { 1551 PARAM_FMF_DEVICE_ID_ID, 1552 "unit", 1553 (PARAM_VAL_RULES *)&Fmf_unit_vals[0], 1554 (sizeof(Fmf_unit_vals) / sizeof(Fmf_unit_vals[0])) - 1, 1555 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1556 0,0,0,0,0,0,0, 1557 "Device id of device on unit to access.", 1558 "Example:\r\n" 1559 " fmf debug activate_device one_specific_device unit 35\r\n" 1560 "Results in activating FAP device with chip id 11\r\n", 1561 "", 1562 { 1563 BIT(3) | BIT(5), 1564 0 1565 }, 1566 (unsigned int)LAST_ORDINAL, 1567 /* 1568 * Pointer to a function to call after symbolic parameter 1569 * has been accepted. 1570 */ 1571 (VAL_PROC_PTR)NULL 1572 }, 1573 { 1574 PARAM_FMF_ACTIVATE_DEVICE_ID, 1575 "activate_device", 1576 (PARAM_VAL_RULES *)&Fmf_empty_vals[0], 1577 (sizeof(Fmf_empty_vals) / sizeof(Fmf_empty_vals[0])) - 1, 1578 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1579 0,0,0,0,0,0,0, 1580 "Activate device within FMF system.", 1581 "Example:\r\n" 1582 " fmf debug activate_device one_specific_device unit 35\r\n" 1583 "Results in activating FAP device with chip id 11\r\n", 1584 "", 1585 { 1586 BIT(3) | BIT(5) | BIT(6), 1587 0 1588 }, 1589 2, 1590 (VAL_PROC_PTR)NULL 1591 }, 1592 { 1593 PARAM_FMF_DEVICE_TYPE_ID, 1594 "device_type", 1595 (PARAM_VAL_RULES *)&Fmf_device_type_vals[0], 1596 (sizeof(Fmf_device_type_vals) / sizeof(Fmf_device_type_vals[0])) - 1, 1597 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1598 0,0,0,0,0,0,0, 1599 "General type of device on unit to access (FAP or FE).", 1600 "Example:\r\n" 1601 " fmf debug add_device unit_ip_address 10.0.0.5 chip_id 55 device_type fap_type\r\n" 1602 " device_sub_type 1\r\n" 1603 "Results in adding FAP device of the SOC_SAND_FAP10M type to FMF using IP address\r\n" 1604 "10.0.0.5 and chip_id 55.\r\n" 1605 "The latter identifiers are used to access the board carrying specified\r\n" 1606 "device and to access the device itself on that board.\r\n", 1607 "", 1608 { 1609 BIT(1) | BIT(6), 1610 0 1611 }, 1612 (unsigned int)LAST_ORDINAL, 1613 /* 1614 * Pointer to a function to call after symbolic parameter 1615 * has been accepted. 1616 */ 1617 (VAL_PROC_PTR)NULL 1618 }, 1619 { 1620 PARAM_FMF_DEVICE_SUB_TYPE_ID, 1621 "device_sub_type", 1622 (PARAM_VAL_RULES *)&Fmf_device_subtype_vals[0], 1623 (sizeof(Fmf_device_subtype_vals) / sizeof(Fmf_device_subtype_vals[0])) - 1, 1624 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1625 0,0,0,0,0,0,0, 1626 "Specific type of device on unit to access (SOC_SAND_FE200 as FE13, SOC_SAND_FAP10M, etc.).", 1627 "Example:\r\n" 1628 " fmf debug add_device unit_ip_address 10.0.0.5 chip_id 55 device_type fap_type\r\n" 1629 " device_sub_type fap10m_subtype\r\n" 1630 "Results in adding FAP device of the SOC_SAND_FAP10M type to FMF using IP address\r\n" 1631 "10.0.0.5 and chip_id 55.\r\n" 1632 "The latter identifiers are used to access the board carrying specified\r\n" 1633 "device and to access the device itself on that board.\r\n", 1634 "", 1635 { 1636 BIT(1) | BIT(6), 1637 0 1638 }, 1639 (unsigned int)LAST_ORDINAL, 1640 /* 1641 * Pointer to a function to call after symbolic parameter 1642 * has been accepted. 1643 */ 1644 (VAL_PROC_PTR)NULL 1645 }, 1646 { 1647 PARAM_FMF_DEVICE_CHIP_ID_ID, 1648 "chip_id", 1649 (PARAM_VAL_RULES *)&Fmf_chip_id_vals[0], 1650 (sizeof(Fmf_chip_id_vals) / sizeof(Fmf_chip_id_vals[0])) - 1, 1651 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1652 0,0,0,0,0,0,0, 1653 "Chip id of device on unit to access.", 1654 "Example:\r\n" 1655 " fmf debug add_device unit_ip_address 10.0.0.5 chip_id 55 device_type 3\r\n" 1656 " device_sub_type 1\r\n" 1657 "Results in adding FAP device of the SOC_SAND_FAP10M type to FMF using IP address\r\n" 1658 "10.0.0.5 and chip_id 55.\r\n" 1659 "The latter identifiers are used to access the board carrying specified\r\n" 1660 "device and to access the device itself on that board.\r\n", 1661 "", 1662 { 1663 BIT(1), 1664 0 1665 }, 1666 (unsigned int)LAST_ORDINAL, 1667 /* 1668 * Pointer to a function to call after symbolic parameter 1669 * has been accepted. 1670 */ 1671 (VAL_PROC_PTR)NULL 1672 }, 1673 { 1674 PARAM_FMF_UNIT_IP_ADDRESS_ID, 1675 "unit_ip_address", 1676 (PARAM_VAL_RULES *)&Fmf_ip_address_vals[0], 1677 (sizeof(Fmf_ip_address_vals) / sizeof(Fmf_ip_address_vals[0])) - 1, 1678 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1679 0,0,0,0,0,0,0, 1680 "IP address of unit to access.", 1681 "Example:\r\n" 1682 " fmf debug add_device unit_ip_address 10.0.0.5 chip_id 55 device_type 3\r\n" 1683 " device_sub_type 1\r\n" 1684 "Results in adding FAP device of the SOC_SAND_FAP10M type to FMF using IP address\r\n" 1685 "10.0.0.5 and chip_id 55.\r\n" 1686 "The latter identifiers are used to access the board carrying specified\r\n" 1687 "device and to access the device itself on that board.\r\n", 1688 "", 1689 { 1690 BIT(1), 1691 0 1692 }, 1693 (unsigned int)LAST_ORDINAL, 1694 /* 1695 * Pointer to a function to call after symbolic parameter 1696 * has been accepted. 1697 */ 1698 (VAL_PROC_PTR)NULL 1699 }, 1700 { 1701 PARAM_FMF_ADD_DEVICE_ID, 1702 "add_device", 1703 (PARAM_VAL_RULES *)&Fmf_empty_vals[0], 1704 (sizeof(Fmf_empty_vals) / sizeof(Fmf_empty_vals[0])) - 1, 1705 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1706 0,0,0,0,0,0,0, 1707 "Add device to FMF system.", 1708 "Example:\r\n" 1709 " fmf debug add_device unit_ip_address 10.0.0.5 chip_id 55 device_type 3\r\n" 1710 " device_sub_type 1\r\n" 1711 "Results in adding FAP device of the SOC_SAND_FAP10M type to FMF using IP address\r\n" 1712 "10.0.0.5 and chip_id 55.\r\n" 1713 "The latter identifiers are used to access the board carrying specified\r\n" 1714 "device and to access the device itself on that board.\r\n", 1715 "", 1716 { 1717 BIT(1), 1718 0 1719 }, 1720 2, 1721 (VAL_PROC_PTR)NULL 1722 }, 1723 { 1724 PARAM_FMF_REGISTER_DRIVER_ID, 1725 "register_driver", 1726 (PARAM_VAL_RULES *)&Fmf_empty_vals[0], 1727 (sizeof(Fmf_empty_vals) / sizeof(Fmf_empty_vals[0])) - 1, 1728 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1729 0,0,0,0,0,0,0, 1730 "Register FMF and activate it.", 1731 "Example:\r\n" 1732 " fmf debug register_driver\r\n" 1733 "Results in registering FMF and starting it. This also includes initialization\r\n" 1734 "of SOC_SAND and activation of TCM task\r\n", 1735 "", 1736 { 1737 BIT(0), 1738 0 1739 }, 1740 2, 1741 (VAL_PROC_PTR)NULL 1742 }, 1743 { 1744 PARAM_FMF_UNREGISTER_DRIVER_ID, 1745 "unregister_driver", 1746 (PARAM_VAL_RULES *)&Fmf_empty_vals[0], 1747 (sizeof(Fmf_empty_vals) / sizeof(Fmf_empty_vals[0])) - 1, 1748 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1749 0,0,0,0,0,0,0, 1750 "Register FMF and activate it.", 1751 "Example:\r\n" 1752 " fmf debug unregister_driver\r\n" 1753 "Results in unregistering FMF and starting it. This does NOT include SOC_SAND\r\n" 1754 "operations (deactivation or TCM task handling)\r\n", 1755 "", 1756 { 1757 BIT(0), 1758 0 1759 }, 1760 2, 1761 (VAL_PROC_PTR)NULL 1762 }, 1763 { 1764 PARAM_FMF_FORMAT_ID, 1765 "format", 1766 (PARAM_VAL_RULES *)&Fmf_format_vals[0], 1767 (sizeof(Fmf_format_vals) / sizeof(Fmf_format_vals[0])) - 1, 1768 HAS_DEFAULT | MAY_NOT_APPEAR,(PARAM_VAL *)&Fmf_format_default, 1769 0,0,0,0,0,0,0, 1770 "Select display format (detailed or brief) for specified operation.", 1771 "Example:\r\n" 1772 " fmf debug show unit 0 format short\r\n" 1773 "Results in displaying information on specified unit in short\r\n" 1774 "(i.e., not detailed) format.\r\n", 1775 "", 1776 { 1777 BIT(2), 1778 0 1779 }, 1780 (unsigned int)LAST_ORDINAL, 1781 (VAL_PROC_PTR)NULL 1782 }, 1783 { 1784 PARAM_FMF_SHOW_ALL_ID, 1785 "all", 1786 (PARAM_VAL_RULES *)&Fmf_empty_vals[0], 1787 (sizeof(Fmf_empty_vals) / sizeof(Fmf_empty_vals[0])) - 1, 1788 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1789 0,0,0,0,0,0,0, 1790 "Select ALL FMF objects for specified operation.", 1791 "Example:\r\n" 1792 " fmf debug show all format short\r\n" 1793 "Results in displaying all FMF objects (units, devices, ...) in short\r\n" 1794 "(i.e., not detailed) format.\r\n", 1795 "", 1796 { 1797 BIT(2), 1798 0 1799 }, 1800 3, 1801 (VAL_PROC_PTR)NULL 1802 }, 1803 { 1804 PARAM_FMF_SHOW_UNIT_ID, 1805 "unit", 1806 (PARAM_VAL_RULES *)&Fmf_unit_vals[0], 1807 (sizeof(Fmf_unit_vals) / sizeof(Fmf_unit_vals[0])) - 1, 1808 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1809 0,0,0,0,0,0,0, 1810 "Select indicated unit for specified operation.", 1811 "Example:\r\n" 1812 " fmf debug show unit 0 format short\r\n" 1813 "Results in displaying information on specified unit in short\r\n" 1814 "(i.e., not detailed) format.\r\n", 1815 "", 1816 { 1817 BIT(2), 1818 0 1819 }, 1820 3, 1821 (VAL_PROC_PTR)NULL 1822 }, 1823 { 1824 PARAM_FMF_SHOW_ID, 1825 "show", 1826 (PARAM_VAL_RULES *)&Fmf_empty_vals[0], 1827 (sizeof(Fmf_empty_vals) / sizeof(Fmf_empty_vals[0])) - 1, 1828 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1829 0,0,0,0,0,0,0, 1830 "Show details of specified FMF object.", 1831 "Example:\r\n" 1832 " fmf debug show all format short\r\n" 1833 "Results in displaying all FMF objects (units, devices, ...) in short\r\n" 1834 "(i.e., not detailed) format.\r\n", 1835 "", 1836 { 1837 BIT(2), 1838 0 1839 }, 1840 2, 1841 (VAL_PROC_PTR)NULL 1842 }, 1843 { 1844 PARAM_FMF_DEBUG_ID, 1845 "debug", 1846 (PARAM_VAL_RULES *)&Fmf_empty_vals[0], 1847 (sizeof(Fmf_empty_vals) / sizeof(Fmf_empty_vals[0])) - 1, 1848 HAS_NO_DEFAULT | MUST_APPEAR,(PARAM_VAL *)0, 1849 0,0,0,0,0,0,0, 1850 "Invoke various debug tools for FMF.", 1851 "Example:\r\n" 1852 " fmf debug register_driver\r\n" 1853 "Results in registering FMF and starting it. This also includes initialization\r\n" 1854 "of SOC_SAND and activation of TCM task\r\n", 1855 "", 1856 { 1857 BIT(0) | BIT(1) | BIT(2) | BIT(3) | BIT(4) | 1858 BIT(5) | BIT(6) | BIT(7) | BIT(8) | BIT(9) | 1859 BIT(10), 1860 0 1861 }, 1862 1, 1863 (VAL_PROC_PTR)NULL 1864 }, 1865 /* 1866 * Last element. Do not remove. 1867 */ 1868 { 1869 PARAM_END_OF_LIST 1870 } 1871 } 1872 #endif 1873 ; 1874 /* } */ 1875 #endif