Return to sff.c CVS log

Up to [local] / src / sbin / ifconfig

Fix ifconfig(8) compiler warnings regarding variable "name" reuse.
Call the global variable with the name of the interface "ifname".
Do not pass it around, just use it globally.  Do not use "ifname"
for anything else.
OK deraadt@

/*	$OpenBSD: sff.c,v 1.23 2019/10/24 18:54:10 bluhm Exp $ */

/*
 * Copyright (c) 2019 David Gwynne <dlg@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef SMALL

#include <sys/ioctl.h>

#include <net/if.h>

#include <math.h>
#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
#include <vis.h>

#include "ifconfig.h"

#ifndef nitems
#define nitems(_a)	(sizeof((_a)) / sizeof((_a)[0]))
#endif

#ifndef ISSET
#define ISSET(_w, _m)	((_w) & (_m))
#endif

#define SFF_THRESH_HI_ALARM	0
#define SFF_THRESH_LO_ALARM	1
#define SFF_THRESH_HI_WARN	2
#define SFF_THRESH_LO_WARN	3
#define SFF_THRESH_COUNT	4

#define SFF_THRESH_REG(_i)	((_i) * 2)

struct sff_thresholds {
	 float		thresholds[SFF_THRESH_COUNT];
};

struct sff_media_map {
	float		factor_wavelength;
	int		scale_om1;
	int		scale_om2;
	int		scale_om3;
	uint8_t		connector_type;
	uint8_t		wavelength;
	uint8_t		dist_smf_m;
	uint8_t		dist_smf_km;
	uint8_t		dist_om1;
	uint8_t		dist_om2;
	uint8_t		dist_om3;
	uint8_t		dist_cu;
};

#define SFF8024_ID_UNKNOWN	0x00
#define SFF8024_ID_GBIC		0x01
#define SFF8024_ID_MOBO		0x02 /* Module/connector soldered to mobo */
				     /* using SFF-8472 */
#define SFF8024_ID_SFP		0x03 /* SFP/SFP+/SFP28 */
#define SFF8024_ID_300PIN_XBI	0x04 /* 300 pin XBI */
#define SFF8024_ID_XENPAK	0x05
#define SFF8024_ID_XFP		0x06
#define SFF8024_ID_XFF		0x07
#define SFF8024_ID_XFPE		0x08 /* XFP-E */
#define SFF8024_ID_XPAK		0x09
#define SFF8024_ID_X2		0x0a
#define SFF8024_ID_DWDM_SFP	0x0b /* DWDM-SFP/SFP+ */
				     /* not using SFF-8472 */
#define SFF8024_ID_QSFP		0x0c
#define SFF8024_ID_QSFP_PLUS	0x0d /* or later */
				     /* using SFF-8436/8665/8685 et al */
#define SFF8024_ID_CXP		0x0e /* or later */
#define SFF8024_ID_HD4X		0x0f /* shielded mini multilane HD 4X */
#define SFF8024_ID_HD8X		0x10 /* shielded mini multilane HD 8X */
#define SFF8024_ID_QSFP28	0x11 /* or later */
				     /* using SFF-8665 et al */
#define SFF8024_ID_CXP2		0x12 /* aka CXP28, or later */
#define SFF8024_ID_CDFP		0x13 /* style 1/style 2 */
#define SFF8024_ID_HD4X_FAN	0x14 /* shielded mini multilane HD 4X fanout */
#define SFF8024_ID_HD8X_FAN	0x15 /* shielded mini multilane HD 8X fanout */
#define SFF8024_ID_CDFP3	0x16 /* style 3 */
#define SFF8024_ID_uQSFP	0x17 /* microQSFP */
#define SFF8024_ID_QSFP_DD	0x18 /* QSFP-DD double density 8x */
				     /* INF-8628 */
#define SFF8024_ID_RESERVED	0x7f /* up to here is reserved */
				     /* 0x80 to 0xff is vendor specific */

#define SFF8024_ID_IS_RESERVED(_id)	((_id) <= SFF8024_ID_RESERVED)
#define SFF8024_ID_IS_VENDOR(_id)	((_id) > SFF8024_ID_RESERVED)

