/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright (c) 2017, Joyent, Inc.
 * Copyright 2020 Robert Mustacchi
 * Copyright 2023 Oxide Computer Company
 */

/*
 * This module covers enumerating properties of physical NICs. At this time, as
 * various devices are discovered that may relate to various networking gear, we
 * will attempt to enumerate ports and transceivers under them, if requested.
 */

#include <strings.h>
#include <libdevinfo.h>
#include <libdladm.h>
#include <libdllink.h>
#include <libdlstat.h>
#include <libsff.h>
#include <unistd.h>
#include <sys/dld_ioc.h>
#include <sys/dld.h>
#include <sys/mac.h>

#include <sys/fm/protocol.h>
#include <fm/topo_mod.h>
#include <fm/topo_list.h>
#include <fm/topo_method.h>

#include <topo_port.h>
#include <topo_transceiver.h>

#include "topo_nic.h"

typedef enum {
	NIC_PORT_UNKNOWN,
	NIC_PORT_SFF
} nic_port_type_t;

static const topo_pgroup_info_t datalink_pgroup = {
	TOPO_PGROUP_DATALINK,
	TOPO_STABILITY_PRIVATE,
	TOPO_STABILITY_PRIVATE,
	1
};

typedef struct nic_port_mac {
	char npm_mac[ETHERADDRSTRL];
	boolean_t npm_valid;
	topo_mod_t *npm_mod;
} nic_port_mac_t;

/*
 * The following drivers have their main function be a nexus driver which
 * enumerates children itself which are mac providers rather than having the
 * main PCI functions actually be the device nodes. As such, when we encounter
 * them, we need to enumerate them in a slightly different way by walking over
 * each child of the instance.
 */
static const char *nic_nexuses[] = {
	"t4nex",
	NULL
};

/*
 * The first MAC address is always the primary MAC address, so we only worry
 * about the first. Thus this function always returns B_FALSE, to terminate
 * iteration.
 */
static boolean_t
nic_port_datalink_mac_cb(void *arg, dladm_macaddr_attr_t *attr)
{
	nic_port_mac_t *mac = arg;

	if (attr->ma_addrlen != ETHERADDRL) {
		topo_mod_dprintf(mac->npm_mod,
		    "found address with bad length: %u\n", attr->ma_addrlen);
		return (B_FALSE);
	}

	(void) snprintf(mac->npm_mac, sizeof (mac->npm_mac),
	    "%02x:%02x:%02x:%02x:%02x:%02x",
	    attr->ma_addr[0], attr->ma_addr[1], attr->ma_addr[2],
	    attr->ma_addr[3], attr->ma_addr[4], attr->ma_addr[5]);
	mac->npm_valid = B_TRUE;
	return (B_FALSE);
}

