int i_cpr_is_supported(int sleeptype) { char es_prop[] = "energystar-v2"; pnode_t node; int last; extern int cpr_supported_override; extern int cpr_platform_enable; if (sleeptype != CPR_TODISK) return (0); /* * The next statement tests if a specific platform has turned off * cpr support. */ if (cpr_supported_override) return (0); /* * Do not inspect energystar-v* property if a platform has * specifically turned on cpr support */ if (cpr_platform_enable) return (1); node = prom_rootnode(); if (prom_getproplen(node, es_prop) != -1) return (1); last = strlen(es_prop) - 1; es_prop[last] = '3'; return (prom_getproplen(node, es_prop) != -1); }
/* * Finds the device node with device_type "rtc" and opens it to * execute the get-time method */ static int todds1307_setup_prom() { pnode_t todnode; char tod1307_devpath[MAXNAMELEN]; if ((todnode = prom_findnode_bydevtype(prom_rootnode(), DS1307_DEVICE_TYPE)) == OBP_NONODE) return (DDI_FAILURE); /* * We now have the phandle of the rtc node, we need to open the * node and get the ihandle */ if (prom_phandle_to_path(todnode, tod1307_devpath, sizeof (tod1307_devpath)) < 0) { cmn_err(CE_WARN, "prom_phandle_to_path failed"); return (DDI_FAILURE); } /* * Now open the node and store it's ihandle */ if ((todds1307_ihandle = prom_open(tod1307_devpath)) == NULL) { cmn_err(CE_WARN, "prom_open failed"); return (DDI_FAILURE); } return (DDI_SUCCESS); }
void kmdb_prom_walk_cpus(int (*cb)(pnode_t, void *, void *), void *arg, void *result) { walk_cpu_data_t wcd; wcd.wcd_cb = cb; wcd.wcd_arg = arg; prom_walk_devs(prom_rootnode(), walk_cpus_cb, &wcd, result); }
void system_check(void) { char buf[PROM_VERS_MAX_LEN]; pnode_t n; char arch[128]; size_t len; bootplat_defaults_t *plat_defaults; /* * This is a sun4v machine iff the device_type property * exists on the root node and has the value "sun4v". * Some older sunfire proms do not have such a property. */ is_sun4v = 0; n = prom_rootnode(); len = prom_getproplen(n, "device_type"); if (len > 0 && len < sizeof (arch)) { (void) prom_getprop(n, "device_type", arch); arch[len] = '\0'; dprintf("device_type=%s\n", arch); if (strcmp(arch, "sun4v") == 0) { is_sun4v = 1; } } else { dprintf("device_type: no such property, len=%d\n", (int)len); } if (!is_sun4v && cpu_is_ultrasparc_1()) { printf("UltraSPARC I processors are not supported by this " "release of Solaris.\n"); prom_exit_to_mon(); } /* * Set up defaults per platform */ plat_defaults = (is_sun4v) ? &sun4v_plat_defaults : &sun4u_plat_defaults; default_name = plat_defaults->plat_defaults_name; default_path = plat_defaults->plat_defaults_path; vac = plat_defaults->plat_defaults_vac; dprintf("default_name: %s\n", default_name); dprintf("default_path: %s\n", default_path); dprintf("vac: %d\n", vac); if (prom_version_check(buf, PROM_VERS_MAX_LEN, NULL) != PROM_VER64_OK) { printf("The firmware on this system does not support the 64-bit" " OS.\n\tPlease upgrade to at least the following version:" "\n\n\t%s\n", buf); prom_exit_to_mon(); } }
static int impl_name(char *buf, size_t bufsz) { pnode_t n = prom_rootnode(); size_t len = prom_getproplen(n, "name"); if (len == 0 || len >= bufsz) return (-1); (void) prom_getprop(n, "name", buf); buf[len] = '\0'; return (0); }
char * prom_bootpath(void) { static char bootpath[OBP_MAXPATHLEN]; int length; pnode_t node; static char *name = "bootpath"; if (bootpath[0] != (char)0) return (bootpath); node = prom_chosennode(); if ((node == OBP_NONODE) || (node == OBP_BADNODE)) node = prom_rootnode(); length = prom_getproplen(node, name); if ((length == -1) || (length == 0)) return (NULL); if (length > OBP_MAXPATHLEN) length = OBP_MAXPATHLEN - 1; /* Null terminator */ (void) prom_bounded_getprop(node, name, bootpath, length); return (bootpath); }
ddi_prop_t * get_proplist(char *name) { ddi_prop_t *plist, *npp, *plast; char *curprop, *newprop; unsigned char *propval; unsigned long id; plist = NULL; plast = NULL; id = prom_findnode_byname(prom_rootnode(), name); if (id == 0) return (plist); curprop = ""; while (newprop = (char *)prom_nextprop(curprop)) { curprop = strdup(newprop); npp = (ddi_prop_t *)malloc(sizeof (ddi_prop_t)); if (npp == 0) exit(_error(PERROR, mfail)); propval = prom_getprop(curprop, &npp->prop_len); npp->prop_name = curprop; if (propval != NULL) { npp->prop_val = (char *)malloc(npp->prop_len); if (npp->prop_val == 0) exit(_error(PERROR, mfail)); memcpy(npp->prop_val, propval, npp->prop_len); } else npp->prop_val = NULL; npp->prop_next = NULL; if (plast == NULL) { plist = npp; } else { plast->prop_next = npp; } plast = npp; } return (plist); }
/* * find cpu node for the boot processor * * sets globals: * cb_mid */ static pnode_t get_cpu_node(void) { static char *props[] = { "upa-portid", "portid", NULL }; pnode_t node; char *str, *name, **propp; uint_t cpu_id; int err; str = "get_cpu_node"; name = "cpu"; cb_mid = getmid(); for (node = prom_rootnode(); ; node = prom_nextnode(node)) { node = prom_findnode_bydevtype(node, name); if (node == OBP_NONODE) { prom_printf("\n%s: cant find node for devtype \"%s\"\n", str, name); break; } cpu_id = (uint_t)-1; for (propp = props; *propp; propp++) { err = get_intprop(node, *propp, &cpu_id); CB_VPRINTF((" cpu node 0x%x, " "prop \"%s\", cpu_id %d\n", node, *propp, (int)cpu_id)); if (err == 0) break; } if (cpu_id == cb_mid) return (node); } return (OBP_NONODE); }
/* * Platform specific lgroup initialization */ void plat_lgrp_init(void) { pnode_t curnode; char tmp_name[MAXSYSNAME]; int portid; int cpucnt = 0; int max_portid = -1; extern uint32_t lgrp_expand_proc_thresh; extern uint32_t lgrp_expand_proc_diff; extern pgcnt_t lgrp_mem_free_thresh; extern uint32_t lgrp_loadavg_tolerance; extern uint32_t lgrp_loadavg_max_effect; extern uint32_t lgrp_load_thresh; extern lgrp_mem_policy_t lgrp_mem_policy_root; /* * Count the number of CPUs installed to determine if * NUMA optimization should be enabled or not. * * All CPU nodes reside in the root node and have a * device type "cpu". */ curnode = prom_rootnode(); for (curnode = prom_childnode(curnode); curnode; curnode = prom_nextnode(curnode)) { bzero(tmp_name, MAXSYSNAME); if (prom_getprop(curnode, OBP_NAME, (caddr_t)tmp_name) == -1 || prom_getprop(curnode, OBP_DEVICETYPE, tmp_name) == -1 || strcmp(tmp_name, "cpu") != 0) continue; cpucnt++; if (prom_getprop(curnode, "portid", (caddr_t)&portid) != -1 && portid > max_portid) max_portid = portid; } if (cpucnt <= 1) max_mem_nodes = 1; else if (max_portid >= 0 && max_portid < MAX_MEM_NODES) max_mem_nodes = max_portid + 1; /* * Set tuneables for fiesta architecture * * lgrp_expand_proc_thresh is the minimum load on the lgroups * this process is currently running on before considering * expanding threads to another lgroup. * * lgrp_expand_proc_diff determines how much less the remote lgroup * must be loaded before expanding to it. * * Optimize for memory bandwidth by spreading multi-threaded * program to different lgroups. */ lgrp_expand_proc_thresh = lgrp_loadavg_max_effect - 1; lgrp_expand_proc_diff = lgrp_loadavg_max_effect / 2; lgrp_loadavg_tolerance = lgrp_loadavg_max_effect / 2; lgrp_mem_free_thresh = 1; /* home lgrp must have some memory */ lgrp_expand_proc_thresh = lgrp_loadavg_max_effect - 1; lgrp_mem_policy_root = LGRP_MEM_POLICY_NEXT; lgrp_load_thresh = 0; mem_node_pfn_shift = ENCHILADA_MC_SHIFT - MMU_PAGESHIFT; }