/*
 * 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 2023 Oxide Computer Company
 */

/*
 * This facility provider works with libhotplug to use its private properties to
 * try and provide LED functionality. To work with libhotplug's bus-specific
 * private options (which really here is all about PCIe) we require that the
 * caller give us the name of the slot as cfgadm and others know about it. This
 * varies on the system.
 *
 * Our assumption is that the name of this is the name of the 'connector' in
 * libhotplug parlance and that by reading the /dev/cfg/<name> link, we'll
 * figure out where in the tree it is.
 *
 * The LED method on this facility does not attempt to prescribe meaning to the
 * actual logical topology facility type. The assumption we have is that the
 * caller has set up what makes sense. That means if they want to use the power
 * LED for attention or something else entirely, that is their prerogative. For
 * all of this to work, the members of the 'libhp' property group defined below
 * are required.
 *
 * "connector" (string): This is the name of the connector to look for.
 *
 * "option" (string): This is the name of the libhotplug option to actually look
 * for. For a PCI class device this is generally something like "attn_led",
 * "power_led", etc. or similar.
 *
 * "opt_on" (string): This indicates the value of the option that should be set
 * when we are turning it on. This must be one of the supported option strings.
 * Currently there is no validation of the option string. When querying for
 * whether the indicator is on or off in libtopo, if we get a value that is not
 * this string, then we will consider the indicator off.
 *
 * "opt_off" (string): This indicates the value of the option that should be set
 * when we are turning it off. This should generally by the 'default' option for
 * cases where the indicator is otherwise used.
 */

#include <sys/fm/protocol.h>
#include <fm/topo_mod.h>
#include <libhotplug.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>

/*
 * The following are the members of the libhp property group that we expect to
 * exist. These values are defined above.
 */
#define	TOPO_PGROUP_LIBHP	"libhp"
#define	TOPO_PGROUP_LIBHP_CONNECTOR	"connector"
#define	TOPO_PGROUP_LIBHP_OPTION	"option"
#define	TOPO_PGROUP_LIBHP_OPT_ON	"opt_on"
#define	TOPO_PGROUP_LIBHP_OPT_OFF	"opt_off"
#define	LIBHP_OFF_MODE_VALUE		"value"
#define	LIBHP_OFF_MODE_CONN_POWER	"conn_power"

/*
 * This is the approximate buffer size we expect to use construct the
 * opt_name=opt_val buffers in here.
 */
#define	FAC_PROV_LIBHP_OPTLEN	128

/*
 * Given the name for a connector, attempt to find the corresponding hp_node_t.
 * As mentioned in the introduction to this module, the connector name is
 * expected to be something in the form of a /dev/cfg/<name> link that'll point
 * back to a /devices minor node. This link will have a fair bit of data before
 * it gets back to a /devices part. So we'll find that and move past that.
 */
static hp_node_t
fac_prov_libhp_find_node(topo_mod_t *mod, const char *conn)
{
	char cfg[PATH_MAX], link[PATH_MAX];
	ssize_t ret;
	const char *prefix = "/devices";
	char *start, *end;
	hp_node_t node;

	if (snprintf(cfg, sizeof (cfg), "/dev/cfg/%s", conn) >= sizeof (cfg)) {
		topo_mod_dprintf(mod, "failed to construct /dev/cfg path");
		return (NULL);
	}

	ret = readlink(cfg, link, sizeof (link));
	if (ret < 0) {
		topo_mod_dprintf(mod, "failed to readlink %s: %s", cfg,
		    strerror(errno));
		return (NULL);
	}

	if ((size_t)ret >= sizeof (link)) {
		topo_mod_dprintf(mod, "cannot process readlink of %s: link "
		    "did not fit in buffer", cfg);
		return (NULL);
	}
	link[ret] = '\0';

	start = strstr(link, prefix);
	if (start == NULL) {
		topo_mod_dprintf(mod, "failed to find %s in %s", prefix, link);
		return (NULL);
	}

	start += strlen(prefix);
	end = strchr(start, ':');
	if (end == NULL) {
		topo_mod_dprintf(mod, "failed to find ':' to indicate start of "
		    "minor node in %s", start);
		return (NULL);
	}
	*end = '\0';

	topo_mod_dprintf(mod, "attempting to hp_init %s %s", start, conn);
	node = hp_init(start, conn, 0);
	if (node == NULL) {
		topo_mod_dprintf(mod, "failed to init hp node: %s\n",
		    strerror(errno));
		return (NULL);
	}

	return (node);
}