static int
nic_port_datalink_props(topo_mod_t *mod, tnode_t *port, dladm_handle_t handle,
    datalink_id_t linkid)
{
	int err;
	dladm_status_t status;
	uint64_t ifspeed;
	link_duplex_t duplex;
	link_state_t state;
	const char *duplex_str, *state_str, *media_str;
	datalink_class_t dlclass;
	uint32_t media;
	char dlname[MAXLINKNAMELEN * 2];
	char dlerr[DLADM_STRSIZE], dlmedia[DLADM_PROP_VAL_MAX], *valptr[1];
	uint_t valcnt = 1;
	nic_port_mac_t mac;

	status = dladm_datalink_id2info(handle, linkid, NULL, &dlclass, &media,
	    dlname, sizeof (dlname));
	if (status != DLADM_STATUS_OK) {
		topo_mod_dprintf(mod, "failed to get link info: %s\n",
		    dladm_status2str(status, dlerr));
		return (topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM));
	}

	if (dlclass != DATALINK_CLASS_PHYS) {
		return (0);
	}

	status = dladm_get_single_mac_stat(handle, linkid, "ifspeed",
	    KSTAT_DATA_UINT64, &ifspeed);
	if (status != DLADM_STATUS_OK) {
		topo_mod_dprintf(mod, "failed to get ifspeed: %s\n",
		    dladm_status2str(status, dlerr));
		return (topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM));
	}

	status = dladm_get_single_mac_stat(handle, linkid, "link_duplex",
	    KSTAT_DATA_UINT32, &duplex);
	if (status != DLADM_STATUS_OK) {
		topo_mod_dprintf(mod, "failed to get link_duplex: %s\n",
		    dladm_status2str(status, dlerr));
		return (topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM));
	}

	switch (duplex) {
	case LINK_DUPLEX_HALF:
		duplex_str = TOPO_PGROUP_DATALINK_LINK_DUPLEX_HALF;
		break;
	case LINK_DUPLEX_FULL:
		duplex_str = TOPO_PGROUP_DATALINK_LINK_DUPLEX_FULL;
		break;
	default:
		duplex_str = TOPO_PGROUP_DATALINK_LINK_DUPLEX_UNKNOWN;
		break;
	}

	status = dladm_get_single_mac_stat(handle, linkid, "link_state",
	    KSTAT_DATA_UINT32, &state);
	if (status != DLADM_STATUS_OK) {
		topo_mod_dprintf(mod, "failed to get link_duplex: %s\n",
		    dladm_status2str(status, dlerr));
		return (topo_mod_seterrno(mod, status));
	}

	switch (state) {
	case LINK_STATE_UP:
		state_str = TOPO_PGROUP_DATALINK_LINK_STATUS_UP;
		break;
	case LINK_STATE_DOWN:
		state_str = TOPO_PGROUP_DATALINK_LINK_STATUS_DOWN;
		break;
	default:
		state_str = TOPO_PGROUP_DATALINK_LINK_STATUS_UNKNOWN;
		break;
	}

	/*
	 * Override the duplex if the link is down. Some devices will leave it
	 * set at half as opposed to unknown.
	 */
	if (state == LINK_STATE_DOWN || state == LINK_STATE_UNKNOWN) {
		duplex_str = TOPO_PGROUP_DATALINK_LINK_DUPLEX_UNKNOWN;
	}

	media_str = NULL;
	if (state == LINK_STATE_UP) {
		valptr[0] = dlmedia;
		if (dladm_get_linkprop(handle, linkid, DLADM_PROP_VAL_CURRENT,
		    "media", valptr, &valcnt) == DLADM_STATUS_OK) {
			media_str = dlmedia;
		}
	}

	mac.npm_mac[0] = '\0';
	mac.npm_valid = B_FALSE;
	mac.npm_mod = mod;
	if (media == DL_ETHER) {
		(void) dladm_walk_macaddr(handle, linkid, &mac,
		    nic_port_datalink_mac_cb);
	}

	if (topo_pgroup_create(port, &datalink_pgroup, &err) != 0) {
		topo_mod_dprintf(mod, "falied to create property group %s: "
		    "%s\n", TOPO_PGROUP_DATALINK, topo_strerror(err));
		return (topo_mod_seterrno(mod, err));
	}

	if (topo_prop_set_uint64(port, TOPO_PGROUP_DATALINK,
	    TOPO_PGROUP_DATALINK_LINK_SPEED, TOPO_PROP_IMMUTABLE, ifspeed,
	    &err) != 0) {
		topo_mod_dprintf(mod, "failed to set %s property: %s\n",
		    TOPO_PGROUP_DATALINK_LINK_SPEED, topo_strerror(err));
		return (topo_mod_seterrno(mod, err));
	}

	if (topo_prop_set_string(port, TOPO_PGROUP_DATALINK,
	    TOPO_PGROUP_DATALINK_LINK_DUPLEX, TOPO_PROP_IMMUTABLE, duplex_str,
	    &err) != 0) {
		topo_mod_dprintf(mod, "failed to set %s property: %s\n",
		    TOPO_PGROUP_DATALINK_LINK_DUPLEX, topo_strerror(err));
		return (topo_mod_seterrno(mod, err));
	}

	if (topo_prop_set_string(port, TOPO_PGROUP_DATALINK,
	    TOPO_PGROUP_DATALINK_LINK_STATUS, TOPO_PROP_IMMUTABLE, state_str,
	    &err) != 0) {
		topo_mod_dprintf(mod, "failed to set %s property: %s\n",
		    TOPO_PGROUP_DATALINK_LINK_STATUS, topo_strerror(err));
		return (topo_mod_seterrno(mod, err));
	}

	if (topo_prop_set_string(port, TOPO_PGROUP_DATALINK,
	    TOPO_PGROUP_DATALINK_LINK_NAME, TOPO_PROP_IMMUTABLE, dlname,
	    &err) != 0) {
		topo_mod_dprintf(mod, "failed to set %s propery: %s\n",
		    TOPO_PGROUP_DATALINK_LINK_NAME, topo_strerror(err));
		return (topo_mod_seterrno(mod, err));
	}

	if (media_str != NULL && topo_prop_set_string(port,
	    TOPO_PGROUP_DATALINK, TOPO_PGROUP_DATALINK_LINK_MEDIA,
	    TOPO_PROP_IMMUTABLE, media_str, &err) != 0) {
		topo_mod_dprintf(mod, "failed to set %s propery: %s\n",
		    TOPO_PGROUP_DATALINK_LINK_MEDIA, topo_strerror(err));
		return (topo_mod_seterrno(mod, err));
	}

	if (mac.npm_valid) {
		if (topo_prop_set_string(port, TOPO_PGROUP_DATALINK,
		    TOPO_PGROUP_DATALINK_PMAC, TOPO_PROP_IMMUTABLE,
		    mac.npm_mac, &err) != 0) {
			topo_mod_dprintf(mod, "failed to set %s propery: %s\n",
			    TOPO_PGROUP_DATALINK_PMAC, topo_strerror(err));
			return (topo_mod_seterrno(mod, err));
		}
	}


	return (0);
}

