/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2019, Joyent, Inc.
 */

#include <sys/fm/protocol.h>
#include <strings.h>
#include <fm/topo_mod.h>
#include <fm/topo_method.h>
#include <sys/scsi/impl/inquiry.h>
#include <sys/scsi/impl/scsi_sas.h>
#include <sys/scsi/scsi_address.h>
#include <did_props.h>

static const topo_pgroup_info_t storage_pgroup =
	{ TOPO_PGROUP_STORAGE, TOPO_STABILITY_PRIVATE,
	    TOPO_STABILITY_PRIVATE, 1 };

static const topo_method_t recep_methods[] = {
	{ TOPO_METH_OCCUPIED, TOPO_METH_OCCUPIED_DESC,
	    TOPO_METH_OCCUPIED_VERSION, TOPO_STABILITY_INTERNAL,
	    topo_mod_hc_occupied },
	{ NULL }
};

void
pci_di_prop_set(tnode_t *tn, di_node_t din, char *dpnm, char *tpnm)
{
	int err;
	char *tmpbuf;

	if (di_prop_lookup_strings(DDI_DEV_T_ANY, din, dpnm, &tmpbuf) == 1)
		(void) topo_prop_set_string(tn, TOPO_PGROUP_STORAGE, tpnm,
		    TOPO_PROP_IMMUTABLE, tmpbuf, &err);
}

void
pci_pi_prop_set(tnode_t *tn, di_path_t din, char *dpnm, char *tpnm)
{
	int err;
	char *tmpbuf;

	if (di_path_prop_lookup_strings(din, dpnm, &tmpbuf) == 1)
		(void) topo_prop_set_string(tn, TOPO_PGROUP_STORAGE, tpnm,
		    TOPO_PROP_IMMUTABLE, tmpbuf, &err);
}

static void
pci_scsi_device_create(topo_mod_t *mod, nvlist_t *auth, tnode_t *parent,
    di_node_t cn, int instance, di_path_t pi)
{
	tnode_t *child;
	nvlist_t *fmri;
	int e, *val;
	int64_t *val64;

	fmri = topo_mod_hcfmri(mod, parent, FM_HC_SCHEME_VERSION, SCSI_DEVICE,
	    instance, NULL, auth, NULL, NULL, NULL);
	if (fmri == NULL)
		return;
	child = topo_node_bind(mod, parent, SCSI_DEVICE, instance, fmri);
	nvlist_free(fmri);
	if (child == NULL)
		return;
	if (topo_pgroup_create(child, &storage_pgroup, &e) < 0)
		return;
	if (pi != NULL) {
		pci_pi_prop_set(child, pi, SCSI_ADDR_PROP_TARGET_PORT,
		    TOPO_STORAGE_TARGET_PORT);
		pci_pi_prop_set(child, pi, SCSI_ADDR_PROP_ATTACHED_PORT,
		    TOPO_STORAGE_ATTACHED_PORT);
		pci_pi_prop_set(child, pi, SCSI_ADDR_PROP_TARGET_PORT_PM,
		    TOPO_STORAGE_TARGET_PORT_PM);
		pci_pi_prop_set(child, pi, SCSI_ADDR_PROP_ATTACHED_PORT_PM,
		    TOPO_STORAGE_ATTACHED_PORT_PM);
		if (di_path_prop_lookup_int64s(pi,
		    SCSI_ADDR_PROP_LUN64, &val64) == 1)
			(void) topo_prop_set_int64(child, TOPO_PGROUP_STORAGE,
			    TOPO_STORAGE_LUN64, TOPO_PROP_IMMUTABLE, *val64,
			    &e);
	} else {
		pci_di_prop_set(child, cn, SCSI_ADDR_PROP_TARGET_PORT,
		    TOPO_STORAGE_TARGET_PORT);
		pci_di_prop_set(child, cn, SCSI_ADDR_PROP_ATTACHED_PORT,
		    TOPO_STORAGE_ATTACHED_PORT);
		pci_di_prop_set(child, cn, SCSI_ADDR_PROP_TARGET_PORT_PM,
		    TOPO_STORAGE_TARGET_PORT_PM);
		pci_di_prop_set(child, cn, SCSI_ADDR_PROP_ATTACHED_PORT_PM,
		    TOPO_STORAGE_ATTACHED_PORT_PM);
		if (di_prop_lookup_int64(DDI_DEV_T_ANY, cn,
		    SCSI_ADDR_PROP_LUN64, &val64) == 1)
			(void) topo_prop_set_int64(child, TOPO_PGROUP_STORAGE,
			    TOPO_STORAGE_LUN64, TOPO_PROP_IMMUTABLE, *val64,
			    &e);
	}
	pci_di_prop_set(child, cn, DEVID_PROP_NAME, TOPO_STORAGE_DEVID);
	pci_di_prop_set(child, cn, INQUIRY_VENDOR_ID,
	    TOPO_STORAGE_MANUFACTURER);
	pci_di_prop_set(child, cn, INQUIRY_PRODUCT_ID, TOPO_STORAGE_MODEL);
	pci_di_prop_set(child, cn, INQUIRY_REVISION_ID,
	    TOPO_STORAGE_FIRMWARE_REV);
	if (di_prop_lookup_ints(DDI_DEV_T_ANY, cn,
	    INQUIRY_DEVICE_TYPE, &val) == 1)
		(void) topo_prop_set_int32(child, TOPO_PGROUP_STORAGE,
		    TOPO_STORAGE_DEVICE_TYPE, TOPO_PROP_IMMUTABLE, *val, &e);
}

