rom/devs/ahci/bus_pci.c

   1 /*
   2     Copyright © 2004-2018, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: PCI bus driver for ahci.device
   6     Lang: English
   7 */
   8
   9 #include <aros/debug.h>
  10
  11 #include <proto/exec.h>
  12
  13 /* We want all other bases obtained from our base */
  14 #define __NOLIBBASE__
  15
  16 #include <proto/oop.h>
  17
  18 #include <aros/asmcall.h>
  19 #include <aros/symbolsets.h>
  20 #include <asm/io.h>
  21 #include <exec/lists.h>
  22 #include <hardware/ahci.h>
  23 #include <hidd/pci.h>
  24 #include <oop/oop.h>
  25
  26 #include <string.h>
  27
  28 #include "ahci.h"
  29 #include "pci.h"
  30
  31 typedef struct
  32 {
  33     struct AHCIBase *AHCIBase;
  34     struct List     devices;
  35     OOP_AttrBase    HiddPCIDeviceAttrBase;
  36     OOP_MethodID    HiddPCIDriverMethodBase;
  37 } EnumeratorArgs;
  38
  39 CONST_STRPTR ahciDeviceName = "ahci.device";
  40 CONST_STRPTR ahciControllerName = "PCI AHCI Controller";
  41
  42 int ahci_attach(device_t dev)
  43 {
  44     struct ahci_softc *sc = device_get_softc(dev);
  45
  46     if (sc->sc_ad == NULL)
  47     {
  48         sc->sc_ad = ahci_lookup_device(dev);
  49         if (sc->sc_ad == NULL)
  50                 return ENXIO; /* WTF? This matched during the probe... */
  51     }
  52     return sc->sc_ad->ad_attach(dev);
  53 }
  54
  55 void ahci_release(device_t dev)
  56 {
  57     struct AHCIBase *AHCIBase = dev->dev_AHCIBase;
  58     OOP_MethodID HiddPCIDeviceBase = AHCIBase->ahci_HiddPCIDeviceMethodBase;
  59
  60     HIDD_PCIDevice_Release(dev->dev_Object);
  61     FreePooled(AHCIBase->ahci_MemPool, dev, sizeof(*dev) + sizeof(*(dev->dev_softc)));
  62 }
  63
  64 /*
  65  * PCI BUS ENUMERATOR
  66  *   collect all SATA devices and spawn concurrent tasks.
  67  *
  68  * ahci.device unit numbers are as follows:
  69  *   First AHCI device:  unit   0..31
  70  *   Second device:      units 32..63
  71  *   etc..
  72  */
  73
  74 static
  75 AROS_UFH3(void, ahci_PCIEnumerator_h,
  76     AROS_UFHA(struct Hook *,    hook,   A0),
  77     AROS_UFHA(OOP_Object *,     Device, A2),
  78     AROS_UFHA(APTR,             message,A1))
  79 {
  80     AROS_USERFUNC_INIT
  81
  82     device_t dev;
  83
  84     EnumeratorArgs *a = hook->h_Data;
  85     struct AHCIBase *AHCIBase = a->AHCIBase;
  86     OOP_MethodID HiddPCIDeviceBase = AHCIBase->ahci_HiddPCIDeviceMethodBase;
  87     CONST_STRPTR owner;
  88
  89     dev = AllocPooled(AHCIBase->ahci_MemPool, sizeof(*dev) + sizeof(*(dev->dev_softc)));
  90     if (dev == NULL)
  91         return;
  92
  93     dev->dev_AHCIBase = AHCIBase;
  94     dev->dev_Object   = Device;
  95     dev->dev_softc    = (void *)&dev[1];
  96     dev->dev_HostID   = AHCIBase->ahci_HostCount;
  97
  98     D(bug("[AHCI:PCI] %s: Checking PCI device @ 0x%p\n", __PRETTY_FUNCTION__, Device));
  99
 100     dev->dev_softc->sc_ad = ahci_lookup_device(dev);
 101     if (!dev->dev_softc->sc_ad) {
 102         D(bug("[AHCI:PCI] %s: Device not supported\n", __PRETTY_FUNCTION__));
 103         FreePooled(AHCIBase->ahci_MemPool, dev, sizeof(*dev) + sizeof(*(dev->dev_softc)));
 104         return;
 105     }
 106
 107     D(bug("[AHCI:PCI] %s: Found '%s'\n", __PRETTY_FUNCTION__, dev->dev_softc->sc_ad->name));
 108
 109     owner = HIDD_PCIDevice_Obtain(Device, AHCIBase->ahci_Device.dd_Library.lib_Node.ln_Name);
 110     if (owner)
 111     {
 112         D(bug("[AHCI:PCI] Device is already in use by %s\n", __PRETTY_FUNCTION__, owner));
 113         FreePooled(AHCIBase->ahci_MemPool, dev, sizeof(*dev) + sizeof(*(dev->dev_softc)));
 114         return;
 115     }
 116
 117     AHCIBase->ahci_HostCount++;
 118
 119     AddTail(&a->devices, (struct Node *)dev);
 120
 121     return;
 122     AROS_USERFUNC_EXIT
 123 }
 124
 125 static const struct TagItem Requirements[] =
 126 {
 127     {tHidd_PCI_Class,     PCI_CLASS_MASSSTORAGE},
 128     {tHidd_PCI_SubClass,  PCI_SUBCLASS_SATA},
 129     {tHidd_PCI_Interface, 1},
 130     {TAG_DONE }
 131 };
 132
 133 static int ahci_bus_Detect(struct AHCIBase *AHCIBase)
 134 {
 135     OOP_Object *pci;
 136     EnumeratorArgs Args;
 137     device_t dev;
 138     struct TagItem ahci_tags[] =
 139     {
 140         {aHidd_Name             , (IPTR)ahciDeviceName          },
 141         {aHidd_HardwareName     , (IPTR)ahciControllerName      },
 142         {aHidd_Producer         , 0                             },
 143 #define AHCI_TAG_VEND 2
 144         {aHidd_Product          , 0                             },
 145 #define AHCI_TAG_PROD 3
 146         {aHidd_DriverData       , 0                             },
 147 #define AHCI_TAG_DATA 4
 148         {TAG_DONE               , 0                             }
 149     };
 150
 151     D(bug("[AHCI:PCI] %s: Enumerating PCI Devices\n", __PRETTY_FUNCTION__));
 152
 153     Args.AHCIBase                 = AHCIBase;
 154     NEWLIST(&Args.devices);
 155
 156     pci = OOP_NewObject(NULL, CLID_Hidd_PCI, NULL);
 157
 158     if (pci)
 159     {
 160         struct Hook FindHook =
 161         {
 162             h_Entry:    (IPTR (*)())ahci_PCIEnumerator_h,
 163             h_Data:     &Args
 164         };
 165
 166         struct pHidd_PCI_EnumDevices enummsg =
 167         {
 168             mID:            OOP_GetMethodID(IID_Hidd_PCI, moHidd_PCI_EnumDevices),
 169             callback:       &FindHook,
 170             requirements:   Requirements,
 171         };
 172
 173         OOP_DoMethod(pci, &enummsg.mID);
 174         OOP_DisposeObject(pci);
 175     }
 176
 177     D(bug("[AHCI:PCI] %s: Registering Detected Hosts..\n", __PRETTY_FUNCTION__));
 178
 179     while ((dev = (device_t)RemHead(&Args.devices)) != NULL) {
 180         if ((ahci_tags[AHCI_TAG_VEND].ti_Data = dev->dev_softc->sc_ad->ad_vendor) == 0)
 181             ahci_tags[AHCI_TAG_VEND].ti_Data = pci_get_vendor(dev);
 182         if ((ahci_tags[AHCI_TAG_PROD].ti_Data = dev->dev_softc->sc_ad->ad_product) == 0)
 183             ahci_tags[AHCI_TAG_PROD].ti_Data = pci_get_device(dev);
 184         ahci_tags[AHCI_TAG_DATA].ti_Data = (IPTR)dev;
 185         HW_AddDriver(AHCIBase->storageRoot, AHCIBase->ahciClass, ahci_tags);
 186         D(bug("[AHCI:PCI] %s: AHCI Controller Object @ 0x%p\n", __PRETTY_FUNCTION__, dev->dev_Controller));
 187         if (dev->dev_Controller)
 188         {
 189             if (ahci_attach(dev) != 0) {
 190                 ahci_release(dev);
 191                 return FALSE;
 192             }
 193         }
 194     }
 195
 196     return TRUE;
 197 }
 198
 199 /*
 200  * ahci.device main code has two init routines with 0 and 127 priorities.
 201  * All bus scanners must run between them.
 202  */
 203 ADD2INITLIB(ahci_bus_Detect, 30)