static int
fac_prov_libhp_set_val(topo_mod_t *mod, hp_node_t hp, const char *opt_name,
    const char *val)
{
	int ret;
	char buf[FAC_PROV_LIBHP_OPTLEN];
	char *res = NULL;

	if (snprintf(buf, sizeof (buf), "%s=%s", opt_name, val) >=
	    sizeof (buf)) {
		topo_mod_dprintf(mod, "failed to construct option buf");
		return (topo_mod_seterrno(mod, EMOD_UNKNOWN));
	}

	ret = hp_set_private(hp, buf, &res);
	if (ret != 0) {
		topo_mod_dprintf(mod, "failed to set prop %s: %s", buf,
		    strerror(ret));
		return (topo_mod_seterrno(mod, EMOD_UNKNOWN));
	}
	free(res);

	return (0);
}

static int
fac_prov_libhp_get_opt(topo_mod_t *mod, hp_node_t hp, const char *opt_name,
    const char *opt_on, nvlist_t **nvout)
{
	int ret;
	char *val;
	uint32_t state;
	nvlist_t *nvl;
	char buf[FAC_PROV_LIBHP_OPTLEN];

	if (snprintf(buf, sizeof (buf), "%s=%s", opt_name, opt_on) >=
	    sizeof (buf)) {
		topo_mod_dprintf(mod, "failed to construct option buf");
		return (topo_mod_seterrno(mod, EMOD_UNKNOWN));
	}

	ret = hp_get_private(hp, opt_name, &val);
	if (ret != 0) {
		topo_mod_dprintf(mod, "failed to get hp node private prop "
		    "%s: %s", opt_name, strerror(ret));
		return (topo_mod_seterrno(mod, EMOD_UNKNOWN));
	}

	topo_mod_dprintf(mod, "got hp node opt %s", val);
	if (strcmp(val, buf) == 0) {
		state = TOPO_LED_STATE_ON;
	} else {
		state = TOPO_LED_STATE_OFF;
	}
	free(val);

	if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0 ||
	    nvlist_add_string(nvl, TOPO_PROP_VAL_NAME, TOPO_LED_MODE) != 0 ||
	    nvlist_add_uint32(nvl, TOPO_PROP_VAL_TYPE, TOPO_TYPE_UINT32) != 0 ||
	    nvlist_add_uint32(nvl, TOPO_PROP_VAL_VAL, state) != 0) {
		topo_mod_dprintf(mod, "failed to construct output nvl for "
		    "libhp node state");
		nvlist_free(nvl);
		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
	}

	*nvout = nvl;
	return (0);
}

