static int
disk_declare(topo_mod_t *mod, tnode_t *parent, dev_di_node_t *dnode,
tnode_t **childp)
{
tnode_t *dtn = NULL;
int rval;
rval = disk_tnode_create(mod, parent, dnode, DISK, 0, &dtn);
if (dtn == NULL) {
if (rval == 0)
return (0);
topo_mod_dprintf(mod, "disk_declare: "
"disk_tnode_create error %s\n",
topo_strerror(topo_mod_errno(mod)));
return (-1);
}
/* register disk_methods against the disk topo node */
if (topo_method_register(mod, dtn, disk_methods) != 0) {
topo_mod_dprintf(mod, "disk_declare: "
"topo_method_register error %s\n",
topo_strerror(topo_mod_errno(mod)));
topo_node_unbind(dtn);
return (-1);
}
if (childp != NULL)
*childp = dtn;
return (0);
}
/*ARGSUSED*/
static int
sw_enum(topo_mod_t *mod, tnode_t *pnode, const char *name,
topo_instance_t min, topo_instance_t max, void *notused1, void *notused2)
{
(void) topo_method_register(mod, pnode, sw_methods);
return (0);
}
static tnode_t *
iob_tnode_create(tnode_t *parent,
const char *name, topo_instance_t i, void *priv, topo_mod_t *mod)
{
topo_hdl_t *thp;
nvlist_t *args, *fmri, *pfmri;
tnode_t *ntn;
int err;
thp = topo_mod_handle(mod);
if (topo_node_resource(parent, &pfmri, &err) < 0) {
topo_mod_seterrno(mod, err);
topo_mod_dprintf(mod,
"Unable to retrieve parent resource.\n");
return (NULL);
}
if (topo_mod_nvalloc(mod, &args, NV_UNIQUE_NAME) != 0) {
(void) topo_mod_seterrno(mod, EMOD_FMRI_NVL);
nvlist_free(pfmri);
return (NULL);
}
err = nvlist_add_nvlist(args, TOPO_METH_FMRI_ARG_PARENT, pfmri);
if (err != 0) {
nvlist_free(pfmri);
nvlist_free(args);
(void) topo_mod_seterrno(mod, EMOD_FMRI_NVL);
return (NULL);
}
fmri = topo_fmri_create(thp, FM_FMRI_SCHEME_HC, name, i, args, &err);
if (fmri == NULL) {
topo_mod_dprintf(mod,
"Unable to make nvlist for %s bind.\n", name);
return (NULL);
}
ntn = topo_node_bind(mod, parent, name, i, fmri, priv);
if (ntn == NULL) {
topo_mod_dprintf(mod,
"topo_node_bind (%s%d/%s%d) failed: %s\n",
topo_node_name(parent), topo_node_instance(parent),
name, i,
topo_strerror(topo_mod_errno(mod)));
nvlist_free(fmri);
return (NULL);
}
nvlist_free(fmri);
if (topo_method_register(mod, ntn, Iob_methods) < 0) {
topo_mod_dprintf(mod, "topo_method_register failed: %s\n",
topo_strerror(topo_mod_errno(mod)));
topo_node_unbind(ntn);
return (NULL);
}
return (ntn);
}
static tnode_t *
hb_tnode_create(topo_mod_t *mod, tnode_t *parent,
const char *name, topo_instance_t i, void *priv)
{
int err;
nvlist_t *fmri;
tnode_t *ntn;
nvlist_t *auth = topo_mod_auth(mod, parent);
fmri = topo_mod_hcfmri(mod, parent, FM_HC_SCHEME_VERSION, name, i,
NULL, auth, NULL, NULL, NULL);
nvlist_free(auth);
if (fmri == NULL) {
topo_mod_dprintf(mod,
"Unable to make nvlist for %s bind: %s.\n",
name, topo_mod_errmsg(mod));
return (NULL);
}
ntn = topo_node_bind(mod, parent, name, i, fmri);
if (ntn == NULL) {
topo_mod_dprintf(mod,
"topo_node_bind (%s%d/%s%d) failed: %s\n",
topo_node_name(parent), topo_node_instance(parent),
name, i,
topo_strerror(topo_mod_errno(mod)));
nvlist_free(fmri);
return (NULL);
}
nvlist_free(fmri);
topo_node_setspecific(ntn, priv);
if (topo_pgroup_create(ntn, &hb_auth_pgroup, &err) == 0) {
(void) topo_prop_inherit(ntn, FM_FMRI_AUTHORITY,
FM_FMRI_AUTH_PRODUCT, &err);
(void) topo_prop_inherit(ntn, FM_FMRI_AUTHORITY,
FM_FMRI_AUTH_PRODUCT_SN, &err);
(void) topo_prop_inherit(ntn, FM_FMRI_AUTHORITY,
FM_FMRI_AUTH_CHASSIS, &err);
(void) topo_prop_inherit(ntn, FM_FMRI_AUTHORITY,
FM_FMRI_AUTH_SERVER, &err);
}
if (topo_method_register(mod, ntn, Hb_methods) < 0) {
topo_mod_dprintf(mod, "topo_method_register failed: %s\n",
topo_strerror(topo_mod_errno(mod)));
topo_node_unbind(ntn);
return (NULL);
}
return (ntn);
}
/*ARGSUSED*/
static int
fac_prov_mptsas_enum(topo_mod_t *mod, tnode_t *rnode, const char *name,
topo_instance_t min, topo_instance_t max, void *arg, void *unused)
{
if (topo_node_flags(rnode) == TOPO_NODE_FACILITY) {
if (topo_method_register(mod, rnode, mptsas_fac_methods) != 0) {
topo_mod_dprintf(mod, "%s: topo_method_register() "
"failed: %s", __func__, topo_mod_errmsg(mod));
return (-1);
}
return (0);
}
topo_mod_dprintf(mod, "%s: unexpected node flags %x", __func__,
topo_node_flags(rnode));
return (-1);
}
static int
create_chip(topo_mod_t *mod, tnode_t *pnode, topo_instance_t min,
topo_instance_t max, nvlist_t *cpu, nvlist_t *auth,
int mc_offchip)
{
tnode_t *chip;
nvlist_t *fmri = NULL;
int err, perr, nerr = 0;
int32_t chipid, procnodeid, procnodes_per_pkg;
const char *vendor;
int32_t family, model;
boolean_t create_mc = B_FALSE;
uint16_t smbios_id;
/*
* /dev/fm will export the chipid based on SMBIOS' ordering
* of Type-4 structures, if SMBIOS meets FMA needs
*/
err = nvlist_lookup_pairs(cpu, 0,
FM_PHYSCPU_INFO_CHIP_ID, DATA_TYPE_INT32, &chipid,
FM_PHYSCPU_INFO_NPROCNODES, DATA_TYPE_INT32, &procnodes_per_pkg,
FM_PHYSCPU_INFO_PROCNODE_ID, DATA_TYPE_INT32, &procnodeid,
FM_PHYSCPU_INFO_VENDOR_ID, DATA_TYPE_STRING, &vendor,
FM_PHYSCPU_INFO_FAMILY, DATA_TYPE_INT32, &family,
FM_PHYSCPU_INFO_MODEL, DATA_TYPE_INT32, &model,
NULL);
if (err) {
whinge(mod, NULL, "create_chip: lookup failed: %s\n",
strerror(err));
return (-1);
}
if (chipid < min || chipid > max)
return (-1);
if (FM_AWARE_SMBIOS(mod)) {
if ((err = nvlist_lookup_uint16(cpu,
FM_PHYSCPU_INFO_SMBIOS_ID, &smbios_id)) != 0) {
whinge(mod, NULL,
"create_chip: lookup smbios_id failed"
": enumerating x86pi & chip topology, but"
" no Chip properties from SMBIOS"
" - err msg : %s\n", strerror(err));
/*
* Lets reset the module specific
* data to NULL, overriding any
* SMBIOS capability encoded earlier.
* This will fail all subsequent
* FM_AWARE_SMBIOS checks.
*/
topo_mod_setspecific(mod, NULL);
}
}
if ((chip = topo_node_lookup(pnode, CHIP_NODE_NAME, chipid)) == NULL) {
if ((chip = create_node(mod, pnode, auth, CHIP_NODE_NAME,
chipid, smbios_id)) == NULL)
return (-1);
/*
* Do not register XML map methods if SMBIOS can provide
* serial, part, revision & label
*/
if (!FM_AWARE_SMBIOS(mod)) {
if (topo_method_register(mod, chip, chip_methods) < 0)
whinge(mod, &nerr, "create_chip: "
"topo_method_register failed\n");
}
(void) topo_pgroup_create(chip, &chip_pgroup, &err);
nerr -= add_nvlist_strprop(mod, chip, cpu, PGNAME(CHIP),
CHIP_VENDOR_ID, NULL);
nerr -= add_nvlist_longprops(mod, chip, cpu, PGNAME(CHIP),
NULL, CHIP_FAMILY, CHIP_MODEL, CHIP_STEPPING, NULL);
if (FM_AWARE_SMBIOS(mod)) {
int fru = 0;
char *serial = NULL;
char *part = NULL;
char *rev = NULL;
char *label;
fru = chip_fru_smbios_get(mod, smbios_id);
/*
* Chip is not a FRU, set the FRU fmri of parent node
*/
if (topo_node_resource(chip, &fmri, &perr) != 0)
whinge(mod, &nerr, "create_chip: "
"topo_node_resource failed\n");
if (!fru) {
(void) topo_node_fru_set(chip, NULL, 0, &perr);
label = NULL;
} else {
label = (char *)chip_label_smbios_get(mod,
pnode, smbios_id, NULL);
if (topo_node_fru_set(chip, fmri, 0, &perr)
!= 0) {
whinge(mod, NULL, "create_chip: "
"topo_node_fru_set failed\n");
perr = 0;
}
}
perr += nvlist_lookup_string(fmri,
FM_FMRI_HC_SERIAL_ID, &serial);
perr += nvlist_lookup_string(fmri,
FM_FMRI_HC_PART, &part);
perr += nvlist_lookup_string(fmri,
FM_FMRI_HC_REVISION, &rev);
if (perr != 0) {
whinge(mod, NULL,
"create_chip: nvlist_lookup_string"
"failed\n");
perr = 0;
}
perr += topo_prop_set_string(chip, PGNAME(CHIP),
FM_FMRI_HC_SERIAL_ID, TOPO_PROP_IMMUTABLE,
serial, &perr);
perr += topo_prop_set_string(chip, PGNAME(CHIP),
FM_FMRI_HC_PART, TOPO_PROP_IMMUTABLE,
part, &perr);
perr += topo_prop_set_string(chip, PGNAME(CHIP),
FM_FMRI_HC_REVISION, TOPO_PROP_IMMUTABLE,
rev, &perr);
if (perr != 0)
whinge(mod, NULL,
"create_chip: topo_prop_set_string"
"failed\n");
nvlist_free(fmri);
if (topo_node_label_set(chip, label, &perr)
== -1) {
whinge(mod, NULL, "create_chip: "
"topo_node_label_set failed\n");
}
topo_mod_strfree(mod, label);
} else {
if (topo_node_resource(chip, &fmri, &err) == -1) {
whinge(mod, &nerr, "create_chip: "
"topo_node_resource failed\n");
} else {
(void) topo_node_fru_set(chip, fmri, 0, &perr);
nvlist_free(fmri);
}
}
if (topo_method_register(mod, chip, strands_retire_methods) < 0)
whinge(mod, &nerr, "create_chip: "
"topo_method_register failed\n");
if (topo_node_range_create(mod, chip, CORE_NODE_NAME, 0, 255))
return (-1);
if (strcmp(vendor, "AuthenticAMD") == 0) {
if (topo_node_range_create(mod, chip, MCT_NODE_NAME,
0, 255))
return (-1);
}
create_mc = B_TRUE;
}
if (FM_AWARE_SMBIOS(mod)) {
int status = 0;
/*
* STATUS
* CPU Socket Populated
* CPU Socket Unpopulated
* Populated : Enabled
* Populated : Disabled by BIOS (Setup)
* Populated : Disabled by BIOS (Error)
* Populated : Idle
*
* Enumerate core & strand only for Populated : Enabled
* Enumerate Off-Chip Memory Controller only for
* Populated : Enabled
*/
status = chip_status_smbios_get(mod, (id_t)smbios_id);
if (!status) {
whinge(mod, NULL, "create_chip: "
"CPU Socket is not populated or is disabled\n");
return (0);
}
}
err = create_core(mod, chip, cpu, auth, smbios_id);
/*
* Create memory-controller node under a chip for architectures
* that may have on-chip memory-controller(s).
* If SMBIOS meets FMA needs, when Multi-Chip-Module is
* addressed, mc instances should be derived from SMBIOS
*/
if (strcmp(vendor, "AuthenticAMD") == 0) {
amd_mc_create(mod, smbios_id, chip, MCT_NODE_NAME, auth,
procnodeid, procnodes_per_pkg, family, model, &nerr);
} else if (create_mc && !mc_offchip)
onchip_mc_create(mod, smbios_id, chip, MCT_NODE_NAME, auth);
return (err == 0 && nerr == 0 ? 0 : -1);
}
static int
create_core(topo_mod_t *mod, tnode_t *pnode, nvlist_t *cpu,
nvlist_t *auth, uint16_t chip_smbiosid)
{
tnode_t *core;
int32_t coreid, cpuid;
int err, perr, nerr = 0;
nvlist_t *fmri;
char *serial = NULL;
char *part = NULL;
char *rev = NULL;
if ((err = nvlist_lookup_int32(cpu, FM_PHYSCPU_INFO_CORE_ID, &coreid))
!= 0) {
whinge(mod, NULL, "create_core: lookup core_id failed: %s\n",
strerror(err));
return (-1);
}
if ((core = topo_node_lookup(pnode, CORE_NODE_NAME, coreid)) == NULL) {
if ((core = create_node(mod, pnode, auth, CORE_NODE_NAME,
coreid, chip_smbiosid)) == NULL)
return (-1);
/*
* Inherit FRU from the chip node, for native, we use hc
* scheme ASRU for the core node.
*/
(void) topo_node_fru_set(core, NULL, 0, &perr);
/*
* From the inherited FRU, extract the Serial
* number if SMBIOS donates and set it in the ASRU
*/
if (FM_AWARE_SMBIOS(mod)) {
char *val = NULL;
if (topo_node_resource(core, &fmri, &err) != 0)
whinge(mod, NULL,
"create_core: topo_prop_get_fmri failed\n");
if (nvlist_lookup_string(fmri, FM_FMRI_HC_SERIAL_ID,
&val) != 0)
whinge(mod, NULL, "create_core:"
"nvlist_lookup_string failed\n");
else
serial = topo_mod_strdup(mod, val);
nvlist_free(fmri);
}
if (is_xpv()) {
if (topo_node_resource(core, &fmri, &err) == -1) {
whinge(mod, &nerr, "create_core: "
"topo_node_resource failed\n");
} else {
if (FM_AWARE_SMBIOS(mod))
(void) nvlist_add_string(fmri,
FM_FMRI_HC_SERIAL_ID, serial);
(void) topo_node_asru_set(core, fmri, 0, &err);
nvlist_free(fmri);
}
}
if (topo_method_register(mod, core, strands_retire_methods) < 0)
whinge(mod, &nerr, "create_core: "
"topo_method_register failed\n");
(void) topo_pgroup_create(core, &core_pgroup, &err);
nerr -= add_nvlist_longprops(mod, core, cpu, PGNAME(CORE), NULL,
CORE_CHIP_ID, CORE_PROCNODE_ID, NULL);
if (topo_node_range_create(mod, core, STRAND_NODE_NAME,
0, 255) != 0)
return (-1);
}
if (!is_xpv()) {
/*
* In native mode, we're in favor of cpu scheme ASRU for
* printing reason. More work needs to be done to support
* multi-strand cpu: the ASRU will be a list of cpuid then.
*/
if (nvlist_lookup_int32(cpu, STRAND_CPU_ID, &cpuid) != 0) {
whinge(mod, &nerr, "create_core: lookup cpuid "
"failed\n");
} else {
if ((fmri = cpu_fmri_create(mod, cpuid, serial, 0))
!= NULL) {
(void) topo_node_asru_set(core, fmri, 0, &err);
nvlist_free(fmri);
} else {
whinge(mod, &nerr, "create_core: "
"cpu_fmri_create() failed\n");
}
}
}
if (FM_AWARE_SMBIOS(mod)) {
(void) topo_node_label_set(core, NULL, &perr);
if (topo_node_resource(core, &fmri, &perr) != 0) {
whinge(mod, &nerr, "create_core: "
"topo_node_resource failed\n");
perr = 0;
}
perr += nvlist_lookup_string(fmri,
FM_FMRI_HC_PART, &part);
perr += nvlist_lookup_string(fmri,
FM_FMRI_HC_REVISION, &rev);
if (perr != 0) {
whinge(mod, NULL,
"create_core: nvlist_lookup_string failed\n");
perr = 0;
}
perr += topo_prop_set_string(core, PGNAME(CORE),
FM_FMRI_HC_SERIAL_ID, TOPO_PROP_IMMUTABLE, serial, &perr);
perr += topo_prop_set_string(core, PGNAME(CORE),
FM_FMRI_HC_PART, TOPO_PROP_IMMUTABLE, part, &perr);
perr += topo_prop_set_string(core, PGNAME(CORE),
FM_FMRI_HC_REVISION, TOPO_PROP_IMMUTABLE, rev, &perr);
if (perr != 0)
whinge(mod, NULL, "create_core: topo_prop_set_string"
"failed\n");
nvlist_free(fmri);
topo_mod_strfree(mod, serial);
}
err = create_strand(mod, core, cpu, auth, chip_smbiosid);
return (err == 0 && nerr == 0 ? 0 : -1);
}
static int
create_strand(topo_mod_t *mod, tnode_t *pnode, nvlist_t *cpu,
nvlist_t *auth, uint16_t chip_smbiosid)
{
tnode_t *strand;
int32_t strandid, cpuid;
int err, perr, nerr = 0;
nvlist_t *fmri;
char *serial = NULL;
char *part = NULL;
char *rev = NULL;
if ((err = nvlist_lookup_int32(cpu, FM_PHYSCPU_INFO_STRAND_ID,
&strandid)) != 0) {
whinge(mod, NULL, "create_strand: lookup strand_id failed: "
"%s\n", strerror(err));
return (-1);
}
if ((strand = topo_node_lookup(pnode, STRAND_NODE_NAME, strandid))
!= NULL) {
whinge(mod, NULL, "create_strand: duplicate tuple found\n");
return (-1);
}
if ((strand = create_node(mod, pnode, auth, STRAND_NODE_NAME,
strandid, chip_smbiosid)) == NULL)
return (-1);
/*
* Inherit FRU from core node, in native use cpu scheme ASRU,
* in xpv, use hc scheme ASRU.
*/
(void) topo_node_fru_set(strand, NULL, 0, &perr);
/*
* From the inherited FRU, extract the Serial
* number(if SMBIOS donates) and set it in the ASRU
*/
if (FM_AWARE_SMBIOS(mod)) {
char *val = NULL;
if (topo_prop_get_fmri(strand, TOPO_PGROUP_PROTOCOL,
TOPO_PROP_RESOURCE, &fmri, &err) != 0)
whinge(mod, NULL,
"create_strand: topo_prop_get_fmri failed\n");
if (nvlist_lookup_string(fmri, FM_FMRI_HC_SERIAL_ID, &val) != 0)
whinge(mod, NULL,
"create_strand: nvlist_lookup_string failed: \n");
else
serial = topo_mod_strdup(mod, val);
nvlist_free(fmri);
}
if (is_xpv()) {
if (topo_node_resource(strand, &fmri, &err) == -1) {
whinge(mod, &nerr, "create_strand: "
"topo_node_resource failed\n");
} else {
if (FM_AWARE_SMBIOS(mod))
(void) nvlist_add_string(fmri,
FM_FMRI_HC_SERIAL_ID, serial);
(void) topo_node_asru_set(strand, fmri, 0, &err);
nvlist_free(fmri);
}
} else {
if (nvlist_lookup_int32(cpu, STRAND_CPU_ID, &cpuid) != 0) {
whinge(mod, &nerr, "create_strand: lookup cpuid "
"failed\n");
} else {
if ((fmri = cpu_fmri_create(mod, cpuid, serial, 0))
!= NULL) {
(void) topo_node_asru_set(strand, fmri,
0, &err);
nvlist_free(fmri);
} else {
whinge(mod, &nerr, "create_strand: "
"cpu_fmri_create() failed\n");
}
}
}
if (topo_method_register(mod, strand, strands_retire_methods) < 0)
whinge(mod, &nerr, "create_strand: "
"topo_method_register failed\n");
(void) topo_pgroup_create(strand, &strand_pgroup, &err);
nerr -= add_nvlist_longprops(mod, strand, cpu, PGNAME(STRAND), NULL,
STRAND_CHIP_ID, STRAND_PROCNODE_ID, STRAND_CORE_ID, STRAND_CPU_ID,
NULL);
if (FM_AWARE_SMBIOS(mod)) {
(void) topo_node_label_set(strand, NULL, &perr);
if (topo_node_resource(strand, &fmri, &perr) != 0) {
whinge(mod, &nerr, "create_strand: "
"topo_node_resource failed\n");
perr = 0;
}
perr += nvlist_lookup_string(fmri,
FM_FMRI_HC_PART, &part);
perr += nvlist_lookup_string(fmri,
FM_FMRI_HC_REVISION, &rev);
if (perr != 0) {
whinge(mod, NULL,
"create_strand: nvlist_lookup_string failed\n");
perr = 0;
}
perr += topo_prop_set_string(strand, PGNAME(STRAND),
FM_FMRI_HC_SERIAL_ID, TOPO_PROP_IMMUTABLE, serial, &perr);
perr += topo_prop_set_string(strand, PGNAME(STRAND),
FM_FMRI_HC_PART, TOPO_PROP_IMMUTABLE, part, &perr);
perr += topo_prop_set_string(strand, PGNAME(STRAND),
FM_FMRI_HC_REVISION, TOPO_PROP_IMMUTABLE, rev, &perr);
if (perr != 0)
whinge(mod, NULL, "create_strand: topo_prop_set_string"
"failed\n");
nvlist_free(fmri);
topo_mod_strfree(mod, serial);
}
return (err == 0 && nerr == 0 ? 0 : -1);
}
static int
disk_add_temp_sensor(topo_mod_t *mod, tnode_t *pnode, const char *devid)
{
tnode_t *fnode;
topo_pgroup_info_t pgi;
nvlist_t *arg_nvl = NULL;
int err;
if ((fnode = topo_node_facbind(mod, pnode, "temp",
TOPO_FAC_TYPE_SENSOR)) == NULL) {
topo_mod_dprintf(mod, "failed to bind facility node");
/* errno set */
return (-1);
}
/*
* Set props:
* - facility/sensor-class
* - facility/sensor-type
* - facility/units
*/
pgi.tpi_name = TOPO_PGROUP_FACILITY;
pgi.tpi_namestab = TOPO_STABILITY_PRIVATE;
pgi.tpi_datastab = TOPO_STABILITY_PRIVATE;
pgi.tpi_version = 1;
if (topo_pgroup_create(fnode, &pgi, &err) != 0) {
if (err != ETOPO_PROP_DEFD) {
topo_mod_dprintf(mod, "pgroups create failure (%s)\n",
topo_strerror(err));
/* errno set */
goto err;
}
}
if (topo_prop_set_string(fnode, TOPO_PGROUP_FACILITY,
TOPO_SENSOR_CLASS, TOPO_PROP_IMMUTABLE,
TOPO_SENSOR_CLASS_THRESHOLD, &err) != 0 ||
topo_prop_set_uint32(fnode, TOPO_PGROUP_FACILITY,
TOPO_FACILITY_TYPE, TOPO_PROP_IMMUTABLE, TOPO_SENSOR_TYPE_TEMP,
&err) != 0 ||
topo_prop_set_uint32(fnode, TOPO_PGROUP_FACILITY,
TOPO_SENSOR_UNITS, TOPO_PROP_IMMUTABLE,
TOPO_SENSOR_UNITS_DEGREES_C, &err) != 0) {
topo_mod_dprintf(mod, "Failed to set props on facnode (%s)",
topo_strerror(err));
/* errno set */
goto err;
}
/*
* Register a property method for facility/reading
*/
if (topo_method_register(mod, fnode, disk_fac_methods) < 0) {
topo_mod_dprintf(mod, "failed to register facility methods");
goto err;
}
if (topo_mod_nvalloc(mod, &arg_nvl, NV_UNIQUE_NAME) < 0 ||
nvlist_add_string(arg_nvl, TOPO_IO_DEVID, devid) != 0) {
topo_mod_dprintf(mod, "Failed build arg nvlist\n");
(void) topo_mod_seterrno(mod, EMOD_NOMEM);
goto err;
}
if (topo_prop_method_register(fnode, TOPO_PGROUP_FACILITY,
TOPO_SENSOR_READING, TOPO_TYPE_DOUBLE, "disk_temp_reading",
arg_nvl, &err) != 0) {
topo_mod_dprintf(mod, "Failed to register %s propmeth "
"on fac node %s (%s)\n", TOPO_SENSOR_READING,
topo_node_name(fnode), topo_strerror(err));
/* errno set */
goto err;
}
nvlist_free(arg_nvl);
return (0);
err:
topo_node_unbind(fnode);
nvlist_free(arg_nvl);
return (-1);
}
static int
amd_dimm_create(topo_mod_t *mod, uint16_t chip_smbid, tnode_t *pnode,
const char *name, nvlist_t *mc, nvlist_t *auth)
{
int i, err, nerr = 0;
int perr = 0;
nvpair_t *nvp;
tnode_t *dimmnode;
nvlist_t *fmri, **dimmarr = NULL;
uint64_t num;
uint_t ndimm;
id_t smbid;
const char *serial;
const char *part;
const char *rev;
if (nvlist_lookup_nvlist_array(mc, "dimmlist", &dimmarr, &ndimm) != 0) {
whinge(mod, NULL, "amd_dimm_create: dimmlist lookup failed\n");
return (-1);
}
if (ndimm == 0)
return (0); /* no dimms present on this node */
if (topo_node_range_create(mod, pnode, name, 0, MAX_DIMMNUM) < 0) {
whinge(mod, NULL, "amd_dimm_create: range create failed\n");
return (-1);
}
for (i = 0; i < ndimm; i++) {
if (nvlist_lookup_uint64(dimmarr[i], "num", &num) != 0) {
whinge(mod, &nerr, "amd_dimm_create: dimm num property "
"missing\n");
continue;
}
if (mkrsrc(mod, pnode, name, num, auth, &fmri) < 0) {
whinge(mod, &nerr, "amd_dimm_create: mkrsrc failed\n");
continue;
}
if (FM_AWARE_SMBIOS(mod)) {
smbid = memnode_to_smbiosid(mod, chip_smbid,
DIMM_NODE_NAME, i, NULL);
serial = chip_serial_smbios_get(mod, smbid);
part = chip_part_smbios_get(mod, smbid);
rev = chip_rev_smbios_get(mod, smbid);
perr += nvlist_add_string(fmri, FM_FMRI_HC_SERIAL_ID,
serial);
perr += nvlist_add_string(fmri, FM_FMRI_HC_PART,
part);
perr += nvlist_add_string(fmri, FM_FMRI_HC_REVISION,
rev);
if (perr != 0)
whinge(mod, NULL, "amd_dimm_create:"
"nvlist_add_string failed\n");
}
if ((dimmnode = topo_node_bind(mod, pnode, name, num, fmri))
== NULL) {
nvlist_free(fmri);
whinge(mod, &nerr, "amd_dimm_create: node bind "
"failed\n");
continue;
}
if (!FM_AWARE_SMBIOS(mod))
if (topo_method_register(mod,
dimmnode, dimm_methods) < 0)
whinge(mod, &nerr, "amd_dimm_create: "
"topo_method_register failed");
(void) topo_pgroup_create(dimmnode, &dimm_pgroup, &err);
if (FM_AWARE_SMBIOS(mod)) {
char *label;
nvlist_free(fmri);
(void) topo_node_resource(dimmnode,
&fmri, &err);
label = (char *)chip_label_smbios_get(mod,
pnode, smbid, NULL);
if (topo_node_label_set(dimmnode, label,
&perr) == -1)
topo_mod_dprintf(mod, "Failed"
"to set label\n");
topo_mod_strfree(mod, label);
(void) topo_prop_set_string(dimmnode, PGNAME(DIMM),
FM_FMRI_HC_SERIAL_ID, TOPO_PROP_IMMUTABLE,
serial, &err);
(void) topo_prop_set_string(dimmnode, PGNAME(DIMM),
FM_FMRI_HC_PART, TOPO_PROP_IMMUTABLE,
part, &err);
(void) topo_prop_set_string(dimmnode, PGNAME(DIMM),
FM_FMRI_HC_REVISION, TOPO_PROP_IMMUTABLE,
rev, &err);
}
(void) topo_node_asru_set(dimmnode, fmri, 0, &err);
(void) topo_node_fru_set(dimmnode, fmri, 0, &err);
nvlist_free(fmri);
for (nvp = nvlist_next_nvpair(dimmarr[i], NULL); nvp != NULL;
nvp = nvlist_next_nvpair(dimmarr[i], nvp)) {
if (nvpair_type(nvp) == DATA_TYPE_UINT64_ARRAY &&
strcmp(nvpair_name(nvp), "csnums") == 0 ||
nvpair_type(nvp) == DATA_TYPE_STRING_ARRAY &&
strcmp(nvpair_name(nvp), "csnames") == 0)
continue; /* used in amd_rank_create() */
nerr += nvprop_add(mod, nvp, PGNAME(DIMM), dimmnode);
}
nerr += amd_rank_create(mod, dimmnode, dimmarr[i], auth);
}
return (nerr == 0 ? 0 : -1);
}
int
amd_rank_create(topo_mod_t *mod, tnode_t *pnode, nvlist_t *dimmnvl,
nvlist_t *auth)
{
uint64_t *csnumarr;
char **csnamearr;
uint_t ncs, ncsname;
tnode_t *ranknode;
nvlist_t *fmri, *pfmri = NULL;
uint64_t dsz, rsz;
int nerr = 0;
int err;
int i;
if (nvlist_lookup_uint64_array(dimmnvl, "csnums", &csnumarr,
&ncs) != 0 || nvlist_lookup_string_array(dimmnvl, "csnames",
&csnamearr, &ncsname) != 0 || ncs != ncsname) {
whinge(mod, &nerr, "amd_rank_create: "
"csnums/csnames extraction failed\n");
return (nerr);
}
if (topo_node_resource(pnode, &pfmri, &err) < 0) {
whinge(mod, &nerr, "amd_rank_create: parent fmri lookup "
"failed\n");
return (nerr);
}
if (topo_node_range_create(mod, pnode, RANK_NODE_NAME, 0, ncs) < 0) {
whinge(mod, &nerr, "amd_rank_create: range create failed\n");
nvlist_free(pfmri);
return (nerr);
}
if (topo_prop_get_uint64(pnode, PGNAME(DIMM), "size", &dsz,
&err) == 0) {
rsz = dsz / ncs;
} else {
whinge(mod, &nerr, "amd_rank_create: parent dimm has no "
"size\n");
return (nerr);
}
for (i = 0; i < ncs; i++) {
if (mkrsrc(mod, pnode, RANK_NODE_NAME, i, auth, &fmri) < 0) {
whinge(mod, &nerr, "amd_rank_create: mkrsrc failed\n");
continue;
}
if ((ranknode = topo_node_bind(mod, pnode, RANK_NODE_NAME, i,
fmri)) == NULL) {
nvlist_free(fmri);
whinge(mod, &nerr, "amd_rank_create: node bind "
"failed\n");
continue;
}
nvlist_free(fmri);
if (FM_AWARE_SMBIOS(mod))
(void) topo_node_fru_set(ranknode, NULL, 0, &err);
else
(void) topo_node_fru_set(ranknode, pfmri, 0, &err);
/*
* If a rank is faulted the asru is the associated
* chip-select, but if a page within a rank is faulted
* the asru is just that page. Hence the dual preconstructed
* and computed ASRU.
*/
if (topo_method_register(mod, ranknode, rank_methods) < 0)
whinge(mod, &nerr, "amd_rank_create: "
"topo_method_register failed");
if (! is_xpv() && topo_method_register(mod, ranknode,
ntv_page_retire_methods) < 0)
whinge(mod, &nerr, "amd_rank_create: "
"topo_method_register failed");
(void) topo_node_asru_set(ranknode, cs_fmri[csnumarr[i]],
TOPO_ASRU_COMPUTE, &err);
(void) topo_pgroup_create(ranknode, &rank_pgroup, &err);
(void) topo_prop_set_uint64(ranknode, PGNAME(RANK), "size",
TOPO_PROP_IMMUTABLE, rsz, &err);
(void) topo_prop_set_string(ranknode, PGNAME(RANK), "csname",
TOPO_PROP_IMMUTABLE, csnamearr[i], &err);
(void) topo_prop_set_uint64(ranknode, PGNAME(RANK), "csnum",
TOPO_PROP_IMMUTABLE, csnumarr[i], &err);
}
nvlist_free(pfmri);
return (nerr);
}
/*ARGSUSED*/
static int
amd_generic_mc_create(topo_mod_t *mod, uint16_t smbid, tnode_t *cnode,
tnode_t *mcnode, int family, int model, nvlist_t *auth)
{
int chan, cs;
/*
* Elsewhere we have already returned for families less than 0xf.
* This "generic" topology is adequate for all of family 0xf and
* for revisions A to E of family 0x10 (for the list of models
* in each revision, refer to usr/src/uts/i86pc/os/cpuid_subr.c).
* We cover all family 0x10 models, till model 10.
*/
if (family > 0x10 || (family == 0x10 && model > 10))
return (1);
if (topo_node_range_create(mod, mcnode, CHAN_NODE_NAME, 0,
MAX_CHANNUM) < 0) {
whinge(mod, NULL, "amd_generic_mc_create: range create for "
"channels failed\n");
return (-1);
}
for (chan = 0; chan <= MAX_CHANNUM; chan++) {
tnode_t *chnode;
nvlist_t *fmri;
int err;
if (mkrsrc(mod, mcnode, CHAN_NODE_NAME, chan, auth,
&fmri) != 0) {
whinge(mod, NULL, "amd_generic_mc_create: mkrsrc "
"failed\n");
return (-1);
}
if ((chnode = topo_node_bind(mod, mcnode, CHAN_NODE_NAME,
chan, fmri)) == NULL) {
nvlist_free(fmri);
whinge(mod, NULL, "amd_generic_mc_create: node "
"bind failed\n");
return (-1);
}
nvlist_free(fmri);
(void) topo_pgroup_create(chnode, &chan_pgroup, &err);
(void) topo_prop_set_string(chnode, PGNAME(CHAN), "channel",
TOPO_PROP_IMMUTABLE, chan == 0 ? "A" : "B", &err);
if (FM_AWARE_SMBIOS(mod)) {
if (topo_node_label_set(chnode, NULL, &err) == -1)
whinge(mod, NULL, "amd_generic_mc_create: "
"topo_node_label_set\n");
if (topo_node_fru_set(chnode, NULL, 0, &err) != 0)
whinge(mod, NULL, "amd_generic_mc_create: "
"topo_node_fru_set failed\n");
}
if (topo_node_range_create(mod, chnode, CS_NODE_NAME,
0, MAX_CSNUM) < 0) {
whinge(mod, NULL, "amd_generic_mc_create: "
"range create for cs failed\n");
return (-1);
}
for (cs = 0; cs <= MAX_CSNUM; cs++) {
tnode_t *csnode;
if (mkrsrc(mod, chnode, CS_NODE_NAME, cs, auth,
&fmri) != 0) {
whinge(mod, NULL, "amd_generic_mc_create: "
"mkrsrc for cs failed\n");
return (-1);
}
if ((csnode = topo_node_bind(mod, chnode, CS_NODE_NAME,
cs, fmri)) == NULL) {
nvlist_free(fmri);
whinge(mod, NULL, "amd_generic_mc_create: "
"bind for cs failed\n");
return (-1);
}
/*
* Dynamic ASRU for page faults within a chip-select.
* The topology does not represent pages (there are
* too many) so when a page is faulted we generate
* an ASRU to represent the individual page.
* If SMBIOS meets FMA needs, derive labels & serials
* for DIMMS and apply to chip-select nodes.
* If deriving from SMBIOS, skip IPMI
*/
if (FM_AWARE_SMBIOS(mod)) {
if (topo_method_register(mod, csnode,
x86pi_gen_cs_methods) < 0)
whinge(mod, NULL,
"amd_generic_mc_create: "
"method registration failed\n");
} else {
if (topo_method_register(mod, csnode,
gen_cs_methods) < 0)
whinge(mod, NULL,
"amd_generic_mc_create: method"
"registration failed\n");
}
(void) topo_node_asru_set(csnode, fmri,
TOPO_ASRU_COMPUTE, &err);
nvlist_free(fmri);
/*
* If SMBIOS meets FMA needs, set DIMM as the FRU for
* the chip-select node. Use the channel & chip-select
* numbers to get the DIMM instance.
* Send via inst : dram channel number
* Receive via inst : dimm instance
*/
if (FM_AWARE_SMBIOS(mod)) {
int inst;
id_t dimm_smbid;
const char *serial;
const char *part;
const char *rev;
char *label;
(void) topo_pgroup_create(csnode,
&cs_pgroup, &err);
inst = chan;
dimm_smbid = memnode_to_smbiosid(mod, smbid,
CS_NODE_NAME, cs, &inst);
serial = chip_serial_smbios_get(mod,
dimm_smbid);
part = chip_part_smbios_get(mod,
dimm_smbid);
rev = chip_rev_smbios_get(mod, dimm_smbid);
label = (char *)chip_label_smbios_get(mod,
chnode, dimm_smbid, NULL);
(void) topo_prop_set_string(csnode, PGNAME(CS),
FM_FMRI_HC_SERIAL_ID, TOPO_PROP_IMMUTABLE,
serial, &err);
(void) topo_prop_set_string(csnode, PGNAME(CS),
FM_FMRI_HC_PART, TOPO_PROP_IMMUTABLE,
part, &err);
(void) topo_prop_set_string(csnode, PGNAME(CS),
FM_FMRI_HC_REVISION, TOPO_PROP_IMMUTABLE,
rev, &err);
/*
* We apply DIMM labels to chip-select nodes,
* FRU for chip-selects should be DIMMs, and
* we do not derive dimm nodes for Family 0x10
* so FRU fmri is NULL, but FRU Labels are set,
* the FRU labels point to the DIMM.
*/
(void) topo_node_label_set(csnode, label, &err);
topo_mod_strfree(mod, label);
}
}
}
return (0);
}