#define SFF8024_CON_UNKNOWN	0x00
#define SFF8024_CON_SC		0x01 /* Subscriber Connector */
#define SFF8024_CON_FC_1	0x02 /* Fibre Channel Style 1 copper */
#define SFF8024_CON_FC_2	0x03 /* Fibre Channel Style 2 copper */
#define SFF8024_CON_BNC_TNC	0x04 /* BNC/TNC */
#define SFF8024_CON_FC_COAX	0x05 /* Fibre Channel coax headers */
#define SFF8024_CON_FJ		0x06 /* Fibre Jack */
#define SFF8024_CON_LC		0x07 /* Lucent Connector */
#define SFF8024_CON_MT_RJ	0x08 /* Mechanical Transfer - Registered Jack */
#define SFF8024_CON_MU		0x09 /* Multiple Optical */
#define SFF8024_CON_SG		0x0a
#define SFF8024_CON_O_PIGTAIL	0x0b /* Optical Pigtail */
#define SFF8024_CON_MPO_1x12	0x0c /* Multifiber Parallel Optic 1x12 */
#define SFF8024_CON_MPO_2x16	0x0e /* Multifiber Parallel Optic 2x16 */
#define SFF8024_CON_HSSDC2	0x20 /* High Speed Serial Data Connector */
#define SFF8024_CON_Cu_PIGTAIL	0x21 /* Copper Pigtail */
#define SFF8024_CON_RJ45	0x22
#define SFF8024_CON_NO		0x23 /* No separable connector */
#define SFF8024_CON_MXC_2x16	0x24
#define SFF8024_CON_RESERVED	0x7f /* up to here is reserved */
				     /* 0x80 to 0xff is vendor specific */

#define SFF8024_CON_IS_RESERVED(_id)	((_id) <= SFF8024_CON_RESERVED)
#define SFF8024_CON_IS_VENDOR(_id)	((_id) > SFF8024_CON_RESERVED)

static const char *sff8024_id_names[] = {
	[SFF8024_ID_UNKNOWN]	= "Unknown",
	[SFF8024_ID_GBIC]	= "GBIC",
	[SFF8024_ID_SFP]	= "SFP",
	[SFF8024_ID_300PIN_XBI]	= "XBI",
	[SFF8024_ID_XENPAK]	= "XENPAK",
	[SFF8024_ID_XFP]	= "XFP",
	[SFF8024_ID_XFF]	= "XFF",
	[SFF8024_ID_XFPE]	= "XFPE",
	[SFF8024_ID_XPAK]	= "XPAK",
	[SFF8024_ID_X2]		= "X2",
	[SFF8024_ID_DWDM_SFP]	= "DWDM-SFP",
	[SFF8024_ID_QSFP]	= "QSFP",
	[SFF8024_ID_QSFP_PLUS]	= "QSFP+",
	[SFF8024_ID_CXP]	= "CXP",
	[SFF8024_ID_HD4X]	= "HD 4X",
	[SFF8024_ID_HD8X]	= "HD 8X",
	[SFF8024_ID_QSFP28]	= "QSFP28",
	[SFF8024_ID_CXP2]	= "CXP2",
	[SFF8024_ID_CDFP]	= "CDFP Style 1/2",
	[SFF8024_ID_HD4X_FAN]	= "HD 4X Fanout",
	[SFF8024_ID_HD8X_FAN]	= "HD 8X Fanout",
	[SFF8024_ID_CDFP3]	= "CDFP Style 3",
	[SFF8024_ID_uQSFP]	= "microQSFP",
	[SFF8024_ID_QSFP_DD]	= "QSFP-DD",
};

static const char *sff8024_con_names[] = {
	[SFF8024_CON_UNKNOWN]	= "Unknown",
	[SFF8024_CON_SC]	= "SC",
	[SFF8024_CON_FC_1]	= "FC Style 1",
	[SFF8024_CON_FC_2]	= "FC Style 2",
	[SFF8024_CON_BNC_TNC]	= "BNC/TNC",
	[SFF8024_CON_FC_COAX]	= "FC coax headers",
	[SFF8024_CON_FJ]	= "FJ",
	[SFF8024_CON_LC]	= "LC",
	[SFF8024_CON_MT_RJ]	= "MT-RJ",
	[SFF8024_CON_MU]	= "MU",
	[SFF8024_CON_SG]	= "SG",
	[SFF8024_CON_O_PIGTAIL]	= "AOC",
	[SFF8024_CON_MPO_1x12]	= "MPO 1x12",
	[SFF8024_CON_MPO_2x16]	= "MPO 2x16",
	[SFF8024_CON_HSSDC2]	= "HSSDC II",
	[SFF8024_CON_Cu_PIGTAIL]
				= "DAC",
	[SFF8024_CON_RJ45]	= "RJ45",
	[SFF8024_CON_NO]	= "No connector",
	[SFF8024_CON_MXC_2x16]	= "MXC 2x16",
};

