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  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  *
  25  * pci_resource.c -- routines to retrieve available bus resources from
  26  *               the MP Spec. Table and Hotplug Resource Table
  27  */
  28 
  29 #include <sys/types.h>
  30 #include <sys/memlist.h>
  31 #include <sys/pci_impl.h>
  32 #include <sys/systm.h>
  33 #include <sys/cmn_err.h>
  34 #include <sys/acpi/acpi.h>
  35 #include <sys/acpica.h>
  36 #include "mps_table.h"
  37 #include "pcihrt.h"
  38 
  39 extern int pci_boot_debug;
  40 extern int pci_bios_maxbus;
  41 #define dprintf if (pci_boot_debug) printf
  42 
  43 static int tbl_init = 0;
  44 static uchar_t *mps_extp = NULL;
  45 static uchar_t *mps_ext_endp = NULL;
  46 static struct php_entry *hrt_hpep;
  47 static int hrt_entry_cnt = 0;
  48 static int acpi_cb_cnt = 0;
  49 
  50 static void mps_probe(void);
  51 static void acpi_pci_probe(void);
  52 static int mps_find_bus_res(int, int, struct memlist **);
  53 static void hrt_probe(void);
  54 static int hrt_find_bus_res(int, int, struct memlist **);
  55 static int acpi_find_bus_res(int, int, struct memlist **);
  56 static uchar_t *find_sig(uchar_t *cp, int len, char *sig);
  57 static int checksum(unsigned char *cp, int len);
  58 static ACPI_STATUS acpi_wr_cb(ACPI_RESOURCE *rp, void *context);
  59 void bus_res_fini(void);
  60 static void acpi_trim_bus_ranges(void);
  61 
  62 struct memlist *acpi_io_res[256];
  63 struct memlist *acpi_mem_res[256];
  64 struct memlist *acpi_pmem_res[256];
  65 struct memlist *acpi_bus_res[256];
  66 
  67 /*
  68  * -1 = attempt ACPI resource discovery
  69  *  0 = don't attempt ACPI resource discovery
  70  *  1 = ACPI resource discovery successful
  71  */
  72 volatile int acpi_resource_discovery = -1;
  73 
  74 struct memlist *
  75 find_bus_res(int bus, int type)
  76 {
  77         struct memlist *res = NULL;
  78 
  79         if (tbl_init == 0) {
  80                 tbl_init = 1;
  81                 acpi_pci_probe();
  82                 hrt_probe();
  83                 mps_probe();
  84         }
  85 
  86         if (acpi_find_bus_res(bus, type, &res) > 0)
  87                 return (res);
  88 
  89         if (hrt_find_bus_res(bus, type, &res) > 0)
  90                 return (res);
  91 
  92         (void) mps_find_bus_res(bus, type, &res);
  93         return (res);
  94 }
  95 
  96 
  97 static void
  98 acpi_pci_probe(void)
  99 {
 100         ACPI_HANDLE ah;
 101         dev_info_t *dip;
 102         int bus;
 103 
 104         if (acpi_resource_discovery == 0)
 105                 return;
 106 
 107         for (bus = 0; bus <= pci_bios_maxbus; bus++) {
 108                 /* if no dip or no ACPI handle, no resources to discover */
 109                 dip = pci_bus_res[bus].dip;
 110                 if ((dip == NULL) ||
 111                     (ACPI_FAILURE(acpica_get_handle(dip, &ah))))
 112                         continue;
 113 
 114                 (void) AcpiWalkResources(ah, "_CRS", acpi_wr_cb,
 115                     (void *)(uintptr_t)bus);
 116         }
 117 
 118         if (acpi_cb_cnt > 0) {
 119                 acpi_resource_discovery = 1;
 120                 acpi_trim_bus_ranges();
 121         }
 122 }
 123 
 124 /*
 125  * Trim overlapping bus ranges in acpi_bus_res[]
 126  * Some BIOSes report root-bridges with bus ranges that
 127  * overlap, for example:"0..255" and "8..255". Lower-numbered
 128  * ranges are trimmed by upper-numbered ranges (so "0..255" would
 129  * be trimmed to "0..7", in the example).
 130  */
 131 static void
 132 acpi_trim_bus_ranges()
 133 {
 134         struct memlist *ranges, *current;
 135         int bus;
 136 
 137         ranges = NULL;
 138 
 139         /*
 140          * Assumptions:
 141          *  - there exists at most 1 bus range entry for each bus number
 142          *  - there are no (broken) ranges that start at the same bus number
 143          */
 144         for (bus = 0; bus < 256; bus++) {
 145                 struct memlist *prev, *orig, *new;
 146                 /* skip buses with no range entry */
 147                 if ((orig = acpi_bus_res[bus]) == NULL)
 148                         continue;
 149 
 150                 /*
 151                  * create copy of existing range and overload
 152                  * 'prev' pointer to link existing to new copy
 153                  */
 154                 new = memlist_alloc();
 155                 new->ml_address = orig->ml_address;
 156                 new->ml_size = orig->ml_size;
 157                 new->ml_prev = orig;
 158 
 159                 /* sorted insertion of 'new' into ranges list */
 160                 for (current = ranges, prev = NULL; current != NULL;
 161                     prev = current, current = current->ml_next)
 162                         if (new->ml_address < current->ml_address)
 163                                 break;
 164 
 165                 if (prev == NULL) {
 166                         /* place at beginning of (possibly) empty list */
 167                         new->ml_next = ranges;
 168                         ranges = new;
 169                 } else {
 170                         /* place in list (possibly at end) */
 171                         new->ml_next = current;
 172                         prev->ml_next = new;
 173                 }
 174         }
 175 
 176         /* scan the list, perform trimming */
 177         current = ranges;
 178         while (current != NULL) {
 179                 struct memlist *next = current->ml_next;
 180 
 181                 /* done when no range above current */
 182                 if (next == NULL)
 183                         break;
 184 
 185                 /*
 186                  * trim size in original range element
 187                  * (current->ml_prev points to the original range)
 188                  */
 189                 if ((current->ml_address + current->ml_size) > next->ml_address)
 190                         current->ml_prev->ml_size =
 191                             next->ml_address - current->ml_address;
 192 
 193                 current = next;
 194         }
 195 
 196         /* discard the list */
 197         memlist_free_all(&ranges);  /* OK if ranges == NULL */
 198 }
 199 
 200 static int
 201 acpi_find_bus_res(int bus, int type, struct memlist **res)
 202 {
 203 
 204         switch (type) {
 205         case IO_TYPE:
 206                 *res = acpi_io_res[bus];
 207                 break;
 208         case MEM_TYPE:
 209                 *res = acpi_mem_res[bus];
 210                 break;
 211         case PREFETCH_TYPE:
 212                 *res = acpi_pmem_res[bus];
 213                 break;
 214         case BUSRANGE_TYPE:
 215                 *res = acpi_bus_res[bus];
 216                 break;
 217         default:
 218                 *res = NULL;
 219                 break;
 220         }
 221 
 222         /* memlist_count() treats NULL head as zero-length */
 223         return (memlist_count(*res));
 224 }
 225 
 226 void
 227 bus_res_fini(void)
 228 {
 229         int bus;
 230 
 231         for (bus = 0; bus <= pci_bios_maxbus; bus++) {
 232                 memlist_free_all(&acpi_io_res[bus]);
 233                 memlist_free_all(&acpi_mem_res[bus]);
 234                 memlist_free_all(&acpi_pmem_res[bus]);
 235                 memlist_free_all(&acpi_bus_res[bus]);
 236         }
 237 }
 238 
 239 
 240 struct memlist **
 241 rlistpp(UINT8 t, UINT8 flags, int bus)
 242 {
 243         switch (t) {
 244 
 245                 case ACPI_MEMORY_RANGE:
 246                         /* is this really the best we've got? */
 247                         if (((flags >> 1) & 0x3) == ACPI_PREFETCHABLE_MEMORY)
 248                                 return (&acpi_pmem_res[bus]);
 249                         else
 250                                 return (&acpi_mem_res[bus]);
 251 
 252                 case ACPI_IO_RANGE:     return &acpi_io_res[bus];
 253                 case ACPI_BUS_NUMBER_RANGE: return &acpi_bus_res[bus];
 254         }
 255         return ((struct memlist **)NULL);
 256 }
 257 
 258 
 259 ACPI_STATUS
 260 acpi_wr_cb(ACPI_RESOURCE *rp, void *context)
 261 {
 262         int bus = (intptr_t)context;
 263 
 264         /* ignore consumed resources */
 265         if (rp->Data.Address.ProducerConsumer == 1)
 266                 return (AE_OK);
 267 
 268         switch (rp->Type) {
 269         case ACPI_RESOURCE_TYPE_IRQ:
 270                 /* never expect to see a PCI bus produce an Interrupt */
 271                 dprintf("%s\n", "IRQ");
 272                 break;
 273 
 274         case ACPI_RESOURCE_TYPE_DMA:
 275                 /* never expect to see a PCI bus produce DMA */
 276                 dprintf("%s\n", "DMA");
 277                 break;
 278 
 279         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
 280                 dprintf("%s\n", "START_DEPENDENT");
 281                 break;
 282 
 283         case ACPI_RESOURCE_TYPE_END_DEPENDENT:
 284                 dprintf("%s\n", "END_DEPENDENT");
 285                 break;
 286 
 287         case ACPI_RESOURCE_TYPE_IO:
 288                 if (rp->Data.Io.AddressLength == 0)
 289                         break;
 290                 acpi_cb_cnt++;
 291                 memlist_insert(&acpi_io_res[bus], rp->Data.Io.Minimum,
 292                     rp->Data.Io.AddressLength);
 293                 break;
 294 
 295         case ACPI_RESOURCE_TYPE_FIXED_IO:
 296                 /* only expect to see this as a consumer */
 297                 dprintf("%s\n", "FIXED_IO");
 298                 break;
 299 
 300         case ACPI_RESOURCE_TYPE_VENDOR:
 301                 dprintf("%s\n", "VENDOR");
 302                 break;
 303 
 304         case ACPI_RESOURCE_TYPE_END_TAG:
 305                 dprintf("%s\n", "END_TAG");
 306                 break;
 307 
 308         case ACPI_RESOURCE_TYPE_MEMORY24:
 309                 /* only expect to see this as a consumer */
 310                 dprintf("%s\n", "MEMORY24");
 311                 break;
 312 
 313         case ACPI_RESOURCE_TYPE_MEMORY32:
 314                 /* only expect to see this as a consumer */
 315                 dprintf("%s\n", "MEMORY32");
 316                 break;
 317 
 318         case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
 319                 /* only expect to see this as a consumer */
 320                 dprintf("%s\n", "FIXED_MEMORY32");
 321                 break;
 322 
 323         case ACPI_RESOURCE_TYPE_ADDRESS16:
 324                 if (rp->Data.Address16.AddressLength == 0)
 325                         break;
 326                 acpi_cb_cnt++;
 327                 memlist_insert(rlistpp(rp->Data.Address16.ResourceType,
 328                     rp->Data.Address16.Info.TypeSpecific, bus),
 329                     rp->Data.Address16.Minimum,
 330                     rp->Data.Address16.AddressLength);
 331                 break;
 332 
 333         case ACPI_RESOURCE_TYPE_ADDRESS32:
 334                 if (rp->Data.Address32.AddressLength == 0)
 335                         break;
 336                 acpi_cb_cnt++;
 337                 memlist_insert(rlistpp(rp->Data.Address32.ResourceType,
 338                     rp->Data.Address32.Info.TypeSpecific, bus),
 339                     rp->Data.Address32.Minimum,
 340                     rp->Data.Address32.AddressLength);
 341                 break;
 342 
 343         case ACPI_RESOURCE_TYPE_ADDRESS64:
 344         /*
 345          * We comment out this block because we currently cannot deal with
 346          * PCI 64-bit addresses. Will revisit this when we add PCI 64-bit MMIO
 347          * support.
 348          */
 349 #if 0
 350                 if (rp->Data.Address64.AddressLength == 0)
 351                         break;
 352                 acpi_cb_cnt++;
 353                 memlist_insert(rlistpp(rp->Data.Address64.ResourceType,
 354                     rp->Data.Address64.Info.TypeSpecific, bus),
 355                     rp->Data.Address64.Minimum,
 356                     rp->Data.Address64.AddressLength);
 357 #endif
 358                 break;
 359 
 360         case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
 361 #if 0   /* Will revisit this when we add PCI 64-bit MMIO support */
 362                 if (rp->Data.ExtAddress64.AddressLength == 0)
 363                         break;
 364                 acpi_cb_cnt++;
 365                 memlist_insert(rlistpp(rp->Data.ExtAddress64.ResourceType,
 366                     rp->Data.ExtAddress64.Info.TypeSpecific, bus),
 367                     rp->Data.ExtAddress64.Minimum,
 368                     rp->Data.ExtAddress64.AddressLength);
 369 #endif
 370                 break;
 371 
 372         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 373                 /* never expect to see a PCI bus produce an Interrupt */
 374                 dprintf("%s\n", "EXTENDED_IRQ");
 375                 break;
 376 
 377         case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
 378                 /* never expect to see a PCI bus produce an GAS */
 379                 dprintf("%s\n", "GENERIC_REGISTER");
 380                 break;
 381         }
 382 
 383         return (AE_OK);
 384 }
 385 
 386 static void
 387 mps_probe()
 388 {
 389         uchar_t *extp;
 390         struct mps_fps_hdr *fpp = NULL;
 391         struct mps_ct_hdr *ctp;
 392         uintptr_t ebda_start, base_end;
 393         ushort_t ebda_seg, base_size, ext_len, base_len, base_end_seg;
 394 
 395         base_size = *((ushort_t *)(0x413));
 396         ebda_seg = *((ushort_t *)(0x40e));
 397         ebda_start = ((uint32_t)ebda_seg) << 4;
 398         if (ebda_seg != 0) {
 399                 fpp = (struct mps_fps_hdr *)find_sig(
 400                     (uchar_t *)ebda_start, 1024, "_MP_");
 401         }
 402         if (fpp == NULL) {
 403                 base_end_seg = (base_size > 512) ? 0x9FC0 : 0x7FC0;
 404                 if (base_end_seg != ebda_seg) {
 405                         base_end = ((uintptr_t)base_end_seg) << 4;
 406                         fpp = (struct mps_fps_hdr *)find_sig(
 407                             (uchar_t *)base_end, 1024, "_MP_");
 408                 }
 409         }
 410         if (fpp == NULL) {
 411                 fpp = (struct mps_fps_hdr *)find_sig(
 412                     (uchar_t *)0xF0000, 0x10000, "_MP_");
 413         }
 414 
 415         if (fpp == NULL) {
 416                 dprintf("MP Spec table doesn't exist");
 417                 return;
 418         } else {
 419                 dprintf("Found MP Floating Pointer Structure at %p\n",
 420                     (void *)fpp);
 421         }
 422 
 423         if (checksum((uchar_t *)fpp, fpp->fps_len * 16) != 0) {
 424                 dprintf("MP Floating Pointer Structure checksum error");
 425                 return;
 426         }
 427 
 428         ctp = (struct mps_ct_hdr *)(uintptr_t)fpp->fps_mpct_paddr;
 429         if (ctp->ct_sig != 0x504d4350) { /* check "PCMP" signature */
 430                 dprintf("MP Configuration Table signature is wrong");
 431                 return;
 432         }
 433 
 434         base_len = ctp->ct_len;
 435         if (checksum((uchar_t *)ctp, base_len) != 0) {
 436                 dprintf("MP Configuration Table checksum error");
 437                 return;
 438         }
 439         if (ctp->ct_spec_rev != 4) { /* not MPSpec rev 1.4 */
 440                 dprintf("MP Spec 1.1 found - extended table doesn't exist");
 441                 return;
 442         }
 443         if ((ext_len = ctp->ct_ext_tbl_len) == 0) {
 444                 dprintf("MP Spec 1.4 found - extended table doesn't exist");
 445                 return;
 446         }
 447         extp = (uchar_t *)ctp + base_len;
 448         if (((checksum(extp, ext_len) + ctp->ct_ext_cksum) & 0xFF) != 0) {
 449                 dprintf("MP Extended Table checksum error");
 450                 return;
 451         }
 452         mps_extp = extp;
 453         mps_ext_endp = mps_extp + ext_len;
 454 }
 455 
 456 
 457 static int
 458 mps_find_bus_res(int bus, int type, struct memlist **res)
 459 {
 460         struct sasm *sasmp;
 461         uchar_t *extp;
 462         int res_cnt;
 463 
 464         if (mps_extp == NULL)
 465                 return (0);
 466         extp = mps_extp;
 467         res_cnt = 0;
 468         while (extp < mps_ext_endp) {
 469                 switch (*extp) {
 470                 case SYS_AS_MAPPING:
 471                         sasmp = (struct sasm *)extp;
 472                         if (((int)sasmp->sasm_as_type) == type &&
 473                             ((int)sasmp->sasm_bus_id) == bus) {
 474                                 if (sasmp->sasm_as_base_hi != 0 ||
 475                                     sasmp->sasm_as_len_hi != 0) {
 476                                         printf("64 bits address space\n");
 477                                         extp += SYS_AS_MAPPING_SIZE;
 478                                         break;
 479                                 }
 480                                 memlist_insert(res,
 481                                     (uint64_t)sasmp->sasm_as_base,
 482                                     sasmp->sasm_as_len);
 483                                 res_cnt++;
 484                         }
 485                         extp += SYS_AS_MAPPING_SIZE;
 486                         break;
 487                 case BUS_HIERARCHY_DESC:
 488                         extp += BUS_HIERARCHY_DESC_SIZE;
 489                         break;
 490                 case COMP_BUS_AS_MODIFIER:
 491                         extp += COMP_BUS_AS_MODIFIER_SIZE;
 492                         break;
 493                 default:
 494                         cmn_err(CE_WARN, "Unknown descriptor type %d"
 495                             " in BIOS Multiprocessor Spec table.",
 496                             *extp);
 497                         while (*res) {
 498                                 struct memlist *tmp = *res;
 499                                 *res = tmp->ml_next;
 500                                 memlist_free(tmp);
 501                         }
 502                         return (0);
 503                 }
 504         }
 505         return (res_cnt);
 506 }
 507 
 508 static void
 509 hrt_probe()
 510 {
 511         struct hrt_hdr *hrtp;
 512 
 513         dprintf("search PCI Hot-Plug Resource Table starting at 0xF0000\n");
 514         if ((hrtp = (struct hrt_hdr *)find_sig((uchar_t *)0xF0000,
 515             0x10000, "$HRT")) == NULL) {
 516                 dprintf("NO PCI Hot-Plug Resource Table");
 517                 return;
 518         }
 519         dprintf("Found PCI Hot-Plug Resource Table at %p\n", (void *)hrtp);
 520         if (hrtp->hrt_ver != 1) {
 521                 dprintf("PCI Hot-Plug Resource Table version no. <> 1\n");
 522                 return;
 523         }
 524         hrt_entry_cnt = (int)hrtp->hrt_entry_cnt;
 525         dprintf("No. of PCI hot-plug slot entries = 0x%x\n", hrt_entry_cnt);
 526         hrt_hpep = (struct php_entry *)(hrtp + 1);
 527 }
 528 
 529 static int
 530 hrt_find_bus_res(int bus, int type, struct memlist **res)
 531 {
 532         int res_cnt, i;
 533         struct php_entry *hpep;
 534 
 535         if (hrt_hpep == NULL || hrt_entry_cnt == 0)
 536                 return (0);
 537         hpep = hrt_hpep;
 538         res_cnt = 0;
 539         for (i = 0; i < hrt_entry_cnt; i++, hpep++) {
 540                 if (hpep->php_pri_bus != bus)
 541                         continue;
 542                 if (type == IO_TYPE) {
 543                         if (hpep->php_io_start == 0 || hpep->php_io_size == 0)
 544                                 continue;
 545                         memlist_insert(res, (uint64_t)hpep->php_io_start,
 546                             (uint64_t)hpep->php_io_size);
 547                         res_cnt++;
 548                 } else if (type == MEM_TYPE) {
 549                         if (hpep->php_mem_start == 0 || hpep->php_mem_size == 0)
 550                                 continue;
 551                         memlist_insert(res,
 552                             (uint64_t)(((int)hpep->php_mem_start) << 16),
 553                             (uint64_t)(((int)hpep->php_mem_size) << 16));
 554                         res_cnt++;
 555                 } else if (type == PREFETCH_TYPE) {
 556                         if (hpep->php_pfmem_start == 0 ||
 557                             hpep->php_pfmem_size == 0)
 558                                 continue;
 559                         memlist_insert(res,
 560                             (uint64_t)(((int)hpep->php_pfmem_start) << 16),
 561                             (uint64_t)(((int)hpep->php_pfmem_size) << 16));
 562                         res_cnt++;
 563                 }
 564         }
 565         return (res_cnt);
 566 }
 567 
 568 static uchar_t *
 569 find_sig(uchar_t *cp, int len, char *sig)
 570 {
 571         long i;
 572 
 573         /* Search for the "_MP_"  or "$HRT" signature */
 574         for (i = 0; i < len; i += 16) {
 575                 if (cp[0] == sig[0] && cp[1] == sig[1] &&
 576                     cp[2] == sig[2] && cp[3] == sig[3])
 577                         return (cp);
 578                 cp += 16;
 579         }
 580         return (NULL);
 581 }
 582 
 583 static int
 584 checksum(unsigned char *cp, int len)
 585 {
 586         int i;
 587         unsigned int cksum;
 588 
 589         for (i = cksum = 0; i < len; i++)
 590                 cksum += (unsigned int) *cp++;
 591 
 592         return ((int)(cksum & 0xFF));
 593 }
 594 
 595 #ifdef UNUSED_BUS_HIERARY_INFO
 596 
 597 /*
 598  * At this point, the bus hierarchy entries do not appear to
 599  * provide anything we can't find out from PCI config space.
 600  * The only interesting bit is the ISA bus number, which we
 601  * don't care.
 602  */
 603 int
 604 mps_find_parent_bus(int bus)
 605 {
 606         struct sasm *sasmp;
 607         uchar_t *extp;
 608 
 609         if (mps_extp == NULL)
 610                 return (-1);
 611 
 612         extp = mps_extp;
 613         while (extp < mps_ext_endp) {
 614                 bhdp = (struct bhd *)extp;
 615                 switch (*extp) {
 616                 case SYS_AS_MAPPING:
 617                         extp += SYS_AS_MAPPING_SIZE;
 618                         break;
 619                 case BUS_HIERARCHY_DESC:
 620                         if (bhdp->bhd_bus_id == bus)
 621                                 return (bhdp->bhd_parent);
 622                         extp += BUS_HIERARCHY_DESC_SIZE;
 623                         break;
 624                 case COMP_BUS_AS_MODIFIER:
 625                         extp += COMP_BUS_AS_MODIFIER_SIZE;
 626                         break;
 627                 default:
 628                         cmn_err(CE_WARN, "Unknown descriptor type %d"
 629                             " in BIOS Multiprocessor Spec table.",
 630                             *extp);
 631                         return (-1);
 632                 }
 633         }
 634         return (-1);
 635 }
 636 
 637 int
 638 hrt_find_bus_range(int bus)
 639 {
 640         int i, max_bus, sub_bus;
 641         struct php_entry *hpep;
 642 
 643         if (hrt_hpep == NULL || hrt_entry_cnt == 0) {
 644                 return (-1);
 645         }
 646         hpep = hrt_hpep;
 647         max_bus = -1;
 648         for (i = 0; i < hrt_entry_cnt; i++, hpep++) {
 649                 if (hpep->php_pri_bus != bus)
 650                         continue;
 651                 sub_bus = (int)hpep->php_subord_bus;
 652                 if (sub_bus > max_bus)
 653                         max_bus = sub_bus;
 654         }
 655         return (max_bus);
 656 }
 657 
 658 #endif /* UNUSED_BUS_HIERARY_INFO */