/*
 * Create an instance of a transceiver with the specified id. We must create
 * both its port and the transceiver node.
 */
static int
nic_create_transceiver(topo_mod_t *mod, tnode_t *pnode, dladm_handle_t handle,
    datalink_id_t linkid, topo_instance_t inst, uint_t tranid,
    nic_port_type_t port_type)
{
	int ret;
	tnode_t *port;
	dld_ioc_gettran_t dgt;
	dld_ioc_tranio_t dti;
	uint8_t buf[256];
	char ouibuf[16];
	char *vendor = NULL, *part = NULL, *rev = NULL, *serial = NULL;
	nvlist_t *nvl = NULL;

	switch (port_type) {
	case NIC_PORT_UNKNOWN:
		ret = port_create_unknown(mod, pnode, inst, &port);
		break;
	case NIC_PORT_SFF:
		ret = port_create_sff(mod, pnode, inst, &port);
		break;
	default:
		return (-1);
	}

	if ((ret = nic_port_datalink_props(mod, port, handle, linkid)) != 0)
		return (ret);

	if (port_type != NIC_PORT_SFF)
		return (0);

	bzero(&dgt, sizeof (dgt));
	dgt.dgt_linkid = linkid;
	dgt.dgt_tran_id = tranid;

	if (ioctl(dladm_dld_fd(handle), DLDIOC_GETTRAN, &dgt) != 0) {
		if (errno == ENOTSUP)
			return (0);
		return (-1);
	}

	if (dgt.dgt_present == 0)
		return (0);

	bzero(&dti, sizeof (dti));
	dti.dti_linkid = linkid;
	dti.dti_tran_id = tranid;
	dti.dti_page = 0xa0;
	dti.dti_nbytes = sizeof (buf);
	dti.dti_buf = (uintptr_t)buf;

	if (ioctl(dladm_dld_fd(handle), DLDIOC_READTRAN, &dti) == 0) {
		uchar_t *oui;
		uint_t nbyte;

		if (libsff_parse(buf, dti.dti_nbytes, dti.dti_page,
		    &nvl) == 0) {
			if ((ret = nvlist_lookup_string(nvl, LIBSFF_KEY_VENDOR,
			    &vendor)) != 0 && nvlist_lookup_byte_array(nvl,
			    LIBSFF_KEY_OUI, &oui, &nbyte) == 0 && nbyte == 3) {
				if (snprintf(ouibuf, sizeof (ouibuf),
				    "%02x:%02x:%02x", oui[0], oui[1], oui[2]) <
				    sizeof (ouibuf)) {
					vendor = ouibuf;
				}
			} else if (ret != 0) {
				vendor = NULL;
			}

			if (nvlist_lookup_string(nvl, LIBSFF_KEY_PART,
			    &part) != 0) {
				part = NULL;
			}

			if (nvlist_lookup_string(nvl, LIBSFF_KEY_REVISION,
			    &rev) != 0) {
				rev = NULL;
			}

			if (nvlist_lookup_string(nvl, LIBSFF_KEY_SERIAL,
			    &serial) != 0) {
				serial = NULL;
			}
		}
	}

	if (transceiver_range_create(mod, port, 0, 0) != 0) {
		nvlist_free(nvl);
		return (-1);
	}

	if (transceiver_create_sff(mod, port, 0, dgt.dgt_usable, vendor, part,
	    rev, serial, NULL) != 0) {
		nvlist_free(nvl);
		return (-1);
	}

	nvlist_free(nvl);
	return (0);
}

