lib/libifconfig/libifconfig_sfp.c

   1 /*-
   2  * Copyright (c) 2014, Alexander V. Chernikov
   3  * Copyright (c) 2020, Ryan Moeller <freqlabs@FreeBSD.org>
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #include <sys/types.h>
  30 #include <sys/param.h>
  31 #include <sys/ioctl.h>
  32 #include <sys/socket.h>
  33
  34 #include <net/if.h>
  35 #include <net/sff8436.h>
  36 #include <net/sff8472.h>
  37
  38 #include <math.h>
  39 #include <err.h>
  40 #include <errno.h>
  41 #include <fcntl.h>
  42 #include <stdbool.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <unistd.h>
  47
  48 #include <libifconfig.h>
  49 #include <libifconfig_internal.h>
  50 #include <libifconfig_sfp.h>
  51 #include <libifconfig_sfp_tables_internal.h>
  52
  53 #define     SFF_8636_EXT_COMPLIANCE 0x80
  54
  55 struct i2c_info {
  56         struct ifreq ifr;
  57         ifconfig_handle_t *h;
  58         int error;              /* Store first error */
  59         enum sfp_id id;         /* Module type */
  60 };
  61
  62 static uint8_t
  63 find_zero_bit(const struct sfp_enum_metadata *table, int value, int sz)
  64 {
  65         int v, m;
  66
  67         for (v = 1, m = 1 << (8 * sz); v < m; v <<= 1) {
  68                 if ((value & v) == 0)
  69                         continue;
  70                 if (find_metadata(table, value & v) != NULL) {
  71                         return (value & v);
  72                 }
  73         }
  74         return (0);
  75 }
  76
  77 /*
  78  * Reads i2c data from opened kernel socket.
  79  */
  80 static int
  81 read_i2c(struct i2c_info *ii, uint8_t addr, uint8_t off, uint8_t len,
  82     uint8_t *buf)
  83 {
  84         struct ifi2creq req;
  85         int i, l;
  86
  87         if (ii->error != 0)
  88                 return (ii->error);
  89
  90         ii->ifr.ifr_data = (caddr_t)&req;
  91
  92         i = 0;
  93         l = 0;
  94         memset(&req, 0, sizeof(req));
  95         req.dev_addr = addr;
  96         req.offset = off;
  97         req.len = len;
  98
  99         while (len > 0) {
 100                 l = MIN(sizeof(req.data), len);
 101                 req.len = l;
 102                 if (ifconfig_ioctlwrap(ii->h, AF_LOCAL, SIOCGI2C,
 103                     &ii->ifr) != 0) {
 104                         ii->error = errno;
 105                         return (errno);
 106                 }
 107
 108                 memcpy(&buf[i], req.data, l);
 109                 len -= l;
 110                 i += l;
 111                 req.offset += l;
 112         }
 113
 114         return (0);
 115 }
 116
 117 static int
 118 i2c_info_init(struct i2c_info *ii, ifconfig_handle_t *h, const char *name)
 119 {
 120         uint8_t id_byte;
 121
 122         memset(ii, 0, sizeof(*ii));
 123         strlcpy(ii->ifr.ifr_name, name, sizeof(ii->ifr.ifr_name));
 124         ii->h = h;
 125
 126         /*
 127          * Try to read byte 0 from i2c:
 128          * Both SFF-8472 and SFF-8436 use it as
 129          * 'identification byte'.
 130          * Stop reading status on zero as value -
 131          * this might happen in case of empty transceiver slot.
 132          */
 133         id_byte = 0;
 134         read_i2c(ii, SFF_8472_BASE, SFF_8472_ID, 1, &id_byte);
 135         if (ii->error != 0)
 136                 return (-1);
 137         if (id_byte == 0) {
 138                 h->error.errtype = OTHER;
 139                 h->error.errcode = ENOENT;
 140                 return (-1);
 141         }
 142         ii->id = id_byte;
 143         return (0);
 144 }
 145
 146 static int
 147 get_sfp_info(struct i2c_info *ii, struct ifconfig_sfp_info *sfp)
 148 {
 149         uint8_t code;
 150
 151         read_i2c(ii, SFF_8472_BASE, SFF_8472_ID, 1, &sfp->sfp_id);
 152         read_i2c(ii, SFF_8472_BASE, SFF_8472_CONNECTOR, 1, &sfp->sfp_conn);
 153
 154         /* Use extended compliance code if it's valid */
 155         read_i2c(ii, SFF_8472_BASE, SFF_8472_TRANS, 1, &sfp->sfp_eth_ext);
 156         if (sfp->sfp_eth_ext == 0) {
 157                 /* Next, check 10G Ethernet/IB CCs */
 158                 read_i2c(ii, SFF_8472_BASE, SFF_8472_TRANS_START, 1, &code);
 159                 sfp->sfp_eth_10g = find_zero_bit(sfp_eth_10g_table, code, 1);
 160                 if (sfp->sfp_eth_10g == 0) {
 161                         /* No match. Try Ethernet 1G */
 162                         read_i2c(ii, SFF_8472_BASE, SFF_8472_TRANS_START + 3,
 163                             1, &code);
 164                         sfp->sfp_eth = find_zero_bit(sfp_eth_table, code, 1);
 165                 }
 166         }
 167
 168         return (ii->error);
 169 }
 170
 171 static int
 172 get_qsfp_info(struct i2c_info *ii, struct ifconfig_sfp_info *sfp)
 173 {
 174         uint8_t code;
 175
 176         read_i2c(ii, SFF_8436_BASE, SFF_8436_ID, 1, &sfp->sfp_id);
 177         read_i2c(ii, SFF_8436_BASE, SFF_8436_CONNECTOR, 1, &sfp->sfp_conn);
 178
 179         read_i2c(ii, SFF_8436_BASE, SFF_8436_STATUS, 1, &sfp->sfp_rev);
 180
 181         /* Check for extended specification compliance */
 182         read_i2c(ii, SFF_8436_BASE, SFF_8436_CODE_E1040100G, 1, &code);
 183         if (code & SFF_8636_EXT_COMPLIANCE) {
 184                 read_i2c(ii, SFF_8436_BASE, SFF_8436_OPTIONS_START, 1,
 185                     &sfp->sfp_eth_ext);
 186         } else {
 187                 /* Check 10/40G Ethernet class only */
 188                 sfp->sfp_eth_1040g =
 189                     find_zero_bit(sfp_eth_1040g_table, code, 1);
 190         }
 191
 192         return (ii->error);
 193 }
 194
 195 int
 196 ifconfig_sfp_get_sfp_info(ifconfig_handle_t *h,
 197     const char *name, struct ifconfig_sfp_info *sfp)
 198 {
 199         struct i2c_info ii;
 200         char buf[8];
 201
 202         memset(sfp, 0, sizeof(*sfp));
 203
 204         if (i2c_info_init(&ii, h, name) != 0)
 205                 return (-1);
 206
 207         /* Read bytes 3-10 at once */
 208         read_i2c(&ii, SFF_8472_BASE, SFF_8472_TRANS_START, 8, buf);
 209         if (ii.error != 0)
 210                 return (ii.error);
 211
 212         /* Check 10G ethernet first */
 213         sfp->sfp_eth_10g = find_zero_bit(sfp_eth_10g_table, buf[0], 1);
 214         if (sfp->sfp_eth_10g == 0) {
 215                 /* No match. Try 1G */
 216                 sfp->sfp_eth = find_zero_bit(sfp_eth_table, buf[3], 1);
 217         }
 218         sfp->sfp_fc_len = find_zero_bit(sfp_fc_len_table, buf[4], 1);
 219         sfp->sfp_fc_media = find_zero_bit(sfp_fc_media_table, buf[6], 1);
 220         sfp->sfp_fc_speed = find_zero_bit(sfp_fc_speed_table, buf[7], 1);
 221         sfp->sfp_cab_tech =
 222             find_zero_bit(sfp_cab_tech_table, (buf[4] << 8) | buf[5], 2);
 223
 224         if (ifconfig_sfp_id_is_qsfp(ii.id))
 225                 return (get_qsfp_info(&ii, sfp));
 226         return (get_sfp_info(&ii, sfp));
 227 }
 228
 229 static size_t
 230 channel_count(enum sfp_id id)
 231 {
 232         /* TODO: other ids */
 233         switch (id) {
 234         case SFP_ID_UNKNOWN:
 235                 return (0);
 236         case SFP_ID_QSFP:
 237         case SFP_ID_QSFPPLUS:
 238         case SFP_ID_QSFP28:
 239                 return (4);
 240         default:
 241                 return (1);
 242         }
 243 }
 244
 245 size_t
 246 ifconfig_sfp_channel_count(const struct ifconfig_sfp_info *sfp)
 247 {
 248         return (channel_count(sfp->sfp_id));
 249 }
 250
 251 /*
 252  * Print SFF-8472/SFF-8436 string to supplied buffer.
 253  * All (vendor-specific) strings are padded right with '0x20'.
 254  */
 255 static void
 256 get_sff_string(struct i2c_info *ii, uint8_t addr, uint8_t off, char *dst)
 257 {
 258         read_i2c(ii, addr, off, SFF_VENDOR_STRING_SIZE, dst);
 259         dst += SFF_VENDOR_STRING_SIZE;
 260         do { *dst-- = '\0'; } while (*dst == 0x20);
 261 }
 262
 263 static void
 264 get_sff_date(struct i2c_info *ii, uint8_t addr, uint8_t off, char *dst)
 265 {
 266         char buf[SFF_VENDOR_DATE_SIZE];
 267
 268         read_i2c(ii, addr, off, SFF_VENDOR_DATE_SIZE, buf);
 269         sprintf(dst, "20%c%c-%c%c-%c%c", buf[0], buf[1], buf[2], buf[3],
 270             buf[4], buf[5]);
 271 }
 272
 273 static int
 274 get_sfp_vendor_info(struct i2c_info *ii, struct ifconfig_sfp_vendor_info *vi)
 275 {
 276         get_sff_string(ii, SFF_8472_BASE, SFF_8472_VENDOR_START, vi->name);
 277         get_sff_string(ii, SFF_8472_BASE, SFF_8472_PN_START, vi->pn);
 278         get_sff_string(ii, SFF_8472_BASE, SFF_8472_SN_START, vi->sn);
 279         get_sff_date(ii, SFF_8472_BASE, SFF_8472_DATE_START, vi->date);
 280         return (ii->error);
 281 }
 282
 283 static int
 284 get_qsfp_vendor_info(struct i2c_info *ii, struct ifconfig_sfp_vendor_info *vi)
 285 {
 286         get_sff_string(ii, SFF_8436_BASE, SFF_8436_VENDOR_START, vi->name);
 287         get_sff_string(ii, SFF_8436_BASE, SFF_8436_PN_START, vi->pn);
 288         get_sff_string(ii, SFF_8436_BASE, SFF_8436_SN_START, vi->sn);
 289         get_sff_date(ii, SFF_8436_BASE, SFF_8436_DATE_START, vi->date);
 290         return (ii->error);
 291 }
 292
 293 int
 294 ifconfig_sfp_get_sfp_vendor_info(ifconfig_handle_t *h,
 295     const char *name, struct ifconfig_sfp_vendor_info *vi)
 296 {
 297         struct i2c_info ii;
 298
 299         memset(vi, 0, sizeof(*vi));
 300
 301         if (i2c_info_init(&ii, h, name) != 0)
 302                 return (-1);
 303
 304         if (ifconfig_sfp_id_is_qsfp(ii.id))
 305                 return (get_qsfp_vendor_info(&ii, vi));
 306         return (get_sfp_vendor_info(&ii, vi));
 307 }
 308
 309 /*
 310  * Converts internal temperature (SFF-8472, SFF-8436)
 311  * 16-bit unsigned value to human-readable representation:
 312  *
 313  * Internally measured Module temperature are represented
 314  * as a 16-bit signed twos complement value in increments of
 315  * 1/256 degrees Celsius, yielding a total range of –128C to +128C
 316  * that is considered valid between –40 and +125C.
 317  */
 318 static double
 319 get_sff_temp(struct i2c_info *ii, uint8_t addr, uint8_t off)
 320 {
 321         double d;
 322         uint8_t buf[2];
 323
 324         read_i2c(ii, addr, off, 2, buf);
 325         d = (double)buf[0];
 326         d += (double)buf[1] / 256;
 327         return (d);
 328 }
 329
 330 /*
 331  * Retrieves supplied voltage (SFF-8472, SFF-8436).
 332  * 16-bit usigned value, treated as range 0..+6.55 Volts
 333  */
 334 static double
 335 get_sff_voltage(struct i2c_info *ii, uint8_t addr, uint8_t off)
 336 {
 337         double d;
 338         uint8_t buf[2];
 339
 340         read_i2c(ii, addr, off, 2, buf);
 341         d = (double)((buf[0] << 8) | buf[1]);
 342         return (d / 10000);
 343 }
 344
 345 /*
 346  * The following conversions assume internally-calibrated data.
 347  * This is always true for SFF-8346, and explicitly checked for SFF-8472.
 348  */
 349
 350 double
 351 power_mW(uint16_t power)
 352 {
 353         /* Power is specified in units of 0.1 uW. */
 354         return (1.0 * power / 10000);
 355 }
 356
 357 double
 358 power_dBm(uint16_t power)
 359 {
 360         return (10.0 * log10(power_mW(power)));
 361 }
 362
 363 double
 364 bias_mA(uint16_t bias)
 365 {
 366         /* Bias current is specified in units of 2 uA. */
 367         return (1.0 * bias / 500);
 368 }
 369
 370 static uint16_t
 371 get_sff_channel(struct i2c_info *ii, uint8_t addr, uint8_t off)
 372 {
 373         uint8_t buf[2];
 374
 375         read_i2c(ii, addr, off, 2, buf);
 376         if (ii->error != 0)
 377                 return (0);
 378
 379         return ((buf[0] << 8) + buf[1]);
 380 }
 381
 382 static int
 383 get_sfp_status(struct i2c_info *ii, struct ifconfig_sfp_status *ss)
 384 {
 385         uint8_t diag_type, flags;
 386
 387         /* Read diagnostic monitoring type */
 388         read_i2c(ii, SFF_8472_BASE, SFF_8472_DIAG_TYPE, 1, (caddr_t)&diag_type);
 389         if (ii->error != 0)
 390                 return (-1);
 391
 392         /*
 393          * Read monitoring data IFF it is supplied AND is
 394          * internally calibrated
 395          */
 396         flags = SFF_8472_DDM_DONE | SFF_8472_DDM_INTERNAL;
 397         if ((diag_type & flags) != flags) {
 398                 ii->h->error.errtype = OTHER;
 399                 ii->h->error.errcode = ENXIO;
 400                 return (-1);
 401         }
 402
 403         ss->temp = get_sff_temp(ii, SFF_8472_DIAG, SFF_8472_TEMP);
 404         ss->voltage = get_sff_voltage(ii, SFF_8472_DIAG, SFF_8472_VCC);
 405         ss->channel = calloc(channel_count(ii->id), sizeof(*ss->channel));
 406         if (ss->channel == NULL) {
 407                 ii->h->error.errtype = OTHER;
 408                 ii->h->error.errcode = ENOMEM;
 409                 return (-1);
 410         }
 411         ss->channel[0].rx = get_sff_channel(ii, SFF_8472_DIAG, SFF_8472_RX_POWER);
 412         ss->channel[0].tx = get_sff_channel(ii, SFF_8472_DIAG, SFF_8472_TX_BIAS);
 413         return (ii->error);
 414 }
 415
 416 static uint32_t
 417 get_qsfp_bitrate(struct i2c_info *ii)
 418 {
 419         uint8_t code;
 420         uint32_t rate;
 421
 422         code = 0;
 423         read_i2c(ii, SFF_8436_BASE, SFF_8436_BITRATE, 1, &code);
 424         rate = code * 100;
 425         if (code == 0xFF) {
 426                 read_i2c(ii, SFF_8436_BASE, SFF_8636_BITRATE, 1, &code);
 427                 rate = code * 250;
 428         }
 429
 430         return (rate);
 431 }
 432
 433 static int
 434 get_qsfp_status(struct i2c_info *ii, struct ifconfig_sfp_status *ss)
 435 {
 436         size_t channels;
 437
 438         ss->temp = get_sff_temp(ii, SFF_8436_BASE, SFF_8436_TEMP);
 439         ss->voltage = get_sff_voltage(ii, SFF_8436_BASE, SFF_8436_VCC);
 440         channels = channel_count(ii->id);
 441         ss->channel = calloc(channels, sizeof(*ss->channel));
 442         if (ss->channel == NULL) {
 443                 ii->h->error.errtype = OTHER;
 444                 ii->h->error.errcode = ENOMEM;
 445                 return (-1);
 446         }
 447         for (size_t chan = 0; chan < channels; ++chan) {
 448                 uint8_t rxoffs = SFF_8436_RX_CH1_MSB + chan * sizeof(uint16_t);
 449                 uint8_t txoffs = SFF_8436_TX_CH1_MSB + chan * sizeof(uint16_t);
 450                 ss->channel[chan].rx =
 451                     get_sff_channel(ii, SFF_8436_BASE, rxoffs);
 452                 ss->channel[chan].tx =
 453                     get_sff_channel(ii, SFF_8436_BASE, txoffs);
 454         }
 455         ss->bitrate = get_qsfp_bitrate(ii);
 456         return (ii->error);
 457 }
 458
 459 int
 460 ifconfig_sfp_get_sfp_status(ifconfig_handle_t *h, const char *name,
 461     struct ifconfig_sfp_status *ss)
 462 {
 463         struct i2c_info ii;
 464
 465         memset(ss, 0, sizeof(*ss));
 466
 467         if (i2c_info_init(&ii, h, name) != 0)
 468                 return (-1);
 469
 470         if (ifconfig_sfp_id_is_qsfp(ii.id))
 471                 return (get_qsfp_status(&ii, ss));
 472         return (get_sfp_status(&ii, ss));
 473 }
 474
 475 void
 476 ifconfig_sfp_free_sfp_status(struct ifconfig_sfp_status *ss)
 477 {
 478         if (ss != NULL)
 479                 free(ss->channel);
 480 }
 481
 482 static const char *
 483 sfp_id_string_alt(uint8_t value)
 484 {
 485         const char *id;
 486
 487         if (value <= SFF_8024_ID_LAST)
 488                 id = sff_8024_id[value];
 489         else if (value > 0x80)
 490                 id = "Vendor specific";
 491         else
 492                 id = "Reserved";
 493
 494         return (id);
 495 }
 496
 497 static const char *
 498 sfp_conn_string_alt(uint8_t value)
 499 {
 500         const char *conn;
 501
 502         if (value >= 0x0D && value <= 0x1F)
 503                 conn = "Unallocated";
 504         else if (value >= 0x24 && value <= 0x7F)
 505                 conn = "Unallocated";
 506         else
 507                 conn = "Vendor specific";
 508
 509         return (conn);
 510 }
 511
 512 void
 513 ifconfig_sfp_get_sfp_info_strings(const struct ifconfig_sfp_info *sfp,
 514     struct ifconfig_sfp_info_strings *strings)
 515 {
 516         get_sfp_info_strings(sfp, strings);
 517         if (strings->sfp_id == NULL)
 518                 strings->sfp_id = sfp_id_string_alt(sfp->sfp_id);
 519         if (strings->sfp_conn == NULL)
 520                 strings->sfp_conn = sfp_conn_string_alt(sfp->sfp_conn);
 521         if (strings->sfp_rev == NULL)
 522                 strings->sfp_rev = "Unallocated";
 523 }
 524
 525 const char *
 526 ifconfig_sfp_physical_spec(const struct ifconfig_sfp_info *sfp,
 527     const struct ifconfig_sfp_info_strings *strings)
 528 {
 529         switch (sfp->sfp_id) {
 530         case SFP_ID_UNKNOWN:
 531                 break;
 532         case SFP_ID_QSFP:
 533         case SFP_ID_QSFPPLUS:
 534         case SFP_ID_QSFP28:
 535                 if (sfp->sfp_eth_1040g & SFP_ETH_1040G_EXTENDED)
 536                         return (strings->sfp_eth_ext);
 537                 else if (sfp->sfp_eth_1040g)
 538                         return (strings->sfp_eth_1040g);
 539                 break;
 540         default:
 541                 if (sfp->sfp_eth_ext)
 542                         return (strings->sfp_eth_ext);
 543                 else if (sfp->sfp_eth_10g)
 544                         return (strings->sfp_eth_10g);
 545                 else if (sfp->sfp_eth)
 546                         return (strings->sfp_eth);
 547                 break;
 548         }
 549         return ("Unknown");
 550 }
 551
 552 int
 553 ifconfig_sfp_get_sfp_dump(ifconfig_handle_t *h, const char *name,
 554     struct ifconfig_sfp_dump *dump)
 555 {
 556         struct i2c_info ii;
 557         uint8_t *buf = dump->data;
 558
 559         memset(dump->data, 0, sizeof(dump->data));
 560
 561         if (i2c_info_init(&ii, h, name) != 0)
 562                 return (-1);
 563
 564         if (ifconfig_sfp_id_is_qsfp(ii.id)) {
 565                 read_i2c(&ii, SFF_8436_BASE, QSFP_DUMP0_START, QSFP_DUMP0_SIZE,
 566                     buf + QSFP_DUMP0_START);
 567                 read_i2c(&ii, SFF_8436_BASE, QSFP_DUMP1_START, QSFP_DUMP1_SIZE,
 568                     buf + QSFP_DUMP1_START);
 569         } else {
 570                 read_i2c(&ii, SFF_8472_BASE, SFP_DUMP_START, SFP_DUMP_SIZE,
 571                     buf + SFP_DUMP_START);
 572         }
 573
 574         return (ii.error != 0 ? -1 : 0);
 575 }
 576
 577 size_t
 578 ifconfig_sfp_dump_region_count(const struct ifconfig_sfp_dump *dp)
 579 {
 580         uint8_t id_byte = dp->data[0];
 581
 582         switch ((enum sfp_id)id_byte) {
 583         case SFP_ID_UNKNOWN:
 584                 return (0);
 585         case SFP_ID_QSFP:
 586         case SFP_ID_QSFPPLUS:
 587         case SFP_ID_QSFP28:
 588                 return (2);
 589         default:
 590                 return (1);
 591         }
 592 }