1 /* 2 * This file and its contents are supplied under the terms of the 3 * Common Development and Distribution License ("CDDL"), version 1.0. 4 * You may only use this file in accordance with the terms of version 5 * 1.0 of the CDDL. 6 * 7 * A full copy of the text of the CDDL should have accompanied this 8 * source. A copy of the CDDL is also available via the Internet at 9 * http://www.illumos.org/license/CDDL. 10 */ 11 12 /* 13 * Copyright (c) 2017, Joyent, Inc. 14 */ 15 16 /* 17 * Parse raw SFF data into an nvlist that can be processed by users, providing 18 * them with what can be printable strings. At the moment, we handle the 19 * majority of parsing page 0xa0 based on SFF 8472 (thus covering INF-8074 and 20 * friends) and SFF 8636 (thus covering SFF-8436 and friends). Interfaces that 21 * parse data into logical structures may be useful to add when considering 22 * monitoring data in page 0xa2. 23 * 24 * When parsing, we try to make sure that the user has supplied, or at least 25 * thinks they have supplied, a buffer of sufficient length. The general design 26 * is that we require the buffer to be large enough to cover all of the offsets 27 * that we care about. If the buffer isn't this large, then we leave it be. 28 * 29 * This library is private and subject to change at any time. 30 */ 31 32 #include <assert.h> 33 #include <strings.h> 34 #include <libsff.h> 35 #include <errno.h> 36 #include <ctype.h> 37 38 #include "sff.h" 39 40 #define MIN(a, b) ((a) < (b) ? (a) : (b)) 41 42 /* 43 * Maximum size of a string buffer while parsing. 44 */ 45 #define SFP_STRBUF 128 46 47 /* 48 * Minimum length of the buffer we require to parse the SFP data. 49 */ 50 #define SFP_MIN_LEN_8472 96 51 #define SFP_MIN_LEN_8636 224 52 53 /* 54 * This table is derived from SFF 8024 Section 4.1, Table 4-1. 55 */ 56 static const char *sff_8024_id_strs[SFF_8024_NIDS] = { 57 "Unknown or Unspecified", 58 "GBIC", 59 "Module/connector soldered to motherboard", 60 "SFP/SFP+/SFP28", 61 "300 pin XBI", 62 "XENPAK", 63 "XFP", 64 "XFF", 65 "XFP-E", 66 "XPAK", 67 "X2", 68 "DWDM-SFP/SFP+ (not using SFF-8472)", 69 "QSFP", 70 "QSFP+ or later", 71 "CXP or later", 72 "Shielded Mini Multilane HD 4X", 73 "Shielded Mini Multilane HD 8X", 74 "QSFP28 or later", 75 "CXP2 (aka CXP28) or later", 76 "CDFP (Style 1/Style2)", 77 "Shielded Mini Multilane HD 4X Fanout Cable", 78 "Shielded Mini Multilane HD 8X Fanout Cable", 79 "CDFP (Style 3)", 80 "microQSFP" 81 }; 82 83 /* 84 * The set of values used for the encoding depends on whether we're a basic SFP 85 * device or not. The values are inconsistent between SFP and QSFP based 86 * devices. 87 * 88 * This table is derived from SFF 8024 r3.9 Table 4-2. 89 */ 90 #define SFF_8024_NENCS 9 91 static const char *sff_8024_enc_sfp[] = { 92 "Unspecified", 93 "8B/10B", 94 "4B/5B", 95 "NRZ", 96 "Manchester", 97 "SONET Scrambled", 98 "64B/66B", 99 "256B/257B", 100 "PAM4" 101 }; 102 103 static const char *sff_8024_enc_qsfp[] = { 104 "Unspecified", 105 "8B/10B", 106 "4B/5B", 107 "NRZ", 108 "SONET Scrambled", 109 "64B/66B", 110 "Manchester", 111 "256B/257B", 112 "PAM4" 113 }; 114 115 /* 116 * This table is derived from SFF 8024 r3.9 Section 4.4. 117 */ 118 #define SFF_8024_EXT_SPEC_NENTRIES 27 119 static const char *sff_8024_ext_spec[] = { 120 "Unspecified", 121 "100G AOC or 25GAUI C2M AOC", 122 "100GBASE-SR4 or 25GBASE-SR", 123 "100GBASE-LR4 or 25GBASE-LR", 124 "100GBASE-ER4 or 25GBASE-ER", 125 "100GBASE-SR10", 126 "100G CWDM4", 127 "100G PSM4 Parallel SMF", 128 "100G ACC or 25GAUI C2M ACC", 129 "Obsolete", 130 "Reserved", 131 "100GBASE-CR4 or 25GBASE-CR CA-L", 132 "25GBASE-CR CA-S", 133 "25GBASE-CR CA-N", 134 "Reserved", 135 "Reserved", 136 "40GBASE-ER4", 137 "4 x 10GBASE-SR", 138 "40G PSM4 Parallel SMF", 139 "G959.1 profile P1I1-2D1", 140 "G959.1 profile P1S1-2D2", 141 "G959.1 profile P1L1-2D2", 142 "10GBASE-T with SFI electrical interface", 143 "100G CLR4", 144 "100G AOC or 25GAUI C2M AOC", 145 "100G ACC or 25GAUI C2M ACC", 146 "100GE-DWDM2" 147 }; 148 149 typedef struct sff_pair { 150 uint_t sp_val; 151 const char *sp_name; 152 } sff_pair_t; 153 154 /* 155 * This table is derived from SFF 8024 r3.9 Section 4.3. 156 */ 157 static sff_pair_t sff_8024_connectors[] = { 158 { 0x00, "Unknown" }, 159 { 0x01, "SC (Subscriber Connector)" }, 160 { 0x02, "Fibre Channel Style 1 copper connector" }, 161 { 0x03, "Fibre Channel Style 2 copper connector" }, 162 { 0x04, "BNC/TNC (Bayonet/Threaded Neill-Concelman)" }, 163 { 0x05, "Fibre Channel coax headers" }, 164 { 0x06, "Fiber Jack" }, 165 { 0x07, "LC (Lucent Connector)" }, 166 { 0x08, "MT-RJ (Mechanical Transfer - Registered Jack)" }, 167 { 0x09, "MU (Multiple Optical)" }, 168 { 0x0A, "SG" }, 169 { 0x0B, "Optical Pigtail" }, 170 { 0x0C, "MPO 1x12 (Multifiber Parallel Optic)" }, 171 { 0x0D, "MPO 2x16" }, 172 { 0x20, "HSSDC II (High Speed Serial Data Connector)" }, 173 { 0x21, "Copper pigtail" }, 174 { 0x22, "RJ45 (Registered Jack)" }, 175 { 0x23, "No separable connector" }, 176 { 0x24, "MXC 2x16" }, 177 { 0x0, NULL } 178 }; 179 180 /* 181 * This is derived from SFF 8472 r12.2 Table 5-3. 182 */ 183 #define SFF_8472_COMP_10GETH_MASK 0xf0 184 static sff_pair_t sff_8472_comp_10geth[] = { 185 { 0x80, "10G Base-ER" }, 186 { 0x40, "10G Base-LRM" }, 187 { 0x20, "10G Base-LR" }, 188 { 0x10, "10G Base-SR" }, 189 { 0x0, NULL } 190 }; 191 192 /* 193 * This is derived from SFF 8472 r12.2 Table 5-3. 194 */ 195 #define SFF_8472_COMP_IB_MASK 0x0f 196 static sff_pair_t sff_8472_comp_ib[] = { 197 { 0x08, "1X SX" }, 198 { 0x04, "1X LX" }, 199 { 0x02, "1X Copper Active" }, 200 { 0x01, "1X Copper Passive" }, 201 { 0x0, NULL } 202 }; 203 204 /* 205 * This is derived from SFF 8472 r12.2 Table 5-3. 206 */ 207 #define SFF_8472_COMP_ESCON_MASK 0xc0 208 static sff_pair_t sff_8472_comp_escon[] = { 209 { 0x80, "ESCON MMF, 1310nm LED" }, 210 { 0x40, "ESCON SMF, 1310nm Laser" }, 211 { 0x0, NULL } 212 }; 213 214 /* 215 * This is derived from SFF 8472 r12.2 Table 5-3. These values come from both 216 * bytes 4 and 5. We treat this as a uint16_t with the low byte as byte 4 and 217 * the high byte as byte 5. 218 */ 219 #define SFF_8472_COMP_SOCON_MASK 0x773f 220 static sff_pair_t sff_8472_comp_sonet[] = { 221 { 0x20, "OC-192, short reach" }, 222 { 0x10, "SONET reach specifier bit 1" }, 223 { 0x08, "ONET reach specifier bit 2" }, 224 { 0x04, "OC-48, long reach" }, 225 { 0x02, "OC-48, intermediate reach" }, 226 { 0x01, "OC-48, short reach" }, 227 /* 0x8000 is unallocated */ 228 { 0x4000, "OC-12, single mode, long reach" }, 229 { 0x2000, "OC-12, single mode, inter. reach" }, 230 { 0x1000, "OC-12, short reach" }, 231 /* 0x800 is unallocted */ 232 { 0x0400, "OC-3, single mode, long reach" }, 233 { 0x0200, "OC-3, single mode, inter. reach" }, 234 { 0x0100, "OC-3, short reach" }, 235 { 0x0, NULL } 236 }; 237 238 /* 239 * This is derived from SFF 8472 r12.2 Table 5-3. 240 */ 241 #define SFF_8472_COMP_ETH_MASK 0xff 242 static sff_pair_t sff_8472_comp_eth[] = { 243 { 0x80, "BASE-PX" }, 244 { 0x40, "BASE-BX10" }, 245 { 0x20, "100BASE-FX" }, 246 { 0x10, "100BASE-LX/LX10" }, 247 { 0x08, "1000BASE-T" }, 248 { 0x04, "1000BASE-CX" }, 249 { 0x02, "1000BASE-LX" }, 250 { 0x01, "1000BASE-SX" }, 251 { 0x0, NULL } 252 }; 253 254 /* 255 * This is derived from SFF 8472 r12.2 Table 5-3. 256 */ 257 #define SFF_8472_COMP_FCLEN_MASK 0xf8 258 static sff_pair_t sff_8472_comp_fclen[] = { 259 { 0x80, "very long distance (V)" }, 260 { 0x40, "short distance (S)" }, 261 { 0x20, "intermeddiate distance (I)" }, 262 { 0x10, "long distance (L)" }, 263 { 0x08, "medium distance (M)" }, 264 { 0x0, NULL } 265 }; 266 267 /* 268 * This is derived from SFF 8472 r12.2 Table 5-3. These values come from both 269 * bytes 7 and 8. We treat this as a uint16_t with the low byte as byte 7 and 270 * the high byte as byte 8. 271 */ 272 #define SFF_8472_COMP_TECH_MASK 0xf007 273 static sff_pair_t sff_8472_comp_tech[] = { 274 { 0x4, "Shortwave laser, linear Rx (SA)" }, 275 { 0x2, "Longwave laser (LC)" }, 276 { 0x1, "Electrical inter-enclosure (EL)" }, 277 { 0x8000, "Electrical intra-enclosure (EL)" }, 278 { 0x4000, "Shortwave laser w/o OFC (SN)" }, 279 { 0x2000, "Shortwave laser with OFC (SL)" }, 280 { 0x1000, "Longwave laser (LL)" }, 281 { 0x0, NULL } 282 }; 283 284 /* 285 * This is derived from SFF 8472 r12.2 Table 5-3. 286 */ 287 #define SFF_8472_COMP_CABLE_MASK 0x0c 288 #define SFF_8472_COMP_CABLE_ACTIVE 0x08 289 #define SFF_8472_COMP_CABLE_PASSIVE 0x04 290 static sff_pair_t sff_8472_comp_cable[] = { 291 { 0x08, "Active Cable" }, 292 { 0x04, "Passive Cable" }, 293 { 0x0, NULL } 294 }; 295 296 /* 297 * This is derived from SFF 8472 r12.2 Table 5-3. 298 */ 299 #define SFF_8472_COMP_MEDIA_MASK 0xfd 300 static sff_pair_t sff_8472_comp_media[] = { 301 { 0x80, "Twin Axial Pair (TW)" }, 302 { 0x40, "Twisted Pair (TP)" }, 303 { 0x20, "Miniature Coax (MI)" }, 304 { 0x10, "Video Coax (TV)" }, 305 { 0x08, "Multimode, 62.5um (M6)" }, 306 { 0x04, "Multimode, 50um (M5, M5E)" }, 307 /* 0x02 is Unallocated */ 308 { 0x01, "Single Mode (SM)" }, 309 { 0x0, NULL } 310 }; 311 312 /* 313 * This is derived from SFF 8472 r12.2 Table 5-3. 314 */ 315 #define SFF_8472_COMP_SPEED_MASK 0xfd 316 static sff_pair_t sff_8472_comp_speed[] = { 317 { 0x80, "1200 MBytes/sec" }, 318 { 0x40, "800 MBytes/sec" }, 319 { 0x20, "1600 MBytes/sec" }, 320 { 0x10, "400 MBytes/sec" }, 321 { 0x08, "3200 MBytes/sec" }, 322 { 0x04, "200 MBytes/sec" }, 323 /* 0x02 is Unallocated */ 324 { 0x01, "100 MBytes/sec" }, 325 { 0x0, NULL } 326 }; 327 328 /* 329 * This is derived from SFF 8472 r12.2 Table 8-1. 330 * Note, only byte 60 is allocated at this time. 331 */ 332 #define SFF_8472_PCABLE_COMP_MASK 0x3f 333 static sff_pair_t sff_8472_pcable_comp[] = { 334 { 0x20, "Reserved for SFF-8461" }, 335 { 0x10, "Reserved for SFF-8461" }, 336 { 0x08, "Reserved for SFF-8461" }, 337 { 0x04, "Reserved for SFF-8461" }, 338 { 0x02, "Compliant to FC-PI-4 Appendix H" }, 339 { 0x01, "Compliant to SFF-8431 Appendix E" }, 340 { 0x0, NULL } 341 }; 342 343 /* 344 * This is derived from SFF 8472 r12.2 Table 8-2. 345 * Note, only byte 60 is allocated at this time. 346 */ 347 #define SFF_8472_ACABLE_COMP_MASK 0xf 348 static sff_pair_t sff_8472_acable_comp[] = { 349 { 0x08, "Compliant to FC-PI-4 Limiting" }, 350 { 0x04, "Compliant to SFF-8431 Limiting" }, 351 { 0x02, "Compliant to FC-PI-4 Appendix H" }, 352 { 0x01, "Compliant to SFF-8431 Appendix" }, 353 { 0x0, NULL } 354 }; 355 356 /* 357 * This is derived from SFF 8472 r12.2 Table 8-3. 358 * Note that we combined byte 64 and 65. Byte 64 is the upper bit. 359 */ 360 #define SFF_8472_OPTION_MASK 0x3ffe 361 static sff_pair_t sff_8472_options[] = { 362 { 0x2000, "Power Level 3 Requirement"}, 363 { 0x1000, "Paging Implemented"}, 364 { 0x0800, "Retimer or CDR implemented"}, 365 { 0x0400, "Cooled Transceiver Implemented"}, 366 { 0x0200, "Power Level 2 Requirement"}, 367 { 0x0100, "Linear Receiver Output Implemented"}, 368 { 0x0080, "Receiver decision threshold implemented"}, 369 { 0x0040, "Tunable transmitter"}, 370 { 0x0020, "RATE_SELECT implemented"}, 371 { 0x0010, "TX_DISABLE implemented"}, 372 { 0x0008, "TX_FAULT implemented"}, 373 { 0x0004, "Rx_LOS inverted"}, 374 { 0x0002, "Rx_LOS implemented"}, 375 }; 376 377 /* 378 * This is derived from SFF 8472 r12.2 Table 8-6. 379 */ 380 #define SFF_8472_EXTOPT_MASK 0xfe 381 static sff_pair_t sff_8472_extopts[] = { 382 { 0x80, "Alarm/Warning flags implemented" }, 383 { 0x40, "Soft TX_DISABLE implemented" }, 384 { 0x20, "Soft TX_FAULT implemented" }, 385 { 0x10, "Soft RX_LOS implemented" }, 386 { 0x08, "Soft RATE_SELECT implemented" }, 387 { 0x04, "Application Select implemented" }, 388 { 0x02, "Soft Rate Select Control Implemented" }, 389 { 0x01, "" }, 390 }; 391 392 /* 393 * This is derived from SFF 8472 r12.2 Table 8-8. 394 */ 395 #define SFF_8472_8472_COMP_NENTRIES 9 396 static const char *sff_8472_8472_comp[] = { 397 "Not compliant", 398 "Rev 9.3", 399 "Rev 9.5", 400 "Rev 10.2", 401 "Rev 10.4", 402 "Rev 11.0", 403 "Rev 11.3", 404 "Rev 11.4", 405 "Rev 12.0" 406 }; 407 408 /* 409 * This is derived from SFF 8636 r2.7 Table 6-17. 410 */ 411 #define SFF_8636_COMP_10GETH_MASK 0x7f 412 static sff_pair_t sff_8636_comp_10geth[] = { 413 { 0x40, "10GBASE-LRM" }, 414 { 0x20, "10GBASE-LR" }, 415 { 0x10, "10GBASE-SR" }, 416 { 0x08, "40GBASE-CR4" }, 417 { 0x04, "40GBASE-SR4" }, 418 { 0x02, "40GBASE-LR4" }, 419 { 0x01, "40G Active Cable (XLPPI)" }, 420 { 0x0, NULL } 421 }; 422 423 /* 424 * This is derived from SFF 8636 r2.7 Table 6-17. 425 */ 426 #define SFF_8636_COMP_SONET_MASK 0x07 427 static sff_pair_t sff_8636_comp_sonet[] = { 428 { 0x04, "OC 48, long reach" }, 429 { 0x02, "OC 48, intermediate reach" }, 430 { 0x01, "OC 48 short reach" }, 431 { 0x0, NULL } 432 }; 433 434 /* 435 * This is derived from SFF 8636 r2.7 Table 6-17. 436 */ 437 #define SFF_8636_COMP_SAS_MASK 0xf0 438 static sff_pair_t sff_8636_comp_sas[] = { 439 { 0x80, "SAS 24.0 Gb/s" }, 440 { 0x40, "SAS 12.0 Gb/s" }, 441 { 0x20, "SAS 6.0 Gb/s" }, 442 { 0x10, "SAS 3.0 Gb/s" }, 443 { 0x0, NULL } 444 }; 445 446 /* 447 * This is derived from SFF 8636 r2.7 Table 6-17. 448 */ 449 #define SFF_8636_COMP_ETH_MASK 0x0f 450 static sff_pair_t sff_8636_comp_eth[] = { 451 { 0x08, "1000BASE-T" }, 452 { 0x04, "1000BASE-CX" }, 453 { 0x02, "1000BASE-LX" }, 454 { 0x01, "1000BASE-SX" }, 455 { 0x0, NULL } 456 }; 457 458 /* 459 * This is derived from SFF 8636 r2.7 Table 6-17. 460 */ 461 #define SFF_8636_COMP_FCLEN_MASK 0xf8 462 static sff_pair_t sff_8636_comp_fclen[] = { 463 { 0x80, "very long distance (V)" }, 464 { 0x40, "short distance (S)" }, 465 { 0x20, "intermeddiate distance (I)" }, 466 { 0x10, "long distance (L)" }, 467 { 0x08, "medium distance (M)" }, 468 { 0x0, NULL } 469 }; 470 471 /* 472 * This is derived from SFF 8636 r2.7 Table 6-17. 473 */ 474 #define SFF_8636_COMP_TECH_MASK 0xf003 475 static sff_pair_t sff_8636_comp_tech[] = { 476 { 0x2, "Longwave laser (LC)" }, 477 { 0x1, "Electrical inter-enclosure (EL)" }, 478 { 0x8000, "Electrical intra-enclosure (EL)" }, 479 { 0x4000, "Shortwave laser w/o OFC (SN)" }, 480 { 0x2000, "Shortwave laser with OFC (SL)" }, 481 { 0x1000, "Longwave laser (LL)" }, 482 { 0x0, NULL } 483 }; 484 485 /* 486 * This is derived from SFF 8636 r2.7 Table 6-17. 487 */ 488 #define SFF_8636_COMP_MEDIA_MASK 0xff 489 static sff_pair_t sff_8636_comp_media[] = { 490 { 0x80, "Twin Axial Pair (TW)" }, 491 { 0x40, "Twisted Pair (TP)" }, 492 { 0x20, "Miniature Coax (MI)" }, 493 { 0x10, "Video Coax (TV)" }, 494 { 0x08, "Multimode, 62.5um (M6)" }, 495 { 0x04, "Multimode, 50m (M5)" }, 496 { 0x02, "Multimode, 50um (OM3)" }, 497 { 0x01, "Single Mode (SM)" }, 498 { 0x0, NULL } 499 }; 500 501 /* 502 * This is derived from SFF 8636 r2.7 Table 6-17. 503 */ 504 #define SFF_8636_COMP_SPEED_MASK 0xfd 505 static sff_pair_t sff_8636_comp_speed[] = { 506 { 0x80, "1200 MBytes/sec" }, 507 { 0x40, "800 MBytes/sec" }, 508 { 0x20, "1600 MBytes/sec" }, 509 { 0x10, "400 MBytes/sec" }, 510 { 0x08, "3200 MBytes/sec" }, 511 { 0x04, "200 MBytes/sec" }, 512 { 0x01, "100 MBytes/sec" }, 513 { 0x0, NULL } 514 }; 515 516 /* 517 * This is derived from SFF 8636 r2.7 Table 6-20. 518 */ 519 static const char *sff_8636_trans_tech[] = { 520 "850 nm VCSEL", 521 "1310 nm VCSEL", 522 "1550 nm VCSEL", 523 "1310 nm FP", 524 "1310 nm DFB", 525 "1550 nm DFB", 526 "1310 nm EML", 527 "1550 nm EML", 528 "Other / Undefined", 529 "1490 nm DFB", 530 "Copper cable unequalized", 531 "Copper cable passive equalized", 532 "Copper cable, near and far end limiting active equalizers", 533 "Copper cable, far end limiting active equalizers", 534 "Copper cable, near end limiting active equalizers", 535 "Copper cable, linear active equalizers" 536 }; 537 538 /* 539 * This is derived from SFF 8636 r2.7 Table 6-21. 540 */ 541 #define SFF_8636_EXTMOD_CODES 0x1f 542 static sff_pair_t sff_8636_extmod_codes[] = { 543 { 0x10, "EDR" }, 544 { 0x08, "FDR" }, 545 { 0x04, "QDR" }, 546 { 0x02, "DDR" }, 547 { 0x01, "SDR" }, 548 { 0x00, NULL } 549 }; 550 551 /* 552 * This is derived from SFF 8636 r2.7 Table 6-22. This combines bytes 193-195. 553 * We treat byte 193 as the most significant. 554 */ 555 #define SFF_8636_OPTION_MASK 0x0ffffe 556 static sff_pair_t sff_8636_options[] = { 557 { 0x080000, "TX Input Equalization Auto Adaptive Capable" }, 558 { 0x040000, "TX Input Equalization Fixed Programmable" }, 559 { 0x020000, "RX Output Emphasis Fixed Programmable Settings" }, 560 { 0x010000, "RX Output Amplitude Fixed Programmable Settings" }, 561 { 0x008000, "TX CDR On/Off Control implemented" }, 562 { 0x004000, "RX CDR On/Off Control implemented" }, 563 { 0x002000, "Tx CDR Loss of Lock Flag implemented" }, 564 { 0x001000, "Rx CDR Loss of Lock Flag implemented" }, 565 { 0x000800, "Rx Squelch Disable implemented" }, 566 { 0x000400, "Rx Output Disable capable" }, 567 { 0x000200, "Tx Squelch Disable implemented" }, 568 { 0x000100, "Tx Squelch implemented" }, 569 { 0x000080, "Memory page 02h provided" }, 570 { 0x000040, "Memory page 01h provided" }, 571 { 0x000020, "Rate Select implemented" }, 572 { 0x000010, "Tx_DISABLE implemented" }, 573 { 0x000008, "Tx_FAULT implemented" }, 574 { 0x000004, "Tx Squelch for Pave" }, 575 { 0x000002, "Tx Loss of Signal implemented" }, 576 { 0x0, NULL } 577 }; 578 579 /* 580 * This is derived from SFF 8636 r2.7 Table 6-25. 581 */ 582 #define SFF_8636_ENHANCED_OPTIONS_MASK 0x1c 583 static sff_pair_t sff_8636_eopt[] = { 584 { 0x10, "Initialization Complete Flag Implemented" }, 585 { 0x08, "Extended Rate Selection Supported" }, 586 { 0x04, "Application Select Table Supported" }, 587 { 0x0, NULL } 588 }; 589 590 static const char * 591 sff_pair_find(uint_t val, sff_pair_t *pairs) 592 { 593 while (pairs->sp_name != NULL) { 594 if (val == pairs->sp_val) 595 return (pairs->sp_name); 596 pairs++; 597 } 598 599 return (NULL); 600 } 601 602 static int 603 sff_parse_id(uint8_t id, nvlist_t *nvl) 604 { 605 const char *val; 606 607 if (id >= SFF_8024_VENDOR) { 608 val = "Vendor Specific"; 609 } else if (id >= SFF_8024_NIDS) { 610 val = "Reserved"; 611 } else { 612 val = sff_8024_id_strs[id]; 613 } 614 615 return (nvlist_add_string(nvl, LIBSFF_KEY_IDENTIFIER, val)); 616 } 617 618 static int 619 sff_add_unit_string(uint64_t val, uint64_t factor, const char *unit, 620 nvlist_t *nvl, const char *key) 621 { 622 char str[SFP_STRBUF]; 623 624 val *= factor; 625 (void) snprintf(str, sizeof (str), "%" PRIu64 " %s", val, unit); 626 return (nvlist_add_string(nvl, key, str)); 627 } 628 629 static int 630 sff_parse_connector(uint8_t con, nvlist_t *nvl) 631 { 632 const char *val; 633 634 if (con >= 0x80) { 635 val = "Vendor Specific"; 636 } else { 637 if ((val = sff_pair_find(con, sff_8024_connectors)) == NULL) 638 val = "Reserved"; 639 } 640 641 return (nvlist_add_string(nvl, LIBSFF_KEY_CONNECTOR, val)); 642 } 643 644 /* 645 * Many of the values in the specifications are bitfields of which one or more 646 * bits may be set. We represent that as an array of strings. One entry will be 647 * added for each set bit that's found in pairs. 648 */ 649 static int 650 sff_gather_bitfield(uint32_t value, const char *name, sff_pair_t *pairs, 651 nvlist_t *nvl) 652 { 653 uint32_t i; 654 const char *vals[32]; 655 uint_t count; 656 657 count = 0; 658 for (i = 0; i < 32; i++) { 659 uint32_t bit; 660 const char *str; 661 662 bit = 1 << i; 663 if ((bit & value) == 0) 664 continue; 665 666 str = sff_pair_find(bit, pairs); 667 if (str != NULL) { 668 vals[count++] = str; 669 } 670 } 671 672 if (count == 0) 673 return (0); 674 675 /* 676 * The nvlist routines don't touch the array, so we end up lying about 677 * the type of data so that we can avoid a rash of additional 678 * allocations and strdups. 679 */ 680 return (nvlist_add_string_array(nvl, name, (char **)vals, count)); 681 } 682 683 static int 684 sff_parse_compliance(const uint8_t *buf, nvlist_t *nvl) 685 { 686 int ret; 687 uint16_t v; 688 689 if ((ret = sff_gather_bitfield(buf[SFF_8472_COMPLIANCE_10GE] & 690 SFF_8472_COMP_10GETH_MASK, LIBSFF_KEY_COMPLIANCE_10GBE, 691 sff_8472_comp_10geth, nvl)) != 0) 692 return (ret); 693 694 if ((ret = sff_gather_bitfield(buf[SFF_8472_COMPLIANCE_IB] & 695 SFF_8472_COMP_IB_MASK, LIBSFF_KEY_COMPLIANCE_IB, 696 sff_8472_comp_ib, nvl)) != 0) 697 return (ret); 698 699 if ((ret = sff_gather_bitfield(buf[SFF_8472_COMPLIANCE_ESCON] & 700 SFF_8472_COMP_ESCON_MASK, LIBSFF_KEY_COMPLIANCE_ESCON, 701 sff_8472_comp_escon, nvl)) != 0) 702 return (ret); 703 704 v = buf[SFF_8472_COMPLIANCE_SONET_LOW] | 705 (buf[SFF_8472_COMPLIANCE_SONET_HIGH] << 8); 706 if ((ret = sff_gather_bitfield(v & SFF_8472_COMP_SOCON_MASK, 707 LIBSFF_KEY_COMPLIANCE_SONET, sff_8472_comp_sonet, nvl)) != 0) 708 return (ret); 709 710 if ((ret = sff_gather_bitfield(buf[SFF_8472_COMPLIANCE_ETHERNET] & 711 SFF_8472_COMP_ETH_MASK, LIBSFF_KEY_COMPLIANCE_GBE, 712 sff_8472_comp_eth, nvl)) != 0) 713 return (ret); 714 715 if ((ret = sff_gather_bitfield(buf[SFF_8472_COMPLIANCE_FCLEN] & 716 SFF_8472_COMP_FCLEN_MASK, LIBSFF_KEY_COMPLIANCE_FC_LEN, 717 sff_8472_comp_fclen, nvl)) != 0) 718 return (ret); 719 720 v = buf[SFF_8472_COMPLIANCE_FC_LOW] | 721 (buf[SFF_8472_COMPLIANCE_FC_HIGH] << 8); 722 if ((ret = sff_gather_bitfield(v & SFF_8472_COMP_TECH_MASK, 723 LIBSFF_KEY_COMPLIANCE_FC_TECH, sff_8472_comp_tech, nvl)) != 0) 724 return (ret); 725 726 if ((ret = sff_gather_bitfield(buf[SFF_8472_COMPLIANCE_SFP] & 727 SFF_8472_COMP_CABLE_MASK, LIBSFF_KEY_COMPLIANCE_SFP, 728 sff_8472_comp_cable, nvl)) != 0) 729 return (ret); 730 731 if ((ret = sff_gather_bitfield(buf[SFF_8472_COMPLIANCE_FC_MEDIA] & 732 SFF_8472_COMP_MEDIA_MASK, LIBSFF_KEY_COMPLIANCE_FC_MEDIA, 733 sff_8472_comp_media, nvl)) != 0) 734 return (ret); 735 736 if ((ret = sff_gather_bitfield(buf[SFF_8472_COMPLIANCE_FC_SPEED] & 737 SFF_8472_COMP_SPEED_MASK, LIBSFF_KEY_COMPLIANCE_FC_SPEED, 738 sff_8472_comp_speed, nvl)) != 0) 739 return (ret); 740 741 return (0); 742 } 743 744 static int 745 sff_parse_encoding(uint8_t val, nvlist_t *nvl, boolean_t sfp) 746 { 747 const char *str; 748 if (val >= SFF_8024_NENCS) { 749 str = "Reserved"; 750 } else if (sfp) { 751 str = sff_8024_enc_sfp[val]; 752 } else { 753 str = sff_8024_enc_qsfp[val]; 754 } 755 756 return (nvlist_add_string(nvl, LIBSFF_KEY_ENCODING, str)); 757 } 758 759 static int 760 sff_parse_br(const uint8_t *buf, nvlist_t *nvl) 761 { 762 if (buf[SFF_8472_BR_NOMINAL] == 0xff) { 763 int ret; 764 if ((ret = sff_add_unit_string(buf[SFF_8472_BR_MAX], 765 SFF_8472_BR_MAX_FACTOR, "MBd", nvl, 766 LIBSFF_KEY_BR_MAX)) != 0) 767 return (ret); 768 return (sff_add_unit_string(buf[SFF_8472_BR_MIN], 769 SFF_8472_BR_MIN_FACTOR, "MBd", nvl, LIBSFF_KEY_BR_MIN)); 770 } else { 771 return (sff_add_unit_string(buf[SFF_8472_BR_NOMINAL], 772 SFF_8472_BR_NOMINAL_FACTOR, "MBd", nvl, 773 LIBSFF_KEY_BR_NOMINAL)); 774 } 775 } 776 777 static int 778 sff_parse_lengths(const uint8_t *buf, nvlist_t *nvl) 779 { 780 int ret; 781 782 if (buf[SFF_8472_LENGTH_SMF_KM] != 0) { 783 if ((ret = sff_add_unit_string(buf[SFF_8472_LENGTH_SMF_KM], 784 SFF_8472_LENGTH_SMF_KM_FACTOR, "km", nvl, 785 LIBSFF_KEY_LENGTH_SMF_KM)) != 0) 786 return (ret); 787 } 788 789 if (buf[SFF_8472_LENGTH_SMF] != 0) { 790 if ((ret = sff_add_unit_string(buf[SFF_8472_LENGTH_SMF], 791 SFF_8472_LENGTH_SMF_FACTOR, "m", nvl, 792 LIBSFF_KEY_LENGTH_SMF)) != 0) 793 return (ret); 794 } 795 796 if (buf[SFF_8472_LENGTH_50UM] != 0) { 797 if ((ret = sff_add_unit_string(buf[SFF_8472_LENGTH_50UM], 798 SFF_8472_LENGTH_50UM_FACTOR, "m", nvl, 799 LIBSFF_KEY_LENGTH_OM2)) != 0) 800 return (ret); 801 } 802 803 if (buf[SFF_8472_LENGTH_62UM] != 0) { 804 if ((ret = sff_add_unit_string(buf[SFF_8472_LENGTH_62UM], 805 SFF_8472_LENGTH_62UM_FACTOR, "m", nvl, 806 LIBSFF_KEY_LENGTH_OM1)) != 0) 807 return (ret); 808 } 809 810 if (buf[SFF_8472_LENGTH_COPPER] != 0) { 811 if ((ret = sff_add_unit_string(buf[SFF_8472_LENGTH_COPPER], 812 SFF_8472_LENGTH_COPPER_FACTOR, "m", nvl, 813 LIBSFF_KEY_LENGTH_COPPER)) != 0) 814 return (ret); 815 } 816 817 if (buf[SFF_8472_LENGTH_OM3] != 0) { 818 if ((ret = sff_add_unit_string(buf[SFF_8472_LENGTH_OM3], 819 SFF_8472_LENGTH_OM3_FACTOR, "m", nvl, 820 LIBSFF_KEY_LENGTH_OM3)) != 0) 821 return (ret); 822 } 823 824 return (0); 825 } 826 827 /* 828 * Strings in the SFF specification are written into fixed sized buffers. The 829 * strings are padded to the right with spaces (ASCII 0x20) and there is no NUL 830 * character like in a standard C string. While the string is padded with 831 * spaces, spaces may appear in the middle of the string and should not be 832 * confused as padding. 833 */ 834 static int 835 sff_parse_string(const uint8_t *buf, uint_t start, uint_t len, 836 const char *field, nvlist_t *nvl) 837 { 838 uint_t i; 839 char strbuf[SFP_STRBUF]; 840 841 assert(len < sizeof (strbuf)); 842 strbuf[0] = '\0'; 843 while (len > 0) { 844 if (buf[start + len - 1] != ' ') 845 break; 846 len--; 847 } 848 if (len == 0) 849 return (0); 850 851 /* 852 * This is supposed to be 7-bit printable ASCII. If we find any 853 * characters that aren't, don't include this string. 854 */ 855 for (i = 0; i < len; i++) { 856 if (isascii(buf[start + i]) == 0 || 857 isprint(buf[start + i]) == 0) { 858 return (0); 859 } 860 } 861 bcopy(&buf[start], strbuf, len); 862 strbuf[len] = '\0'; 863 864 return (nvlist_add_string(nvl, field, strbuf)); 865 } 866 867 static int 868 sff_parse_optical(const uint8_t *buf, nvlist_t *nvl) 869 { 870 /* 871 * The value in byte 8 determines whether we interpret this as 872 * describing aspects of a copper device or if it describes the 873 * wavelength. 874 */ 875 if (buf[SFF_8472_COMPLIANCE_SFP] & SFF_8472_COMP_CABLE_PASSIVE) { 876 return (sff_gather_bitfield(buf[SFF_8472_PASSIVE_SPEC] & 877 SFF_8472_PCABLE_COMP_MASK, LIBSFF_KEY_COMPLIANCE_PASSIVE, 878 sff_8472_pcable_comp, nvl)); 879 } else if (buf[SFF_8472_COMPLIANCE_SFP] & SFF_8472_COMP_CABLE_ACTIVE) { 880 return (sff_gather_bitfield(buf[SFF_8472_ACTIVE_SPEC] & 881 SFF_8472_ACABLE_COMP_MASK, LIBSFF_KEY_COMPLIANCE_ACTIVE, 882 sff_8472_acable_comp, nvl)); 883 884 } else { 885 uint16_t val = (buf[SFF_8472_WAVELENGTH_HI] << 8) | 886 buf[SFF_8472_WAVELENGTH_LOW]; 887 888 return (sff_add_unit_string(val, SFF_8472_WAVELENGTH_FACTOR, 889 "nm", nvl, LIBSFF_KEY_WAVELENGTH)); 890 } 891 } 892 893 static int 894 sff_parse_options(const uint8_t *buf, nvlist_t *nvl) 895 { 896 uint16_t val; 897 898 val = (buf[SFF_8472_OPTIONS_HI] << 8) | buf[SFF_8472_OPTIONS_LOW]; 899 return (sff_gather_bitfield(val & SFF_8472_OPTION_MASK, 900 LIBSFF_KEY_OPTIONS, sff_8472_options, nvl)); 901 } 902 903 static int 904 sff_parse_8472_comp(uint8_t val, nvlist_t *nvl) 905 { 906 const char *str; 907 908 if (val >= SFF_8472_8472_COMP_NENTRIES) { 909 str = "Unallocated"; 910 } else { 911 str = sff_8472_8472_comp[val]; 912 } 913 914 return (nvlist_add_string(nvl, LIBSFF_KEY_COMPLIANCE_8472, str)); 915 } 916 917 /* 918 * Parse an SFP that is either based on INF 8074 or SFF 8472. These are GBIC, 919 * SFP, SFP+, and SFP28 based devices. 920 * 921 * The SFP parsing into an nvlist_t is incomplete. At the moment we're not 922 * parsing the following pieces from SFF 8472 page 0xa0: 923 * 924 * o Rate Selection Logic 925 * o Diagnostic Monitoring Type 926 */ 927 static int 928 sff_parse_sfp(const uint8_t *buf, nvlist_t *nvl) 929 { 930 int ret; 931 932 if ((ret = sff_parse_id(buf[SFF_8472_IDENTIFIER], nvl)) != 0) 933 return (ret); 934 935 /* 936 * The extended identifier is derived from SFF 8472, Table 5-2. It 937 * generally is just the value 4. The other values are not well defined. 938 */ 939 if ((ret = nvlist_add_uint8(nvl, LIBSFF_KEY_8472_EXT_IDENTIFIER, 940 buf[SFF_8472_EXT_IDENTIFER])) != 0) 941 return (ret); 942 943 if ((ret = sff_parse_connector(buf[SFF_8472_CONNECTOR], nvl)) != 0) 944 return (ret); 945 946 if ((ret = sff_parse_compliance(buf, nvl)) != 0) 947 return (ret); 948 949 if ((ret = sff_parse_encoding(buf[SFF_8472_ENCODING], nvl, 950 B_TRUE)) != 0) 951 return (ret); 952 953 if ((ret = sff_parse_br(buf, nvl)) != 0) 954 return (ret); 955 956 if ((ret = sff_parse_lengths(buf, nvl)) != 0) 957 return (ret); 958 959 if ((ret = sff_parse_string(buf, SFF_8472_VENDOR, SFF_8472_VENDOR_LEN, 960 LIBSFF_KEY_VENDOR, nvl)) != 0) 961 return (ret); 962 963 if ((ret = nvlist_add_byte_array(nvl, LIBSFF_KEY_OUI, 964 (uchar_t *)&buf[SFF_8472_OUI], SFF_8472_OUI_LEN)) != 0) 965 return (ret); 966 967 if ((ret = sff_parse_string(buf, SFF_8472_VENDOR_PN, 968 SFF_8472_VENDOR_PN_LEN, LIBSFF_KEY_PART, nvl)) != 0) 969 return (ret); 970 971 if ((ret = sff_parse_string(buf, SFF_8472_VENDOR_REV, 972 SFF_8472_VENDOR_REV_LEN, LIBSFF_KEY_REVISION, nvl)) != 0) 973 return (ret); 974 975 if ((ret = sff_parse_optical(buf, nvl)) != 0) 976 return (ret); 977 978 if ((ret = sff_parse_options(buf, nvl)) != 0) 979 return (ret); 980 981 if ((ret = sff_parse_string(buf, SFF_8472_VENDOR_SN, 982 SFF_8472_VENDOR_SN_LEN, LIBSFF_KEY_SERIAL, nvl)) != 0) 983 return (ret); 984 985 if ((ret = sff_parse_string(buf, SFF_8472_DATE_CODE, 986 SFF_8472_DATE_CODE_LEN, LIBSFF_KEY_DATECODE, nvl)) != 0) 987 return (ret); 988 989 if ((ret = sff_gather_bitfield(buf[SFF_8472_ENHANCED_OPTIONS] & 990 SFF_8472_EXTOPT_MASK, LIBSFF_KEY_EXTENDED_OPTIONS, 991 sff_8472_extopts, nvl)) != 0) 992 return (ret); 993 994 if ((ret = sff_parse_8472_comp(buf[SFF_8472_SFF_8472_COMPLIANCE], 995 nvl)) != 0) 996 return (ret); 997 998 return (0); 999 } 1000 1001 static int 1002 sff_qsfp_parse_compliance(const uint8_t *buf, nvlist_t *nvl) 1003 { 1004 int ret; 1005 uint16_t fc_val; 1006 1007 if ((ret = sff_gather_bitfield(buf[SFF_8636_COMPLIANCE_10GBEP] & 1008 SFF_8636_COMP_10GETH_MASK, LIBSFF_KEY_COMPLIANCE_10GBE, 1009 sff_8636_comp_10geth, nvl)) != 0) 1010 return (ret); 1011 1012 if ((ret = sff_gather_bitfield(buf[SFF_8636_COMPLIANCE_SONET] & 1013 SFF_8636_COMP_SONET_MASK, LIBSFF_KEY_COMPLIANCE_SONET, 1014 sff_8636_comp_sonet, nvl)) != 0) 1015 return (ret); 1016 1017 if ((ret = sff_gather_bitfield(buf[SFF_8636_COMPLIANCE_SAS] & 1018 SFF_8636_COMP_SAS_MASK, LIBSFF_KEY_COMPLIANCE_SAS, 1019 sff_8636_comp_sas, nvl)) != 0) 1020 return (ret); 1021 1022 if ((ret = sff_gather_bitfield(buf[SFF_8636_COMPLIANCE_ETHERNET] & 1023 SFF_8636_COMP_ETH_MASK, LIBSFF_KEY_COMPLIANCE_GBE, 1024 sff_8636_comp_eth, nvl)) != 0) 1025 return (ret); 1026 1027 if ((ret = sff_gather_bitfield(buf[SFF_8636_COMPLIANCE_FCLEN] & 1028 SFF_8636_COMP_FCLEN_MASK, LIBSFF_KEY_COMPLIANCE_FC_LEN, 1029 sff_8636_comp_fclen, nvl)) != 0) 1030 return (ret); 1031 1032 fc_val = buf[SFF_8636_COMPLIANCE_FC_LOW] | 1033 (buf[SFF_8636_COMPLIANCE_FC_HIGH] << 8); 1034 if ((ret = sff_gather_bitfield(fc_val & SFF_8636_COMP_TECH_MASK, 1035 LIBSFF_KEY_COMPLIANCE_FC_TECH, sff_8636_comp_tech, nvl)) != 0) 1036 return (ret); 1037 1038 if ((ret = sff_gather_bitfield(buf[SFF_8636_COMPLIANCE_FC_MEDIA] & 1039 SFF_8636_COMP_MEDIA_MASK, LIBSFF_KEY_COMPLIANCE_FC_MEDIA, 1040 sff_8636_comp_media, nvl)) != 0) 1041 return (ret); 1042 1043 if ((ret = sff_gather_bitfield(buf[SFF_8636_COMPLIANCE_FC_SPEED] & 1044 SFF_8636_COMP_SPEED_MASK, LIBSFF_KEY_COMPLIANCE_FC_SPEED, 1045 sff_8636_comp_speed, nvl)) != 0) 1046 return (ret); 1047 1048 return (0); 1049 } 1050 1051 static int 1052 sff_qsfp_parse_br(const uint8_t *buf, nvlist_t *nvl) 1053 { 1054 if (buf[SFF_8636_BR_NOMINAL] == 0xff) { 1055 return (sff_add_unit_string(buf[SFF_8636_BR_NOMINAL_EXT], 1056 SFF_8636_BR_NOMINAL_EXT_FACTOR, "Mbps", nvl, 1057 LIBSFF_KEY_BR_NOMINAL)); 1058 } else { 1059 return (sff_add_unit_string(buf[SFF_8636_BR_NOMINAL], 1060 SFF_8636_BR_NOMINAL_FACTOR, "Mbps", nvl, 1061 LIBSFF_KEY_BR_NOMINAL)); 1062 } 1063 } 1064 1065 static int 1066 sff_qsfp_parse_lengths(const uint8_t *buf, nvlist_t *nvl) 1067 { 1068 int ret; 1069 1070 if (buf[SFF_8636_LENGTH_SMF] != 0) { 1071 if ((ret = sff_add_unit_string(buf[SFF_8636_LENGTH_SMF], 1072 SFF_8636_LENGTH_SMF_FACTOR, "km", nvl, 1073 LIBSFF_KEY_LENGTH_SMF_KM)) != 0) 1074 return (ret); 1075 } 1076 1077 if (buf[SFF_8636_LENGTH_OM3] != 0) { 1078 if ((ret = sff_add_unit_string(buf[SFF_8636_LENGTH_OM3], 1079 SFF_8636_LENGTH_OM3_FACTOR, "m", nvl, 1080 LIBSFF_KEY_LENGTH_OM3)) != 0) 1081 return (ret); 1082 } 1083 1084 if (buf[SFF_8636_LENGTH_OM2] != 0) { 1085 if ((ret = sff_add_unit_string(buf[SFF_8636_LENGTH_OM2], 1086 SFF_8636_LENGTH_OM2_FACTOR, "m", nvl, 1087 LIBSFF_KEY_LENGTH_OM2)) != 0) 1088 return (ret); 1089 } 1090 1091 if (buf[SFF_8636_LENGTH_OM1] != 0) { 1092 if ((ret = sff_add_unit_string(buf[SFF_8636_LENGTH_OM1], 1093 SFF_8636_LENGTH_OM1_FACTOR, "m", nvl, 1094 LIBSFF_KEY_LENGTH_OM1)) != 0) 1095 return (ret); 1096 } 1097 1098 if (buf[SFF_8636_LENGTH_COPPER] != 0) { 1099 if ((ret = sff_add_unit_string(buf[SFF_8636_LENGTH_COPPER], 1100 SFF_8636_LENGTH_COPPER_FACTOR, "m", nvl, 1101 LIBSFF_KEY_LENGTH_COPPER)) != 0) 1102 return (ret); 1103 } 1104 1105 return (0); 1106 } 1107 1108 static int 1109 sff_qsfp_parse_tech(uint8_t val, nvlist_t *nvl) 1110 { 1111 const char *strs[5]; 1112 1113 strs[0] = sff_8636_trans_tech[(val & 0xf0) >> 4]; 1114 if (val & 0x08) { 1115 strs[1] = "Active Wavelength Control"; 1116 } else { 1117 strs[1] = "No Wavelength Control"; 1118 } 1119 1120 if (val & 0x04) { 1121 strs[2] = "Cooled Transmitter"; 1122 } else { 1123 strs[2] = "Uncooled Transmitter"; 1124 } 1125 1126 if (val & 0x02) { 1127 strs[3] = "APD Detector"; 1128 } else { 1129 strs[3] = "Pin Detector"; 1130 } 1131 1132 if (val & 0x01) { 1133 strs[4] = "Transmitter Tunable"; 1134 } else { 1135 strs[4] = "Transmitter Not Tunable"; 1136 } 1137 1138 /* 1139 * The nvlist routines don't touch the array, so we end up lying about 1140 * the type of data so that we can avoid a rash of additional 1141 * allocations and strdups. 1142 */ 1143 return (nvlist_add_string_array(nvl, LIBSFF_KEY_TRAN_TECH, 1144 (char **)strs, 5)); 1145 } 1146 1147 static int 1148 sff_qsfp_parse_copperwave(const uint8_t *buf, nvlist_t *nvl) 1149 { 1150 int ret; 1151 1152 /* 1153 * The values that we get depend on whether or not we are a copper 1154 * device or not. We can determine this based on the identification 1155 * information in the device technology field. 1156 */ 1157 if ((buf[SFF_8636_DEVICE_TECH] & 0xf0) >= 0xa0) { 1158 if ((ret = sff_add_unit_string(buf[SFF_8636_ATTENUATE_2G], 1, 1159 "dB", nvl, LIBSFF_KEY_ATTENUATE_2G)) != 0) 1160 return (ret); 1161 if ((ret = sff_add_unit_string(buf[SFF_8636_ATTENUATE_5G], 1, 1162 "dB", nvl, LIBSFF_KEY_ATTENUATE_5G)) != 0) 1163 return (ret); 1164 if ((ret = sff_add_unit_string(buf[SFF_8636_ATTENUATE_7G], 1, 1165 "dB", nvl, LIBSFF_KEY_ATTENUATE_7G)) != 0) 1166 return (ret); 1167 if ((ret = sff_add_unit_string(buf[SFF_8636_ATTENUATE_12G], 1, 1168 "dB", nvl, LIBSFF_KEY_ATTENUATE_12G)) != 0) 1169 return (ret); 1170 } else { 1171 uint16_t val; 1172 double d; 1173 char strbuf[SFP_STRBUF]; 1174 1175 /* 1176 * Because we need to divide the units here into doubles, we 1177 * can't use the standard unit routine. 1178 */ 1179 val = (buf[SFF_8636_WAVELENGTH_NOMINAL_HI] << 8) | 1180 buf[SFF_8636_WAVELENGTH_NOMINAL_LOW]; 1181 if (val != 0) { 1182 d = val / 20.0; 1183 (void) snprintf(strbuf, sizeof (strbuf), "%.3lf nm", d); 1184 if ((ret = nvlist_add_string(nvl, LIBSFF_KEY_WAVELENGTH, 1185 strbuf)) != 0) 1186 return (ret); 1187 } 1188 1189 val = (buf[SFF_8636_WAVELENGTH_TOLERANCE_HI] << 8) | 1190 buf[SFF_8636_WAVELENGTH_TOLERANCE_LOW]; 1191 if (val != 0) { 1192 d = val / 20.0; 1193 (void) snprintf(strbuf, sizeof (strbuf), "%.3lf nm", d); 1194 if ((ret = nvlist_add_string(nvl, 1195 LIBSFF_KEY_WAVE_TOLERANCE, strbuf)) != 0) 1196 return (ret); 1197 } 1198 } 1199 1200 return (0); 1201 } 1202 1203 static int 1204 sff_qsfp_parse_casetemp(uint8_t val, nvlist_t *nvl) 1205 { 1206 /* 1207 * The default temperature per SFF 8636 r2.7 6.3.21 'Maximum Case 1208 * Temperature' is 70 C. If the value is zero, we're supposed to assume 1209 * it's the default. 1210 */ 1211 if (val == 0) 1212 val = 70; 1213 1214 return (sff_add_unit_string(val, 1, "C", nvl, 1215 LIBSFF_KEY_MAX_CASE_TEMP)); 1216 } 1217 1218 static int 1219 sff_qsfp_parse_extcomp(uint8_t val, nvlist_t *nvl) 1220 { 1221 const char *str; 1222 1223 if (val >= SFF_8024_EXT_SPEC_NENTRIES) { 1224 str = "Reserved"; 1225 } else { 1226 str = sff_8024_ext_spec[val]; 1227 } 1228 1229 return (nvlist_add_string(nvl, LIBSFF_KEY_EXT_SPEC, str)); 1230 } 1231 1232 static int 1233 sff_qsfp_parse_options(const uint8_t *buf, nvlist_t *nvl) 1234 { 1235 uint_t val; 1236 1237 val = (buf[SFF_8636_OPTIONS_HI] << 16) | 1238 (buf[SFF_8636_OPTIONS_MID] << 8) | buf[SFF_8636_OPTIONS_LOW]; 1239 1240 return (sff_gather_bitfield(val & SFF_8636_OPTION_MASK, 1241 LIBSFF_KEY_OPTIONS, sff_8636_options, nvl)); 1242 } 1243 1244 static int 1245 sff_qsfp_parse_diag(uint8_t val, nvlist_t *nvl) 1246 { 1247 const char *buf[2]; 1248 uint_t count = 1; 1249 1250 if (val & 0x08) { 1251 buf[0] = "Received power measurements: Average Power"; 1252 } else { 1253 buf[0] = "Received power measurements: OMA"; 1254 } 1255 1256 if (val & 0x04) { 1257 count++; 1258 buf[1] = "Transmitter power measurement"; 1259 } 1260 1261 /* 1262 * The nvlist routines don't touch the array, so we end up lying about 1263 * the type of data so that we can avoid a rash of additional 1264 * allocations and strdups. 1265 */ 1266 return (nvlist_add_string_array(nvl, LIBSFF_KEY_DIAG_MONITOR, 1267 (char **)buf, count)); 1268 } 1269 1270 /* 1271 * Parse a QSFP family device that is based on SFF-8436 / SFF-8636. Note that we 1272 * ignore the lower half of page 0xa0 at this time and instead focus on the 1273 * upper half of page 0xa0 which has identification information. 1274 * 1275 * For the moment we're not parsing the following fields: 1276 * 1277 * o Extended Identifier (byte 129) 1278 * o Extended Rate Select Compliance (byte 141) 1279 */ 1280 static int 1281 sff_parse_qsfp(const uint8_t *buf, nvlist_t *nvl) 1282 { 1283 int ret; 1284 1285 if ((ret = sff_parse_id(buf[SFF_8636_IDENTIFIER], nvl)) != 0) 1286 return (ret); 1287 1288 if ((ret = sff_parse_connector(buf[SFF_8636_CONNECTOR], nvl)) != 0) 1289 return (ret); 1290 1291 if ((ret = sff_qsfp_parse_compliance(buf, nvl)) != 0) 1292 return (ret); 1293 1294 if ((ret = sff_parse_encoding(buf[SFF_8636_ENCODING], nvl, 1295 B_FALSE)) != 0) 1296 return (ret); 1297 1298 if ((ret = sff_qsfp_parse_br(buf, nvl)) != 0) 1299 return (ret); 1300 1301 if ((ret = sff_qsfp_parse_lengths(buf, nvl)) != 0) 1302 return (ret); 1303 1304 if ((ret = sff_qsfp_parse_tech(buf[SFF_8636_DEVICE_TECH], nvl)) != 0) 1305 return (ret); 1306 1307 if ((ret = sff_parse_string(buf, SFF_8636_VENDOR, SFF_8636_VENDOR_LEN, 1308 LIBSFF_KEY_VENDOR, nvl)) != 0) 1309 return (ret); 1310 1311 if ((ret = sff_gather_bitfield(buf[SFF_8636_EXTENDED_MODULE] & 1312 SFF_8636_EXTMOD_CODES, LIBSFF_KEY_EXT_MOD_CODES, 1313 sff_8636_extmod_codes, nvl)) != 0) 1314 return (ret); 1315 1316 if ((ret = nvlist_add_byte_array(nvl, LIBSFF_KEY_OUI, 1317 (uchar_t *)&buf[SFF_8636_OUI], SFF_8636_OUI_LEN)) != 0) 1318 return (ret); 1319 1320 if ((ret = sff_parse_string(buf, SFF_8636_VENDOR_PN, 1321 SFF_8636_VENDOR_PN_LEN, LIBSFF_KEY_PART, nvl)) != 0) 1322 return (ret); 1323 1324 if ((ret = sff_parse_string(buf, SFF_8636_VENDOR_REV, 1325 SFF_8636_VENDOR_REV_LEN, LIBSFF_KEY_REVISION, nvl)) != 0) 1326 return (ret); 1327 1328 if ((ret = sff_qsfp_parse_copperwave(buf, nvl)) != 0) 1329 return (ret); 1330 1331 if ((ret = sff_qsfp_parse_casetemp(buf[SFF_8636_MAX_CASE_TEMP], 1332 nvl)) != 0) 1333 return (ret); 1334 1335 if ((ret = sff_qsfp_parse_extcomp(buf[SFF_8636_LINK_CODES], nvl)) != 0) 1336 return (ret); 1337 1338 if ((ret = sff_qsfp_parse_options(buf, nvl)) != 0) 1339 return (ret); 1340 1341 if ((ret = sff_parse_string(buf, SFF_8636_VENDOR_SN, 1342 SFF_8636_VENDOR_SN_LEN, LIBSFF_KEY_SERIAL, nvl)) != 0) 1343 return (ret); 1344 1345 if ((ret = sff_parse_string(buf, SFF_8636_DATE_CODE, 1346 SFF_8636_DATE_CODE_LEN, LIBSFF_KEY_DATECODE, nvl)) != 0) 1347 return (ret); 1348 1349 if ((ret = sff_qsfp_parse_diag(buf[SFF_8636_DIAG_MONITORING], 1350 nvl)) != 0) 1351 return (ret); 1352 1353 if ((ret = sff_gather_bitfield(buf[SFF_8636_ENHANCED_OPTIONS] & 1354 SFF_8636_ENHANCED_OPTIONS_MASK, LIBSFF_KEY_ENHANCED_OPTIONS, 1355 sff_8636_eopt, nvl)) != 0) 1356 return (ret); 1357 1358 return (0); 1359 } 1360 1361 int 1362 libsff_parse(const uint8_t *buf, size_t len, uint_t page, nvlist_t **nvpp) 1363 { 1364 int ret; 1365 nvlist_t *nvp = NULL; 1366 uint8_t ubuf[256]; 1367 1368 /* 1369 * At the moment, we only support page a0. 1370 */ 1371 if (page != 0xa0 || buf == NULL || len == 0 || nvpp == NULL) 1372 return (EINVAL); 1373 1374 *nvpp = NULL; 1375 1376 /* 1377 * Make sure that the library has been given valid data to parse. 1378 */ 1379 if (uucopy(buf, ubuf, MIN(sizeof (ubuf), len)) != 0) 1380 return (errno); 1381 1382 if ((ret = nvlist_alloc(&nvp, NV_UNIQUE_NAME, 0)) != 0) 1383 return (ret); 1384 1385 switch (buf[0]) { 1386 case SFF_8024_ID_QSFP: 1387 case SFF_8024_ID_QSFP_PLUS: 1388 case SFF_8024_ID_QSFP28: 1389 /* 1390 * For QSFP based products, identification information is spread 1391 * across both the top and bottom half of page 0xa0. 1392 */ 1393 if (len < SFP_MIN_LEN_8636) { 1394 ret = EINVAL; 1395 break; 1396 } 1397 ret = sff_parse_qsfp(ubuf, nvp); 1398 break; 1399 default: 1400 if (len < SFP_MIN_LEN_8472) { 1401 ret = EINVAL; 1402 break; 1403 } 1404 ret = sff_parse_sfp(ubuf, nvp); 1405 break; 1406 } 1407 1408 if (ret != 0) { 1409 nvlist_free(nvp); 1410 } else { 1411 *nvpp = nvp; 1412 } 1413 return (ret); 1414 } 1415