static int
fac_prov_libhp_opt_set(topo_mod_t *mod, tnode_t *tn, topo_version_t vers,
    nvlist_t *in, nvlist_t **nvout)
{
	int err, ret = -1;
	char *conn = NULL, *opt_name = NULL, *opt_on = NULL, *opt_off = NULL;
	hp_node_t hp = NULL;
	nvlist_t *pargs;

	if (vers != 0) {
		return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));
	}

	if (topo_prop_get_string(tn, TOPO_PGROUP_LIBHP,
	    TOPO_PGROUP_LIBHP_CONNECTOR, &conn, &err) != 0 ||
	    topo_prop_get_string(tn, TOPO_PGROUP_LIBHP,
	    TOPO_PGROUP_LIBHP_OPTION, &opt_name, &err) != 0 ||
	    topo_prop_get_string(tn, TOPO_PGROUP_LIBHP,
	    TOPO_PGROUP_LIBHP_OPT_ON, &opt_on, &err) != 0 ||
	    topo_prop_get_string(tn, TOPO_PGROUP_LIBHP,
	    TOPO_PGROUP_LIBHP_OPT_OFF, &opt_off, &err) != 0) {
		topo_mod_dprintf(mod, "failed to get required libhp props: %s",
		    topo_strerror(err));
		(void) topo_mod_seterrno(mod, err);
		goto out;
	}

	hp = fac_prov_libhp_find_node(mod, conn);
	if (hp == NULL) {
		(void) topo_mod_seterrno(mod, EMOD_UNKNOWN);
		goto out;
	}

	if ((nvlist_lookup_nvlist(in, TOPO_PROP_PARGS, &pargs) == 0) &&
	    nvlist_exists(pargs, TOPO_PROP_VAL_VAL)) {
		uint32_t val;

		err = nvlist_lookup_uint32(pargs, TOPO_PROP_VAL_VAL, &val);
		if (err != 0) {
			ret = topo_mod_seterrno(mod, EMOD_NVL_INVAL);
			goto out;
		}

		switch (val) {
		case TOPO_LED_STATE_ON:
			ret = fac_prov_libhp_set_val(mod, hp, opt_name, opt_on);
			break;
		case TOPO_LED_STATE_OFF:
			ret = fac_prov_libhp_set_val(mod, hp, opt_name,
			    opt_off);
			break;
		default:
			topo_mod_dprintf(mod, "unknown LED mode: 0x%x\n", val);
			ret = topo_mod_seterrno(mod, EMOD_NVL_INVAL);
			break;
		}
	} else {
		ret = fac_prov_libhp_get_opt(mod, hp, opt_name, opt_on, nvout);
	}

out:
	topo_mod_strfree(mod, conn);
	topo_mod_strfree(mod, opt_name);
	topo_mod_strfree(mod, opt_on);
	topo_mod_strfree(mod, opt_off);
	if (hp != NULL) {
		hp_fini(hp);
	}
	return (ret);
}

static const topo_method_t fac_prov_libhp_methods[] = {
	{ "libhp_opt_set", TOPO_PROP_METH_DESC, 0,
	    TOPO_STABILITY_INTERNAL, fac_prov_libhp_opt_set },
	{ NULL }
};

static int
topo_fac_prov_libhp_enum(topo_mod_t *mod, tnode_t *tn, const char *name,
    topo_instance_t min, topo_instance_t max, void *modarg, void *data)
{
	const char *tname = topo_node_name(tn);
	topo_instance_t inst = topo_node_instance(tn);
	int flags = topo_node_flags(tn);

	topo_mod_dprintf(mod, "asked to enum %s [%" PRIu64 ", %" PRIu64 "] on "
	    "%s[%" PRIu64 "]", name, min, max, tname, inst);

	if (flags != TOPO_NODE_FACILITY) {
		topo_mod_dprintf(mod, "node %s[%" PRIu64 "] has unexpected "
		    "flags: 0x%x", tname, inst, flags);
		return (-1);
	}

	if (topo_method_register(mod, tn, fac_prov_libhp_methods) != 0) {
		topo_mod_dprintf(mod, "failed to register libhp facility "
		    "methods: %s", topo_mod_errmsg(mod));
		return (-1);
	}

	return (0);
}

static const topo_modops_t fac_prov_libhp_ops = {
	topo_fac_prov_libhp_enum, NULL
};

static const topo_modinfo_t fac_prov_libhp_mod = {
	"libhotplug facility provider", FM_FMRI_SCHEME_HC, TOPO_VERSION,
	&fac_prov_libhp_ops
};

int
_topo_init(topo_mod_t *mod, topo_version_t version)
{
	if (getenv("TOPOFACLIBHPDEBUG") != NULL)
		topo_mod_setdebug(mod);

	return (topo_mod_register(mod, &fac_prov_libhp_mod, TOPO_VERSION));
}

void
_topo_fini(topo_mod_t *mod)
{
	topo_mod_unregister(mod);
}