#define SFF8472_ID			0 /* SFF8027 for identifier values */
#define SFF8472_EXT_ID			1
#define SFF8472_EXT_ID_UNSPECIFIED		0x00
#define SFF8472_EXT_ID_MOD_DEF_1		0x01
#define SFF8472_EXT_ID_MOD_DEF_2		0x02
#define SFF8472_EXT_ID_MOD_DEF_3		0x03
#define SFF8472_EXT_ID_2WIRE			0x04
#define SFF8472_EXT_ID_MOD_DEF_5		0x05
#define SFF8472_EXT_ID_MOD_DEF_6		0x06
#define SFF8472_EXT_ID_MOD_DEF_7		0x07
#define SFF8472_CON			2 /* SFF8027 for connector values */
#define SFF8472_DIST_SMF_KM		14
#define SFF8472_DIST_SMF_M		15
#define SFF8472_DIST_OM2		16
#define SFF8472_DIST_OM1		17
#define SFF8472_DIST_CU			18
#define SFF8472_DIST_OM3		19
#define SFF8472_VENDOR_START		20
#define SFF8472_VENDOR_END		35
#define SFF8472_PRODUCT_START		40
#define SFF8472_PRODUCT_END		55
#define SFF8472_REVISION_START		56
#define SFF8472_REVISION_END		59
#define SFF8472_WAVELENGTH		60
#define SFF8472_SERIAL_START		68
#define SFF8472_SERIAL_END		83
#define SFF8472_DATECODE		84
#define SFF8472_DDM_TYPE		92
#define SFF8472_DDM_TYPE_AVG_POWER		(1U << 3)
#define SFF8472_DDM_TYPE_CAL_EXT		(1U << 4)
#define SFF8472_DDM_TYPE_CAL_INT		(1U << 5)
#define SFF8472_DDM_TYPE_IMPL			(1U << 6)
#define SFF8472_COMPLIANCE		94
#define SFF8472_COMPLIANCE_NONE			0x00
#define SFF8472_COMPLIANCE_9_3			0x01 /* SFF-8472 Rev 9.3 */
#define SFF8472_COMPLIANCE_9_5			0x02 /* SFF-8472 Rev 9.5 */
#define SFF8472_COMPLIANCE_10_2			0x03 /* SFF-8472 Rev 10.2 */
#define SFF8472_COMPLIANCE_10_4			0x04 /* SFF-8472 Rev 10.4 */
#define SFF8472_COMPLIANCE_11_0			0x05 /* SFF-8472 Rev 11.0 */
#define SFF8472_COMPLIANCE_11_3			0x06 /* SFF-8472 Rev 11.3 */
#define SFF8472_COMPLIANCE_11_4			0x07 /* SFF-8472 Rev 11.4 */
#define SFF8472_COMPLIANCE_12_3			0x08 /* SFF-8472 Rev 12.3 */

static const struct sff_media_map sff8472_media_map = {
	.connector_type		= SFF8472_CON,
	.wavelength		= SFF8472_WAVELENGTH,
	.factor_wavelength	= 1.0,
	.dist_smf_m		= SFF8472_DIST_SMF_M,
	.dist_smf_km		= SFF8472_DIST_SMF_KM,
	.dist_om1		= SFF8472_DIST_OM1,
	.scale_om1		= 10,
	.dist_om2		= SFF8472_DIST_OM2,
	.scale_om2		= 10,
	.dist_om3		= SFF8472_DIST_OM3,
	.scale_om3		= 20,
	.dist_cu		= SFF8472_DIST_CU,
};

/*
 * page 0xa2
 */
#define SFF8472_AW_TEMP			0
#define SFF8472_AW_VCC			8
#define SFF8472_AW_TX_BIAS		16
#define SFF8472_AW_TX_POWER		24
#define SFF8472_AW_RX_POWER		32
#define ALRM_HIGH		0
#define ALRM_LOW		2
#define WARN_HIGH		4
#define WARN_LOW		6
#define SFF8472_DDM_TEMP		96
#define SFF8472_DDM_VCC			98
#define SFF8472_DDM_TX_BIAS		100
#define SFF8472_DDM_TX_POWER		102
#define SFF8472_DDM_RX_POWER		104
#define SFF8472_DDM_LASER		106 /* laser temp/wavelength */
					    /* optional */
#define SFF8472_DDM_TEC			108 /* Measured TEC current */
					    /* optional */

#define SFF_TEMP_FACTOR		256.0
#define SFF_VCC_FACTOR		10000.0
#define SFF_BIAS_FACTOR		500.0
#define SFF_POWER_FACTOR	10000.0

/*
 * QSFP is defined by SFF-8436, but the management interface is
 * updated and maintained by SFF-8636.
 */

#define SFF8436_STATUS1		1
#define SFF8436_STATUS2		2
#define SFF8436_STATUS2_DNR		(1 << 0) /* Data_Not_Ready */
#define SFF8436_STATUS2_INTL		(1 << 1) /* Interrupt output state */
#define SFF8436_STATUS2_FLAT_MEM	(1 << 2) /* Upper memory flat/paged */

#define SFF8436_TEMP		22
#define SFF8436_VCC		26

