/* * Copyright (c) 1992-1998 Michael A. Cooper. * This software may be freely used and distributed provided it is not * sold for profit or used in part or in whole for commercial gain * without prior written agreement, and the author is credited * appropriately. */ #ifndef lint static char *RCSid = "$Revision: 1.1.1.1 $"; #endif /* * Open Boot PROM (OBP) routines */ #include "defs.h" #include "sunos-kdt.h" #include "sunos-obp.h" #if defined(HAVE_OPENPROM) #define OBP_IS_BOOL(tp) (tp->Key[strlen(tp->Key)-1] == '?' \ || !tp->Value || tp->Value[0] == CNULL) /* * Pointer to Tree of all OBP nodes. */ static OBPnode_t *OBPnodeTree = NULL; /* * Various declarations */ static long CpuClockFreq = 0; /* * Function declarations */ static int OBPgetCPUspeed(); /* * Print debugging info of Prop Info */ static void OBPprintPropInfo(NodeName, Prop) char *NodeName; OBPprop_t *Prop; { register OBPprop_t *Ptr; for (Ptr = Prop; Ptr; Ptr = Ptr->Next) SImsg(SIM_DBG, "OBPpropInfo:\t<%s> <%s>=<%s>", PRTS(NodeName), (Ptr->Key) ? Ptr->Key : "", (Ptr->Value) ? Ptr->Value : ""); } /* * Print debugging info of OBP Node */ static void OBPprintInfo(Node) OBPnode_t *Node; { SImsg(SIM_DBG, "OBPnode: Name=<%s> ID=<0x%x> ParentID=<0x%x> ParentName=<%s>", (Node->Name) ? Node->Name : "", Node->NodeID, Node->ParentID, (Node->ParentName) ? Node->ParentName : ""); if (Node->PropTable) OBPprintPropInfo(Node->Name, Node->PropTable); if (Node->Children) OBPprintInfo(Node->Children); if (Node->Next) OBPprintInfo(Node->Next); } /* * Get next OBP tree node id using "what" as what to get. */ static OBPnodeid_t OBPnodeNext(NodeID, obp_fd, What) OBPnodeid_t NodeID; int obp_fd; int What; { OBPio_t opio; struct openpromio *op; int *idptr; op = &(opio.opio_oprom); idptr = (OBPnodeid_t *) (op->oprom_array); memset((void *)opio.opio_buff, 0, sizeof(opio.opio_buff)); *idptr = NodeID; op->oprom_size = sizeof(opio.opio_buff); if (ioctl(obp_fd, What, op) < 0) { SImsg(SIM_GERR, "OBP ioctl %s failed: %s.", (What == OPROMNEXT) ? "OPROMNEXT" : "OPROMCHILD", SYSERR); return(0); } return(*((OBPnodeid_t *)op->oprom_array)); } /* * Set the property value of propname from the OBP. */ static int OBPsetPropVal(Prop, obp_fd) OBPprop_t *Prop; int obp_fd; { static OBPio_t opio; struct openpromio *op; register char *cp; op = &(opio.opio_oprom); op->oprom_size = sizeof(opio.opio_buff); (void) strcpy(op->oprom_array, Prop->Key); if (ioctl(obp_fd, OPROMGETPROP, op) < 0) { SImsg(SIM_GERR, "OBP ioctl OPROMGETPROP failed for '%s': %s.", Prop->Key, SYSERR); return(-1); } if (op->oprom_size == -1) { SImsg(SIM_DBG, "OBP no data available for '%s'.", Prop->Key); return(-1); } /* * Copy Raw info */ Prop->RawLen = op->oprom_size; Prop->Raw = (void *) xcalloc(1, Prop->RawLen); (void) memcpy(Prop->Raw, op->oprom_array, Prop->RawLen); /* * Now create a nice ASCII String for Value. * op->oprom_array points at opio.opio_buff where the results * really live. */ if (cp = DecodeVal(Prop->Key, op->oprom_array, op->oprom_size)) Prop->Value = strdup(cp); return(0); } /* * Create and copy a OBPprop_t */ static OBPprop_t *OBPcopyProp(old) OBPprop_t *old; { OBPprop_t *new; new = (OBPprop_t *) xmalloc(sizeof(OBPprop_t)); memcpy((void *)new, (void *)old, sizeof(OBPprop_t)); return(new); } /* * Get all OBP properties for the current OBP node and return * a table of the results. */ static OBPprop_t *OBPgetProps(obp_fd, OBPpropPtr) int obp_fd; OBPprop_t **OBPpropPtr; { static OBPio_t opio; struct openpromio *op; static OBPprop_t NewProp; OBPprop_t *PropTable; register OBPprop_t *PropPtr; if (OBPpropPtr) PropTable = *OBPpropPtr; else return((OBPprop_t *) NULL); op = &(opio.opio_oprom); memset((void *)opio.opio_buff, 0, sizeof(opio.opio_buff)); for ( ; ; ) { /* * Get next property */ op->oprom_size = sizeof(opio.opio_buff); if (ioctl(obp_fd, OPROMNXTPROP, op) < 0) { SImsg(SIM_GERR, "OBP ioctl OPROMNXTPROP failed: %s.", SYSERR); return((OBPprop_t *) NULL); } /* * We're done */ if (!op->oprom_size) break; (void) memset(&NewProp, 0, sizeof(NewProp)); NewProp.Key = strdup(op->oprom_array); /* * Set Value, Raw, RawLen */ (void) OBPsetPropVal(&NewProp, obp_fd); /* * Add this entry to the linked list. */ NewProp.Next = NULL; if (PropTable) { for (PropPtr = PropTable; PropPtr && PropPtr->Next; PropPtr = PropPtr->Next); PropPtr->Next = OBPcopyProp(&NewProp); } else PropTable = OBPcopyProp(&NewProp); } *OBPpropPtr = PropTable; return(PropTable); } /* * Get info about a CPU. * * CpuType is the type/model to lookup. * OBPprop is the OBP Property table for CpuType. * Results are stored in ModelPtr, VendorPtr, FreqPtr */ static int OBPgetCPUinfo(CpuType, OBPprop, ModelPtr, VendorPtr, FreqPtr) char *CpuType; OBPprop_t *OBPprop; char **ModelPtr; char **VendorPtr; long *FreqPtr; { long ClockFreq = 0; Define_t *Def; char *Str; char *Model = NULL; char *cp; Str = OBPfindPropVal(OBP_CLOCKFREQ, OBPprop, NULL, NULL); if (Str) ClockFreq = strtol(Str, (char **)NULL, 0); /* * No individual clock frequency, so we use the "global" * clock freqency that (hopefully) was set earlier. */ if (!ClockFreq) ClockFreq = CpuClockFreq; /* * Set the frequency we're using so our caller can use it. */ if (ClockFreq && FreqPtr) *FreqPtr = ClockFreq; /* * If CpuType is of form 'Foo,Bar' then use 'Foo' as the Vendor * and 'Bar' as the actual Model. */ if (cp = strchr(CpuType, ',')) { Model = strdup(cp + 1); Str = (char *) xmalloc(cp - CpuType); (void) strncpy(Str, CpuType, cp - CpuType); Str[cp - CpuType] = CNULL; *VendorPtr = Str; } /* * Scan the CPU types table looking for an entry that has * the same type name and the same clock frequency. */ for (Def = DefGetList(DL_CPU); Def; Def = Def->Next) { if (EQ(Def->KeyStr, CpuType)) { if ((Def->KeyNum == 0) || (Def->KeyNum == -1) || ((ClockFreq / MHERTZ) == Def->KeyNum)) *ModelPtr = Def->ValStr1; } } if (!*ModelPtr) { /* No special CPU Definetion was found, so use the OBP value */ if (Model) *ModelPtr = strdup(Model); /* Without Vendor Str */ else *ModelPtr = strdup(CpuType); } SImsg(SIM_DBG, "OBPgetCPUinfo(%s) Vendor=<%s> Model=<%s> Freq=%d", PRTS(CpuType), PRTS(*VendorPtr), PRTS(*ModelPtr), *FreqPtr); return(0); } /* * Get a nice informative string describing OBPprop information and * set the info into DevInfo. */ static void OBPsetOBPinfo(OBPprop, DevInfo) OBPprop_t *OBPprop; DevInfo_t *DevInfo; { char *ExpName = NULL; char *Val = NULL; Define_t *Def; /* * Try to see if this is one of the types of OBP info * that we want to use a more descriptive text than * the key itself. */ Def = DefGet(DL_OBP, OBPprop->Key, -1, 0); if (Def && Def->ValStr1) ExpName = Def->ValStr1; if (!ExpName) ExpName = ExpandKey(OBPprop->Key); if (!OBP_IS_BOOL(OBPprop) && OBPprop->Value) { if (EQ(OBPprop->Key, OBP_CLOCKFREQ)) Val = strdup(FreqStr(strtol(OBPprop->Value, (char **)NULL, 0))); else if (EQ(OBPprop->Key, OBP_ECACHESIZE) || EQ(OBPprop->Key, OBP_DCACHESIZE)) Val = GetSizeStr((Large_t) strtol(OBPprop->Value, (char **)NULL, 0), BYTES); else Val = OBPprop->Value; } if (OBP_IS_BOOL(OBPprop)) AddDevDesc(DevInfo, ExpName, "Has", DA_APPEND); else AddDevDesc(DevInfo, Val, ExpName, DA_APPEND); } /* * Fix an OBP node name to be compatable with the * conventions used in SunOS 5.x. * * i.e. All '/' characters are mapped to '_'. */ static char *OBPfixNodeName(string) char *string; { register char *cp; static char Buff[256]; (void) snprintf(Buff, sizeof(Buff), "%s", string); cp = Buff; while (cp = strchr(cp, '/')) *cp++ = '_'; return(Buff); } /* * Get (make) name of a CPU */ extern char *GetCpuName(ncpus, cpuid) int *ncpus; int cpuid; { static char Buff[32]; (void) snprintf(Buff, sizeof(Buff), "cpu%d", (cpuid >= 0) ? cpuid : (*ncpus)++); return(Buff); } /* * Probe a CPU using OBP info. */ extern DevInfo_t *OBPprobeCPU(ProbeData, Node, TreePtr, SearchNames) ProbeData_t *ProbeData; OBPnode_t *Node; DevInfo_t **TreePtr; char **SearchNames; { register OBPprop_t *PropPtr; DevInfo_t *DevInfo; DevInfo_t *fdev; static DevFind_t Find; register char *cp; register int i; static char Buff[256]; static int ncpus = 0; int cpuid = -1; char *CpuModel = NULL; char *CpuModelPart = NULL; char *CpuVendor = NULL; long ClockFreq = 0; char *ClockFreqStr = NULL; /* * This function may be called accidentally if a PROM/kernel node * called "cpu" is found. In such a case, we return immediately. * This function should only be called explicitly. */ if (ProbeData) return((DevInfo_t *) NULL); if (!(DevInfo = NewDevInfo(NULL))) return((DevInfo_t *)NULL); if (Debug) { (void) snprintf(Buff, sizeof(Buff), "Node ID is 0x%x", Node->NodeID); AddDevDesc(DevInfo, Buff, NULL, DA_APPEND); } for (PropPtr = Node->PropTable; PropPtr; PropPtr = PropPtr->Next) { /* * See if this is the CPU type */ if (EQ(OBP_NAME, PropPtr->Key)) { CpuModelPart = strdup(PropPtr->Value); OBPgetCPUinfo(PropPtr->Value, Node->PropTable, &CpuModel, &CpuVendor, &ClockFreq); continue; } else if (EQ(PropPtr->Key, OBP_CPUID) && PropPtr->Value) { cpuid = (int) strtol(PropPtr->Value, (char **)NULL, 0); } else if (EQ(PropPtr->Key, OBP_DEVTYPE) || EQ(PropPtr->Key, OBP_DEVTYPE2) || EQ(PropPtr->Key, OBP_CLOCKFREQ)) { continue; } OBPsetOBPinfo(PropPtr, DevInfo); } if (cp = GetCpuName(&ncpus, cpuid)) DevInfo->Name = strdup(cp); if (SearchNames && !SearchCheck(DevInfo->Name, SearchNames)) return((DevInfo_t *) NULL); if (CpuVendor) if (!(DevInfo->Vendor = GetVendorName(CpuVendor))) DevInfo->Vendor = CpuVendor; if (ClockFreq) { ClockFreqStr = FreqStr(ClockFreq); DevInfo->ModelDesc = strdup(ClockFreqStr); AddDevDesc(DevInfo, ClockFreqStr, "Speed", DA_INSERT); } if (CpuModel) DevInfo->Model = CpuModel; /* * This must be an unknown type of CPU */ if (!DevInfo->Model) DevInfo->Model = PrimeDesc(DevInfo); DevInfo->Type = DT_CPU; DevInfo->NodeID = Node->NodeID; /* * The rest of this function depends on CpuModel being available * so if it's not, return what we have so far. */ if (!CpuModel) return(DevInfo); /* * If no device by our name exists try to find a device * with a name which matches our CPU Model. This should * be the root device node. If so, make our device name * match the root device node name, so AddDevice() will * add our info to the root device node later. */ if (TreePtr && *TreePtr) { (void) memset(&Find, 0, sizeof(Find)); Find.Tree = *TreePtr; Find.NodeName = DevInfo->Name; if (!DevFind(&Find)) { Find.NodeName = CpuModelPart; fdev = DevFind(&Find); if (!fdev) { SImsg(SIM_DBG, "Cannot find CPU device <%s>", PRTS(CpuModelPart)); cp = OBPfixNodeName(CpuModelPart); if (!EQ(cp, CpuModelPart)) { Find.NodeName = cp; fdev = DevFind(&Find); } } else SImsg(SIM_DBG, "Found CPU device <%s>", PRTS(CpuModelPart)); if (fdev && !fdev->Master) DevInfo->Name = fdev->Name; } } if (CpuModelPart) (void) free(CpuModelPart); return(DevInfo); } /* * Get part description information using a model (part) name. */ static Define_t *OBPGetPart(PartName) char *PartName; { Define_t *PartList; register Define_t *Ptr; register int i; register char *cp; PartList = DefGetList(DL_PART); if (!PartList) { SImsg(SIM_DBG, "No Part List found."); return((Define_t *) NULL); } for (Ptr = PartList; Ptr; Ptr = Ptr->Next) { if (EQN(Ptr->KeyStr, PartName, strlen(Ptr->KeyStr))) return(Ptr); /* Try it without the manufacturer part of part name */ if ((cp = strchr(Ptr->KeyStr, ',')) && EQN(++cp, PartName, strlen(cp))) return(Ptr); } return((Define_t *) NULL); } /* * This is for sun4d and sun4u platforms. * * If this device has a board number, then we make a "fake" * device called OBP_SYSBOARD that we insert in between the * Device and it's logical/current Master. */ static void OBPsetBoard(DevInfo, OBPprop, BoardNum, TreePtr, SearchNames) DevInfo_t *DevInfo; OBPprop_t *OBPprop; int BoardNum; DevInfo_t **TreePtr; char **SearchNames; { static char BoardName[64]; static char Buff[128]; static DevFind_t Find; char *What; char *BoardType; register DevInfo_t *DevPtr; register DevInfo_t *SaveDev; register DevInfo_t *LastDev; register DevInfo_t *OldMaster = NULL; register DevInfo_t *Master = NULL; DevDefine_t *DevDefine = NULL; if (BoardNum < 0 || !DevInfo) return; (void) snprintf(BoardName, sizeof(BoardName), "%s%d", OBP_SYSBOARD, BoardNum); /* * Find the Old Master */ if (DevInfo->Master) { (void) memset(&Find, 0, sizeof(Find)); Find.Tree = *TreePtr; Find.NodeID = DevInfo->Master->NodeID; Find.NodeName = DevInfo->Master->Name; OldMaster = DevFind(&Find); } /* * If the Master (sysboard) device doesn't exit, create one. */ (void) memset(&Find, 0, sizeof(Find)); Find.Tree = *TreePtr; Find.NodeName = BoardName; if (!(Master = DevFind(&Find))) { Master = NewDevInfo(NULL); Master->Name = strdup(BoardName); Master->Unit = BoardNum; if (DevDefine = DevDefGet(OBP_SYSBOARD, 0, 0)) { Master->Model = DevDefine->Model; Master->ModelDesc = DevDefine->Desc; Master->Type = DevDefine->Type; } if (OldMaster) { Master->MasterName = OldMaster->Name; Master->Master = OldMaster; } AddDevice(Master, TreePtr, SearchNames); } /* * Insert sysboard between Device and it's logical Master. */ if (OldMaster) { Master->Master = OldMaster; /* * Find Device in OldMaster and remove it. */ SaveDev = NULL; for (DevPtr = OldMaster->Slaves, LastDev = DevPtr; DevPtr; LastDev = DevPtr, DevPtr = DevPtr->Next) { if (!EQ(DevPtr->Name, DevInfo->Name)) continue; SaveDev = DevPtr; LastDev->Next = DevPtr->Next; break; } /* * Add SaveDev back to new Master */ SaveDev->Next = NULL; if (Master->Slaves) { for (DevPtr = Master->Slaves; DevPtr && DevPtr->Next; DevPtr = DevPtr->Next); DevPtr->Next = SaveDev; } else Master->Slaves = SaveDev; } /* * Update Device */ if (Master) { DevInfo->MasterName = Master->Name; DevInfo->Master = Master; } /* * If this is an FHC device (sun4u), then try to figure out more * info about the type of board this is. */ if (EQN(DevInfo->Name, OBP_FHC, strlen(OBP_FHC))) { BoardType = OBPfindPropVal(OBP_BOARDTYPE, OBPprop, NULL, NULL); if (BoardType) { /* * There are different board types: * VALUE DESCRIPTION * mem CPU & Memory * cpu CPU & Memory * dual-sbus I/O * ? Graphics */ if (EQ(BoardType, "mem") || EQ(BoardType, "cpu")) What = "CPU & Memory"; else if (EQ(BoardType, "dual-sbus")) What = "Sbus I/O"; else What = NULL; if (What) { (void) snprintf(Buff, sizeof(Buff), "%s Board", What); Master->Model = strdup(Buff); } } } } /* * Decode memory string into number of MBYTES. */ static int OBPGetMemSize(MemStr) char *MemStr; { register char *cp; char *MemBuff; u_long Amt = 0; if (strchr(MemStr, '.')) { MemBuff = strdup(MemStr); for (cp = strtok(MemBuff, "."); cp; cp = strtok((char *)NULL, ".")) Amt += strtol(cp, (char **) NULL, 0); (void) free(MemBuff); } else Amt = strtol(MemStr, (char **) NULL, 0); return(Amt / MBYTES); } /* * Decode memory string into memory groups and add as a dev description. */ static void OBPSetMemGrps(DevInfo, MemStr) DevInfo_t *DevInfo; char *MemStr; { static char Buff[512]; register char *bPtr; register char *End; char Str[100]; register char *cp; char *MemBuff; int GrpNum = 0; if (!strchr(MemStr, '.')) return; Buff[0] = CNULL; bPtr = Buff; End = &Buff[sizeof(Buff)-1]; MemBuff = strdup(MemStr); for (cp = strtok(MemBuff, "."); cp && bPtr < End; cp = strtok((char *)NULL, ".")) { (void) snprintf(bPtr, sizeof(Buff)-(End-bPtr), "#%d=%s", GrpNum++, GetSizeStr((Large_t) strtol(cp, (char **) NULL, 0), BYTES)); if (bPtr != Buff) strcat(bPtr, ", "); bPtr += strlen(bPtr); } (void) free(MemBuff); AddDevDesc(DevInfo, Buff, "Memory Groups", DA_APPEND); } /* * Probe an OBP node. */ extern DevInfo_t *OBPprobe(Node, TreePtr, SearchNames) OBPnode_t *Node; DevInfo_t **TreePtr; char **SearchNames; { register OBPprop_t *PropPtr; DevInfo_t *DevInfo = NULL; DevInfo_t *ParentDevInfo; static DevFind_t Find; register char **cpp; register char *cp; static char Buff[128]; int BoardNum = -1; char *ObpModel = NULL; char *ObpModelBase = NULL; char *Vendor = NULL; Define_t *PartInfo = NULL; int MemSize = 0; /* * See if we can find the node by it's NodeID or NodeName. * NodeName works for the root "system" node and a few others. */ (void) memset(&Find, 0, sizeof(Find)); Find.Tree = *TreePtr; Find.NodeID = Node->NodeID; Find.NodeName = Node->Name; DevInfo = DevFind(&Find); if (!DevInfo) return((DevInfo_t *)NULL); /* * Get all the info we need */ for (PropPtr = Node->PropTable; PropPtr; PropPtr = PropPtr->Next) { /* * Skip these */ if (EQ(PropPtr->Key, OBP_NAME)) continue; else if (EQ(PropPtr->Key, OBP_MODEL)) ObpModel = PropPtr->Value; else if (EQ(PropPtr->Key, OBP_BOARD) && PropPtr->Value) BoardNum = strtol(PropPtr->Value, (char **) NULL, 0); else if (EQ(PropPtr->Key, OBP_SIZE) && EQ(Node->Name, OBP_MEMUNIT)) { MemSize = OBPGetMemSize(PropPtr->Value); OBPSetMemGrps(DevInfo, PropPtr->Value); /* * If this node has a key="keyboard" and is _NOT_ the * node called "aliases", then this is the kbd parent */ } else if (EQ(PropPtr->Key, OBP_KEYBOARD) && !EQ(Node->Name, OBP_ALIASES)) { DevInfo->Slaves = ProbeKbd((DevInfo_t **)NULL); } OBPsetOBPinfo(PropPtr, DevInfo); } /* * Handle special cases */ if (MemSize && DevInfo->Model) { (void) snprintf(Buff, sizeof(Buff), "%d MB %s", MemSize, DevInfo->Model); DevInfo->Model = strdup(Buff); } if (BoardNum >= 0) OBPsetBoard(DevInfo, Node->PropTable, BoardNum, TreePtr, SearchNames); /* * Add information to existing Device. */ if (ObpModel) { /* * If ObpModel is of form 'Foo,Bar' then use 'Foo' as the Vendor * and 'Bar' as the actual Model. */ if (cp = strchr(ObpModel, ',')) { ObpModelBase = cp + 1; Vendor = (char *) xmalloc(cp - ObpModel); (void) strncpy(Vendor, ObpModel, cp - ObpModel); Vendor[cp - ObpModel] = CNULL; if (cp = GetVendorName(Vendor)) { DevInfo->Vendor = cp; (void) free(Vendor); } else DevInfo->Vendor = Vendor; } /* * Now lookup the Part (including the Vendor part if any) */ PartInfo = OBPGetPart(ObpModel); if (PartInfo) { DevInfo->Model = PartInfo->ValStr1; AddDevDesc(DevInfo, PartInfo->ValStr2, NULL, DA_INSERT|DA_PRIME); } else if (!DevInfo->Model) DevInfo->Model = (ObpModelBase) ? ObpModelBase : ObpModel; } return((DevInfo_t *)NULL); } /* * Check over an OBP device. */ static void OBPdevCheck(Node, TreePtr, SearchNames) OBPnode_t *Node; DevInfo_t **TreePtr; char **SearchNames; { register OBPprop_t *PropPtr; static int first = TRUE; DevDefine_t *DevDefine = NULL; DevType_t *DevType = NULL; ClassType_t *ClassType = NULL; DevInfo_t *DevInfo = NULL; DevInfo_t *master = NULL; static DevFind_t Find; /* * Iterate over all the properties looking for interesting properties * or until we find the device type. If the device type is one which * we found in our probe list, go ahead and probe it. */ for (PropPtr = Node->PropTable; PropPtr; PropPtr = PropPtr->Next) { SImsg(SIM_DBG, "OBPdevCheck: NodeID 0x%x <%s> = <%s> (0x%x)", Node->NodeID, PropPtr->Key, (PropPtr->Value) ? PropPtr->Value : "", (PropPtr->Value) ? atol(PropPtr->Value) : 0); /* * If this is the first node and this property is the Clock Frequency * then save it for later use by the individual CPUs. */ if (first && !CpuClockFreq && EQ(PropPtr->Key, OBP_CLOCKFREQ) && PropPtr->Value) CpuClockFreq = strtol(PropPtr->Value, (char **)NULL, 0); if (EQ(PropPtr->Key, OBP_DEVTYPE) || EQ(PropPtr->Key, OBP_DEVTYPE2)) { /* * OBP isn't consistant in what OBP_DEVTYPE really is so * we do multiple lookups */ DevDefine = DevDefGet(PropPtr->Value, 0, 0); DevType = TypeGetByName(PropPtr->Value); ClassType = ClassTypeGetByName(PropPtr->Value); } } SImsg(SIM_DBG, "OBPdevCheck: NodeID 0x%x Name = <%s> DevDefine.Name = <%s>", Node->NodeID, (Node->Name[0]) ? Node->Name : "", (DevDefine && DevDefine->Name) ? DevDefine->Name : ""); /* * We use DevDefine->Probe for our own internal (obp.c) use so we * need to make sure we only call the right Probe functions */ if (DevDefine && DevDefine->Probe == OBPprobeCPU) DevInfo = OBPprobeCPU((ProbeData_t *) NULL, Node, TreePtr, SearchNames); if (!DevInfo) DevInfo = OBPprobe(Node, TreePtr, SearchNames); if (DevInfo) { /* * Find or create of Master */ if (TreePtr && !DevInfo->Master) { (void) memset(&Find, 0, sizeof(Find)); Find.NodeID = Node->ParentID; Find.Tree = *TreePtr; master = DevFind(&Find); if (!master && Node->ParentName) { master = NewDevInfo(NULL); master->Name = strdup(Node->ParentName); master->NodeID = Node->ParentID; } DevInfo->Master = master; } DevInfo->NodeID = Node->NodeID; if (DevType && !DevInfo->Type) DevInfo->Type = DevType->Type; if (ClassType && !DevInfo->ClassType) DevInfo->ClassType = ClassType->Type; AddDevice(DevInfo, TreePtr, SearchNames); } first = FALSE; } /* * Traverse OBP device tree and build device info */ static void OBPdevTraverse(Node, TreePtr, SearchNames) OBPnode_t *Node; DevInfo_t **TreePtr; char **SearchNames; { OBPdevCheck(Node, TreePtr, SearchNames); if (Node->Next) OBPdevTraverse(Node->Next, TreePtr, SearchNames); if (Node->Children) OBPdevTraverse(Node->Children, TreePtr, SearchNames); } /* * Find an OBP node in Node with an ID of NodeID. */ extern OBPnode_t *OBPfindNodeByID(Node, NodeID) OBPnode_t *Node; OBPnodeid_t NodeID; { OBPnode_t *Found = NULL; if (!Node) Node = OBPnodeTree; if (!Node) return((OBPnode_t *) NULL); if (Node->NodeID == NodeID) return(Node); if (Node->Children) if (Found = OBPfindNodeByID(Node->Children, NodeID)) return(Found); if (Node->Next) if (Found = OBPfindNodeByID(Node->Next, NodeID)) return(Found); return((OBPnode_t *) NULL); } /* * Find an OBP node in Node with a device type of MatchType */ static OBPnode_t *OBPfindNodeByType(Node, MatchType) OBPnode_t *Node; char *MatchType; { OBPnode_t *Found = NULL; char *NodeType; if (!Node) return((OBPnode_t *) NULL); if ((NodeType = OBPfindPropVal(OBP_DEVTYPE, Node->PropTable, NULL, NULL)) || (NodeType = OBPfindPropVal(OBP_DEVTYPE2, Node->PropTable, NULL, NULL))) if (EQ(NodeType, MatchType)) return(Node); if (Node->Children) if (Found = OBPfindNodeByType(Node->Children, MatchType)) return(Found); if (Node->Next) if (Found = OBPfindNodeByType(Node->Next, MatchType)) return(Found); return((OBPnode_t *) NULL); } /* * Find an OBP node in Node with a name of Name. */ static OBPnode_t *OBPfindNodeByName(Node, Name) OBPnode_t *Node; char *Name; { OBPnode_t *Found = NULL; char *cp1; char *cp2; if (!Node) return((OBPnode_t *) NULL); if (EQ(Name, Node->Name)) return(Node); /* * Try a match by stripping out any commas found in the names. */ if (cp1 = strchr(Name, ',')) ++cp1; else cp1 = Name; if (cp2 = strchr(Node->Name, ',')) ++cp2; else cp2 = Node->Name; if (EQ(cp1, cp2)) return(Node); if (Node->Children) if (Found = OBPfindNodeByName(Node->Children, Name)) return(Found); if (Node->Next) if (Found = OBPfindNodeByName(Node->Next, Name)) return(Found); return((OBPnode_t *) NULL); } /* * Get the OBP property entry which matches "Key" * Look for Key in Table, by NodeID, or by NodeName (whichever is * not NULL). */ extern OBPprop_t *OBPfindProp(Key, Table, NodeID, NodeName) char *Key; OBPprop_t *Table; OBPnodeid_t NodeID; char *NodeName; { register OBPprop_t *Ptr; OBPprop_t *PropTable = NULL; OBPnode_t *Node; if (Table) PropTable = Table; else if (NodeID) { if (!OBPnodeTree) OBPbuildNodeTree(&OBPnodeTree); Node = OBPfindNodeByID(OBPnodeTree, NodeID); if (Node) PropTable = Node->PropTable; } else if (NodeName) { if (!OBPnodeTree) OBPbuildNodeTree(&OBPnodeTree); Node = OBPfindNodeByName(OBPnodeTree, NodeName); if (Node) PropTable = Node->PropTable; } else return((OBPprop_t *) NULL); /* * See if this node has it's own clock frequency */ for (Ptr = PropTable; Ptr; Ptr = Ptr->Next) if (Ptr->Key[0] && EQ(Ptr->Key, Key)) return(Ptr); return((OBPprop_t *) NULL); } /* * Front-end to OBPfindProp() */ extern char *OBPfindPropVal(Key, Table, NodeID, NodeName) char *Key; OBPprop_t *Table; OBPnodeid_t NodeID; char *NodeName; { OBPprop_t *Prop; if (Prop = OBPfindProp(Key, Table, NodeID, NodeName)) return(Prop->Value); else return((char *) NULL); } /* * Traverse tree of OBP I/O nodes */ static int OBPnodeTraverse(NodeTree, ParentID, ParentName, NodeID, obp_fd) OBPnode_t **NodeTree; OBPnodeid_t ParentID; char *ParentName; OBPnodeid_t NodeID; int obp_fd; { OBPnodeid_t NewID; OBPnode_t *NewNode; register OBPnode_t *NodePtr; register OBPnode_t *Master; NewNode = (OBPnode_t *) xcalloc(1, sizeof(OBPnode_t)); NewNode->NodeID = NodeID; NewNode->ParentID = ParentID; NewNode->ParentName = ParentName; if (OBPgetProps(obp_fd, &(NewNode->PropTable))) NewNode->Name = OBPfindPropVal(OBP_NAME, NewNode->PropTable, NULL, NULL); /* * Add new node to NodeTree */ Master = OBPfindNodeByID(*NodeTree, ParentID); if (Master) { if (Master->Children) { for (NodePtr = Master->Children; NodePtr && NodePtr->Next; NodePtr = NodePtr->Next); NodePtr->Next = NewNode; } else Master->Children = NewNode; } else *NodeTree = NewNode; /* * Traverse Children and Peers (Next) */ if (NewID = OBPnodeNext(NodeID, obp_fd, OPROMCHILD)) OBPnodeTraverse(NodeTree, NewNode->NodeID, NewNode->Name, NewID, obp_fd); if (NewID = OBPnodeNext(NodeID, obp_fd, OPROMNEXT)) OBPnodeTraverse(NodeTree, ParentID, ParentName, NewID, obp_fd); return(0); } /* * Build tree of OBP nodes based on what we find using I/O calls * to the OBP device. */ extern int OBPbuildNodeTree(NodeTree) OBPnode_t **NodeTree; { int obp_fd; int status; if (!NodeTree) { SImsg(SIM_DBG, "OBPbuildeNodeTree: NULL NodeTree Ptr."); return(-1); } /* * Note: Only one process at a time can open _PATH_OPENPROM. */ if ((obp_fd = open(_PATH_OPENPROM, O_RDONLY)) < 0) { SImsg(SIM_GERR, "Cannot open \"%s\": %s.", _PATH_OPENPROM, SYSERR); return(-1); } status = OBPnodeTraverse(NodeTree, (OBPnodeid_t) 0, (char *) NULL, OBPnodeNext((OBPnodeid_t) 0, obp_fd, OPROMNEXT), obp_fd); (void) close(obp_fd); if (Debug && NodeTree && *NodeTree) OBPprintInfo(*NodeTree); return(status); } /* * Build device tree from OBP device. */ extern int OBPbuild(TreePtr, SearchNames) DevInfo_t **TreePtr; char **SearchNames; { int status = 0; /* * Build the OBP Node Tree if it hasn't been done already. */ if (!OBPnodeTree) { status = OBPbuildNodeTree(&OBPnodeTree); if (status != 0) return(status); } /* * Build the device tree by walking the OBP Node Tree */ OBPdevTraverse(*OBPnodeTree, TreePtr, SearchNames); return(status); } /* * Get the "ROM Version" by querying the OBP */ extern char *OBPgetRomVersion() { static char Version[OPROMMAXPARAM]; #if defined(OPROMGETVERSION) int obp_fd; struct openpromio *op; static OBPio_t opio; /* * Note: Only one process at a time can open _PATH_OPENPROM. */ if ((obp_fd = open(_PATH_OPENPROM, O_RDONLY)) < 0) { SImsg(SIM_GERR, "Cannot open \"%s\": %s.", _PATH_OPENPROM, SYSERR); return((char *) NULL); } op = &(opio.opio_oprom); op->oprom_size = sizeof(opio.opio_buff); if (ioctl(obp_fd, OPROMGETVERSION, op) < 0) { SImsg(SIM_GERR, "OBP ioctl OPROMGETVERSION failed: %s", SYSERR); return((char *) NULL); } (void) close(obp_fd); strcpy(Version, op->oprom_array); #endif /* OPROMGETVERSION */ return((Version[0]) ? Version : (char *) NULL); } /* * Get sub system model variables */ extern char *OBPsubSysGetVar(Variable, Params) char *Variable; Opaque_t Params; { static char *Banner; static int CPUspeed = 0; static int ClockFreq = 0; register char *cp; register char *End; SubSysVar_t *SubSysVar; OBPnode_t *OBPtree; SubSysVar = (SubSysVar_t *) Params; SubSysVar->IntVal = 0; SubSysVar->StrVal = NULL; OBPtree = SubSysVar->OBPtree; if (EQ(Variable, "BannerName")) { Banner = OBPfindPropVal(OBP_BANNERNAME, OBPtree->PropTable, NULL, NULL); if (Banner) { End = &Banner[strlen(Banner)]; if (cp = strchr(Banner, '-')) { if (strncmp(cp, "-slot ", 6) == 0 && cp < End) Banner = cp + 6; else if (strncmp(cp, "-way ", 5) == 0 && cp < End) Banner = cp + 5; } SubSysVar->StrVal = Banner; return(Banner); } } else if (EQ(Variable, "ClockFreq")) { if (!ClockFreq) { cp = OBPfindPropVal(OBP_CLOCKFREQ, OBPtree->PropTable, NULL, NULL); if (cp) ClockFreq = (int) ((long)atoi(cp) / (long)MHERTZ); else return((char *) NULL); } SubSysVar->IntVal = ClockFreq; SubSysVar->StrVal = itoa(ClockFreq); return(SubSysVar->StrVal); } else if (EQ(Variable, "NumCPU")) { if (cp = GetNumCpu()) { SubSysVar->IntVal = atoi(cp); SubSysVar->StrVal = cp; } return(cp); } else if (EQ(Variable, "CPUspeed")) { if (!CPUspeed) CPUspeed = OBPgetCPUspeed(OBPnodeTree); SubSysVar->IntVal = CPUspeed; SubSysVar->StrVal = itoa(CPUspeed); return(SubSysVar->StrVal); } else { SImsg(SIM_UNKN, "OBPsubSysGetVar: Unknown variable `%s'", Variable); } return((char *) NULL); } /* * Get the clock frequency from the OBP property table. */ static int OBPgetCPUclockfreq(PropTable) OBPprop_t *PropTable; { char *ClockStr; long ClockFreq; ClockStr = OBPfindPropVal(OBP_CLOCKFREQ, PropTable, NULL, NULL); if (!ClockStr) { SImsg(SIM_DBG, "OBPgetCPUclockfreq: Could not find CPU clockfreq."); return(0); } ClockFreq = strtol(ClockStr, (char **)NULL, 0); if (ClockFreq > MHERTZ) return((int) (ClockFreq / MHERTZ)); else return((int) ClockFreq); } /* * Get the speed of any CPU (they should all be the same). */ static int OBPgetCPUspeed(NodeTree) OBPnode_t *NodeTree; { OBPnode_t *Node; int Speed; /* * First try to find a CPU node. */ Node = OBPfindNodeByType(NodeTree, OBP_CPU); if (Node) { Speed = OBPgetCPUclockfreq(Node->PropTable); if (Speed) return(Speed); } else { SImsg(SIM_DBG, "OBPgetCPUspeed: Could not find any CPU nodes."); } /* * Some machines have the clock frequency in the root node. */ Speed = OBPgetCPUclockfreq(NodeTree->PropTable); if (Speed) return(Speed); else SImsg(SIM_DBG, "OBPgetCPUspeed: No clockfreq in root Node."); return(0); } /* * Set Conditionals. * Conditions are set in SubSysDef->Conditions. * If String is of form 'key=val', break apart and set Conditions. * If String is of form 'string' (no '=') and DefaultKey is set, do * backwards compatibility. */ Condition_t *SetCondition(SubSysDef, String, DefaultKey) Define_t *SubSysDef; char *String; char *DefaultKey; { register char *cp; register char *StrKey = NULL; register char *StrVal = NULL; Condition_t *Cond = NULL; static Condition_t *LastCon; static Define_t *LastSubSysDef; /* * See if this is 'key=val' */ cp = strchr(String, '='); if (!cp) { if (DefaultKey) { /* * Do backwards compatibility */ StrKey = DefaultKey; StrVal = String; } else return((Condition_t *) NULL); } else *cp = CNULL; /* * If we've changed to a new SubSysDef, invalidate LastCon */ if (LastSubSysDef && LastSubSysDef != SubSysDef) LastCon = NULL; LastSubSysDef = SubSysDef; Cond = (Condition_t *) xcalloc(1, sizeof(Condition_t)); if (StrKey) Cond->Key = StrKey; else Cond->Key = String; if (StrVal) { Cond->StrVal = StrVal; Cond->IntVal = atoi(StrVal); } else if (++cp) { Cond->StrVal = cp; Cond->IntVal = atoi(cp); } /* * Add to end of linked list. */ if (!SubSysDef->Conditions) LastCon = SubSysDef->Conditions = Cond; else { if (LastCon) { LastCon->Next = Cond; LastCon = Cond; } else LastCon = SubSysDef->Conditions = Cond; } return(Cond); } /* * Get the sub system model type. * i.e. "Ultra-1 140" */ extern char *OBPgetSubSysModel(SubSysDef) Define_t *SubSysDef; { static char ErrBuff[128]; static SubSysVar_t SubSysVar; Condition_t *Conditions; register Condition_t *Cond; int AllMatch; register int Argc; char **Argv = NULL; char *ExpandStr = NULL; char *SubSysName = NULL; int CPUspeedDelta = CPU_SPEED_DELTA; char *cp; register int i; if (SubSysDef->ValStr1) ExpandStr = SubSysDef->ValStr1; else return((char *) NULL); /* * Gather info needed for comparision and use in model name expansion */ if (!OBPnodeTree) OBPbuildNodeTree(&OBPnodeTree); SubSysVar.OBPtree = OBPnodeTree; if (SubSysDef->Conditions) { /* Reset */ for (Cond = SubSysDef->Conditions; Cond; Cond = Cond->Next) Cond->Matches = FALSE; } else { /* Initialize */ /* * The first field (ValStr2) is what should be used normally. * We default to CPUspeed if there is no 'key=val' for backwards * compat. The remaining ValStr[3-5] parse are also for backwards * compat. */ if (SubSysDef->ValStr2 && *SubSysDef->ValStr2) if (Argc = StrToArgv(SubSysDef->ValStr2, " ", &Argv, NULL, 0)) for (i = 0; i < Argc; ++i) (void) SetCondition(SubSysDef, Argv[i], "CPUspeed"); if (SubSysDef->ValStr3 && *SubSysDef->ValStr3) if (Argc = StrToArgv(SubSysDef->ValStr3, " ", &Argv, NULL, 0)) for (i = 0; i < Argc; ++i) (void) SetCondition(SubSysDef, Argv[i], "NumCPU"); if (SubSysDef->ValStr4 && *SubSysDef->ValStr4) if (Argc = StrToArgv(SubSysDef->ValStr4, " ", &Argv, NULL, 0)) for (i = 0; i < Argc; ++i) (void) SetCondition(SubSysDef, Argv[i], "HasDev"); if (SubSysDef->ValStr5 && *SubSysDef->ValStr5) if (Argc = StrToArgv(SubSysDef->ValStr5, " ", &Argv, NULL, 0)) for (i = 0; i < Argc; ++i) (void) SetCondition(SubSysDef, Argv[i], "HasType"); } /* * Iterate through each condition and set Matches==TRUE if condition * is met. */ for (Cond = SubSysDef->Conditions; Cond; Cond = Cond->Next) { if (EQ("HasDev", Cond->Key) && Cond->StrVal) { if (OBPfindNodeByName(OBPnodeTree, Cond->StrVal)) Cond->Matches = TRUE; } else if (EQ("HasType", Cond->Key) && Cond->StrVal) { if (OBPfindNodeByType(OBPnodeTree, Cond->StrVal)) Cond->Matches = TRUE; } else if (EQ("CPUspeedDelta", Cond->Key) && Cond->IntVal) { /* * Set the CPUspeedDelta * This variable specifies how much leeway is given when * comparing CPUspeed (in MHz) below. */ CPUspeedDelta = Cond->IntVal; /* Don't use this entry for comparisons */ Cond->Flags |= CONFL_SETONLY; } else if (cp = OBPsubSysGetVar(Cond->Key, (Opaque_t) &SubSysVar)) { if (EQ("CPUspeed", Cond->Key)) { /* * SubSysVar.IntVal is system's actual CPUspeed. * Cond->IntVal is CPUspeed from the .cf parameter. * CPUspeed may vary by +/- CPUspeedDelta. */ if (SubSysVar.IntVal >= (Cond->IntVal - CPUspeedDelta) && SubSysVar.IntVal <= (Cond->IntVal + CPUspeedDelta)) Cond->Matches = TRUE; } else if (EQ("NumCPU", Cond->Key)) { if (SubSysVar.IntVal == Cond->IntVal) Cond->Matches = TRUE; } else if (EQ("ClockFreq", Cond->Key)) { if (Cond->IntVal == atoi(cp)) Cond->Matches = TRUE; } } else { SImsg(SIM_DBG, "%s: Bad keyword in SubSysModel rule.", Cond->Key); } } /* * If all conditions Match (are TRUE), then everything is GO. If any ONE * item is not a Match (FALSE), then it's no GO. */ for (AllMatch = TRUE, Cond = SubSysDef->Conditions; Cond; Cond = Cond->Next) { if (FLAGS_ON(Cond->Flags, CONFL_SETONLY)) continue; if (!Cond->Matches) { AllMatch = FALSE; break; } } /* * Expand name if needed. */ if (AllMatch) { SubSysName = VarSub(ExpandStr, ErrBuff, sizeof(ErrBuff), OBPsubSysGetVar, (Opaque_t) &SubSysVar); if (SubSysName) return(SubSysName); else SImsg(SIM_GERR, "Variable error in `%s': %s", ExpandStr, ErrBuff); } return((char *) NULL); } /* * Get system model type from OBP directly. */ extern char *OBPgetSysModel() { int obp_fd; char *Name; char *SubName; static OBPprop_t *OBPprop = NULL; register Define_t *DefPtr; register Define_t *SubSysDefs; /* * Note: Only one process at a time can open _PATH_OPENPROM. */ if ((obp_fd = open(_PATH_OPENPROM, O_RDONLY)) < 0) { SImsg(SIM_GERR, "Cannot open \"%s\": %s.", _PATH_OPENPROM, SYSERR); return((char *) NULL); } /* * Position ourselves at root OBP node. */ (void) OBPnodeNext((OBPnodeid_t) 0, obp_fd, OPROMNEXT); /* * Get all the properties for the current node. */ if (!OBPgetProps(obp_fd, &OBPprop)) { SImsg(SIM_GERR, "Get OBP Property table failed."); return((char *)NULL); } (void) close(obp_fd); /* * Find the root node's name */ Name = OBPfindPropVal(OBP_NAME, OBPprop, NULL, NULL); if (!Name) { SImsg(SIM_GERR, "Could not find system model in OBP."); return((char *) NULL); } /* * See if there is a sub system model name for this. */ SubSysDefs = DefGet(DL_SUBSYSMODEL, Name, 0, 0); if (!SubSysDefs) { /* No Sub System Model defined, so we just return the base name */ SImsg(SIM_DBG, "No sub system model defined for `%s'", Name); return(Name); } for (DefPtr = SubSysDefs; DefPtr; DefPtr = DefPtr->Next) if (EQ(Name, DefPtr->KeyStr) && (SubName = OBPgetSubSysModel(DefPtr))) return(SubName); return(Name); } #endif /* HAVE_OPENPROM */