static boolean_t
nic_enum_link_ntrans(dladm_handle_t handle, datalink_id_t linkid, uint_t *ntran,
    nic_port_type_t *pt)
{
	dld_ioc_gettran_t dgt;

	memset(&dgt, 0, sizeof (dgt));
	dgt.dgt_linkid = linkid;
	dgt.dgt_tran_id = DLDIOC_GETTRAN_GETNTRAN;

	if (ioctl(dladm_dld_fd(handle), DLDIOC_GETTRAN, &dgt) != 0) {
		if (errno != ENOTSUP) {
			return (B_FALSE);
		}
		*pt = NIC_PORT_UNKNOWN;
		*ntran = 1;
	} else {
		*ntran = dgt.dgt_tran_id;
		*pt = NIC_PORT_SFF;
	}

	return (B_TRUE);
}

static boolean_t
nic_enum_devinfo_linkid(dladm_handle_t handle, di_node_t din,
    datalink_id_t *linkidp)
{
	char dname[MAXNAMELEN];

	if (snprintf(dname, sizeof (dname), "%s%d", di_driver_name(din),
	    di_instance(din)) >= sizeof (dname)) {
		return (B_FALSE);
	}

	if (dladm_dev2linkid(handle, dname, linkidp) != DLADM_STATUS_OK)
		return (B_FALSE);

	return (B_TRUE);
}

/*
 * When we encounter a nexus driver we need to walk each of its children to
 * actually get at the dladm handles and devices that we can use for this.
 */
