usr/src/lib/libsff/common/libsff.c

   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 }