#define SFF8436_CHANNELS	4	/* number of TX and RX channels */
#define SFF8436_RX_POWER_BASE	34
#define SFF8436_RX_POWER(_i)	(SFF8436_RX_POWER_BASE + ((_i) * 2))
#define SFF8436_TX_BIAS_BASE	42
#define SFF8436_TX_BIAS(_i)	(SFF8436_TX_BIAS_BASE + ((_i) * 2))
#define SFF8436_TX_POWER_BASE	50
#define SFF8436_TX_POWER(_i)	(SFF8436_TX_POWER_BASE + ((_i) * 2))

/* Upper Page 00h */

#define SFF8436_MAXCASETEMP	190	/* C */
#define SFF8436_MAXCASETEMP_DEFAULT	70 /* if SFF8436_MAXCASETEMP is 0 */

/* Upper page 03h */

#define SFF8436_AW_TEMP		128
#define SFF8436_AW_VCC		144
#define SFF8436_AW_RX_POWER	176
#define SFF8436_AW_TX_BIAS	184
#define SFF8436_AW_TX_POWER	192

/*
 * XFP stuff is defined by INF-8077.
 *
 * The "Serial ID Memory Map" on page 1 contains the interesting strings
 */

/* SFF-8636 and INF-8077 share a layout for various strings */

#define UPPER_CON			130 /* connector type */
#define UPPER_DIST_SMF			142
#define UPPER_DIST_OM3			143
#define UPPER_DIST_OM2			144
#define UPPER_DIST_OM1			145
#define UPPER_DIST_CU			146
#define UPPER_WAVELENGTH		186

#define UPPER_VENDOR_START		148
#define UPPER_VENDOR_END		163
#define UPPER_PRODUCT_START		168
#define UPPER_PRODUCT_END		183
#define UPPER_REVISION_START		184
#define UPPER_REVISION_END		185
#define UPPER_SERIAL_START		196
#define UPPER_SERIAL_END		211
#define UPPER_DATECODE			212
#define UPPER_LOT_START			218
#define UPPER_LOT_END			219

static const struct sff_media_map upper_media_map = {
	.connector_type		= UPPER_CON,
	.wavelength		= UPPER_WAVELENGTH,
	.factor_wavelength	= 20.0,
	.dist_smf_m		= 0,
	.dist_smf_km		= UPPER_DIST_SMF,
	.dist_om1		= UPPER_DIST_OM1,
	.scale_om1		= 1,
	.dist_om2		= UPPER_DIST_OM1,
	.scale_om2		= 1,
	.dist_om3		= UPPER_DIST_OM3,
	.scale_om3		= 2,
	.dist_cu		= UPPER_DIST_CU,
};

static void	hexdump(const void *, size_t);
static int	if_sff8472(int, const struct if_sffpage *);
static int	if_sff8636(int, const struct if_sffpage *);
static int	if_inf8077(int, const struct if_sffpage *);

static const char *
sff_id_name(uint8_t id)
{
	const char *name = NULL;

	if (id < nitems(sff8024_id_names)) {
		name = sff8024_id_names[id];
		if (name != NULL)
			return (name);
	}

	if (SFF8024_ID_IS_VENDOR(id))
		return ("Vendor Specific");

	return ("Reserved");
}

static const char *
sff_con_name(uint8_t id)
{
	const char *name = NULL;

	if (id < nitems(sff8024_con_names)) {
		name = sff8024_con_names[id];
		if (name != NULL)
			return (name);
	}

	if (SFF8024_CON_IS_VENDOR(id))
		return ("Vendor Specific");

	return ("Reserved");
}

static void
if_sffpage_init(struct if_sffpage *sff, uint8_t addr, uint8_t page)
{
	memset(sff, 0, sizeof(*sff));

	if (strlcpy(sff->sff_ifname, ifname, sizeof(sff->sff_ifname)) >=
	    sizeof(sff->sff_ifname))
		errx(1, "interface name too long");

	sff->sff_addr = addr;
	sff->sff_page = page;
}

static void
if_sffpage_dump(const struct if_sffpage *sff)
{
	printf("%s: addr %02x", ifname, sff->sff_addr);
	if (sff->sff_addr == IFSFF_ADDR_EEPROM)
		printf(" page %u", sff->sff_page);
	putchar('\n');
	hexdump(sff->sff_data, sizeof(sff->sff_data));
}