static int
nic_enum_nexus(topo_mod_t *mod, tnode_t *pnode, dladm_handle_t handle,
    di_node_t din)
{
	uint_t total_ports = 0;
	nic_port_type_t pt;
	di_node_t child;

	/*
	 * We have to iterate child nodes in two passes. The first pass is used
	 * to determine the number of children to create. FM requires that we
	 * create all the children nodes at once currently.
	 */
	for (child = di_child_node(din); child != DI_NODE_NIL;
	    child = di_sibling_node(child)) {
		datalink_id_t linkid;
		uint_t ntrans;

		if (!nic_enum_devinfo_linkid(handle, child, &linkid))
			return (-1);
		if (!nic_enum_link_ntrans(handle, linkid, &ntrans, &pt))
			return (-1);

		total_ports += ntrans;
	}

	if (total_ports == 0)
		return (0);

	if (port_range_create(mod, pnode, 0, total_ports - 1) != 0)
		return (-1);

	total_ports = 0;
	for (child = di_child_node(din); child != DI_NODE_NIL;
	    child = di_sibling_node(child)) {
		datalink_id_t linkid;
		uint_t i, ntrans;

		if (!nic_enum_devinfo_linkid(handle, child, &linkid))
			return (-1);
		if (!nic_enum_link_ntrans(handle, linkid, &ntrans, &pt))
			return (-1);

		for (i = 0; i < ntrans; i++) {
			if (nic_create_transceiver(mod, pnode, handle, linkid,
			    total_ports + i, i, pt) != 0) {
				return (-1);
			}
		}

		total_ports += ntrans;
	}

	return (0);
}

/* ARGSUSED */
static int
nic_enum(topo_mod_t *mod, tnode_t *pnode, const char *name,
    topo_instance_t min, topo_instance_t max, void *modarg, void *data)
{
	di_node_t din = data;
	datalink_id_t linkid;
	dladm_handle_t handle;
	uint_t ntrans, i;
	nic_port_type_t pt;
	const char *drv;

	if (strcmp(name, NIC) != 0) {
		topo_mod_dprintf(mod, "nic_enum: asked to enumerate unknown "
		    "component: %s\n", name);
		return (-1);
	}

	if (din == NULL) {
		topo_mod_dprintf(mod, "nic_enum: missing data argument\n");
		return (-1);
	}

	if ((handle = topo_mod_getspecific(mod)) == NULL) {
		topo_mod_dprintf(mod, "nic_enum: failed to get nic module "
		    "specific data\n");
		return (-1);
	}

	/*
	 * No driver attached, just skip it.
	 */
	if ((drv = di_driver_name(din)) == NULL) {
		return (0);
	}

	for (i = 0; nic_nexuses[i] != NULL; i++) {
		if (strcmp(drv, nic_nexuses[i]) == 0) {
			return (nic_enum_nexus(mod, pnode, handle, din));
		}
	}

	if (!nic_enum_devinfo_linkid(handle, din, &linkid))
		return (-1);

	if (!nic_enum_link_ntrans(handle, linkid, &ntrans, &pt))
		return (-1);

	if (ntrans == 0)
		return (0);

	if (port_range_create(mod, pnode, 0, ntrans - 1) != 0)
		return (-1);

	for (i = 0; i < ntrans; i++) {
		if (nic_create_transceiver(mod, pnode, handle, linkid, i, i,
		    pt) != 0) {
			return (-1);
		}
	}

	return (0);
}

static const topo_modops_t nic_ops = {
	nic_enum, NULL
};

static topo_modinfo_t nic_mod = {
	NIC, FM_FMRI_SCHEME_HC, NIC_VERSION, &nic_ops
};

int
_topo_init(topo_mod_t *mod, topo_version_t version)
{
	dladm_handle_t handle;

	if (getenv("TOPONICDEBUG") != NULL)
		topo_mod_setdebug(mod);

	topo_mod_dprintf(mod, "_mod_init: "
	    "initializing %s enumerator\n", NIC);

	if (version != NIC_VERSION) {
		return (-1);
	}

	if (dladm_open(&handle) != 0)
		return (-1);

	if (topo_mod_register(mod, &nic_mod, TOPO_VERSION) != 0) {
		dladm_close(handle);
		return (-1);
	}

	topo_mod_setspecific(mod, handle);

	return (0);
}

void
_topo_fini(topo_mod_t *mod)
{
	dladm_handle_t handle;

	if ((handle = topo_mod_getspecific(mod)) == NULL)
		return;

	dladm_close(handle);
	topo_mod_setspecific(mod, NULL);
}