1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #include <string.h> 28 #include <fm/topo_mod.h> 29 #include <fm/topo_hc.h> 30 #include <libdevinfo.h> 31 #include <limits.h> 32 #include <sys/fm/protocol.h> 33 #include <sys/param.h> 34 #include <sys/systeminfo.h> 35 #include <assert.h> 36 37 #include <hostbridge.h> 38 #include <pcibus.h> 39 #include <did.h> 40 #include <did_props.h> 41 #include <util.h> 42 43 /* 44 * hostbridge.c 45 * Generic code shared by all the hostbridge enumerators 46 */ 47 static void hb_release(topo_mod_t *, tnode_t *); 48 static int hb_label(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *, 49 nvlist_t **); 50 static int hb_enum(topo_mod_t *, tnode_t *, const char *, topo_instance_t, 51 topo_instance_t, void *, void *); 52 53 extern int platform_hb_label(topo_mod_t *, tnode_t *, nvlist_t *, nvlist_t **); 54 extern int platform_hb_enum(topo_mod_t *, tnode_t *, 55 const char *, topo_instance_t, topo_instance_t); 56 57 extern txprop_t ExHB_common_props[]; 58 extern txprop_t HB_common_props[]; 59 extern txprop_t RC_common_props[]; 60 extern int ExHB_propcnt; 61 extern int HB_propcnt; 62 extern int RC_propcnt; 63 64 static int specific_hb_enum(topo_mod_t *, tnode_t *, const char *, 65 topo_instance_t, topo_instance_t, void *); 66 67 static const topo_modops_t Hb_ops = 68 { hb_enum, hb_release }; 69 static const topo_modinfo_t Hb_info = 70 { HOSTBRIDGE, FM_FMRI_SCHEME_HC, HB_ENUMR_VERS, &Hb_ops }; 71 72 static const topo_method_t Hb_methods[] = { 73 { TOPO_METH_LABEL, TOPO_METH_LABEL_DESC, 74 TOPO_METH_LABEL_VERSION, TOPO_STABILITY_INTERNAL, hb_label }, 75 { NULL } 76 }; 77 78 static const topo_pgroup_info_t hb_auth_pgroup = { 79 FM_FMRI_AUTHORITY, 80 TOPO_STABILITY_PRIVATE, 81 TOPO_STABILITY_PRIVATE, 82 1 83 }; 84 85 int 86 _topo_init(topo_mod_t *modhdl, topo_version_t version) 87 { 88 /* 89 * Turn on module debugging output 90 */ 91 if (getenv("TOPOHBDBG") != NULL) 92 topo_mod_setdebug(modhdl); 93 topo_mod_dprintf(modhdl, "initializing hostbridge enumerator\n"); 94 95 if (version != HB_ENUMR_VERS) 96 return (topo_mod_seterrno(modhdl, EMOD_VER_NEW)); 97 98 if (topo_mod_register(modhdl, &Hb_info, TOPO_VERSION) < 0) { 99 topo_mod_dprintf(modhdl, "hostbridge registration failed: %s\n", 100 topo_mod_errmsg(modhdl)); 101 return (-1); /* mod errno already set */ 102 } 103 104 topo_mod_dprintf(modhdl, "Hostbridge enumr initd\n"); 105 106 return (0); 107 } 108 109 void 110 _topo_fini(topo_mod_t *modhdl) 111 { 112 topo_mod_unregister(modhdl); 113 } 114 115 static int 116 hb_label(topo_mod_t *mp, tnode_t *node, topo_version_t version, 117 nvlist_t *in, nvlist_t **out) 118 { 119 if (version > TOPO_METH_LABEL_VERSION) 120 return (topo_mod_seterrno(mp, EMOD_VER_NEW)); 121 return (platform_hb_label(mp, node, in, out)); 122 } 123 124 static topo_mod_t * 125 pci_enumr_load(topo_mod_t *mp) 126 { 127 topo_mod_t *rp = NULL; 128 129 if ((rp = topo_mod_load(mp, PCI_ENUM, PCI_ENUMR_VERS)) == NULL) { 130 topo_mod_dprintf(mp, 131 "%s enumerator could not load %s.\n", HOSTBRIDGE, PCI_ENUM); 132 } 133 return (rp); 134 } 135 136 /*ARGSUSED*/ 137 static int 138 hb_enum(topo_mod_t *mp, tnode_t *pn, const char *name, topo_instance_t imin, 139 topo_instance_t imax, void *notused, void *data) 140 { 141 int rv; 142 topo_mod_t *pcimod; 143 144 if (strcmp(name, HOSTBRIDGE) != 0) { 145 topo_mod_dprintf(mp, 146 "Currently only know how to enumerate %s components.\n", 147 HOSTBRIDGE); 148 return (0); 149 } 150 /* 151 * Load the pcibus enumerator 152 */ 153 if ((pcimod = pci_enumr_load(mp)) == NULL) 154 return (-1); 155 156 /* 157 * If we're asked to enumerate a whole range of hostbridges, then 158 * we need to find them all. If we're just asked to enumerate a 159 * single hostbridge, we expect our caller to have passed us linked 160 * did_t structures we can use to enumerate the singled out hostbridge. 161 */ 162 if (imin != imax) { 163 164 if (did_hash_init(mp) < 0) { 165 topo_mod_dprintf(mp, 166 "Hash initialization for hostbridge " 167 "enumerator failed.\n"); 168 topo_mod_unload(pcimod); 169 return (-1); 170 } 171 rv = platform_hb_enum(mp, pn, name, imin, imax); 172 did_hash_fini(mp); 173 } else { 174 rv = specific_hb_enum(mp, pn, name, imin, imax, data); 175 } 176 177 return (rv); 178 } 179 180 /*ARGSUSED*/ 181 static void 182 hb_release(topo_mod_t *mp, tnode_t *node) 183 { 184 topo_method_unregister_all(mp, node); 185 } 186 187 static tnode_t * 188 hb_tnode_create(topo_mod_t *mod, tnode_t *parent, 189 const char *name, topo_instance_t i, void *priv) 190 { 191 int err; 192 nvlist_t *fmri; 193 tnode_t *ntn; 194 nvlist_t *auth = topo_mod_auth(mod, parent); 195 196 fmri = topo_mod_hcfmri(mod, parent, FM_HC_SCHEME_VERSION, name, i, 197 NULL, auth, NULL, NULL, NULL); 198 nvlist_free(auth); 199 if (fmri == NULL) { 200 topo_mod_dprintf(mod, 201 "Unable to make nvlist for %s bind: %s.\n", 202 name, topo_mod_errmsg(mod)); 203 return (NULL); 204 } 205 206 ntn = topo_node_bind(mod, parent, name, i, fmri); 207 if (ntn == NULL) { 208 topo_mod_dprintf(mod, 209 "topo_node_bind (%s%d/%s%d) failed: %s\n", 210 topo_node_name(parent), topo_node_instance(parent), 211 name, i, 212 topo_strerror(topo_mod_errno(mod))); 213 nvlist_free(fmri); 214 return (NULL); 215 } 216 nvlist_free(fmri); 217 topo_node_setspecific(ntn, priv); 218 219 if (topo_pgroup_create(ntn, &hb_auth_pgroup, &err) == 0) { 220 (void) topo_prop_inherit(ntn, FM_FMRI_AUTHORITY, 221 FM_FMRI_AUTH_PRODUCT, &err); 222 (void) topo_prop_inherit(ntn, FM_FMRI_AUTHORITY, 223 FM_FMRI_AUTH_PRODUCT_SN, &err); 224 (void) topo_prop_inherit(ntn, FM_FMRI_AUTHORITY, 225 FM_FMRI_AUTH_CHASSIS, &err); 226 (void) topo_prop_inherit(ntn, FM_FMRI_AUTHORITY, 227 FM_FMRI_AUTH_SERVER, &err); 228 } 229 230 if (topo_method_register(mod, ntn, Hb_methods) < 0) { 231 topo_mod_dprintf(mod, "topo_method_register failed: %s\n", 232 topo_strerror(topo_mod_errno(mod))); 233 topo_node_unbind(ntn); 234 return (NULL); 235 } 236 return (ntn); 237 } 238 239 tnode_t * 240 pcihostbridge_declare(topo_mod_t *mod, tnode_t *parent, di_node_t din, 241 topo_instance_t i) 242 { 243 did_t *pd; 244 tnode_t *ntn; 245 246 if ((pd = did_find(mod, din)) == NULL) 247 return (NULL); 248 if ((ntn = hb_tnode_create(mod, parent, HOSTBRIDGE, i, din)) == NULL) 249 return (NULL); 250 if (did_props_set(ntn, pd, HB_common_props, HB_propcnt) < 0) { 251 topo_node_unbind(ntn); 252 return (NULL); 253 } 254 /* 255 * We expect to find pci buses beneath the hostbridge. 256 */ 257 if (child_range_add(mod, ntn, PCI_BUS, 0, MAX_HB_BUSES) < 0) { 258 topo_node_unbind(ntn); 259 return (NULL); 260 } 261 return (ntn); 262 } 263 264 tnode_t * 265 pciexhostbridge_declare(topo_mod_t *mod, tnode_t *parent, di_node_t din, 266 topo_instance_t hi) 267 { 268 did_t *pd; 269 tnode_t *ntn; 270 271 if ((pd = did_find(mod, din)) == NULL) 272 return (NULL); 273 if ((ntn = hb_tnode_create(mod, parent, HOSTBRIDGE, hi, din)) == NULL) 274 return (NULL); 275 if (did_props_set(ntn, pd, ExHB_common_props, ExHB_propcnt) < 0) { 276 topo_node_unbind(ntn); 277 return (NULL); 278 } 279 /* 280 * We expect to find root complexes beneath the hostbridge. 281 */ 282 if (child_range_add(mod, ntn, PCIEX_ROOT, 0, MAX_HB_BUSES) < 0) { 283 topo_node_unbind(ntn); 284 return (NULL); 285 } 286 return (ntn); 287 } 288 289 tnode_t * 290 pciexrc_declare(topo_mod_t *mod, tnode_t *parent, di_node_t din, 291 topo_instance_t ri) 292 { 293 did_t *pd; 294 tnode_t *ntn; 295 296 if ((pd = did_find(mod, din)) == NULL) 297 return (NULL); 298 did_markrc(pd); 299 if ((ntn = hb_tnode_create(mod, parent, PCIEX_ROOT, ri, din)) == NULL) 300 return (NULL); 301 if (did_props_set(ntn, pd, RC_common_props, RC_propcnt) < 0) { 302 topo_node_unbind(ntn); 303 return (NULL); 304 } 305 /* 306 * We expect to find pci-express buses beneath a root complex 307 */ 308 if (child_range_add(mod, ntn, PCIEX_BUS, 0, MAX_HB_BUSES) < 0) { 309 topo_node_range_destroy(ntn, PCIEX_BUS); 310 return (NULL); 311 } 312 return (ntn); 313 } 314 315 /*ARGSUSED*/ 316 static int 317 specific_hb_enum(topo_mod_t *mod, tnode_t *pn, const char *name, 318 topo_instance_t imin, topo_instance_t imax, void *priv) 319 { 320 tnode_t *hb; 321 did_t *iodid = (did_t *)priv; 322 did_t *didp; 323 int brc = 0; 324 int bus; 325 326 did_setspecific(mod, priv); 327 328 /* 329 * Find the hostbridge of interest 330 */ 331 didp = iodid; 332 for (brc = 0; brc < imin; brc++) 333 didp = did_chain_get(didp); 334 assert(didp != NULL); 335 336 if ((hb = pcihostbridge_declare(mod, pn, did_dinode(didp), imin)) 337 == NULL) { 338 return (-1); 339 } 340 while (didp != NULL) { 341 did_BDF(didp, &bus, NULL, NULL); 342 if (topo_mod_enumerate(mod, 343 hb, PCI_BUS, PCI_BUS, bus, bus, didp) != 0) { 344 return (topo_mod_seterrno(mod, EMOD_PARTIAL_ENUM)); 345 } 346 didp = did_link_get(didp); 347 } 348 349 return (0); 350 } 351