int
if_sff_info(int dump)
{
	struct if_sffpage pg0;
	int error = 0;
	uint8_t id, ext_id;

	if_sffpage_init(&pg0, IFSFF_ADDR_EEPROM, 0);
	if (ioctl(sock, SIOCGIFSFFPAGE, (caddr_t)&pg0) == -1) {
		if (errno == ENXIO) {
			/* try 1 for XFP cos myx which can't switch pages... */
			if_sffpage_init(&pg0, IFSFF_ADDR_EEPROM, 1);
			if (ioctl(sock, SIOCGIFSFFPAGE, (caddr_t)&pg0) == -1)
				return (-1);
		} else
			return (-1);
	}

	if (dump)
		if_sffpage_dump(&pg0);

	id = pg0.sff_data[0]; /* SFF8472_ID */

	printf("\ttransceiver: %s ", sff_id_name(id));
	switch (id) {
	case SFF8024_ID_SFP:
		ext_id = pg0.sff_data[SFF8472_EXT_ID];
		if (ext_id != SFF8472_EXT_ID_2WIRE) {
			printf("extended-id %02xh\n", ext_id);
			break;
		}
		/* FALLTHROUGH */
	case SFF8024_ID_GBIC:
		error = if_sff8472(dump, &pg0);
		break;
	case SFF8024_ID_XFP:
		if (pg0.sff_page != 1) {
			if_sffpage_init(&pg0, IFSFF_ADDR_EEPROM, 1);
			if (ioctl(sock, SIOCGIFSFFPAGE, (caddr_t)&pg0) == -1)
				return (-1);
			if (dump)
				if_sffpage_dump(&pg0);
		}
		error = if_inf8077(dump, &pg0);
		break;
	case SFF8024_ID_QSFP:
	case SFF8024_ID_QSFP_PLUS:
	case SFF8024_ID_QSFP28:
		error = if_sff8636(dump, &pg0);
		break;
	default:
		printf("\n");
		break;
	}

	return (error);
}

static void
if_sff_ascii_print(const struct if_sffpage *sff, const char *name,
    size_t start, size_t end, const char *trailer)
{
	const uint8_t *d = sff->sff_data;
	int ch;

	for (;;) {
		ch = d[start];
		if (!isspace(ch) && ch != '\0')
			break;

		start++;
		if (start == end)
			return;
	}

	printf("%s", name);

	for (;;) {
		ch = d[end];
		if (!isspace(ch) && ch != '\0')
			break;

		end--;
	}

	do {
		char dst[8];
		vis(dst, d[start], VIS_TAB | VIS_NL, 0);
		printf("%s", dst);
	} while (++start <= end);

	printf("%s", trailer);
}

static void
if_sff_date_print(const struct if_sffpage *sff, const char *name,
    size_t start, const char *trailer)
{
	const uint8_t *d = sff->sff_data + start;
	size_t i;

	/* YYMMDD */
	for (i = 0; i < 6; i++) {
		if (!isdigit(d[i])) {
			if_sff_ascii_print(sff, name, start,
			    start + 5, trailer);
			return;
		}
	}

	printf("%s20%c%c-%c%c-%c%c%s", name,
	    d[0], d[1], d[2], d[3], d[4], d[5], trailer);
}

static int16_t
if_sff_int(const struct if_sffpage *sff, size_t start)
{
	const uint8_t *d = sff->sff_data + start;

	return (d[0] << 8 | d[1]);
}

static uint16_t
if_sff_uint(const struct if_sffpage *sff, size_t start)
{
	const uint8_t *d = sff->sff_data + start;

	return (d[0] << 8 | d[1]);
}

static float
if_sff_power2dbm(const struct if_sffpage *sff, size_t start)
{
	const uint8_t *d = sff->sff_data + start;

	int power = d[0] << 8 | d[1];
	return (10.0 * log10f((float)power / 10000.0));
}

static void
if_sff_printalarm(const char *unit, int range, float actual,
    float alrm_high, float alrm_low, float warn_high, float warn_log)
{
	printf("%.02f%s", actual, unit);
	if (range == 1)
		printf(" (low %.02f%s, high %.02f%s)", alrm_low,
		    unit, alrm_high, unit);

	if(actual > alrm_high || actual < alrm_low)
		printf(" [ALARM]");
	else if(actual > warn_high || actual < warn_log)
		printf(" [WARNING]");
}

static void
if_sff_printdist(const char *type, int value, int scale)
{
	int distance = value * scale;

	if (value == 0)
		return;

	if (distance < 10000)
		printf (", %s%u%s", value > 254 ? ">" : "", distance, type);
	else
		printf (", %s%0.1fk%s", value > 254 ? ">" : "",
		    distance / 1000.0, type);
}