static void
pci_smp_device_create(topo_mod_t *mod, nvlist_t *auth, tnode_t *parent,
    di_node_t cn, int instance)
{
	tnode_t *child;
	nvlist_t *fmri;
	int e;

	fmri = topo_mod_hcfmri(mod, parent, FM_HC_SCHEME_VERSION, SMP_DEVICE,
	    instance, NULL, auth, NULL, NULL, NULL);
	if (fmri == NULL)
		return;
	child = topo_node_bind(mod, parent, SMP_DEVICE, instance, fmri);
	nvlist_free(fmri);
	if (child == NULL)
		return;
	if (topo_pgroup_create(child, &storage_pgroup, &e) < 0)
		return;
	pci_di_prop_set(child, cn, SCSI_ADDR_PROP_TARGET_PORT,
	    TOPO_STORAGE_TARGET_PORT);
	pci_di_prop_set(child, cn, SCSI_ADDR_PROP_ATTACHED_PORT,
	    TOPO_STORAGE_ATTACHED_PORT);
	pci_di_prop_set(child, cn, SCSI_ADDR_PROP_TARGET_PORT_PM,
	    TOPO_STORAGE_TARGET_PORT_PM);
	pci_di_prop_set(child, cn, SCSI_ADDR_PROP_ATTACHED_PORT_PM,
	    TOPO_STORAGE_ATTACHED_PORT_PM);
	pci_di_prop_set(child, cn, DEVID_PROP_NAME, TOPO_STORAGE_DEVID);
	pci_di_prop_set(child, cn, INQUIRY_VENDOR_ID,
	    TOPO_STORAGE_MANUFACTURER);
	pci_di_prop_set(child, cn, INQUIRY_PRODUCT_ID, TOPO_STORAGE_MODEL);
	pci_di_prop_set(child, cn, INQUIRY_REVISION_ID,
	    TOPO_STORAGE_FIRMWARE_REV);
}

static tnode_t *
pci_iport_device_create(topo_mod_t *mod, nvlist_t *auth, tnode_t *parent,
    di_node_t cn, int instance)
{
	tnode_t *child;
	nvlist_t *fmri;
	int e;

	fmri = topo_mod_hcfmri(mod, parent, FM_HC_SCHEME_VERSION, IPORT,
	    instance, NULL, auth, NULL, NULL, NULL);
	if (fmri == NULL)
		return (NULL);
	child = topo_node_bind(mod, parent, IPORT, instance, fmri);
	nvlist_free(fmri);
	if (child == NULL)
		return (NULL);
	if (topo_pgroup_create(child, &storage_pgroup, &e) < 0)
		return (child);
	pci_di_prop_set(child, cn, SCSI_ADDR_PROP_INITIATOR_PORT,
	    TOPO_STORAGE_INITIATOR_PORT);
	(void) topo_prop_set_string(child, TOPO_PGROUP_STORAGE,
	    TOPO_STORAGE_INITIATOR_PORT_PM, TOPO_PROP_IMMUTABLE,
	    di_bus_addr(cn), &e);
	return (child);
}

