rom/usb/pciusb/pci_aros.c

   1 /* pci_aros.c - pci access abstraction for AROS by Chris Hodges
   2 */
   3
   4 #include <aros/bootloader.h>
   5 #include <aros/symbolsets.h>
   6 #include <exec/types.h>
   7 #include <oop/oop.h>
   8 #include <devices/timer.h>
   9 #include <hidd/hidd.h>
  10 #include <hidd/pci.h>
  11 #include <resources/acpi.h>
  12
  13 #include <proto/acpi.h>
  14 #include <proto/bootloader.h>
  15 #include <proto/oop.h>
  16 #include <proto/utility.h>
  17 #include <proto/exec.h>
  18
  19 #include <inttypes.h>
  20 #include <string.h>
  21
  22 #include "uhwcmd.h"
  23 #include "ohciproto.h"
  24
  25 #ifdef __i386__
  26 #define HAVE_ACPI
  27 #endif
  28 #ifdef __x86_64__
  29 #define HAVE_ACPI
  30 #endif
  31
  32 #define NewList NEWLIST
  33
  34 #undef HiddPCIDeviceAttrBase
  35 //#undef HiddUSBDeviceAttrBase
  36 //#undef HiddUSBHubAttrBase
  37 //#undef HiddUSBDrvAttrBase
  38 #undef HiddAttrBase
  39
  40 #define HiddPCIDeviceAttrBase (hd->hd_HiddPCIDeviceAB)
  41 //#define HiddUSBDeviceAttrBase (hd->hd_HiddUSBDeviceAB)
  42 //#define HiddUSBHubAttrBase (hd->hd_HiddUSBHubAB)
  43 //#define HiddUSBDrvAttrBase (hd->hd_HiddUSBDrvAB)
  44 #define HiddAttrBase (hd->hd_HiddAB)
  45
  46 AROS_UFH3(void, pciEnumerator,
  47           AROS_UFHA(struct Hook *, hook, A0),
  48           AROS_UFHA(OOP_Object *, pciDevice, A2),
  49           AROS_UFHA(APTR, message, A1))
  50 {
  51     AROS_USERFUNC_INIT
  52
  53     struct PCIDevice *hd = (struct PCIDevice *) hook->h_Data;
  54     struct PCIController *hc;
  55     IPTR hcitype;
  56     IPTR bus;
  57     IPTR dev;
  58     IPTR sub;
  59     IPTR intline;
  60     ULONG devid;
  61
  62     OOP_GetAttr(pciDevice, aHidd_PCIDevice_Interface, &hcitype);
  63     OOP_GetAttr(pciDevice, aHidd_PCIDevice_Bus, &bus);
  64     OOP_GetAttr(pciDevice, aHidd_PCIDevice_Dev, &dev);
  65     OOP_GetAttr(pciDevice, aHidd_PCIDevice_Sub, &sub);
  66     OOP_GetAttr(pciDevice, aHidd_PCIDevice_INTLine, &intline);
  67
  68     devid = (bus<<16)|dev;
  69
  70     KPRINTF(10, ("Found PCI device 0x%lx of type %ld, Intline=%ld\n", devid, hcitype, intline));
  71
  72     if(intline == 255)
  73     {
  74         // we can't work without the correct interrupt line
  75         // BIOS needs plug & play os option disabled. Alternatively AROS must support APIC reconfiguration
  76         KPRINTF(200, ("ERROR: PCI card has no interrupt line assigned by BIOS, disable Plug & Play OS!\n"));
  77     }
  78     else
  79     {
  80         switch (hcitype)
  81         {
  82         case HCITYPE_OHCI:
  83         case HCITYPE_EHCI:
  84         case HCITYPE_UHCI:
  85 #ifdef AROS_USB30_CODE
  86         case HCITYPE_XHCI:
  87 #endif
  88             KPRINTF(10, ("Setting up device...\n"));
  89
  90             hc = AllocPooled(hd->hd_MemPool, sizeof(struct PCIController));
  91             if (hc)
  92             {
  93                 hc->hc_Device = hd;
  94                 hc->hc_DevID = devid;
  95                 hc->hc_FunctionNum = sub;
  96                 hc->hc_HCIType = hcitype;
  97                 hc->hc_PCIDeviceObject = pciDevice;
  98                 hc->hc_PCIIntLine = intline;
  99
 100                 OOP_GetAttr(pciDevice, aHidd_PCIDevice_Driver, (IPTR *) &hc->hc_PCIDriverObject);
 101
 102                 NewList(&hc->hc_CtrlXFerQueue);
 103                 NewList(&hc->hc_IntXFerQueue);
 104                 NewList(&hc->hc_IsoXFerQueue);
 105                 NewList(&hc->hc_BulkXFerQueue);
 106                 NewList(&hc->hc_TDQueue);
 107                 NewList(&hc->hc_AbortQueue);
 108                 NewList(&hc->hc_PeriodicTDQueue);
 109                 NewList(&hc->hc_OhciRetireQueue);
 110                 AddTail(&hd->hd_TempHCIList, &hc->hc_Node);
 111             }
 112             break;
 113
 114         default:
 115             KPRINTF(10, ("Unsupported HCI type %ld\n", hcitype));
 116         }
 117     }
 118
 119     AROS_USERFUNC_EXIT
 120 }
 121
 122 /* /// "pciInit()" */
 123 BOOL pciInit(struct PCIDevice *hd)
 124 {
 125     struct PCIController *hc;
 126     struct PCIController *nexthc;
 127     struct PCIUnit *hu;
 128     ULONG unitno = 0;
 129
 130     KPRINTF(10, ("*** pciInit(%p) ***\n", hd));
 131 /*  if(sizeof(IPTR) > 4)
 132     {
 133         KPRINTF(200, ("I said the pciusb.device is not 64bit compatible right now. Go away!\n"));
 134         return FALSE;
 135     }*/
 136
 137     NewList(&hd->hd_TempHCIList);
 138
 139     if((hd->hd_PCIHidd = OOP_NewObject(NULL, (STRPTR) CLID_Hidd_PCI, NULL)))
 140     {
 141         struct TagItem tags[] =
 142         {
 143             { tHidd_PCI_Class,      (PCI_CLASS_SERIAL_USB>>8) & 0xff },
 144             { tHidd_PCI_SubClass,   (PCI_CLASS_SERIAL_USB & 0xff) },
 145             { TAG_DONE, 0UL }
 146         };
 147
 148         struct OOP_ABDescr attrbases[] =
 149         {
 150             { (STRPTR) IID_Hidd,            &hd->hd_HiddAB },
 151             { (STRPTR) IID_Hidd_PCIDevice,  &hd->hd_HiddPCIDeviceAB },
 152             { NULL, NULL }
 153         };
 154
 155         struct Hook findHook =
 156         {
 157              h_Entry:        (IPTR (*)()) pciEnumerator,
 158              h_Data:         hd,
 159         };
 160
 161         OOP_ObtainAttrBases(attrbases);
 162
 163         KPRINTF(20, ("Searching for devices...\n"));
 164
 165         HIDD_PCI_EnumDevices(hd->hd_PCIHidd, &findHook, (struct TagItem *) &tags);
 166     } else {
 167         KPRINTF(20, ("Unable to create PCIHidd object!\n"));
 168         return FALSE;
 169     }
 170
 171     // Create units with a list of host controllers having the same bus and device number.
 172     while(hd->hd_TempHCIList.lh_Head->ln_Succ)
 173     {
 174         hu = AllocPooled(hd->hd_MemPool, sizeof(struct PCIUnit));
 175         if(!hu)
 176         {
 177             // actually, we should get rid of the allocated memory first, but I don't care as DeletePool() will take care of this eventually
 178             return FALSE;
 179         }
 180         hu->hu_Device = hd;
 181         hu->hu_UnitNo = unitno;
 182         hu->hu_DevID = ((struct PCIController *) hd->hd_TempHCIList.lh_Head)->hc_DevID;
 183
 184         NewList(&hu->hu_Controllers);
 185         NewList(&hu->hu_RHIOQueue);
 186
 187         hc = (struct PCIController *) hd->hd_TempHCIList.lh_Head;
 188         while((nexthc = (struct PCIController *) hc->hc_Node.ln_Succ))
 189         {
 190             if(hc->hc_DevID == hu->hu_DevID)
 191             {
 192                 Remove(&hc->hc_Node);
 193                 hc->hc_Unit = hu;
 194                 AddTail(&hu->hu_Controllers, &hc->hc_Node);
 195             }
 196             hc = nexthc;
 197         }
 198         AddTail(&hd->hd_Units, (struct Node *) hu);
 199         unitno++;
 200     }
 201     return TRUE;
 202 }
 203 /* \\\ */
 204
 205 /* /// "PCIXReadConfigByte()" */
 206 UBYTE PCIXReadConfigByte(struct PCIController *hc, UBYTE offset)
 207 {
 208     struct pHidd_PCIDevice_ReadConfigByte msg;
 209
 210     msg.mID = OOP_GetMethodID(CLID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigByte);
 211     msg.reg = offset;
 212
 213     return OOP_DoMethod(hc->hc_PCIDeviceObject, (OOP_Msg) &msg);
 214 }
 215 /* \\\ */
 216
 217 /* /// "PCIXReadConfigWord()" */
 218 UWORD PCIXReadConfigWord(struct PCIController *hc, UBYTE offset)
 219 {
 220     struct pHidd_PCIDevice_ReadConfigWord msg;
 221
 222     msg.mID = OOP_GetMethodID(CLID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigWord);
 223     msg.reg = offset;
 224
 225     return OOP_DoMethod(hc->hc_PCIDeviceObject, (OOP_Msg) &msg);
 226 }
 227 /* \\\ */
 228
 229 /* /// "PCIXReadConfigLong()" */
 230 ULONG PCIXReadConfigLong(struct PCIController *hc, UBYTE offset)
 231 {
 232     struct pHidd_PCIDevice_ReadConfigLong msg;
 233
 234     msg.mID = OOP_GetMethodID(CLID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigLong);
 235     msg.reg = offset;
 236
 237     return OOP_DoMethod(hc->hc_PCIDeviceObject, (OOP_Msg) &msg);
 238 }
 239 /* \\\ */
 240
 241 /* /// "PCIXWriteConfigByte()" */
 242 void PCIXWriteConfigByte(struct PCIController *hc, ULONG offset, UBYTE value)
 243 {
 244     struct pHidd_PCIDevice_WriteConfigByte msg;
 245
 246     msg.mID = OOP_GetMethodID(CLID_Hidd_PCIDevice, moHidd_PCIDevice_WriteConfigByte);
 247     msg.reg = offset;
 248     msg.val = value;
 249
 250     OOP_DoMethod(hc->hc_PCIDeviceObject, (OOP_Msg) &msg);
 251 }
 252 /* \\\ */
 253
 254 /* /// "PCIXWriteConfigWord()" */
 255 void PCIXWriteConfigWord(struct PCIController *hc, ULONG offset, UWORD value)
 256 {
 257     struct pHidd_PCIDevice_WriteConfigWord msg;
 258
 259     msg.mID = OOP_GetMethodID(CLID_Hidd_PCIDevice, moHidd_PCIDevice_WriteConfigWord);
 260     msg.reg = offset;
 261     msg.val = value;
 262
 263     OOP_DoMethod(hc->hc_PCIDeviceObject, (OOP_Msg) &msg);
 264 }
 265 /* \\\ */
 266
 267 /* /// "PCIXWriteConfigLong()" */
 268 void PCIXWriteConfigLong(struct PCIController *hc, ULONG offset, ULONG value)
 269 {
 270     struct pHidd_PCIDevice_WriteConfigLong msg;
 271
 272     msg.mID = OOP_GetMethodID(CLID_Hidd_PCIDevice, moHidd_PCIDevice_WriteConfigLong);
 273     msg.reg = offset;
 274     msg.val = value;
 275
 276     OOP_DoMethod(hc->hc_PCIDeviceObject, (OOP_Msg) &msg);
 277 }
 278 /* \\\ */
 279
 280 /* /// "pciStrcat()" */
 281 void pciStrcat(STRPTR d, STRPTR s)
 282 {
 283     while(*d) d++;
 284     while((*d++ = *s++));
 285 }
 286 /* \\\ */
 287
 288 /* /// "pciAllocUnit()" */
 289 BOOL pciAllocUnit(struct PCIUnit *hu)
 290 {
 291 #if 0
 292     struct PCIDevice *hd = hu->hu_Device;
 293 #endif
 294     struct PCIController *hc;
 295
 296     BOOL allocgood = TRUE;
 297     ULONG usb11ports = 0;
 298     ULONG usb20ports = 0;
 299 #ifdef AROS_USB30_CODE
 300     ULONG usb30ports = 0;
 301 #endif
 302     ULONG cnt;
 303
 304     ULONG ohcicnt = 0;
 305     ULONG uhcicnt = 0;
 306     ULONG ehcicnt = 0;
 307 #ifdef AROS_USB30_CODE
 308     ULONG xhcicnt = 0;
 309 #endif
 310
 311     STRPTR prodname;
 312
 313     KPRINTF(10, ("*** pciAllocUnit(%p) ***\n", hu));
 314
 315 #if 0 // FIXME this needs to be replaced by something AROS supports
 316     hc = (struct PCIController *) hu->hu_Controllers.lh_Head;
 317     while(hc->hc_Node.ln_Succ)
 318     {
 319         PCIXObtainBoard(hc->hc_BoardObject);
 320         if (PCIXSetBoardAttr(hc->hc_BoardObject, PCIXTAG_OWNER, (ULONG) hd->hd_Library.lib_Node.ln_Name))
 321             hc->hc_Flags |= HCF_BOARD_ALLOCATED;
 322         else
 323         {
 324             KPRINTF(20, ("Couldn't allocate board, already allocated by %s\n", PCIXGetBoardAttr(hc->hc_BoardObject, PCIXTAG_OWNER)));
 325             allocgood = FALSE;
 326         }
 327         PCIXReleaseBoard(hc->hc_BoardObject);
 328
 329         hc = (struct PCIController *) hc->hc_Node.ln_Succ;
 330     }
 331
 332     if(allocgood)
 333     {
 334 #endif
 335         // allocate necessary memory
 336         hc = (struct PCIController *) hu->hu_Controllers.lh_Head;
 337         while(hc->hc_Node.ln_Succ)
 338         {
 339             switch(hc->hc_HCIType)
 340             {
 341                 case HCITYPE_UHCI:
 342                 {
 343                     allocgood = uhciInit(hc,hu);
 344                     if(allocgood) {
 345                         uhcicnt++;
 346                     }
 347                     break;
 348                 }
 349
 350                 case HCITYPE_OHCI:
 351                 {
 352                     allocgood = ohciInit(hc,hu);
 353                     if(allocgood) {
 354                         ohcicnt++;
 355                     }
 356                     break;
 357                 }
 358
 359                 case HCITYPE_EHCI:
 360                 {
 361                     allocgood = ehciInit(hc,hu);
 362                     if(allocgood) {
 363                         ehcicnt++;
 364                         if(usb20ports) {
 365                             KPRINTF(200, ("WARNING: More than one EHCI controller per board?!?\n"));
 366                         }
 367                         usb20ports = hc->hc_NumPorts;
 368
 369                         for(cnt = 0; cnt < usb20ports; cnt++) {
 370                             hu->hu_PortMap20[cnt] = hc;
 371                             hc->hc_PortNum20[cnt] = cnt;
 372                         }
 373                     }
 374                     break;
 375                 }
 376 #ifdef AROS_USB30_CODE
 377                 case HCITYPE_XHCI:
 378                 {
 379                     allocgood = xhciInit(hc,hu);
 380                     if(allocgood) {
 381                         xhcicnt++;
 382                         if(usb30ports) {
 383                             KPRINTF(200, ("WARNING: More than one XHCI controller per board?!?\n"));
 384                         }
 385                         usb20ports = hc->xhc_NumPorts20;
 386                         usb30ports = hc->xhc_NumPorts30;
 387                     }
 388                     break;
 389                 }
 390 #endif
 391             }
 392             hc = (struct PCIController *) hc->hc_Node.ln_Succ;
 393         }
 394 #if 0 // FIXME this needs to be replaced by something AROS supports
 395     }
 396
 397     if(!allocgood)
 398     {
 399         // free previously allocated boards
 400         hc = (struct PCIController *) hu->hu_Controllers.lh_Head;
 401         while(hc->hc_Node.ln_Succ)
 402         {
 403             PCIXObtainBoard(hc->hc_BoardObject);
 404             if (hc->hc_Flags & HCF_ALLOCATED)
 405             {
 406                 hc->hc_Flags &= ~HCF_ALLOCATED;
 407                 PCIXSetBoardAttr(hc->hc_BoardObject, PCIXTAG_OWNER, 0);
 408             }
 409             PCIXReleaseBoard(hc->hc_BoardObject);
 410
 411             hc = (struct PCIController *) hc->hc_Node.ln_Succ;
 412         }
 413 #else
 414     if(!allocgood)
 415     {
 416 #endif
 417         return FALSE;
 418     }
 419
 420     hc = (struct PCIController *) hu->hu_Controllers.lh_Head;
 421     while(hc->hc_Node.ln_Succ)
 422     {
 423         if((hc->hc_HCIType == HCITYPE_UHCI) || (hc->hc_HCIType == HCITYPE_OHCI))
 424         {
 425             if(hc->hc_complexrouting)
 426             {
 427                 ULONG locport = 0;
 428                 for(cnt = 0; cnt < usb20ports; cnt++)
 429                 {
 430                     if(((hc->hc_portroute >> (cnt<<2)) & 0xf) == hc->hc_FunctionNum)
 431                     {
 432                         KPRINTF(10, ("CHC %ld Port %ld assigned to global Port %ld\n", hc->hc_FunctionNum, locport, cnt));
 433                         hu->hu_PortMap11[cnt] = hc;
 434                         hu->hu_PortNum11[cnt] = locport;
 435                         hc->hc_PortNum20[locport] = cnt;
 436                         locport++;
 437                     }
 438                 }
 439             } else {
 440                 for(cnt = usb11ports; cnt < usb11ports + hc->hc_NumPorts; cnt++)
 441                 {
 442                     hu->hu_PortMap11[cnt] = hc;
 443                     hu->hu_PortNum11[cnt] = cnt - usb11ports;
 444                     hc->hc_PortNum20[cnt - usb11ports] = cnt;
 445                 }
 446             }
 447             usb11ports += hc->hc_NumPorts;
 448         }
 449         hc = (struct PCIController *) hc->hc_Node.ln_Succ;
 450     }
 451     if((usb11ports != usb20ports) && usb20ports)
 452     {
 453         KPRINTF(20, ("Warning! #EHCI Ports (%ld) does not match USB 1.1 Ports (%ld)!\n", usb20ports, usb11ports));
 454     }
 455
 456     hu->hu_RootHub11Ports = usb11ports;
 457     hu->hu_RootHub20Ports = usb20ports;
 458 #ifdef AROS_USB30_CODE
 459 // FIXME: This is probably wrong as well...
 460     hu->hu_RootHub30Ports = usb30ports;
 461     hu->hu_RootHubPorts = (usb11ports > usb20ports) ? ((usb11ports > usb30ports) ? usb11ports : usb30ports) : ((usb30ports > usb20ports) ? usb30ports : usb20ports);
 462 #else
 463     hu->hu_RootHubPorts = (usb11ports > usb20ports) ? usb11ports : usb20ports;
 464 #endif
 465     for(cnt = 0; cnt < hu->hu_RootHubPorts; cnt++)
 466     {
 467         hu->hu_EhciOwned[cnt] = hu->hu_PortMap20[cnt] ? TRUE : FALSE;
 468     }
 469
 470 #ifdef AROS_USB30_CODE
 471     KPRINTF(1000, ("Unit %ld: USB Board %08lx has %ld USB1.1, %ld USB2.0 and %ld USB3.0 ports!\n", hu->hu_UnitNo, hu->hu_DevID, hu->hu_RootHub11Ports, hu->hu_RootHub20Ports, hu->hu_RootHub30Ports));
 472 #else
 473     KPRINTF(10, ("Unit %ld: USB Board %08lx has %ld USB1.1 and %ld USB2.0 ports!\n", hu->hu_UnitNo, hu->hu_DevID, hu->hu_RootHub11Ports, hu->hu_RootHub20Ports));
 474 #endif
 475
 476     hu->hu_FrameCounter = 1;
 477     hu->hu_RootHubAddr = 0;
 478
 479     // put em online
 480     hc = (struct PCIController *) hu->hu_Controllers.lh_Head;
 481     while(hc->hc_Node.ln_Succ)
 482     {
 483         hc->hc_Flags |= HCF_ONLINE;
 484         hc = (struct PCIController *) hc->hc_Node.ln_Succ;
 485     }
 486
 487     // create product name of device
 488     prodname = hu->hu_ProductName;
 489     *prodname = 0;
 490     pciStrcat(prodname, "PCI ");
 491     if(ohcicnt + uhcicnt)
 492     {
 493         if(ohcicnt + uhcicnt >1)
 494         {
 495             prodname[4] = ohcicnt + uhcicnt + '0';
 496             prodname[5] = 'x';
 497             prodname[6] = 0;
 498         }
 499         pciStrcat(prodname, ohcicnt ? "OHCI" : "UHCI");
 500         if(ehcicnt)
 501         {
 502             pciStrcat(prodname, " +");
 503         } else{
 504             pciStrcat(prodname, " USB 1.1");
 505         }
 506     }
 507     if(ehcicnt)
 508     {
 509         pciStrcat(prodname, " EHCI USB 2.0");
 510     }
 511 #ifdef AROS_USB30_CODE
 512     if(xhcicnt)
 513     {
 514         if(xhcicnt >1)
 515         {
 516             prodname[4] = xhcicnt + '0';
 517             prodname[5] = 'x';
 518             prodname[6] = 0;
 519         }
 520         pciStrcat(prodname, " XHCI USB 3.0");
 521     }
 522 #endif
 523 #if 0 // user can use pcitool to check what the chipset is and not guess it from this
 524     pciStrcat(prodname, " Host Controller (");
 525     if(ohcicnt + uhcicnt)
 526     {
 527         pciStrcat(prodname, ohcicnt ? "NEC)" : "VIA, Intel, ALI, etc.)");
 528     } else {
 529                 pciStrcat(prodname, "Emulated?)");
 530         }
 531 #else
 532     pciStrcat(prodname, " Host Controller");
 533 #endif
 534     KPRINTF(10, ("Unit allocated!\n"));
 535
 536     return TRUE;
 537 }
 538 /* \\\ */
 539
 540 /* /// "pciFreeUnit()" */
 541 void pciFreeUnit(struct PCIUnit *hu)
 542 {
 543     struct PCIDevice *hd = hu->hu_Device;
 544     struct PCIController *hc;
 545
 546     struct TagItem pciDeactivate[] =
 547     {
 548             { aHidd_PCIDevice_isIO,     FALSE },
 549             { aHidd_PCIDevice_isMEM,    FALSE },
 550             { aHidd_PCIDevice_isMaster, FALSE },
 551             { TAG_DONE, 0UL },
 552     };
 553
 554     KPRINTF(10, ("*** pciFreeUnit(%p) ***\n", hu));
 555
 556     // put em offline
 557     hc = (struct PCIController *) hu->hu_Controllers.lh_Head;
 558     while(hc->hc_Node.ln_Succ)
 559     {
 560         hc->hc_Flags &= ~HCF_ONLINE;
 561         hc = (struct PCIController *) hc->hc_Node.ln_Succ;
 562     }
 563
 564 #ifdef AROS_USB30_CODE
 565     xhciFree(hc, hu);
 566 #endif
 567     // doing this in three steps to avoid these damn host errors
 568     ehciFree(hc, hu);
 569     ohciFree(hc, hu);
 570     uhciFree(hc, hu);
 571
 572     //FIXME: (x/e/o/u)hciFree routines actually ONLY stops the chip NOT free anything as below...
 573     hc = (struct PCIController *) hu->hu_Controllers.lh_Head;
 574     while(hc->hc_Node.ln_Succ) {
 575         if(hc->hc_PCIMem) {
 576             HIDD_PCIDriver_FreePCIMem(hc->hc_PCIDriverObject, hc->hc_PCIMem);
 577             hc->hc_PCIMem = NULL;
 578         }
 579         hc = (struct PCIController *) hc->hc_Node.ln_Succ;
 580     }
 581
 582     // disable and free board
 583     hc = (struct PCIController *) hu->hu_Controllers.lh_Head;
 584     while(hc->hc_Node.ln_Succ)
 585     {
 586         OOP_SetAttrs(hc->hc_PCIDeviceObject, (struct TagItem *) pciDeactivate); // deactivate busmaster and IO/Mem
 587         if(hc->hc_PCIIntHandler.is_Node.ln_Name)
 588         {
 589             RemIntServer(INTB_KERNEL + hc->hc_PCIIntLine, &hc->hc_PCIIntHandler);
 590             hc->hc_PCIIntHandler.is_Node.ln_Name = NULL;
 591         }
 592 #if 0
 593
 594         PCIXObtainBoard(hc->hc_BoardObject);
 595         hc->hc_Flags &= ~HCF_ALLOCATED;
 596         PCIXSetBoardAttr(hc->hc_BoardObject, PCIXTAG_OWNER, 0);
 597         PCIXReleaseBoard(hc->hc_BoardObject);
 598 #endif
 599         hc = (struct PCIController *) hc->hc_Node.ln_Succ;
 600     }
 601 }
 602 /* \\\ */
 603
 604 /* /// "pciExpunge()" */
 605 void pciExpunge(struct PCIDevice *hd)
 606 {
 607     struct PCIController *hc;
 608     struct PCIUnit *hu;
 609
 610     KPRINTF(10, ("*** pciExpunge(%p) ***\n", hd));
 611
 612     hu = (struct PCIUnit *) hd->hd_Units.lh_Head;
 613     while(((struct Node *) hu)->ln_Succ)
 614     {
 615         Remove((struct Node *) hu);
 616         hc = (struct PCIController *) hu->hu_Controllers.lh_Head;
 617         while(hc->hc_Node.ln_Succ)
 618         {
 619             Remove(&hc->hc_Node);
 620             FreePooled(hd->hd_MemPool, hc, sizeof(struct PCIController));
 621             hc = (struct PCIController *) hu->hu_Controllers.lh_Head;
 622         }
 623         FreePooled(hd->hd_MemPool, hu, sizeof(struct PCIUnit));
 624         hu = (struct PCIUnit *) hd->hd_Units.lh_Head;
 625     }
 626     if(hd->hd_PCIHidd)
 627     {
 628         struct OOP_ABDescr attrbases[] =
 629         {
 630             { (STRPTR) IID_Hidd,            &hd->hd_HiddAB },
 631             { (STRPTR) IID_Hidd_PCIDevice,  &hd->hd_HiddPCIDeviceAB },
 632             { NULL, NULL }
 633         };
 634
 635         OOP_ReleaseAttrBases(attrbases);
 636
 637         OOP_DisposeObject(hd->hd_PCIHidd);
 638     }
 639 }
 640 /* \\\ */
 641
 642 /* /// "pciGetPhysical()" */
 643 APTR pciGetPhysical(struct PCIController *hc, APTR virtaddr)
 644 {
 645     //struct PCIDevice *hd = hc->hc_Device;
 646     return(HIDD_PCIDriver_CPUtoPCI(hc->hc_PCIDriverObject, virtaddr));
 647 }
 648 /* \\\ */
 649
 650 /*
 651  * Process some AROS-specific arguments.
 652  * 'usbpoweron' helps to bring up USB ports on IntelMac,
 653  * whose firmware sets them up incorrectly.
 654  */
 655 static int getArguments(struct PCIDevice *base)
 656 {
 657     APTR BootLoaderBase;
 658 #ifdef HAVE_ACPI
 659     struct ACPIBase *ACPIBase;
 660
 661     ACPIBase = OpenResource("acpi.resource");
 662     if (ACPIBase)
 663     {
 664         /*
 665          * Use ACPI IDs to identify known machines which need HDF_FORCEPOWER to work.
 666          * Currently we know only MacMini.
 667          */
 668         struct ACPI_TABLE_DEF_HEADER *dsdt = ACPI_FindSDT(ACPI_MAKE_ID('D','S','D','T'));
 669
 670         if (dsdt)
 671         {
 672             /* Yes, the last byte in ID is zero */
 673             if (strcmp(dsdt->oem_table_id, "Macmini") == 0)
 674             {
 675                 base->hd_Flags = HDF_FORCEPOWER;
 676                 return TRUE;
 677             }
 678         }
 679     }
 680 #endif
 681
 682     BootLoaderBase = OpenResource("bootloader.resource");
 683     if (BootLoaderBase)
 684     {
 685         struct List *args = GetBootInfo(BL_Args);
 686
 687         if (args)
 688         {
 689             struct Node *node;
 690
 691             for (node = args->lh_Head; node->ln_Succ; node = node->ln_Succ)
 692             {
 693                 if (stricmp(node->ln_Name, "forceusbpower") == 0)
 694                 {
 695                     base->hd_Flags = HDF_FORCEPOWER;
 696                     break;
 697                 }
 698             }
 699         }
 700     }
 701
 702     return TRUE;
 703 }
 704
 705 ADD2INITLIB(getArguments, 10)