static void
if_sff_printmedia(const struct if_sffpage *pg, const struct sff_media_map *m)
{
	uint8_t con;
	unsigned int wavelength;

	con = pg->sff_data[m->connector_type];
	printf("%s", sff_con_name(con));

	wavelength = if_sff_uint(pg, m->wavelength);
	switch (wavelength) {
	case 0x0000:
		/* not known or is unavailable */
		break;
	/* Copper Cable */
	case 0x0100: /* SFF-8431 Appendix E */
	case 0x0400: /* SFF-8431 limiting */
	case 0x0c00: /* SFF-8431 limiting and FC-PI-4 limiting */
		break;
	default:
		printf(", %.f nm", wavelength / m->factor_wavelength);
	}

	if (m->dist_smf_m != 0 &&
	    pg->sff_data[m->dist_smf_m] > 0 &&
	    pg->sff_data[m->dist_smf_m] < 255)
		if_sff_printdist("m SMF", pg->sff_data[m->dist_smf_m], 100);
	else
		if_sff_printdist("km SMF", pg->sff_data[m->dist_smf_km], 1);
	if_sff_printdist("m OM1", pg->sff_data[m->dist_om1], m->scale_om1);
	if_sff_printdist("m OM2", pg->sff_data[m->dist_om2], m->scale_om2);
	if_sff_printdist("m OM3", pg->sff_data[m->dist_om3], m->scale_om3);
	if_sff_printdist("m", pg->sff_data[m->dist_cu], 1);
}

static int
if_sff8472(int dump, const struct if_sffpage *pg0)
{
	struct if_sffpage ddm;
	uint8_t ddm_types;

	if_sff_printmedia(pg0, &sff8472_media_map);

	printf("\n\tmodel: ");
	if_sff_ascii_print(pg0, "",
	    SFF8472_VENDOR_START, SFF8472_VENDOR_END, " ");
	if_sff_ascii_print(pg0, "",
	    SFF8472_PRODUCT_START, SFF8472_PRODUCT_END, "");
	if_sff_ascii_print(pg0, " rev ",
	    SFF8472_REVISION_START, SFF8472_REVISION_END, "");

	if_sff_ascii_print(pg0, "\n\tserial: ",
	    SFF8472_SERIAL_START, SFF8472_SERIAL_END, ", ");
	if_sff_date_print(pg0, "date: ", SFF8472_DATECODE, "\n");

	ddm_types = pg0->sff_data[SFF8472_DDM_TYPE];
	if (pg0->sff_data[SFF8472_COMPLIANCE] == SFF8472_COMPLIANCE_NONE ||
	    !ISSET(ddm_types, SFF8472_DDM_TYPE_IMPL))
		return (0);

	if_sffpage_init(&ddm, IFSFF_ADDR_DDM, 0);
	if (ioctl(sock, SIOCGIFSFFPAGE, (caddr_t)&ddm) == -1)
		return (-1);

	if (dump)
		if_sffpage_dump(&ddm);

	if (ISSET(ddm_types, SFF8472_DDM_TYPE_CAL_EXT)) {
		printf("\tcalibration: external "
		    "(WARNING: needs more code)\n");
	}

	printf("\tvoltage: ");
	if_sff_printalarm(" V", 0,
	    if_sff_uint(&ddm, SFF8472_DDM_VCC) / SFF_VCC_FACTOR,
	    if_sff_uint(&ddm, SFF8472_AW_VCC + ALRM_HIGH) / SFF_VCC_FACTOR,
	    if_sff_uint(&ddm, SFF8472_AW_VCC + ALRM_LOW) / SFF_VCC_FACTOR,
	    if_sff_uint(&ddm, SFF8472_AW_VCC + WARN_HIGH) / SFF_VCC_FACTOR,
	    if_sff_uint(&ddm, SFF8472_AW_VCC + WARN_LOW) / SFF_VCC_FACTOR);

	printf(", bias current: ");
	if_sff_printalarm(" mA", 0,
	    if_sff_uint(&ddm, SFF8472_DDM_TX_BIAS) / SFF_BIAS_FACTOR,
	    if_sff_uint(&ddm, SFF8472_AW_TX_BIAS + ALRM_HIGH) / SFF_BIAS_FACTOR,
	    if_sff_uint(&ddm, SFF8472_AW_TX_BIAS + ALRM_LOW) / SFF_BIAS_FACTOR,
	    if_sff_uint(&ddm, SFF8472_AW_TX_BIAS + WARN_HIGH) / SFF_BIAS_FACTOR,
	    if_sff_uint(&ddm, SFF8472_AW_TX_BIAS + WARN_LOW) / SFF_BIAS_FACTOR);

	printf("\n\ttemp: ");
	if_sff_printalarm(" C", 1,
	    if_sff_int(&ddm, SFF8472_DDM_TEMP) / SFF_TEMP_FACTOR,
	    if_sff_int(&ddm, SFF8472_AW_TEMP + ALRM_HIGH) / SFF_TEMP_FACTOR,
	    if_sff_int(&ddm, SFF8472_AW_TEMP + ALRM_LOW) / SFF_TEMP_FACTOR,
	    if_sff_int(&ddm, SFF8472_AW_TEMP + WARN_HIGH) / SFF_TEMP_FACTOR,
	    if_sff_int(&ddm, SFF8472_AW_TEMP + WARN_LOW) / SFF_TEMP_FACTOR);

	printf("\n\ttx: ");
	if_sff_printalarm(" dBm", 1,
	    if_sff_power2dbm(&ddm, SFF8472_DDM_TX_POWER),
	    if_sff_power2dbm(&ddm, SFF8472_AW_TX_POWER + ALRM_HIGH),
	    if_sff_power2dbm(&ddm, SFF8472_AW_TX_POWER + ALRM_LOW),
	    if_sff_power2dbm(&ddm, SFF8472_AW_TX_POWER + WARN_HIGH),
	    if_sff_power2dbm(&ddm, SFF8472_AW_TX_POWER + WARN_LOW));

	printf("\n\trx: ");
	if_sff_printalarm(" dBm", 1,
	    if_sff_power2dbm(&ddm, SFF8472_DDM_RX_POWER),
	    if_sff_power2dbm(&ddm, SFF8472_AW_RX_POWER + ALRM_HIGH),
	    if_sff_power2dbm(&ddm, SFF8472_AW_RX_POWER + ALRM_LOW),
	    if_sff_power2dbm(&ddm, SFF8472_AW_RX_POWER + WARN_HIGH),
	    if_sff_power2dbm(&ddm, SFF8472_AW_RX_POWER + WARN_LOW));

	putchar('\n');
	return (0);
}