void
pci_iports_instantiate(topo_mod_t *mod, tnode_t *parent, di_node_t pn,
    int niports)
{
	di_node_t cn, smp, sd;
	di_path_t pi;
	tnode_t *iport;
	int i, j;
	nvlist_t *auth;

	if (topo_node_range_create(mod, parent, IPORT, 0, niports) < 0)
		return;
	auth = topo_mod_auth(mod, parent);
	for (i = 0, cn = di_child_node(pn); cn != DI_NODE_NIL;
	    cn = di_sibling_node(cn)) {
		/*
		 * First create any iport nodes.
		 */
		if (strcmp(di_node_name(cn), "iport") != 0)
			continue;
		iport = pci_iport_device_create(mod, auth, parent, cn, i++);
		if (iport == NULL)
			continue;

		/*
		 * Now create any scsi-device nodes.
		 */
		for (j = 0, sd = di_child_node(cn); sd != DI_NODE_NIL;
		    sd = di_sibling_node(sd))
			if (strcmp(di_node_name(sd), "smp") != 0)
				j++;
		for (pi = di_path_phci_next_path(cn, DI_PATH_NIL);
		    pi != DI_PATH_NIL; pi = di_path_phci_next_path(cn, pi))
			if (di_path_client_node(pi) != NULL &&
			    strcmp(di_node_name(di_path_client_node(pi)),
			    "smp") != 0)
				j++;
		if (topo_node_range_create(mod, iport, SCSI_DEVICE, 0, j) < 0)
			continue;
		for (j = 0, sd = di_child_node(cn); sd != DI_NODE_NIL;
		    sd = di_sibling_node(sd))
			if (strcmp(di_node_name(sd), "smp") != 0)
				pci_scsi_device_create(mod, auth, iport, sd,
				    j++, NULL);
		for (pi = di_path_phci_next_path(cn, DI_PATH_NIL);
		    pi != DI_PATH_NIL; pi = di_path_phci_next_path(cn, pi))
			if (di_path_client_node(pi) != NULL &&
			    strcmp(di_node_name(di_path_client_node(pi)),
			    "smp") != 0)
				pci_scsi_device_create(mod, auth, iport,
				    di_path_client_node(pi),  j++, pi);

		/*
		 * Now create any smp-device nodes.
		 */
		for (j = 0, smp = di_child_node(cn); smp != DI_NODE_NIL;
		    smp = di_sibling_node(smp))
			if (strcmp(di_node_name(smp), "smp") == 0)
				j++;
		if (topo_node_range_create(mod, iport, SMP_DEVICE, 0, j) < 0)
			continue;
		for (j = 0, smp = di_child_node(cn); smp != DI_NODE_NIL;
		    smp = di_sibling_node(smp))
			if (strcmp(di_node_name(smp), "smp") == 0)
				pci_smp_device_create(mod, auth, iport, smp,
				    j++);
	}
	nvlist_free(auth);
}

void
pci_receptacle_instantiate(topo_mod_t *mod, tnode_t *parent, di_node_t pnode)
{
	int err, i, rcnt, lcnt;
	char *propstrpm, *propstrlabel, *pm, *label;
	nvlist_t *fmri, *auth;
	tnode_t	*recep;

	rcnt = di_prop_lookup_strings(DDI_DEV_T_ANY, pnode,
	    DI_RECEPTACLE_PHYMASK, &propstrpm);
	if ((lcnt = di_prop_lookup_strings(DDI_DEV_T_ANY, pnode,
	    DI_RECEPTACLE_LABEL, &propstrlabel)) <= 0) {
		topo_mod_dprintf(mod,
		    "pci_receptacle_instanciate: rececptacle label not "
		    "found for the pci function node.\n");
		return;
	}

	if (rcnt != lcnt) {
		topo_mod_dprintf(mod,
		    "pci_receptacle_instantiate: rececptacle label count %d "
		    "doesn match with phy mask count %d\n", lcnt, rcnt);
	}

	label = propstrlabel;
	pm = propstrpm;
	auth = topo_mod_auth(mod, parent);
	for (i = 0; i < rcnt; i++) {
		fmri = topo_mod_hcfmri(mod, parent, FM_HC_SCHEME_VERSION,
		    RECEPTACLE, i, NULL, auth, NULL, NULL, NULL);
		if (fmri == NULL) {
			topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
			    topo_mod_errmsg(mod));
			continue;
		}
		recep = topo_node_bind(mod, parent, RECEPTACLE, i, fmri);
		nvlist_free(fmri);
		if (recep == NULL) {
			topo_mod_dprintf(mod, "topo_node_bind() failed: %s",
			    topo_mod_errmsg(mod));
			continue;
		}

		if (label) {
			if (topo_node_label_set(recep, label, &err) < 0) {
				topo_mod_dprintf(mod,
				    "topo_receptacle_instantiate: "
				    "topo_node_label_set error(%s)\n",
				    topo_strerror(err));
			}
			if (i < lcnt) {
				label = label + strlen(label) + 1;
			} else {
				label = NULL;
			}
		}

		if (topo_pgroup_create(recep, &storage_pgroup, &err) < 0) {
			topo_mod_dprintf(mod, "ses_set_expander_props: "
			    "create storage error %s\n", topo_strerror(err));
			continue;
		}
		(void) topo_prop_set_string(recep, TOPO_PGROUP_STORAGE,
		    TOPO_STORAGE_SAS_PHY_MASK,
		    TOPO_PROP_IMMUTABLE, pm, &err);

		if (topo_method_register(mod, recep, recep_methods) != 0) {
			topo_mod_dprintf(mod, "topo_method_register() failed "
			    "on %s=%d: %s", RECEPTACLE, i,
			    topo_mod_errmsg(mod));
			/* errno set */
			continue;
		}

		pm = pm + strlen(pm) + 1;
	}

	nvlist_free(auth);
}