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 2015 OmniTI Computer Consulting, Inc. All rights reserved. 24 * Copyright 2016 Joyent, Inc. 25 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 26 * Use is subject to license terms. 27 */ 28 29 /* 30 * SMBIOS Information Routines 31 * 32 * The routines in this file are used to convert from the SMBIOS data format to 33 * a more reasonable and stable set of structures offered as part of our ABI. 34 * These functions take the general form: 35 * 36 * stp = smb_lookup_type(shp, foo); 37 * smb_foo_t foo; 38 * 39 * smb_info_bcopy(stp->smbst_hdr, &foo, sizeof (foo)); 40 * bzero(caller's struct); 41 * 42 * copy/convert foo members into caller's struct 43 * 44 * We copy the internal structure on to an automatic variable so as to avoid 45 * checks everywhere for structures that the BIOS has improperly truncated, and 46 * also to automatically handle the case of a structure that has been extended. 47 * When necessary, this code can use smb_gteq() to determine whether the SMBIOS 48 * data is of a particular revision that is supposed to contain a new field. 49 * 50 * Note, when trying to bzero the caller's struct you have to be careful about 51 * versions. One can only bzero the initial version that existed in illumos. In 52 * other words, if someone passes an older library handle that doesn't support a 53 * version you cannot assume that their structures have those additional members 54 * in them. Instead, a 'base' version is introduced for such types that have 55 * differences and instead we only bzero out the base version and then handle 56 * the additional members. In general, because all additional members will be 57 * assigned, there's no reason to zero them out unless they are arrays that 58 * won't be entirely filled in. 59 * 60 * Due to history, anything added after the update from version 2.4, in other 61 * words additions from or after '5094 Update libsmbios with recent items' 62 * (4e901881) is currently being used for this. While we don't allow software 63 * compiling against this to get an older form, this was the first major update 64 * and a good starting point for us to enforce this behavior which is useful for 65 * moving forward to making this more public. 66 */ 67 68 #include <sys/smbios_impl.h> 69 #include <sys/byteorder.h> 70 71 #ifdef _KERNEL 72 #include <sys/sunddi.h> 73 #else 74 #include <fcntl.h> 75 #include <unistd.h> 76 #include <string.h> 77 #endif 78 79 /* 80 * A large number of SMBIOS structures contain a set of common strings used to 81 * describe a h/w component's serial number, manufacturer, etc. These fields 82 * helpfully have different names and offsets and sometimes aren't consistent. 83 * To simplify life for our clients, we factor these common things out into 84 * smbios_info_t, which can be retrieved for any structure. The following 85 * table describes the mapping from a given structure to the smbios_info_t. 86 * Multiple SMBIOS stuctures' contained objects are also handled here. 87 */ 88 static const struct smb_infospec { 89 uint8_t is_type; /* structure type */ 90 uint8_t is_manu; /* manufacturer offset */ 91 uint8_t is_product; /* product name offset */ 92 uint8_t is_version; /* version offset */ 93 uint8_t is_serial; /* serial number offset */ 94 uint8_t is_asset; /* asset tag offset */ 95 uint8_t is_location; /* location string offset */ 96 uint8_t is_part; /* part number offset */ 97 uint8_t is_contc; /* contained count */ 98 uint8_t is_contsz; /* contained size */ 99 uint8_t is_contv; /* contained objects */ 100 } _smb_infospecs[] = { 101 { SMB_TYPE_SYSTEM, 102 offsetof(smb_system_t, smbsi_manufacturer), 103 offsetof(smb_system_t, smbsi_product), 104 offsetof(smb_system_t, smbsi_version), 105 offsetof(smb_system_t, smbsi_serial), 106 0, 107 0, 108 0, 109 0, 110 0, 111 0 }, 112 { SMB_TYPE_BASEBOARD, 113 offsetof(smb_bboard_t, smbbb_manufacturer), 114 offsetof(smb_bboard_t, smbbb_product), 115 offsetof(smb_bboard_t, smbbb_version), 116 offsetof(smb_bboard_t, smbbb_serial), 117 offsetof(smb_bboard_t, smbbb_asset), 118 offsetof(smb_bboard_t, smbbb_location), 119 0, 120 offsetof(smb_bboard_t, smbbb_cn), 121 SMB_CONT_WORD, 122 offsetof(smb_bboard_t, smbbb_cv) }, 123 { SMB_TYPE_CHASSIS, 124 offsetof(smb_chassis_t, smbch_manufacturer), 125 0, 126 offsetof(smb_chassis_t, smbch_version), 127 offsetof(smb_chassis_t, smbch_serial), 128 offsetof(smb_chassis_t, smbch_asset), 129 0, 130 0, 131 offsetof(smb_chassis_t, smbch_cn), 132 SMB_CONT_BYTE, 133 offsetof(smb_chassis_t, smbch_cv) }, 134 { SMB_TYPE_PROCESSOR, 135 offsetof(smb_processor_t, smbpr_manufacturer), 136 0, 137 offsetof(smb_processor_t, smbpr_version), 138 offsetof(smb_processor_t, smbpr_serial), 139 offsetof(smb_processor_t, smbpr_asset), 140 offsetof(smb_processor_t, smbpr_socket), 141 offsetof(smb_processor_t, smbpr_part), 142 0, 143 0, 144 0 }, 145 { SMB_TYPE_CACHE, 146 0, 147 0, 148 0, 149 0, 150 0, 151 offsetof(smb_cache_t, smbca_socket), 152 0, 153 0, 154 0, 155 0 }, 156 { SMB_TYPE_PORT, 157 0, 158 0, 159 0, 160 0, 161 0, 162 offsetof(smb_port_t, smbpo_iref), 163 0, 164 0, 165 0, 166 0 }, 167 { SMB_TYPE_SLOT, 168 0, 169 0, 170 0, 171 0, 172 0, 173 offsetof(smb_slot_t, smbsl_name), 174 0, 175 0, 176 0, 177 0 }, 178 { SMB_TYPE_MEMDEVICE, 179 offsetof(smb_memdevice_t, smbmdev_manufacturer), 180 0, 181 0, 182 offsetof(smb_memdevice_t, smbmdev_serial), 183 offsetof(smb_memdevice_t, smbmdev_asset), 184 offsetof(smb_memdevice_t, smbmdev_dloc), 185 offsetof(smb_memdevice_t, smbmdev_part), 186 0, 187 0, 188 0 }, 189 { SMB_TYPE_POWERSUP, 190 offsetof(smb_powersup_t, smbpsup_manufacturer), 191 offsetof(smb_powersup_t, smbpsup_devname), 192 offsetof(smb_powersup_t, smbpsup_rev), 193 offsetof(smb_powersup_t, smbpsup_serial), 194 offsetof(smb_powersup_t, smbpsup_asset), 195 offsetof(smb_powersup_t, smbpsup_loc), 196 offsetof(smb_powersup_t, smbpsup_part), 197 0, 198 0, 199 0 }, 200 { SMB_TYPE_EOT } 201 }; 202 203 static const char * 204 smb_info_strptr(const smb_struct_t *stp, uint8_t off, int *n) 205 { 206 const uint8_t *sp = (const uint8_t *)(uintptr_t)stp->smbst_hdr; 207 208 if (off != 0 && sp + off < stp->smbst_end) { 209 (*n)++; /* indicate success for caller */ 210 return (smb_strptr(stp, sp[off])); 211 } 212 213 return (smb_strptr(stp, 0)); 214 } 215 216 static void 217 smb_info_bcopy(const smb_header_t *hp, void *dst, size_t dstlen) 218 { 219 if (dstlen > hp->smbh_len) { 220 bcopy(hp, dst, hp->smbh_len); 221 bzero((char *)dst + hp->smbh_len, dstlen - hp->smbh_len); 222 } else 223 bcopy(hp, dst, dstlen); 224 } 225 226 smbios_entry_point_t 227 smbios_info_smbios(smbios_hdl_t *shp, smbios_entry_t *ep) 228 { 229 bcopy(&shp->sh_ent, ep, sizeof (smbios_entry_t)); 230 return (shp->sh_ent_type); 231 } 232 233 void 234 smbios_info_smbios_version(smbios_hdl_t *shp, smbios_version_t *v) 235 { 236 v->smbv_major = SMB_MAJOR(shp->sh_smbvers); 237 v->smbv_minor = SMB_MINOR(shp->sh_smbvers); 238 } 239 240 #ifndef _KERNEL 241 static char smbios_product_override[256]; 242 static boolean_t smbios_product_checked; 243 #endif 244 245 int 246 smbios_info_common(smbios_hdl_t *shp, id_t id, smbios_info_t *ip) 247 { 248 const smb_struct_t *stp = smb_lookup_id(shp, id); 249 const struct smb_infospec *isp; 250 int n = 0; 251 252 if (stp == NULL) 253 return (-1); /* errno is set for us */ 254 255 for (isp = _smb_infospecs; isp->is_type != SMB_TYPE_EOT; isp++) { 256 if (isp->is_type == stp->smbst_hdr->smbh_type) 257 break; 258 } 259 260 ip->smbi_manufacturer = smb_info_strptr(stp, isp->is_manu, &n); 261 ip->smbi_product = smb_info_strptr(stp, isp->is_product, &n); 262 ip->smbi_version = smb_info_strptr(stp, isp->is_version, &n); 263 ip->smbi_serial = smb_info_strptr(stp, isp->is_serial, &n); 264 ip->smbi_asset = smb_info_strptr(stp, isp->is_asset, &n); 265 ip->smbi_location = smb_info_strptr(stp, isp->is_location, &n); 266 ip->smbi_part = smb_info_strptr(stp, isp->is_part, &n); 267 268 /* 269 * This private file allows developers to experiment with reporting 270 * different platform strings from SMBIOS. It is not a supported 271 * mechanism in the long term, and does not work in the kernel. 272 */ 273 #ifndef _KERNEL 274 if (isp->is_type == SMB_TYPE_SYSTEM) { 275 if (!smbios_product_checked) { 276 int fd = open("/etc/smbios_product", O_RDONLY); 277 if (fd >= 0) { 278 (void) read(fd, smbios_product_override, 279 sizeof (smbios_product_override) - 1); 280 (void) close(fd); 281 } 282 smbios_product_checked = B_TRUE; 283 } 284 285 if (smbios_product_override[0] != '\0') 286 ip->smbi_product = smbios_product_override; 287 } 288 #endif 289 290 /* 291 * If we have a port with an empty internal reference designator string 292 * try using the external reference designator string instead. 293 */ 294 if (isp->is_type == SMB_TYPE_PORT && ip->smbi_location[0] == '\0') { 295 ip->smbi_location = smb_info_strptr(stp, 296 offsetof(smb_port_t, smbpo_eref), &n); 297 } 298 299 return (n ? 0 : smb_set_errno(shp, ESMB_NOINFO)); 300 } 301 302 /* 303 * Returns the actual number of contained objects. 304 * 305 * idc - number of contained objects 306 * idv - returned array of contained objects 307 */ 308 int 309 smbios_info_contains(smbios_hdl_t *shp, id_t id, uint_t idc, id_t *idv) 310 { 311 const smb_struct_t *stp = smb_lookup_id(shp, id); 312 const struct smb_infospec *isp; 313 id_t *cp; 314 uint_t size; 315 uint8_t cnt; 316 int i, n; 317 318 if (stp == NULL) { 319 return (-1); /* errno is set for us */ 320 } 321 322 for (isp = _smb_infospecs; isp->is_type != SMB_TYPE_EOT; isp++) { 323 if (isp->is_type == stp->smbst_hdr->smbh_type) 324 break; 325 } 326 if (isp->is_type == SMB_TYPE_EOT) 327 return (smb_set_errno(shp, ESMB_TYPE)); 328 329 size = isp->is_contsz; 330 cnt = *((uint8_t *)(uintptr_t)stp->smbst_hdr + isp->is_contc); 331 cp = (id_t *)((uintptr_t)stp->smbst_hdr + isp->is_contv); 332 333 n = MIN(cnt, idc); 334 for (i = 0; i < n; i++) { 335 if (size == SMB_CONT_WORD) 336 idv[i] = *((uint8_t *)(uintptr_t)cp + (i * 2)); 337 else if (size == SMB_CONT_BYTE) 338 idv[i] = *((uint8_t *)(uintptr_t)cp + (i * 3)); 339 else 340 return (smb_set_errno(shp, ESMB_INVAL)); 341 } 342 343 return (cnt); 344 } 345 346 id_t 347 smbios_info_bios(smbios_hdl_t *shp, smbios_bios_t *bp) 348 { 349 const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_BIOS); 350 const smb_bios_t *bip; 351 352 if (stp == NULL) 353 return (-1); /* errno is set for us */ 354 355 if (stp->smbst_hdr->smbh_len < sizeof (smb_bios_t) - sizeof (uint8_t)) 356 return (smb_set_errno(shp, ESMB_CORRUPT)); 357 358 bip = (smb_bios_t *)(uintptr_t)stp->smbst_hdr; 359 bzero(bp, sizeof (smb_base_bios_t)); 360 if (smb_libgteq(shp, SMB_VERSION_31)) { 361 bp->smbb_extromsize = 0; 362 } 363 364 bp->smbb_vendor = smb_strptr(stp, bip->smbbi_vendor); 365 bp->smbb_version = smb_strptr(stp, bip->smbbi_version); 366 bp->smbb_segment = bip->smbbi_segment; 367 bp->smbb_reldate = smb_strptr(stp, bip->smbbi_reldate); 368 bp->smbb_romsize = 64 * 1024 * ((uint32_t)bip->smbbi_romsize + 1); 369 bp->smbb_runsize = 16 * (0x10000 - (uint32_t)bip->smbbi_segment); 370 bp->smbb_cflags = bip->smbbi_cflags; 371 372 /* 373 * If one or more extension bytes are present, reset smbb_xcflags to 374 * point to them. Otherwise leave this member set to NULL. 375 */ 376 if (stp->smbst_hdr->smbh_len >= sizeof (smb_bios_t)) { 377 bp->smbb_xcflags = bip->smbbi_xcflags; 378 bp->smbb_nxcflags = stp->smbst_hdr->smbh_len - 379 sizeof (smb_bios_t) + 1; 380 381 if (bp->smbb_nxcflags > SMB_BIOSXB_ECFW_MIN && 382 smb_gteq(shp, SMB_VERSION_24)) { 383 bp->smbb_biosv.smbv_major = 384 bip->smbbi_xcflags[SMB_BIOSXB_BIOS_MAJ]; 385 bp->smbb_biosv.smbv_minor = 386 bip->smbbi_xcflags[SMB_BIOSXB_BIOS_MIN]; 387 bp->smbb_ecfwv.smbv_major = 388 bip->smbbi_xcflags[SMB_BIOSXB_ECFW_MAJ]; 389 bp->smbb_ecfwv.smbv_minor = 390 bip->smbbi_xcflags[SMB_BIOSXB_ECFW_MIN]; 391 } 392 393 if (bp->smbb_nxcflags > SMB_BIOSXB_EXTROM + 1 && 394 smb_gteq(shp, SMB_VERSION_31)) { 395 uint16_t val; 396 uint64_t rs; 397 398 /* 399 * Because of the fact that the extended size is a 400 * uint16_t and we'd need to define an explicit 401 * endian-aware way to access it, we don't include it in 402 * the number of extended flags below and thus subtract 403 * its size. 404 */ 405 bp->smbb_nxcflags -= sizeof (uint16_t); 406 bcopy(&bip->smbbi_xcflags[SMB_BIOSXB_EXTROM], &val, 407 sizeof (val)); 408 val = LE_16(val); 409 410 /* 411 * The upper two bits of the extended rom size are used 412 * to indicate whether the other 14 bits are in MB or 413 * GB. 414 */ 415 rs = SMB_BIOS_EXTROM_VALUE_MASK(val); 416 switch (SMB_BIOS_EXTROM_SHIFT_MASK(val)) { 417 case 0: 418 rs *= 1024ULL * 1024ULL; 419 break; 420 case 1: 421 rs *= 1024ULL * 1024ULL * 1024ULL; 422 break; 423 default: 424 rs = 0; 425 break; 426 } 427 428 if (smb_libgteq(shp, SMB_VERSION_31)) { 429 bp->smbb_extromsize = rs; 430 } 431 } 432 } 433 434 if (smb_libgteq(shp, SMB_VERSION_31) && bp->smbb_extromsize == 0) { 435 bp->smbb_extromsize = bp->smbb_romsize; 436 } 437 438 return (stp->smbst_hdr->smbh_hdl); 439 } 440 441 id_t 442 smbios_info_system(smbios_hdl_t *shp, smbios_system_t *sip) 443 { 444 const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_SYSTEM); 445 smb_system_t si; 446 447 if (stp == NULL) 448 return (-1); /* errno is set for us */ 449 450 smb_info_bcopy(stp->smbst_hdr, &si, sizeof (si)); 451 bzero(sip, sizeof (smbios_system_t)); 452 453 sip->smbs_uuid = ((smb_system_t *)stp->smbst_hdr)->smbsi_uuid; 454 sip->smbs_uuidlen = sizeof (si.smbsi_uuid); 455 sip->smbs_wakeup = si.smbsi_wakeup; 456 sip->smbs_sku = smb_strptr(stp, si.smbsi_sku); 457 sip->smbs_family = smb_strptr(stp, si.smbsi_family); 458 459 return (stp->smbst_hdr->smbh_hdl); 460 } 461 462 int 463 smbios_info_bboard(smbios_hdl_t *shp, id_t id, smbios_bboard_t *bbp) 464 { 465 const smb_struct_t *stp = smb_lookup_id(shp, id); 466 smb_bboard_t bb; 467 468 if (stp == NULL) 469 return (-1); /* errno is set for us */ 470 471 if (stp->smbst_hdr->smbh_type != SMB_TYPE_BASEBOARD) 472 return (smb_set_errno(shp, ESMB_TYPE)); 473 474 smb_info_bcopy(stp->smbst_hdr, &bb, sizeof (bb)); 475 bzero(bbp, sizeof (smbios_bboard_t)); 476 477 bbp->smbb_chassis = bb.smbbb_chassis; 478 bbp->smbb_flags = bb.smbbb_flags; 479 bbp->smbb_type = bb.smbbb_type; 480 bbp->smbb_contn = bb.smbbb_cn; 481 482 return (0); 483 } 484 485 int 486 smbios_info_chassis(smbios_hdl_t *shp, id_t id, smbios_chassis_t *chp) 487 { 488 const smb_struct_t *stp = smb_lookup_id(shp, id); 489 /* Length is measurable by one byte, so it'll be no more than 255. */ 490 uint8_t buf[256]; 491 smb_chassis_t *ch = (smb_chassis_t *)&buf[0]; 492 493 if (stp == NULL) 494 return (-1); /* errno is set for us */ 495 496 if (stp->smbst_hdr->smbh_type != SMB_TYPE_CHASSIS) 497 return (smb_set_errno(shp, ESMB_TYPE)); 498 499 smb_info_bcopy(stp->smbst_hdr, ch, sizeof (buf)); 500 bzero(chp, sizeof (smb_base_chassis_t)); 501 if (smb_libgteq(shp, SMB_VERSION_27)) { 502 bzero(chp->smbc_sku, sizeof (chp->smbc_sku)); 503 } 504 505 chp->smbc_oemdata = ch->smbch_oemdata; 506 chp->smbc_lock = (ch->smbch_type & SMB_CHT_LOCK) != 0; 507 chp->smbc_type = ch->smbch_type & ~SMB_CHT_LOCK; 508 chp->smbc_bustate = ch->smbch_bustate; 509 chp->smbc_psstate = ch->smbch_psstate; 510 chp->smbc_thstate = ch->smbch_thstate; 511 chp->smbc_security = ch->smbch_security; 512 chp->smbc_uheight = ch->smbch_uheight; 513 chp->smbc_cords = ch->smbch_cords; 514 chp->smbc_elems = ch->smbch_cn; 515 chp->smbc_elemlen = ch->smbch_cm; 516 517 if (smb_libgteq(shp, SMB_VERSION_27)) { 518 (void) strlcpy(chp->smbc_sku, SMB_CH_SKU(ch), 519 sizeof (chp->smbc_sku)); 520 } 521 522 return (0); 523 } 524 525 int 526 smbios_info_processor(smbios_hdl_t *shp, id_t id, smbios_processor_t *pp) 527 { 528 const smb_struct_t *stp = smb_lookup_id(shp, id); 529 smb_processor_t p; 530 531 if (stp == NULL) 532 return (-1); /* errno is set for us */ 533 534 if (stp->smbst_hdr->smbh_type != SMB_TYPE_PROCESSOR) 535 return (smb_set_errno(shp, ESMB_TYPE)); 536 537 smb_info_bcopy(stp->smbst_hdr, &p, sizeof (p)); 538 bzero(pp, sizeof (smb_base_processor_t)); 539 540 pp->smbp_cpuid = p.smbpr_cpuid; 541 pp->smbp_type = p.smbpr_type; 542 pp->smbp_family = p.smbpr_family; 543 pp->smbp_voltage = p.smbpr_voltage; 544 pp->smbp_maxspeed = p.smbpr_maxspeed; 545 pp->smbp_curspeed = p.smbpr_curspeed; 546 pp->smbp_status = p.smbpr_status; 547 pp->smbp_upgrade = p.smbpr_upgrade; 548 pp->smbp_l1cache = p.smbpr_l1cache; 549 pp->smbp_l2cache = p.smbpr_l2cache; 550 pp->smbp_l3cache = p.smbpr_l3cache; 551 552 if (smb_libgteq(shp, SMB_VERSION_25)) { 553 pp->smbp_corecount = p.smbpr_corecount; 554 pp->smbp_coresenabled = p.smbpr_coresenabled; 555 pp->smbp_threadcount = p.smbpr_threadcount; 556 pp->smbp_cflags = p.smbpr_cflags; 557 } 558 559 if (smb_libgteq(shp, SMB_VERSION_26)) { 560 pp->smbp_family2 = p.smbpr_family2; 561 } 562 563 if (smb_libgteq(shp, SMB_VERSION_30)) { 564 pp->smbp_corecount2 = p.smbpr_corecount2; 565 pp->smbp_coresenabled2 = p.smbpr_coresenabled2; 566 pp->smbp_threadcount2 = p.smbpr_threadcount2; 567 } 568 569 return (0); 570 } 571 572 int 573 smbios_info_cache(smbios_hdl_t *shp, id_t id, smbios_cache_t *cap) 574 { 575 const smb_struct_t *stp = smb_lookup_id(shp, id); 576 smb_cache_t c; 577 578 if (stp == NULL) 579 return (-1); /* errno is set for us */ 580 581 if (stp->smbst_hdr->smbh_type != SMB_TYPE_CACHE) 582 return (smb_set_errno(shp, ESMB_TYPE)); 583 584 smb_info_bcopy(stp->smbst_hdr, &c, sizeof (c)); 585 bzero(cap, sizeof (smb_base_cache_t)); 586 587 cap->smba_maxsize = SMB_CACHE_SIZE(c.smbca_maxsize); 588 cap->smba_size = SMB_CACHE_SIZE(c.smbca_size); 589 cap->smba_stype = c.smbca_stype; 590 cap->smba_ctype = c.smbca_ctype; 591 cap->smba_speed = c.smbca_speed; 592 cap->smba_etype = c.smbca_etype; 593 cap->smba_ltype = c.smbca_ltype; 594 cap->smba_assoc = c.smbca_assoc; 595 cap->smba_level = SMB_CACHE_CFG_LEVEL(c.smbca_config); 596 cap->smba_mode = SMB_CACHE_CFG_MODE(c.smbca_config); 597 cap->smba_location = SMB_CACHE_CFG_LOCATION(c.smbca_config); 598 599 if (SMB_CACHE_CFG_ENABLED(c.smbca_config)) 600 cap->smba_flags |= SMB_CAF_ENABLED; 601 602 if (SMB_CACHE_CFG_SOCKETED(c.smbca_config)) 603 cap->smba_flags |= SMB_CAF_SOCKETED; 604 605 if (smb_libgteq(shp, SMB_VERSION_31)) { 606 if (smb_gteq(shp, SMB_VERSION_31)) { 607 cap->smba_maxsize2 = 608 SMB_CACHE_EXT_SIZE(c.smbca_maxsize2); 609 cap->smba_size2 = SMB_CACHE_EXT_SIZE(c.smbca_size2); 610 } else { 611 cap->smba_maxsize2 = cap->smba_maxsize; 612 cap->smba_size2 = cap->smba_size; 613 } 614 } 615 616 return (0); 617 } 618 619 int 620 smbios_info_port(smbios_hdl_t *shp, id_t id, smbios_port_t *pop) 621 { 622 const smb_struct_t *stp = smb_lookup_id(shp, id); 623 smb_port_t p; 624 625 if (stp == NULL) 626 return (-1); /* errno is set for us */ 627 628 if (stp->smbst_hdr->smbh_type != SMB_TYPE_PORT) 629 return (smb_set_errno(shp, ESMB_TYPE)); 630 631 smb_info_bcopy(stp->smbst_hdr, &p, sizeof (p)); 632 bzero(pop, sizeof (smbios_port_t)); 633 634 pop->smbo_iref = smb_strptr(stp, p.smbpo_iref); 635 pop->smbo_eref = smb_strptr(stp, p.smbpo_eref); 636 637 pop->smbo_itype = p.smbpo_itype; 638 pop->smbo_etype = p.smbpo_etype; 639 pop->smbo_ptype = p.smbpo_ptype; 640 641 return (0); 642 } 643 644 int 645 smbios_info_slot(smbios_hdl_t *shp, id_t id, smbios_slot_t *sp) 646 { 647 const smb_struct_t *stp = smb_lookup_id(shp, id); 648 smb_slot_t s; 649 650 if (stp == NULL) 651 return (-1); /* errno is set for us */ 652 653 if (stp->smbst_hdr->smbh_type != SMB_TYPE_SLOT) 654 return (smb_set_errno(shp, ESMB_TYPE)); 655 656 smb_info_bcopy(stp->smbst_hdr, &s, sizeof (s)); 657 bzero(sp, sizeof (smbios_slot_t)); 658 659 sp->smbl_name = smb_strptr(stp, s.smbsl_name); 660 sp->smbl_type = s.smbsl_type; 661 sp->smbl_width = s.smbsl_width; 662 sp->smbl_usage = s.smbsl_usage; 663 sp->smbl_length = s.smbsl_length; 664 sp->smbl_id = s.smbsl_id; 665 sp->smbl_ch1 = s.smbsl_ch1; 666 sp->smbl_ch2 = s.smbsl_ch2; 667 sp->smbl_sg = s.smbsl_sg; 668 sp->smbl_bus = s.smbsl_bus; 669 sp->smbl_df = s.smbsl_df; 670 671 return (0); 672 } 673 674 int 675 smbios_info_obdevs_ext(smbios_hdl_t *shp, id_t id, smbios_obdev_ext_t *oep) 676 { 677 const smb_struct_t *stp = smb_lookup_id(shp, id); 678 smb_obdev_ext_t obe; 679 680 if (stp == NULL) 681 return (-1); /* errno is set for us */ 682 683 if (stp->smbst_hdr->smbh_type != SMB_TYPE_OBDEVEXT) 684 return (smb_set_errno(shp, ESMB_TYPE)); 685 686 smb_info_bcopy(stp->smbst_hdr, &obe, sizeof (obe)); 687 bzero(oep, sizeof (smbios_obdev_ext_t)); 688 689 oep->smboe_name = smb_strptr(stp, obe.smbobe_name); 690 oep->smboe_dtype = obe.smbobe_dtype; 691 oep->smboe_dti = obe.smbobe_dti; 692 oep->smboe_sg = obe.smbobe_sg; 693 oep->smboe_bus = obe.smbobe_bus; 694 oep->smboe_df = obe.smbobe_df; 695 696 return (0); 697 } 698 699 int 700 smbios_info_obdevs(smbios_hdl_t *shp, id_t id, int obc, smbios_obdev_t *obp) 701 { 702 const smb_struct_t *stp = smb_lookup_id(shp, id); 703 const smb_obdev_t *op; 704 int i, m, n; 705 706 if (stp == NULL) 707 return (-1); /* errno is set for us */ 708 709 if (stp->smbst_hdr->smbh_type != SMB_TYPE_OBDEVS) 710 return (smb_set_errno(shp, ESMB_TYPE)); 711 712 op = (smb_obdev_t *)((uintptr_t)stp->smbst_hdr + sizeof (smb_header_t)); 713 m = (stp->smbst_hdr->smbh_len - sizeof (smb_header_t)) / sizeof (*op); 714 n = MIN(m, obc); 715 716 for (i = 0; i < n; i++, op++, obp++) { 717 obp->smbd_name = smb_strptr(stp, op->smbob_name); 718 obp->smbd_type = op->smbob_type & ~SMB_OBT_ENABLED; 719 obp->smbd_enabled = (op->smbob_type & SMB_OBT_ENABLED) != 0; 720 } 721 722 return (m); 723 } 724 725 /* 726 * The implementation structures for OEMSTR, SYSCONFSTR, and LANG all use the 727 * first byte to indicate the size of a string table at the end of the record. 728 * Therefore, smbios_info_strtab() can be used to retrieve the table size and 729 * strings for any of these underlying record types. 730 */ 731 int 732 smbios_info_strtab(smbios_hdl_t *shp, id_t id, int argc, const char *argv[]) 733 { 734 const smb_struct_t *stp = smb_lookup_id(shp, id); 735 smb_strtab_t s; 736 int i, n; 737 738 if (stp == NULL) 739 return (-1); /* errno is set for us */ 740 741 if (stp->smbst_hdr->smbh_type != SMB_TYPE_OEMSTR && 742 stp->smbst_hdr->smbh_type != SMB_TYPE_SYSCONFSTR && 743 stp->smbst_hdr->smbh_type != SMB_TYPE_LANG) 744 return (smb_set_errno(shp, ESMB_TYPE)); 745 746 smb_info_bcopy(stp->smbst_hdr, &s, sizeof (s)); 747 n = MIN(s.smbtb_count, argc); 748 749 for (i = 0; i < n; i++) 750 argv[i] = smb_strptr(stp, i + 1); 751 752 return (s.smbtb_count); 753 } 754 755 id_t 756 smbios_info_lang(smbios_hdl_t *shp, smbios_lang_t *lp) 757 { 758 const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_LANG); 759 smb_lang_t l; 760 761 if (stp == NULL) 762 return (-1); /* errno is set for us */ 763 764 smb_info_bcopy(stp->smbst_hdr, &l, sizeof (l)); 765 bzero(lp, sizeof (smbios_lang_t)); 766 767 lp->smbla_cur = smb_strptr(stp, l.smblang_cur); 768 lp->smbla_fmt = l.smblang_flags & 1; 769 lp->smbla_num = l.smblang_num; 770 771 return (stp->smbst_hdr->smbh_hdl); 772 } 773 774 id_t 775 smbios_info_eventlog(smbios_hdl_t *shp, smbios_evlog_t *evp) 776 { 777 const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_EVENTLOG); 778 const smb_sel_t *sel; 779 size_t len; 780 781 if (stp == NULL) 782 return (-1); /* errno is set for us */ 783 784 if (stp->smbst_hdr->smbh_len < sizeof (smb_sel_t) - sizeof (uint8_t)) 785 return (smb_set_errno(shp, ESMB_CORRUPT)); 786 787 sel = (smb_sel_t *)(uintptr_t)stp->smbst_hdr; 788 len = stp->smbst_hdr->smbh_len - sizeof (smb_sel_t) + sizeof (uint8_t); 789 bzero(evp, sizeof (smbios_evlog_t)); 790 791 if (len < sel->smbsel_typec * sel->smbsel_typesz) 792 return (smb_set_errno(shp, ESMB_CORRUPT)); 793 794 evp->smbev_size = sel->smbsel_len; 795 evp->smbev_hdr = sel->smbsel_hdroff; 796 evp->smbev_data = sel->smbsel_dataoff; 797 evp->smbev_method = sel->smbsel_method; 798 evp->smbev_flags = sel->smbsel_status; 799 evp->smbev_format = sel->smbsel_format; 800 evp->smbev_token = sel->smbsel_token; 801 evp->smbev_addr.eva_addr = sel->smbsel_addr; 802 803 if (sel->smbsel_typesz == sizeof (smbios_evtype_t)) { 804 evp->smbev_typec = sel->smbsel_typec; 805 evp->smbev_typev = (void *)(uintptr_t)sel->smbsel_typev; 806 } 807 808 return (stp->smbst_hdr->smbh_hdl); 809 } 810 811 int 812 smbios_info_memarray(smbios_hdl_t *shp, id_t id, smbios_memarray_t *map) 813 { 814 const smb_struct_t *stp = smb_lookup_id(shp, id); 815 smb_memarray_t m; 816 817 if (stp == NULL) 818 return (-1); /* errno is set for us */ 819 820 if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMARRAY) 821 return (smb_set_errno(shp, ESMB_TYPE)); 822 823 smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m)); 824 bzero(map, sizeof (smbios_memarray_t)); 825 826 map->smbma_location = m.smbmarr_loc; 827 map->smbma_use = m.smbmarr_use; 828 map->smbma_ecc = m.smbmarr_ecc; 829 map->smbma_ndevs = m.smbmarr_ndevs; 830 map->smbma_err = m.smbmarr_err; 831 832 if (m.smbmarr_cap != 0x80000000) 833 map->smbma_size = (uint64_t)m.smbmarr_cap * 1024; 834 else if (m.smbmarr_extcap != 0) 835 map->smbma_size = m.smbmarr_extcap; 836 else 837 map->smbma_size = 0; /* unknown */ 838 839 return (0); 840 } 841 842 int 843 smbios_info_memarrmap(smbios_hdl_t *shp, id_t id, smbios_memarrmap_t *map) 844 { 845 const smb_struct_t *stp = smb_lookup_id(shp, id); 846 smb_memarrmap_t m; 847 848 if (stp == NULL) 849 return (-1); /* errno is set for us */ 850 851 if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMARRAYMAP) 852 return (smb_set_errno(shp, ESMB_TYPE)); 853 854 smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m)); 855 bzero(map, sizeof (smbios_memarrmap_t)); 856 857 map->smbmam_array = m.smbamap_array; 858 map->smbmam_width = m.smbamap_width; 859 860 if (m.smbamap_start != 0xFFFFFFFF && m.smbamap_end != 0xFFFFFFFF) { 861 map->smbmam_addr = (uint64_t)m.smbamap_start * 1024; 862 map->smbmam_size = (uint64_t) 863 (m.smbamap_end - m.smbamap_start + 1) * 1024; 864 } else if (m.smbamap_extstart != 0 && m.smbamap_extend != 0) { 865 map->smbmam_addr = m.smbamap_extstart; 866 map->smbmam_size = m.smbamap_extend - m.smbamap_extstart + 1; 867 } 868 869 return (0); 870 } 871 872 int 873 smbios_info_memdevice(smbios_hdl_t *shp, id_t id, smbios_memdevice_t *mdp) 874 { 875 const smb_struct_t *stp = smb_lookup_id(shp, id); 876 smb_memdevice_t m; 877 878 if (stp == NULL) 879 return (-1); /* errno is set for us */ 880 881 if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMDEVICE) 882 return (smb_set_errno(shp, ESMB_TYPE)); 883 884 smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m)); 885 bzero(mdp, sizeof (smb_base_memdevice_t)); 886 887 mdp->smbmd_array = m.smbmdev_array; 888 mdp->smbmd_error = m.smbmdev_error; 889 mdp->smbmd_twidth = m.smbmdev_twidth == 0xFFFF ? -1U : m.smbmdev_twidth; 890 mdp->smbmd_dwidth = m.smbmdev_dwidth == 0xFFFF ? -1U : m.smbmdev_dwidth; 891 892 if (m.smbmdev_size == 0x7FFF) { 893 mdp->smbmd_size = (uint64_t)m.smbmdev_extsize; 894 mdp->smbmd_size *= 1024 * 1024; /* convert MB to bytes */ 895 } else if (m.smbmdev_size != 0xFFFF) { 896 mdp->smbmd_size = (uint64_t)(m.smbmdev_size & ~SMB_MDS_KBYTES); 897 if (m.smbmdev_size & SMB_MDS_KBYTES) 898 mdp->smbmd_size *= 1024; 899 else 900 mdp->smbmd_size *= 1024 * 1024; 901 } else 902 mdp->smbmd_size = -1ULL; /* size unknown */ 903 904 mdp->smbmd_form = m.smbmdev_form; 905 mdp->smbmd_set = m.smbmdev_set; 906 mdp->smbmd_type = m.smbmdev_type; 907 mdp->smbmd_speed = m.smbmdev_speed; 908 mdp->smbmd_flags = m.smbmdev_flags; 909 mdp->smbmd_dloc = smb_strptr(stp, m.smbmdev_dloc); 910 mdp->smbmd_bloc = smb_strptr(stp, m.smbmdev_bloc); 911 912 if (smb_libgteq(shp, SMB_VERSION_26)) { 913 mdp->smbmd_rank = m.smbmdev_attrs & 0x0F; 914 } 915 916 if (smb_libgteq(shp, SMB_VERSION_27)) { 917 mdp->smbmd_clkspeed = m.smbmdev_clkspeed; 918 } 919 920 if (smb_libgteq(shp, SMB_VERSION_28)) { 921 mdp->smbmd_minvolt = m.smbmdev_minvolt; 922 mdp->smbmd_maxvolt = m.smbmdev_maxvolt; 923 mdp->smbmd_confvolt = m.smbmdev_confvolt; 924 } 925 926 return (0); 927 } 928 929 int 930 smbios_info_memdevmap(smbios_hdl_t *shp, id_t id, smbios_memdevmap_t *mdp) 931 { 932 const smb_struct_t *stp = smb_lookup_id(shp, id); 933 smb_memdevmap_t m; 934 935 if (stp == NULL) 936 return (-1); /* errno is set for us */ 937 938 if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMDEVICEMAP) 939 return (smb_set_errno(shp, ESMB_TYPE)); 940 941 smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m)); 942 bzero(mdp, sizeof (smbios_memdevmap_t)); 943 944 mdp->smbmdm_device = m.smbdmap_device; 945 mdp->smbmdm_arrmap = m.smbdmap_array; 946 mdp->smbmdm_rpos = m.smbdmap_rpos; 947 mdp->smbmdm_ipos = m.smbdmap_ipos; 948 mdp->smbmdm_idepth = m.smbdmap_idepth; 949 950 if (m.smbdmap_start != 0xFFFFFFFF && m.smbdmap_end != 0xFFFFFFFF) { 951 mdp->smbmdm_addr = (uint64_t)m.smbdmap_start * 1024; 952 mdp->smbmdm_size = (uint64_t) 953 (m.smbdmap_end - m.smbdmap_start + 1) * 1024; 954 } else if (m.smbdmap_extstart != 0 && m.smbdmap_extend != 0) { 955 mdp->smbmdm_addr = m.smbdmap_extstart; 956 mdp->smbmdm_size = m.smbdmap_extend - m.smbdmap_extstart + 1; 957 } 958 959 return (0); 960 } 961 962 id_t 963 smbios_info_hwsec(smbios_hdl_t *shp, smbios_hwsec_t *hsp) 964 { 965 const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_SECURITY); 966 smb_hwsec_t hs; 967 968 if (stp == NULL) 969 return (-1); /* errno is set for us */ 970 971 smb_info_bcopy(stp->smbst_hdr, &hs, sizeof (hs)); 972 bzero(hsp, sizeof (smbios_hwsec_t)); 973 974 hsp->smbh_pwr_ps = SMB_HWS_PWR_PS(hs.smbhs_settings); 975 hsp->smbh_kbd_ps = SMB_HWS_KBD_PS(hs.smbhs_settings); 976 hsp->smbh_adm_ps = SMB_HWS_ADM_PS(hs.smbhs_settings); 977 hsp->smbh_pan_ps = SMB_HWS_PAN_PS(hs.smbhs_settings); 978 979 return (stp->smbst_hdr->smbh_hdl); 980 } 981 982 id_t 983 smbios_info_boot(smbios_hdl_t *shp, smbios_boot_t *bp) 984 { 985 const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_BOOT); 986 const smb_boot_t *b = (smb_boot_t *)(uintptr_t)stp->smbst_hdr; 987 988 if (stp == NULL) 989 return (-1); /* errno is set for us */ 990 991 bzero(bp, sizeof (smbios_boot_t)); 992 993 bp->smbt_status = b->smbbo_status[0]; 994 bp->smbt_size = stp->smbst_hdr->smbh_len - sizeof (smb_boot_t); 995 bp->smbt_data = bp->smbt_size ? &b->smbbo_status[1] : NULL; 996 997 return (stp->smbst_hdr->smbh_hdl); 998 } 999 1000 id_t 1001 smbios_info_ipmi(smbios_hdl_t *shp, smbios_ipmi_t *ip) 1002 { 1003 const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_IPMIDEV); 1004 smb_ipmi_t i; 1005 1006 if (stp == NULL) 1007 return (-1); /* errno is set for us */ 1008 1009 smb_info_bcopy(stp->smbst_hdr, &i, sizeof (i)); 1010 bzero(ip, sizeof (smbios_ipmi_t)); 1011 1012 ip->smbip_type = i.smbipm_type; 1013 ip->smbip_vers.smbv_major = SMB_IPM_SPEC_MAJOR(i.smbipm_spec); 1014 ip->smbip_vers.smbv_minor = SMB_IPM_SPEC_MINOR(i.smbipm_spec); 1015 ip->smbip_i2c = i.smbipm_i2c; 1016 ip->smbip_addr = i.smbipm_addr & ~SMB_IPM_ADDR_IO; 1017 ip->smbip_intr = i.smbipm_intr; 1018 1019 if (i.smbipm_bus != (uint8_t)-1) 1020 ip->smbip_bus = i.smbipm_bus; 1021 else 1022 ip->smbip_bus = -1u; 1023 1024 if (SMB_IPM_INFO_LSB(i.smbipm_info)) 1025 ip->smbip_addr |= 1; /* turn on least-significant bit of addr */ 1026 1027 if (i.smbipm_addr & SMB_IPM_ADDR_IO) { 1028 switch (SMB_IPM_INFO_REGS(i.smbipm_info)) { 1029 case SMB_IPM_REGS_1B: 1030 ip->smbip_regspacing = 1; 1031 break; 1032 case SMB_IPM_REGS_4B: 1033 ip->smbip_regspacing = 4; 1034 break; 1035 case SMB_IPM_REGS_16B: 1036 ip->smbip_regspacing = 16; 1037 break; 1038 default: 1039 ip->smbip_regspacing = 1; 1040 } 1041 ip->smbip_flags |= SMB_IPMI_F_IOADDR; 1042 } 1043 1044 if (SMB_IPM_INFO_ISPEC(i.smbipm_info)) 1045 ip->smbip_flags |= SMB_IPMI_F_INTRSPEC; 1046 1047 if (SMB_IPM_INFO_IPOL(i.smbipm_info) == SMB_IPM_IPOL_HI) 1048 ip->smbip_flags |= SMB_IPMI_F_INTRHIGH; 1049 1050 if (SMB_IPM_INFO_IMODE(i.smbipm_info) == SMB_IPM_IMODE_EDGE) 1051 ip->smbip_flags |= SMB_IPMI_F_INTREDGE; 1052 1053 return (stp->smbst_hdr->smbh_hdl); 1054 } 1055 1056 static boolean_t 1057 smbios_has_oemstr(smbios_hdl_t *shp, const char *oemstr) 1058 { 1059 const smb_struct_t *stp = shp->sh_structs; 1060 smb_strtab_t s; 1061 int i, j; 1062 1063 for (i = 0; i < shp->sh_nstructs; i++, stp++) { 1064 if (stp->smbst_hdr->smbh_type != SMB_TYPE_OEMSTR) 1065 continue; 1066 1067 smb_info_bcopy(stp->smbst_hdr, &s, sizeof (s)); 1068 for (j = 0; j < s.smbtb_count; j++) 1069 if (strcmp(smb_strptr(stp, j + 1), oemstr) == 0) 1070 return (B_TRUE); 1071 } 1072 1073 return (B_FALSE); 1074 } 1075 1076 static const char * 1077 smb_serial_valid(const char *serial) 1078 { 1079 char buf[MAXNAMELEN]; 1080 int i = 0; 1081 1082 if (serial == NULL) 1083 return (NULL); 1084 1085 (void) strlcpy(buf, serial, sizeof (buf)); 1086 1087 while (buf[i] != '\0' && buf[i] == ' ') 1088 i++; 1089 1090 if (buf[i] == '\0' || strstr(buf, SMB_DEFAULT1) != NULL || 1091 strstr(buf, SMB_DEFAULT2) != NULL) 1092 return (NULL); 1093 1094 return (serial); 1095 } 1096 1097 /* 1098 * Get chassis SN or product SN 1099 */ 1100 static int 1101 smb_get_sn(smbios_hdl_t *shp, const char **psnp, const char **csnp) 1102 { 1103 const smb_struct_t *stp; 1104 smbios_info_t s1, s3; 1105 1106 if (psnp == NULL || csnp == NULL) 1107 return (smb_set_errno(shp, ESMB_INVAL)); 1108 1109 *psnp = *csnp = NULL; 1110 1111 /* 1112 * If SMBIOS meets Sun's PRMS requirements, retrieve product SN 1113 * from type 1 structure, and chassis SN from type 3 structure. 1114 * Otherwise return SN in type 1 structure as chassis SN. 1115 */ 1116 1117 /* Get type 1 SN */ 1118 if ((stp = smb_lookup_type(shp, SMB_TYPE_SYSTEM)) == NULL || 1119 smbios_info_common(shp, stp->smbst_hdr->smbh_hdl, &s1) == SMB_ERR) 1120 s1.smbi_serial = NULL; 1121 1122 /* Get type 3 SN */ 1123 if ((stp = smb_lookup_type(shp, SMB_TYPE_CHASSIS)) == NULL || 1124 smbios_info_common(shp, stp->smbst_hdr->smbh_hdl, &s3) == SMB_ERR) 1125 s3.smbi_serial = NULL; 1126 1127 if (smbios_has_oemstr(shp, SMB_PRMS1)) { 1128 *psnp = smb_serial_valid(s1.smbi_serial); 1129 *csnp = smb_serial_valid(s3.smbi_serial); 1130 } else { 1131 *csnp = smb_serial_valid(s1.smbi_serial); 1132 } 1133 1134 return (0); 1135 } 1136 1137 const char * 1138 smbios_psn(smbios_hdl_t *shp) 1139 { 1140 const char *psn, *csn; 1141 1142 return (smb_get_sn(shp, &psn, &csn) == SMB_ERR ? NULL : psn); 1143 } 1144 1145 const char * 1146 smbios_csn(smbios_hdl_t *shp) 1147 { 1148 const char *psn, *csn; 1149 1150 return (smb_get_sn(shp, &psn, &csn) == SMB_ERR ? NULL : csn); 1151 } 1152 1153 int 1154 smbios_info_extprocessor(smbios_hdl_t *shp, id_t id, 1155 smbios_processor_ext_t *epp) 1156 { 1157 const smb_struct_t *stp = smb_lookup_id(shp, id); 1158 smb_processor_ext_t *exp; 1159 1160 if (stp == NULL) 1161 return (-1); /* errno is set for us */ 1162 1163 if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_PROCESSOR) 1164 return (smb_set_errno(shp, ESMB_TYPE)); 1165 1166 exp = (smb_processor_ext_t *)(uintptr_t)stp->smbst_hdr; 1167 bzero(epp, sizeof (smbios_processor_ext_t)); 1168 1169 epp->smbpe_processor = exp->smbpre_processor; 1170 epp->smbpe_fru = exp->smbpre_fru; 1171 epp->smbpe_n = exp->smbpre_n; 1172 epp->smbpe_apicid = exp->smbpre_apicid; 1173 1174 return (0); 1175 } 1176 1177 int 1178 smbios_info_extport(smbios_hdl_t *shp, id_t id, smbios_port_ext_t *eportp) 1179 { 1180 const smb_struct_t *stp = smb_lookup_id(shp, id); 1181 smb_port_ext_t *ep; 1182 1183 if (stp == NULL) 1184 return (-1); /* errno is set for us */ 1185 1186 if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_PORT) 1187 return (smb_set_errno(shp, ESMB_TYPE)); 1188 1189 ep = (smb_port_ext_t *)(uintptr_t)stp->smbst_hdr; 1190 bzero(eportp, sizeof (smbios_port_ext_t)); 1191 1192 eportp->smbporte_chassis = ep->smbpoe_chassis; 1193 eportp->smbporte_port = ep->smbpoe_port; 1194 eportp->smbporte_dtype = ep->smbpoe_dtype; 1195 eportp->smbporte_devhdl = ep->smbpoe_devhdl; 1196 eportp->smbporte_phy = ep->smbpoe_phy; 1197 1198 return (0); 1199 } 1200 1201 int 1202 smbios_info_pciexrc(smbios_hdl_t *shp, id_t id, 1203 smbios_pciexrc_t *rcp) 1204 { 1205 const smb_struct_t *stp = smb_lookup_id(shp, id); 1206 smb_pciexrc_t rc; 1207 1208 if (stp == NULL) 1209 return (-1); /* errno is set for us */ 1210 1211 if (stp->smbst_hdr->smbh_type != SUN_OEM_PCIEXRC) 1212 return (smb_set_errno(shp, ESMB_TYPE)); 1213 1214 smb_info_bcopy(stp->smbst_hdr, &rc, sizeof (rc)); 1215 bzero(rcp, sizeof (smbios_pciexrc_t)); 1216 1217 rcp->smbpcie_bb = rc.smbpciexrc_bboard; 1218 rcp->smbpcie_bdf = rc.smbpciexrc_bdf; 1219 1220 return (0); 1221 } 1222 1223 int 1224 smbios_info_extmemarray(smbios_hdl_t *shp, id_t id, smbios_memarray_ext_t *emap) 1225 { 1226 const smb_struct_t *stp = smb_lookup_id(shp, id); 1227 smb_memarray_ext_t exma; 1228 1229 if (stp == NULL) 1230 return (-1); /* errno is set for us */ 1231 1232 if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_MEMARRAY) 1233 return (smb_set_errno(shp, ESMB_TYPE)); 1234 1235 smb_info_bcopy(stp->smbst_hdr, &exma, sizeof (exma)); 1236 bzero(emap, sizeof (smbios_memarray_ext_t)); 1237 1238 emap->smbmae_ma = exma.smbmarre_ma; 1239 emap->smbmae_comp = exma.smbmarre_component; 1240 emap->smbmae_bdf = exma.smbmarre_bdf; 1241 1242 return (0); 1243 } 1244 1245 int 1246 smbios_info_extmemdevice(smbios_hdl_t *shp, id_t id, 1247 smbios_memdevice_ext_t *emdp) 1248 { 1249 const smb_struct_t *stp = smb_lookup_id(shp, id); 1250 smb_memdevice_ext_t exmd; 1251 1252 if (stp == NULL) 1253 return (-1); /* errno is set for us */ 1254 1255 if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_MEMDEVICE) 1256 return (smb_set_errno(shp, ESMB_TYPE)); 1257 1258 smb_info_bcopy(stp->smbst_hdr, &exmd, sizeof (exmd)); 1259 bzero(emdp, sizeof (smbios_memdevice_ext_t)); 1260 1261 emdp->smbmdeve_md = exmd.smbmdeve_mdev; 1262 emdp->smbmdeve_drch = exmd.smbmdeve_dchan; 1263 emdp->smbmdeve_ncs = exmd.smbmdeve_ncs; 1264 emdp->smbmdeve_cs = exmd.smbmdeve_cs; 1265 1266 return (0); 1267 } 1268