static void
if_upper_strings(const struct if_sffpage *pg)
{
	if_sff_printmedia(pg, &upper_media_map);

	printf("\n\tmodel: ");
	if_sff_ascii_print(pg, "",
	    UPPER_VENDOR_START, UPPER_VENDOR_END, " ");
	if_sff_ascii_print(pg, "",
	    UPPER_PRODUCT_START, UPPER_PRODUCT_END, "");
	if_sff_ascii_print(pg, " rev ",
	    UPPER_REVISION_START, UPPER_REVISION_END, "");

	if_sff_ascii_print(pg, "\n\tserial: ",
	    UPPER_SERIAL_START, UPPER_SERIAL_END, " ");
	if_sff_date_print(pg, "date: ", UPPER_DATECODE, " ");
	if_sff_ascii_print(pg, "lot: ",
	    UPPER_LOT_START, UPPER_LOT_END, "");

	putchar('\n');
}

static int
if_inf8077(int dump, const struct if_sffpage *pg1)
{
	if_upper_strings(pg1);

	return (0);
}

static int
if_sff8636_thresh(int dump, const struct if_sffpage *pg0)
{
	struct if_sffpage pg3;
	unsigned int i;
	struct sff_thresholds temp, vcc, tx, rx, bias;

	if_sffpage_init(&pg3, IFSFF_ADDR_EEPROM, 3);
	if (ioctl(sock, SIOCGIFSFFPAGE, (caddr_t)&pg3) == -1) {
		if (dump)
			warn("%s SIOCGIFSFFPAGE page 3", ifname);
		return (-1);
	}

	if (dump)
		if_sffpage_dump(&pg3);

	if (pg3.sff_data[0x7f] != 3) { /* just in case... */
		if (dump) {
			warnx("%s SIOCGIFSFFPAGE: page select unsupported",
			    ifname);
		}
		return (-1);
	}

	for (i = 0; i < SFF_THRESH_COUNT; i++) {
		temp.thresholds[i] = if_sff_int(&pg3,
		    SFF8436_AW_TEMP + SFF_THRESH_REG(i)) / SFF_TEMP_FACTOR;

		vcc.thresholds[i] = if_sff_uint(&pg3,
		    SFF8436_AW_VCC + SFF_THRESH_REG(i)) / SFF_VCC_FACTOR;

		rx.thresholds[i] = if_sff_power2dbm(&pg3,
		    SFF8436_AW_RX_POWER + SFF_THRESH_REG(i));

		bias.thresholds[i] = if_sff_uint(&pg3,
		    SFF8436_AW_TX_BIAS + SFF_THRESH_REG(i)) / SFF_BIAS_FACTOR;

		tx.thresholds[i] = if_sff_power2dbm(&pg3,
		    SFF8436_AW_TX_POWER + SFF_THRESH_REG(i));
	}

	printf("\ttemp: ");
	if_sff_printalarm(" C", 1,
	    if_sff_int(&pg3, SFF8436_TEMP) / SFF_TEMP_FACTOR,
	    temp.thresholds[SFF_THRESH_HI_ALARM],
	    temp.thresholds[SFF_THRESH_LO_ALARM],
	    temp.thresholds[SFF_THRESH_HI_WARN],
	    temp.thresholds[SFF_THRESH_LO_WARN]);
	printf("\n");

	printf("\tvoltage: ");
	if_sff_printalarm(" V", 1,
	    if_sff_uint(&pg3, SFF8436_VCC) / SFF_VCC_FACTOR,
	    vcc.thresholds[SFF_THRESH_HI_ALARM],
	    vcc.thresholds[SFF_THRESH_LO_ALARM],
	    vcc.thresholds[SFF_THRESH_HI_WARN],
	    vcc.thresholds[SFF_THRESH_LO_WARN]);
	printf("\n");

	for (i = 0; i < SFF8436_CHANNELS; i++) {
		unsigned int channel = i + 1;

		printf("\tchannel %u bias current: ", channel);
		if_sff_printalarm(" mA", 1,
		    if_sff_uint(&pg3, SFF8436_TX_BIAS(i)) / SFF_BIAS_FACTOR,
		    bias.thresholds[SFF_THRESH_HI_ALARM],
		    bias.thresholds[SFF_THRESH_LO_ALARM],
		    bias.thresholds[SFF_THRESH_HI_WARN],
		    bias.thresholds[SFF_THRESH_LO_WARN]);
		printf("\n");

		printf("\tchannel %u tx: ", channel);
		if_sff_printalarm(" dBm", 1,
		    if_sff_power2dbm(&pg3, SFF8436_TX_POWER(i)),
		    tx.thresholds[SFF_THRESH_HI_ALARM],
		    tx.thresholds[SFF_THRESH_LO_ALARM],
		    tx.thresholds[SFF_THRESH_HI_WARN],
		    tx.thresholds[SFF_THRESH_LO_WARN]);
		printf("\n");

		printf("\tchannel %u rx: ", channel);
		if_sff_printalarm(" dBm", 1,
		    if_sff_power2dbm(&pg3, SFF8436_RX_POWER(i)),
		    rx.thresholds[SFF_THRESH_HI_ALARM],
		    rx.thresholds[SFF_THRESH_LO_ALARM],
		    rx.thresholds[SFF_THRESH_HI_WARN],
		    rx.thresholds[SFF_THRESH_LO_WARN]);
		printf("\n");
	}

	return (0);
}

static int
if_sff8636(int dump, const struct if_sffpage *pg0)
{
	int16_t temp;
	uint8_t maxcasetemp;
	uint8_t flat;
	unsigned int i;

	if_upper_strings(pg0);

	if (pg0->sff_data[SFF8436_STATUS2] & SFF8436_STATUS2_DNR) {
		printf("\tmonitor data not ready\n");
		return (0);
	}

	maxcasetemp = pg0->sff_data[SFF8436_MAXCASETEMP];
	if (maxcasetemp == 0x00)
		maxcasetemp = SFF8436_MAXCASETEMP_DEFAULT;
	printf("\tmax case temp: %u C\n", maxcasetemp);

	temp = if_sff_int(pg0, SFF8436_TEMP);
	/* the temp reading look unset, assume the rest will be unset too */
	if ((uint16_t)temp == 0 || (uint16_t)temp == 0xffffU) {
		if (!dump)
			return (0);
	}

	flat = pg0->sff_data[SFF8436_STATUS2] & SFF8436_STATUS2_FLAT_MEM;
	if (!flat && if_sff8636_thresh(dump, pg0) == 0) {
		if (!dump)
			return (0);
	}

	printf("\t");
	printf("temp: %.02f%s", temp / SFF_TEMP_FACTOR, " C");
	printf(", ");
	printf("voltage: %.02f%s",
	    if_sff_uint(pg0, SFF8436_VCC) / SFF_VCC_FACTOR, " V");
	printf("\n");

	for (i = 0; i < SFF8436_CHANNELS; i++) {
		printf("\t");
		printf("channel %u: ", i + 1);
		printf("bias current: %.02f mA",
		    if_sff_uint(pg0, SFF8436_TX_BIAS(i)) / SFF_BIAS_FACTOR);
		printf(", ");
		printf("rx: %.02f dBm",
		    if_sff_power2dbm(pg0, SFF8436_RX_POWER(i)));
		printf(", ");
		printf("tx: %.02f dBm",
		    if_sff_power2dbm(pg0, SFF8436_TX_POWER(i)));
		printf("\n");
	}

	return (0);
}

static int
printable(int ch)
{
	if (ch == '\0')
		return ('_');
	if (!isprint(ch))
		return ('~');

	return (ch);
}

static void
hexdump(const void *d, size_t datalen)
{
	const uint8_t *data = d;
	int i, j = 0;

	for (i = 0; i < datalen; i += j) {
		printf("% 4d: ", i);
		for (j = 0; j < 16 && i+j < datalen; j++)
			printf("%02x ", data[i + j]);
		while (j++ < 16)
			printf("   ");
		printf("|");
		for (j = 0; j < 16 && i+j < datalen; j++)
			putchar(printable(data[i + j]));
		printf("|\n");
	}
}

#endif /* SMALL */