Changeset 517 for GPL/branches


Ignore:
Timestamp:
Jul 16, 2010, 6:13:04 AM (15 years ago)
Author:
David Azarewicz
Message:

PCI bus scan / initialze changes

Location:
GPL/branches/uniaud32-2.1.x
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • GPL/branches/uniaud32-2.1.x/alsa-kernel/pci/hda/hda_intel.c

    r514 r517  
    27992799        { PCI_DEVICE(0x10b9, 0x5461), .driver_data = AZX_DRIVER_ULI },
    28002800        /* NVIDIA MCP */
    2801 #if 1 /* DAZ kludge for NVidia until PCI_ANY_ID is fixed */
    2802         { PCI_DEVICE(0x10de, 0x026c), .driver_data = AZX_DRIVER_NVIDIA },
    2803         { PCI_DEVICE(0x10de, 0x0371), .driver_data = AZX_DRIVER_NVIDIA },
    2804         { PCI_DEVICE(0x10de, 0x03e4), .driver_data = AZX_DRIVER_NVIDIA },
    2805         { PCI_DEVICE(0x10de, 0x03f0), .driver_data = AZX_DRIVER_NVIDIA },
    2806         { PCI_DEVICE(0x10de, 0x044a), .driver_data = AZX_DRIVER_NVIDIA },
    2807         { PCI_DEVICE(0x10de, 0x044b), .driver_data = AZX_DRIVER_NVIDIA },
    2808         { PCI_DEVICE(0x10de, 0x055c), .driver_data = AZX_DRIVER_NVIDIA },
    2809         { PCI_DEVICE(0x10de, 0x055d), .driver_data = AZX_DRIVER_NVIDIA },
    2810         { PCI_DEVICE(0x10de, 0x0774), .driver_data = AZX_DRIVER_NVIDIA },
    2811         { PCI_DEVICE(0x10de, 0x0775), .driver_data = AZX_DRIVER_NVIDIA },
    2812         { PCI_DEVICE(0x10de, 0x0776), .driver_data = AZX_DRIVER_NVIDIA },
    2813         { PCI_DEVICE(0x10de, 0x0777), .driver_data = AZX_DRIVER_NVIDIA },
    2814         { PCI_DEVICE(0x10de, 0x07fc), .driver_data = AZX_DRIVER_NVIDIA },
    2815         { PCI_DEVICE(0x10de, 0x07fd), .driver_data = AZX_DRIVER_NVIDIA },
    2816         { PCI_DEVICE(0x10de, 0x0ac0), .driver_data = AZX_DRIVER_NVIDIA },
    2817         { PCI_DEVICE(0x10de, 0x0ac1), .driver_data = AZX_DRIVER_NVIDIA },
    2818         { PCI_DEVICE(0x10de, 0x0ac2), .driver_data = AZX_DRIVER_NVIDIA },
    2819         { PCI_DEVICE(0x10de, 0x0ac3), .driver_data = AZX_DRIVER_NVIDIA },
    2820         { PCI_DEVICE(0x10de, 0x0d94), .driver_data = AZX_DRIVER_NVIDIA },
    2821         { PCI_DEVICE(0x10de, 0x0d95), .driver_data = AZX_DRIVER_NVIDIA },
    2822         { PCI_DEVICE(0x10de, 0x0d96), .driver_data = AZX_DRIVER_NVIDIA },
    2823         { PCI_DEVICE(0x10de, 0x0d97), .driver_data = AZX_DRIVER_NVIDIA },
    2824 #else
    28252801        { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID),
    28262802          .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8,
    28272803          .class_mask = 0xffffff,
    28282804          .driver_data = AZX_DRIVER_NVIDIA },
    2829 #endif
    28302805        /* Teradici */
    28312806        { PCI_DEVICE(0x6549, 0x1200), .driver_data = AZX_DRIVER_TERA },

  • GPL/branches/uniaud32-2.1.x/lib32/ossidc.cpp

    r516 r517  
    104104OSSRET OSS32_Initialize(void)
    105105{
    106         short sI;
     106        short sI, iTmp;
    107107
    108108        fStrategyInit = TRUE;
    … …  
    145145                if (cardcalls[sI].cinitcall == NULL) continue;
    146146                if (*cardcalls[sI].cinitcall == NULL) continue;
    147                 if ((*cardcalls[sI].cinitcall)() == 0) fnCardExitCall[nrCardsDetected] = *cardcalls[sI].cexitcall;
     147                iTmp = (*cardcalls[sI].cinitcall)();
     148                if (iTmp <= 0) continue;
     149                while (iTmp) {
     150                        fnCardExitCall[nrCardsDetected++] = *cardcalls[sI].cexitcall;
     151                        iTmp--;
     152                        if (nrCardsDetected >= OSS32_MAX_AUDIOCARDS) break;
     153                }
    148154                if (nrCardsDetected >= OSS32_MAX_AUDIOCARDS) break;
    149155        }

  • GPL/branches/uniaud32-2.1.x/lib32/pci.c

    r516 r517  
    4747struct pci_bus pci_busses[MAX_PCI_BUSSES] = {0};
    4848
    49 BOOL    fSuspended = FALSE;
     49BOOL    fSuspended = FALSE;
    5050extern int nrCardsDetected;
    5151
    5252
    53 #define PCI_CONFIG_ENABLE       0x80000000
    54 #define PCI_CONFIG_ADDRESS      0xCF8
    55 #define PCI_CONFIG_DATA         0xCFC
     53#define PCI_CONFIG_ENABLE               0x80000000
     54#define PCI_CONFIG_ADDRESS              0xCF8
     55#define PCI_CONFIG_DATA                 0xCFC
    5656
    5757#ifdef ACPI
    … …  
    6161//******************************************************************************
    6262#define CONFIG_CMD(dev, where)  \
    63     (PCI_CONFIG_ENABLE | (dev->bus->number<<16) | (dev->devfn<<8) | (where & ~3))
     63        (PCI_CONFIG_ENABLE | (dev->bus->number<<16) | (dev->devfn<<8) | (where & ~3))
    6464//******************************************************************************
    6565int pci_read_config_byte(struct pci_dev *dev, int where, u8 *value)
    6666{
    67     outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
    68     *value = inb(PCI_CONFIG_DATA + (where&3));
    69     return PCIBIOS_SUCCESSFUL;
     67        outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
     68        *value = inb(PCI_CONFIG_DATA + (where&3));
     69        return PCIBIOS_SUCCESSFUL;
    7070}
    7171//******************************************************************************
    … …  
    7373int pci_read_config_word(struct pci_dev *dev, int where, u16 *value)
    7474{
    75     outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
    76     *value = inw(PCI_CONFIG_DATA + (where&2));
    77     return PCIBIOS_SUCCESSFUL;
     75        outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
     76        *value = inw(PCI_CONFIG_DATA + (where&2));
     77        return PCIBIOS_SUCCESSFUL;
    7878}
    7979//******************************************************************************
    … …  
    8181int pci_read_config_dword(struct pci_dev *dev, int where, u32 *value)
    8282{
    83     outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
    84     *value = inl(PCI_CONFIG_DATA);
    85     return PCIBIOS_SUCCESSFUL;
     83        outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
     84        *value = inl(PCI_CONFIG_DATA);
     85        return PCIBIOS_SUCCESSFUL;
    8686}
    8787//******************************************************************************
    … …  
    8989int pci_write_config_byte(struct pci_dev *dev, int where, u8 value)
    9090{
    91     outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
    92     outb(value, PCI_CONFIG_DATA + (where&3));
    93     return PCIBIOS_SUCCESSFUL;
     91        outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
     92        outb(value, PCI_CONFIG_DATA + (where&3));
     93        return PCIBIOS_SUCCESSFUL;
    9494}
    9595//******************************************************************************
    … …  
    9797int pci_write_config_word(struct pci_dev *dev, int where, u16 value)
    9898{
    99     outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
    100     outw(value, PCI_CONFIG_DATA + (where&2));
    101     return PCIBIOS_SUCCESSFUL;
     99        outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
     100        outw(value, PCI_CONFIG_DATA + (where&2));
     101        return PCIBIOS_SUCCESSFUL;
    102102}
    103103//******************************************************************************
    … …  
    105105int pci_write_config_dword(struct pci_dev *dev, int where, u32 value)
    106106{
    107     outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
    108     outl(value, PCI_CONFIG_DATA);
    109     return PCIBIOS_SUCCESSFUL;
     107        outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
     108        outl(value, PCI_CONFIG_DATA);
     109        return PCIBIOS_SUCCESSFUL;
    110110}
    111111//******************************************************************************
    … …  
    113113int pcidev_prepare(struct pci_dev *dev)
    114114{
    115     dprintf(("pcidev_prepare %x not implemented", dev));
    116     return 1; //todo: correct return value??
     115        dprintf(("pcidev_prepare %x not implemented", dev));
     116        return 1; //todo: correct return value??
    117117}
    118118//******************************************************************************
    … …  
    120120int pcidev_activate(struct pci_dev *dev)
    121121{
    122     dprintf(("pcidev_activate %x not implemented", dev));
    123     return 1; //todo: correct return value??
     122        dprintf(("pcidev_activate %x not implemented", dev));
     123        return 1; //todo: correct return value??
    124124}
    125125//******************************************************************************
    … …  
    127127int pcidev_deactivate(struct pci_dev *dev)
    128128{
    129     dprintf(("pcidev_deactivate %x not implemented", dev));
    130     return 1; //todo: correct return value??
     129        dprintf(("pcidev_deactivate %x not implemented", dev));
     130        return 1; //todo: correct return value??
    131131}
    132132
    … …  
    138138struct SaveIRQForSlot
    139139{
    140     ULONG  ulSlotNo;
    141     BYTE   LowIRQ;
    142     BYTE   HighIRQ;
    143     BYTE   Pin;
     140        ULONG  ulSlotNo;
     141        BYTE   LowIRQ;
     142        BYTE   HighIRQ;
     143        BYTE   Pin;
    144144};
    145145extern struct SaveIRQForSlot sISRHigh[];
    146 extern int  SaveIRQCounter;
     146extern int      SaveIRQCounter;
    147147#endif
    148148
    149 static int pci_query_device(unsigned int vendor, unsigned int device,
    150                             struct pci_dev near *pcidev, int idx)
    151 {
    152     int         resNo, addr, found = 0;
    153     u32         devNr, busNr, funcNr, detectedId, pciId, cfgaddrreg, temp, temp2;
     149//Find the next matching PCI device starting with the device specified by pcidev
     150static ULONG pci_query_device(const struct pci_device_id *id_table, struct pci_dev near *pcidev, ULONG ulLast)
     151{
     152        int             resNo, addr;
     153        u32 devNr, busNr, funcNr, detectedId, cfgaddrreg, temp, temp2;
    154154#ifdef ACPI
    155     APIRET          rc;
    156     ULONG            temp1,temp3; //PS++
     155        APIRET                  rc;
     156        ULONG                    temp1,temp3; //PS++
    157157#endif
    158     u8          headerType;
    159 
    160     pciId = (device << 16) | vendor;
    161 
    162     cfgaddrreg = inl(PCI_CONFIG_ADDRESS);
    163     for(busNr=0;busNr<MAX_PCI_BUSSES;busNr++)     //BusNumber<255
    164     {
    165         for(devNr=0;devNr<32;devNr++)
    166         {
    167             for(funcNr=0;funcNr<8;funcNr++)
    168             {
    169                 headerType = 0;
    170                 temp = PCI_CONFIG_ENABLE | (busNr<<16) | (devNr<<11) | (funcNr<<8);
    171                 outl(temp, PCI_CONFIG_ADDRESS);
    172                 detectedId = inl(PCI_CONFIG_DATA);
    173                 if( detectedId != 0xffffffff )
    174                 {
    175                     outl(temp | (PCI_HEADER_TYPE & ~3), PCI_CONFIG_ADDRESS);
    176                     headerType = inb(PCI_CONFIG_DATA + (PCI_HEADER_TYPE & 3));
    177                 }
    178                 //              printk("det: %x (%x), need: %x\n", detectedId, headerType, pciId);
    179 
    180                 if( detectedId == pciId &&
    181                    (headerType & 0x7f) == PCI_HEADER_TYPE_NORMAL )
    182                 {
    183                     if( found++ == idx )
    184                     {
    185                         memset((void near *)pcidev, 0, sizeof(struct pci_dev));
    186 
    187                         pcidev->vendor      = vendor;
    188                         pcidev->device      = device;
    189                         pcidev->bus         = &pci_busses[busNr];
    190                         pcidev->bus->number = busNr;
    191                         pcidev->devfn       = (devNr << 3) | funcNr;
    192                         pcidev->hdr_type    = headerType & 0x7f;
    193 
    194                         pcidev->prepare    = pcidev_prepare;
    195                         pcidev->activate   = pcidev_activate;
    196                         pcidev->deactivate = pcidev_deactivate;
    197                         pcidev->active     = 1;
    198                         pcidev->ro         = 0;
    199                         pcidev->sibling    = NULL;
    200                         pcidev->next       = NULL;
    201                         pcidev->dma_mask   = 0xFFFFFFFF;
    202 
    203                         // Subsystem ID
    204                         pci_read_config_word(pcidev, PCI_SUBSYSTEM_VENDOR_ID,
    205                                              &pcidev->subsystem_vendor);
    206                         pci_read_config_word(pcidev, PCI_SUBSYSTEM_ID,
    207                                              &pcidev->subsystem_device);
    208 
    209                         // I/O  and MEM
    210                         resNo = 0;
    211                         for( addr = PCI_BASE_ADDRESS_0; addr <= PCI_BASE_ADDRESS_5; addr += 4 )
    212                         {
    213                             pci_read_config_dword(pcidev, addr, &temp);
    214                             if( temp != 0 && temp != 0xffffffff )
    215                             {
    216                                 pci_write_config_dword(pcidev, addr, 0xffffffff);
    217                                 pci_read_config_dword(pcidev, addr, &temp2);
    218                                 pci_write_config_dword(pcidev, addr, temp);
    219 
    220                                 if( temp & PCI_BASE_ADDRESS_SPACE_IO )
    221                                 {
    222                                     pcidev->resource[resNo].flags = IORESOURCE_IO | PCI_BASE_ADDRESS_SPACE_IO;
    223                                     pcidev->resource[resNo].start = temp & PCI_BASE_ADDRESS_IO_MASK;
    224                                     pcidev->resource[resNo].end   = pcidev->resource[resNo].start +
    225                                         ~(temp2 & PCI_BASE_ADDRESS_IO_MASK) + 1;
    226                                 }
    227                                 else
    228                                 {
    229                                     pcidev->resource[resNo].flags = IORESOURCE_MEM | IORESOURCE_MEM_WRITEABLE;
    230                                     pcidev->resource[resNo].start = temp & PCI_BASE_ADDRESS_MEM_MASK;
    231                                     pcidev->resource[resNo].end   = pcidev->resource[resNo].start +
    232                                         ~(temp2 & PCI_BASE_ADDRESS_MEM_MASK) + 1;
    233                                 }
    234 
    235                                 resNo++;
    236 
    237                             }
    238                         }
    239 
    240                         // IRQ and PIN
    241                         pci_read_config_dword(pcidev, PCI_INTERRUPT_LINE, &temp);
     158        u8              headerType;
     159
     160        busNr = (ulLast >> 8) & 0x1f;
     161        devNr = PCI_SLOT(ulLast);
     162        funcNr = PCI_FUNC(ulLast);
     163        if (ulLast) funcNr++;
     164
     165        cfgaddrreg = inl(PCI_CONFIG_ADDRESS);
     166        for(;busNr<MAX_PCI_BUSSES;busNr++) {      //BusNumber<255
     167                for(;devNr<32;devNr++) {
     168                        for(;funcNr<8;funcNr++) {
     169                                headerType = 0;
     170                                temp = PCI_CONFIG_ENABLE | (busNr<<16) | (devNr<<11) | (funcNr<<8);
     171                                outl(temp, PCI_CONFIG_ADDRESS);
     172                                detectedId = inl(PCI_CONFIG_DATA);
     173
     174                                if ( detectedId == 0xffffffff ) {
     175                                        if ( funcNr == 0 ) break; /* if func 0 isn't there, the others aren't either */
     176                                        continue;
     177                                }
     178
     179                                outl(temp + PCI_CLASS_REVISION, PCI_CONFIG_ADDRESS);
     180                                temp2 = inl(PCI_CONFIG_DATA) >> 8; /* get class */
     181
     182                                //dprintf(("det=%x(%x) %x need=%x%x %x", detectedId, headerType, temp2, id_table->device&0xffff, id_table->vendor, id_table->class));
     183
     184                                if ( id_table->class ) {
     185                                        if ( (temp2 & id_table->class_mask) != id_table->class ) continue;
     186                                } else {
     187                                        if ( (id_table->device == PCI_ANY_ID) && ((temp2 >> 8) != PCI_CLASS_MULTIMEDIA_AUDIO) ) continue;
     188                                }
     189
     190                                if (id_table->vendor != (detectedId & 0xffff)) continue;
     191                                if ( (id_table->device != PCI_ANY_ID) && (id_table->device != (detectedId >> 16)) ) continue;
     192
     193                                outl(temp | (PCI_HEADER_TYPE & ~3), PCI_CONFIG_ADDRESS);
     194                                headerType = inb(PCI_CONFIG_DATA + (PCI_HEADER_TYPE & 3));
     195
     196                                if ( (headerType & 0x7f) != PCI_HEADER_TYPE_NORMAL ) continue;
     197
     198                                memset((void near *)pcidev, 0, sizeof(struct pci_dev));
     199
     200                                pcidev->vendor          = detectedId & 0xffff;
     201                                pcidev->device          = detectedId >> 16;
     202                                pcidev->bus             = &pci_busses[busNr];
     203                                pcidev->bus->number = busNr;
     204                                pcidev->devfn           = PCI_DEVFN(devNr, funcNr);
     205                                pcidev->hdr_type        = headerType & 0x7f;
     206
     207                                pcidev->prepare    = pcidev_prepare;
     208                                pcidev->activate   = pcidev_activate;
     209                                pcidev->deactivate = pcidev_deactivate;
     210                                pcidev->active     = 1;
     211                                pcidev->ro                 = 0;
     212                                pcidev->sibling    = NULL;
     213                                pcidev->next       = NULL;
     214                                pcidev->dma_mask   = 0xFFFFFFFF;
     215
     216                                // Subsystem ID
     217                                pci_read_config_word(pcidev, PCI_SUBSYSTEM_VENDOR_ID, &pcidev->subsystem_vendor);
     218                                pci_read_config_word(pcidev, PCI_SUBSYSTEM_ID, &pcidev->subsystem_device);
     219
     220                                // I/O  and MEM
     221                                resNo = 0;
     222                                for( addr = PCI_BASE_ADDRESS_0; addr <= PCI_BASE_ADDRESS_5; addr += 4 ) {
     223                                        pci_read_config_dword(pcidev, addr, &temp);
     224                                        if( temp != 0 && temp != 0xffffffff ) {
     225                                                pci_write_config_dword(pcidev, addr, 0xffffffff);
     226                                                pci_read_config_dword(pcidev, addr, &temp2);
     227                                                pci_write_config_dword(pcidev, addr, temp);
     228
     229                                                if( temp & PCI_BASE_ADDRESS_SPACE_IO ) {
     230                                                        pcidev->resource[resNo].flags = IORESOURCE_IO | PCI_BASE_ADDRESS_SPACE_IO;
     231                                                        pcidev->resource[resNo].start = temp & PCI_BASE_ADDRESS_IO_MASK;
     232                                                        pcidev->resource[resNo].end   = pcidev->resource[resNo].start +
     233                                                                ~(temp2 & PCI_BASE_ADDRESS_IO_MASK) + 1;
     234                                                }
     235                                                else
     236                                                {
     237                                                        pcidev->resource[resNo].flags = IORESOURCE_MEM | IORESOURCE_MEM_WRITEABLE;
     238                                                        pcidev->resource[resNo].start = temp & PCI_BASE_ADDRESS_MEM_MASK;
     239                                                        pcidev->resource[resNo].end   = pcidev->resource[resNo].start +
     240                                                                ~(temp2 & PCI_BASE_ADDRESS_MEM_MASK) + 1;
     241                                                }
     242
     243                                                resNo++;
     244
     245                                        }
     246                                }
     247
     248                                // IRQ and PIN
     249                                pci_read_config_dword(pcidev, PCI_INTERRUPT_LINE, &temp);
    242250#ifdef ACPI
    243                         sISRHigh[SaveIRQCounter].Pin  = (temp >> 8) & 0xf;
    244                         temp2 = temp3 = 0;
    245                         rc = ACPIFindPCIDevice( (ULONG)busNr,                        // Bus
    246                                                 (ULONG)devNr,                        // Dev
    247                                                 (ULONG)(pcidev->devfn >> 8) & 7,     // Function
    248                                                 &temp1,                              // PIC IRQ
    249                                                 &temp3,                              // APIC IRQ
    250                                                 NULL,                                // ACPI handle to finding device
    251                                                 "Uniaud32");                         // Name for acpi log
    252                         if (!rc)
    253                         {
    254                         // Check APIC IRQ, if we have /SMP /APIC, must be set
    255                         if (temp1)
    256                            temp = (temp & (~0xff)) | (temp1 & 0xff);
    257                         // Check PIC IRQ
    258                         else if (temp3)
    259                                  temp = (temp & (~0xff)) | (temp3 & 0xff);
    260                         dprintf(("pci_query_device: IRQs ACPI PIC%d APIC%d", temp1, temp3));
    261                         sISRHigh[SaveIRQCounter].LowIRQ  = temp1;
    262                         sISRHigh[SaveIRQCounter].HighIRQ = temp3;
    263                         }
     251                                sISRHigh[SaveIRQCounter].Pin  = (temp >> 8) & 0xf;
     252                                temp2 = temp3 = 0;
     253                                rc = ACPIFindPCIDevice( (ULONG)busNr,                                            // Bus
     254                                                                                (ULONG)devNr,                                            // Dev
     255                                                                                (ULONG)(pcidev->devfn >> 8) & 7,         // Function
     256                                                                                &temp1,                                                          // PIC IRQ
     257                                                                                &temp3,                                                          // APIC IRQ
     258                                                                                NULL,                                                            // ACPI handle to finding device
     259                                                                                "Uniaud32");                                             // Name for acpi log
     260                                if (!rc) {
     261                                        // Check APIC IRQ, if we have /SMP /APIC, must be set
     262                                        if (temp1) temp = (temp & (~0xff)) | (temp1 & 0xff);
     263                                        // Check PIC IRQ
     264                                        else if (temp3) temp = (temp & (~0xff)) | (temp3 & 0xff);
     265                                        dprintf(("pci_query_device: IRQs ACPI PIC%d APIC%d", temp1, temp3));
     266                                        sISRHigh[SaveIRQCounter].LowIRQ  = temp1;
     267                                        sISRHigh[SaveIRQCounter].HighIRQ = temp3;
     268                                }
    264269#endif /* ACPI */
    265                         if( (u8)temp && (u8)temp != 0xff )
    266                         {
    267                             pcidev->irq_resource[0].flags = IORESOURCE_IRQ;
    268                             pcidev->irq_resource[0].start =
    269                                 pcidev->irq_resource[0].end   = temp & 0xffff;
    270                             pcidev->irq = (u8)temp;
    271                         }
    272 
    273                         return 1;
    274                     }
    275                 }
    276 
    277                 // don't need to check more, if function 0 not present or single
    278                 if( funcNr == 0 && !(headerType & 0x80) )               break;
    279             }
    280         }
    281     }
    282     outl(cfgaddrreg, PCI_CONFIG_ADDRESS);
    283     return 0;
    284 
    285 }
    286 
    287 //******************************************************************************
    288 //******************************************************************************
     270                                if( (u8)temp && (u8)temp != 0xff ) {
     271                                        pcidev->irq_resource[0].flags = IORESOURCE_IRQ;
     272                                        pcidev->irq_resource[0].start = pcidev->irq_resource[0].end   = temp & 0xffff;
     273                                        pcidev->irq = (u8)temp;
     274                                }
     275
     276                                return (0x8000 | (busNr << 8) | PCI_DEVFN(devNr, funcNr));
     277                        } /* for funcNr */
     278                        funcNr = 0;
     279                } /* for devNr */
     280                devNr = 0;
     281        }
     282        outl(cfgaddrreg, PCI_CONFIG_ADDRESS);
     283        return 0;
     284}
     285
     286//******************************************************************************
     287//******************************************************************************
     288// Called from:
     289//if from==NULL search pci bus
     290//if from!=NULL only search already found devices starting with from
    289291struct pci_dev *pci_find_device (unsigned int vendor, unsigned int device, struct pci_dev *from)
    290292{
    291     int i, idx;
    292 
    293     if((int)from < 8) {
    294         idx = (int)from; // dirty hack
    295         //        return 0;
    296     } else
    297         idx = 0;
    298 
    299     for(i=0;i<MAX_PCI_DEVICES;i++)
    300     {
    301         if(pci_devices[i].devfn == 0)
    302         {
    303             if( pci_query_device(vendor, device, (struct pci_dev near *)&pci_devices[i], idx) )
    304                 return &pci_devices[i];
    305             else
    306                 break;
    307         }
    308     }
    309 
    310     return NULL;
     293        int i;
     294        struct pci_device_id id_table;
     295
     296        for(i=0;i<MAX_PCI_DEVICES;i++) {
     297                if ( pci_devices[i].devfn && (pci_devices[i].vendor == vendor) && (pci_devices[i].device == device) ) return &pci_devices[i];
     298        }
     299
     300        for(i=0;i<MAX_PCI_DEVICES;i++) {
     301                if(pci_devices[i].devfn == 0) {
     302                        memset(&id_table, 0, sizeof(id_table));
     303                        id_table.vendor = vendor;
     304                        id_table.device = device;
     305                        if( pci_query_device(&id_table, (struct pci_dev near *)&pci_devices[i], 0) ) return &pci_devices[i];
     306                        else break;
     307                }
     308        }
     309
     310        return NULL;
    311311}
    312312//******************************************************************************
    313313//******************************************************************************
    314314struct resource * __request_region(struct resource *a, unsigned long start,
    315                                    unsigned long n, const char *name)
    316 {
    317     struct resource *resource;
    318 
    319     if(a->flags & IORESOURCE_MEM) {
    320         if(RMRequestMem(/*hResMgr,*/ start, n) == FALSE) {
    321             printk("RMRequestIO failed for io %x, length %x\n", start, n);
    322             return NULL;
    323         }
    324     }
    325     else if(a->flags & IORESOURCE_IO) {
    326         if(RMRequestIO(/*hResMgr,*/ start, n) == FALSE) {
    327             printk("RMRequestIO failed for io %x, length %x\n", start, n);
    328             return NULL;
    329         }
    330     }
    331 
    332     resource = kmalloc(sizeof(struct resource), GFP_KERNEL);
    333     if (resource == NULL)
    334         return NULL;
    335     resource->name  = name;
    336     resource->start = start;
    337     resource->end     = start + n; // - 1;
    338     resource->flags = a->flags;
    339     resource->parent  =
    340         resource->child   = NULL;
    341 
    342     // insert in list
    343     resource->sibling = a->sibling;
    344     a->sibling = resource;
    345 
    346     return resource;
     315                                                                   unsigned long n, const char *name)
     316{
     317        struct resource *resource;
     318
     319        if(a->flags & IORESOURCE_MEM) {
     320                if(RMRequestMem(/*hResMgr,*/ start, n) == FALSE) {
     321                        printk("RMRequestIO failed for io %x, length %x\n", start, n);
     322                        return NULL;
     323                }
     324        }
     325        else if(a->flags & IORESOURCE_IO) {
     326                if(RMRequestIO(/*hResMgr,*/ start, n) == FALSE) {
     327                        printk("RMRequestIO failed for io %x, length %x\n", start, n);
     328                        return NULL;
     329                }
     330        }
     331
     332        resource = kmalloc(sizeof(struct resource), GFP_KERNEL);
     333        if (resource == NULL)
     334                return NULL;
     335        resource->name  = name;
     336        resource->start = start;
     337        resource->end     = start + n; // - 1;
     338        resource->flags = a->flags;
     339        resource->parent  =
     340                resource->child   = NULL;
     341
     342        // insert in list
     343        resource->sibling = a->sibling;
     344        a->sibling = resource;
     345
     346        return resource;
    347347}
    348348//******************************************************************************
    349349//******************************************************************************
    350350void __release_region(struct resource *a,
    351                       unsigned long start, unsigned long n)
    352 {
    353     struct resource     *resource;
    354     struct resource     **ppres = &a->sibling;
    355     unsigned long       end = start + n; // - 1;
    356 
    357     while( *ppres )
    358     {
    359         resource = *ppres;
    360 
    361         if( resource->start == start && resource->end == end )
    362         {
    363             // remove from list
    364             *ppres = resource->sibling;
    365             kfree(resource);
    366             return;
    367         }
    368 
    369         ppres = &resource->sibling;
    370     }
     351                                          unsigned long start, unsigned long n)
     352{
     353        struct resource *resource;
     354        struct resource **ppres = &a->sibling;
     355        unsigned long   end = start + n; // - 1;
     356
     357        while( *ppres )
     358        {
     359                resource = *ppres;
     360
     361                if( resource->start == start && resource->end == end )
     362                {
     363                        // remove from list
     364                        *ppres = resource->sibling;
     365                        kfree(resource);
     366                        return;
     367                }
     368
     369                ppres = &resource->sibling;
     370        }
    371371}
    372372//******************************************************************************
    … …  
    374374int pci_get_flags (struct pci_dev *dev, int n_base)
    375375{
    376     if(n_base >= DEVICE_COUNT_RESOURCE || !dev->resource[n_base].flags) {
    377         DebugInt3();
    378         return 0;
    379     }
    380     return dev->resource[n_base].flags;
     376        if(n_base >= DEVICE_COUNT_RESOURCE || !dev->resource[n_base].flags) {
     377                DebugInt3();
     378                return 0;
     379        }
     380        return dev->resource[n_base].flags;
    381381}
    382382//******************************************************************************
    … …  
    384384int pcibios_present(void)
    385385{
    386     printk("pcibios_present -> pretend BIOS present\n");
    387     return 1;
     386        printk("pcibios_present -> pretend BIOS present\n");
     387        return 1;
    388388}
    389389//******************************************************************************
    … …  
    391391struct pci_dev *pci_find_slot (unsigned int bus, unsigned int devfn)
    392392{
    393     printk("pci_find_slot %d %x not implemented!!\n", bus, devfn);
    394     DebugInt3();
    395     return NULL;
     393        printk("pci_find_slot %d %x not implemented!!\n", bus, devfn);
     394        DebugInt3();
     395        return NULL;
    396396}
    397397//******************************************************************************
    … …  
    399399int pci_dma_supported(struct pci_dev *dev, unsigned long mask)
    400400{
    401     printk("pci_dma_supported: return TRUE\n");
    402     return 1;
     401        printk("pci_dma_supported: return TRUE\n");
     402        return 1;
    403403}
    404404//******************************************************************************
    … …  
    406406int pci_find_capability(struct pci_dev *dev, int cap)
    407407{
    408     u16 status;
    409     u8 pos, id;
    410     int ttl = 48;
    411 
    412     pci_read_config_word(dev, PCI_STATUS, &status);
    413     if (!(status & PCI_STATUS_CAP_LIST))
    414         return 0;
    415     pci_read_config_byte(dev, PCI_CAPABILITY_LIST, &pos);
    416     while (ttl-- && pos >= 0x40) {
    417         pos &= ~3;
    418         pci_read_config_byte(dev, pos + PCI_CAP_LIST_ID, &id);
    419         if (id == 0xff)
    420             break;
    421         if (id == cap)
    422             return pos;
    423         pci_read_config_byte(dev, pos + PCI_CAP_LIST_NEXT, &pos);
    424     }
    425     return 0;
     408        u16 status;
     409        u8 pos, id;
     410        int ttl = 48;
     411
     412        pci_read_config_word(dev, PCI_STATUS, &status);
     413        if (!(status & PCI_STATUS_CAP_LIST))
     414                return 0;
     415        pci_read_config_byte(dev, PCI_CAPABILITY_LIST, &pos);
     416        while (ttl-- && pos >= 0x40) {
     417                pos &= ~3;
     418                pci_read_config_byte(dev, pos + PCI_CAP_LIST_ID, &id);
     419                if (id == 0xff)
     420                        break;
     421                if (id == cap)
     422                        return pos;
     423                pci_read_config_byte(dev, pos + PCI_CAP_LIST_NEXT, &pos);
     424        }
     425        return 0;
    426426}
    427427//******************************************************************************
    428428/*
    429  *  Set power management state of a device.  For transitions from state D3
    430  *  it isn't as straightforward as one could assume since many devices forget
    431  *  their configuration space during wakeup.  Returns old power state.
     429 *      Set power management state of a device.  For transitions from state D3
     430 *      it isn't as straightforward as one could assume since many devices forget
     431 *      their configuration space during wakeup.  Returns old power state.
    432432 */
    433433//******************************************************************************
    434434int pci_set_power_state(struct pci_dev *dev, int new_state)
    435435{
    436     u32 base[5], romaddr;
    437     u16 pci_command, pwr_command;
    438     u8  pci_latency, pci_cacheline;
    439     int i, old_state;
    440     int pm = pci_find_capability(dev, PCI_CAP_ID_PM);
    441 
    442     if (!pm)
    443         return 0;
    444     pci_read_config_word(dev, pm + PCI_PM_CTRL, &pwr_command);
    445     old_state = pwr_command & PCI_PM_CTRL_STATE_MASK;
    446     if (old_state == new_state)
    447         return old_state;
    448     if (old_state == 3) {
    449         pci_read_config_word(dev, PCI_COMMAND, &pci_command);
    450         pci_write_config_word(dev, PCI_COMMAND, pci_command & ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY));
    451         for (i = 0; i < 5; i++)
    452             pci_read_config_dword(dev, PCI_BASE_ADDRESS_0 + i*4, &base[i]);
    453         pci_read_config_dword(dev, PCI_ROM_ADDRESS, &romaddr);
    454         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
    455         pci_read_config_byte(dev, PCI_CACHE_LINE_SIZE, &pci_cacheline);
    456         pci_write_config_word(dev, pm + PCI_PM_CTRL, new_state);
    457         for (i = 0; i < 5; i++)
    458             pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + i*4, base[i]);
    459         pci_write_config_dword(dev, PCI_ROM_ADDRESS, romaddr);
    460         pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
    461         pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, pci_cacheline);
    462         pci_write_config_byte(dev, PCI_LATENCY_TIMER, pci_latency);
    463         pci_write_config_word(dev, PCI_COMMAND, pci_command);
    464     } else
    465         pci_write_config_word(dev, pm + PCI_PM_CTRL, (pwr_command & ~PCI_PM_CTRL_STATE_MASK) | new_state);
    466     return old_state;
     436        u32 base[5], romaddr;
     437        u16 pci_command, pwr_command;
     438        u8      pci_latency, pci_cacheline;
     439        int i, old_state;
     440        int pm = pci_find_capability(dev, PCI_CAP_ID_PM);
     441
     442        if (!pm)
     443                return 0;
     444        pci_read_config_word(dev, pm + PCI_PM_CTRL, &pwr_command);
     445        old_state = pwr_command & PCI_PM_CTRL_STATE_MASK;
     446        if (old_state == new_state)
     447                return old_state;
     448        if (old_state == 3) {
     449                pci_read_config_word(dev, PCI_COMMAND, &pci_command);
     450                pci_write_config_word(dev, PCI_COMMAND, pci_command & ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY));
     451                for (i = 0; i < 5; i++)
     452                        pci_read_config_dword(dev, PCI_BASE_ADDRESS_0 + i*4, &base[i]);
     453                pci_read_config_dword(dev, PCI_ROM_ADDRESS, &romaddr);
     454                pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
     455                pci_read_config_byte(dev, PCI_CACHE_LINE_SIZE, &pci_cacheline);
     456                pci_write_config_word(dev, pm + PCI_PM_CTRL, new_state);
     457                for (i = 0; i < 5; i++)
     458                        pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + i*4, base[i]);
     459                pci_write_config_dword(dev, PCI_ROM_ADDRESS, romaddr);
     460                pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
     461                pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, pci_cacheline);
     462                pci_write_config_byte(dev, PCI_LATENCY_TIMER, pci_latency);
     463                pci_write_config_word(dev, PCI_COMMAND, pci_command);
     464        } else
     465                pci_write_config_word(dev, pm + PCI_PM_CTRL, (pwr_command & ~PCI_PM_CTRL_STATE_MASK) | new_state);
     466        return old_state;
    467467}
    468468//******************************************************************************
    469469/*
    470  *  Initialize device before it's used by a driver. Ask low-level code
    471  *  to enable I/O and memory. Wake up the device if it was suspended.
    472  *  Beware, this function can fail.
     470 *      Initialize device before it's used by a driver. Ask low-level code
     471 *      to enable I/O and memory. Wake up the device if it was suspended.
     472 *      Beware, this function can fail.
    473473 */
    474474//******************************************************************************
    475475int pci_enable_device(struct pci_dev *dev)
    476476{
    477     u16 pci_command;
    478 
    479     printk("pci_enable_device %x\n", dev);
    480 
    481     pci_read_config_word(dev, PCI_COMMAND, &pci_command);
    482     pci_write_config_word(dev, PCI_COMMAND, pci_command | (PCI_COMMAND_IO | PCI_COMMAND_MEMORY));
    483     pci_set_power_state(dev, 0);
    484     return 0;
     477        u16 pci_command;
     478
     479        printk("pci_enable_device %x\n", dev);
     480
     481        pci_read_config_word(dev, PCI_COMMAND, &pci_command);
     482        pci_write_config_word(dev, PCI_COMMAND, pci_command | (PCI_COMMAND_IO | PCI_COMMAND_MEMORY));
     483        pci_set_power_state(dev, 0);
     484        return 0;
    485485}
    486486//******************************************************************************
    … …  
    488488int pci_register_driver(struct pci_driver *driver)
    489489{
    490     int i, j, dev_num;
    491     struct pci_dev *pcidev;
    492 
    493     for( i = 0; driver->id_table[i].vendor; i++)
    494     {
    495         dev_num = 0;
    496         while( (pcidev = pci_find_device(driver->id_table[i].vendor,
    497                                          driver->id_table[i].device,
    498                                          (struct pci_dev *)dev_num)) != NULL )
    499         {
    500             RMInit();
    501             if( driver->probe) {
    502                 printk("found: %x, id: %x idx %i\n",driver->id_table[i].vendor, driver->id_table[i].device, dev_num);
    503 
    504                 if(driver->probe(pcidev, &driver->id_table[i]) == 0) {
    505                     pcidev->pcidriver = (void *)driver;
    506                     pcidev->current_state = 4;
    507 
    508                     // create adapter
    509                     RMDone((driver->id_table[i].device << 16) | driver->id_table[i].vendor);
    510                     nrCardsDetected++;
    511                 }
    512                 else pcidev->devfn = 0;
    513             }
    514 
    515             RMDone(0);
    516 
    517             dev_num++;
    518 
    519         }
    520     }
    521     if (nrCardsDetected >=1)
    522         return 1;
    523 
    524     return 0;
     490        int iTableIx, iNumCards, iTmp;
     491        ULONG ulLast;
     492        struct pci_dev *pcidev;
     493
     494        if (!driver->probe) return 0;
     495
     496        iNumCards = 0;
     497        ulLast = 0;
     498        pcidev=&pci_devices[0];
     499
     500        for( iTableIx = 0; driver->id_table[iTableIx].vendor; iTableIx++) {
     501
     502                if (pcidev->devfn) { /* find an empty slot */
     503                        for (iTmp=0; iTmp<MAX_PCI_DEVICES; iTmp++) {
     504                                if (pci_devices[iTmp].devfn == 0) break;
     505                        }
     506                        if (iTmp >= MAX_PCI_DEVICES) break;
     507                        pcidev=&pci_devices[iTmp];
     508                }
     509
     510
     511                while( (ulLast = pci_query_device(&driver->id_table[iTableIx], pcidev, ulLast)) ) {
     512                        RMInit();
     513                        dprintf(("pci_register_driver: found=%x:%x searching for %x:%x\n",
     514                                pcidev->vendor, pcidev->device, driver->id_table[iTableIx].vendor, driver->id_table[iTableIx].device));
     515
     516                        if(driver->probe(pcidev, &driver->id_table[iTableIx]) == 0) {
     517                                pcidev->pcidriver = (void *)driver;
     518                                pcidev->current_state = 4;
     519
     520                                // create adapter
     521                                RMDone((pcidev->device << 16) | pcidev->vendor);
     522                                iNumCards++;
     523                        } else pcidev->devfn = 0;
     524
     525                        RMDone(0);
     526                }
     527        }
     528
     529        return iNumCards;
    525530}
    526531//******************************************************************************
    … …  
    528533int pci_module_init(struct pci_driver *drv)
    529534{
    530     int res = pci_register_driver(drv);
    531     if (res < 0)
    532         return res;
    533     if (res == 0)
    534         return -ENODEV;
    535     return 0;
     535        int res = pci_register_driver(drv);
     536        if (res == 0) return -ENODEV;
     537        return res;
    536538}
    537539//******************************************************************************
    … …  
    539541int pci_unregister_driver(struct pci_driver *driver)
    540542{
    541     struct pci_dev *pcidev;
    542     int i = 0, j;
    543 
    544     while(driver->id_table[i].vendor)
    545     {
    546         for(j=0;j<MAX_PCI_DEVICES;j++)
    547         {
    548             if(pci_devices[j].vendor == driver->id_table[i].vendor &&
    549                pci_devices[j].device == driver->id_table[i].device)
    550             {
    551                 if(driver->remove) {
    552                     driver->remove(&pci_devices[j]);
    553                 }
    554             }
    555         }
    556         i++;
    557     }
    558     return 0;
     543        struct pci_dev *pcidev;
     544        int i = 0, j;
     545
     546        while(driver->id_table[i].vendor)
     547        {
     548                for(j=0;j<MAX_PCI_DEVICES;j++)
     549                {
     550                        if(pci_devices[j].vendor == driver->id_table[i].vendor &&
     551                           pci_devices[j].device == driver->id_table[i].device)
     552                        {
     553                                if(driver->remove) {
     554                                        driver->remove(&pci_devices[j]);
     555                                }
     556                        }
     557                }
     558                i++;
     559        }
     560        return 0;
    559561}
    560562//******************************************************************************
    … …  
    562564void pci_set_master(struct pci_dev *dev)
    563565{
    564     u16 cmd;
    565 
    566     pci_read_config_word(dev, PCI_COMMAND, &cmd);
    567     if (! (cmd & PCI_COMMAND_MASTER)) {
    568         dprintf(("pci_set_master %x", dev));
    569         cmd |= PCI_COMMAND_MASTER;
    570         pci_write_config_word(dev, PCI_COMMAND, cmd);
    571     }
    572     return;
     566        u16 cmd;
     567
     568        pci_read_config_word(dev, PCI_COMMAND, &cmd);
     569        if (! (cmd & PCI_COMMAND_MASTER)) {
     570                dprintf(("pci_set_master %x", dev));
     571                cmd |= PCI_COMMAND_MASTER;
     572                pci_write_config_word(dev, PCI_COMMAND, cmd);
     573        }
     574        return;
    573575}
    574576//******************************************************************************
    … …  
    577579struct pm_dev *pm_register(pm_dev_t type, unsigned long id,  pm_callback callback)
    578580{
    579     dprintf(("pm_register STUB"));
    580     DebugInt3();
    581     return NULL;
     581        dprintf(("pm_register STUB"));
     582        DebugInt3();
     583        return NULL;
    582584}
    583585//******************************************************************************
    … …  
    586588void pm_unregister(struct pm_dev *dev)
    587589{
    588     dprintf(("pm_unregister STUB"));
     590        dprintf(("pm_unregister STUB"));
    589591}
    590592//******************************************************************************
    … …  
    592594int __compat_get_order(unsigned long size)
    593595{
    594     int order;
    595 
    596     size = (size-1) >> (PAGE_SHIFT-1);
    597     order = -1;
    598     do {
    599         size >>= 1;
    600         order++;
    601     } while (size);
    602     return order;
     596        int order;
     597
     598        size = (size-1) >> (PAGE_SHIFT-1);
     599        order = -1;
     600        do {
     601                size >>= 1;
     602                order++;
     603        } while (size);
     604        return order;
    603605}
    604606//******************************************************************************
    605607//******************************************************************************
    606608void *pci_alloc_consistent(struct pci_dev *hwdev,
    607                            long size, dma_addr_t *dma_handle)
    608 {
    609     void *ret = NULL;
    610     int gfp = GFP_ATOMIC;
    611     int order;
     609                                                   long size, dma_addr_t *dma_handle)
     610{
     611        void *ret = NULL;
     612        int gfp = GFP_ATOMIC;
     613        int order;
    612614#ifdef DEBUG
    613     dprintf(("pci_alloc_consistent %d mask %x", size, (hwdev) ? hwdev->dma_mask : 0));
     615        dprintf(("pci_alloc_consistent %d mask %x", size, (hwdev) ? hwdev->dma_mask : 0));
    614616#endif
    615     if (hwdev == NULL || hwdev->dma_mask != 0xffffffff) {
    616         //try not to exhaust low memory (< 16mb) so allocate from the high region first
    617         //if that doesn't satisfy the dma mask requirement, then get it from the low
    618         //regino anyway
    619         if(hwdev->dma_mask > 0x00ffffff) {
    620             order = __compat_get_order(size);
    621             ret = (void *)__get_free_pages(gfp|GFP_DMAHIGHMEM, order);
    622             *dma_handle = virt_to_bus(ret);
    623             if(*dma_handle > hwdev->dma_mask) {
    624                 free_pages((unsigned long)ret, __compat_get_order(size));
    625                 //be sure and allocate below 16 mb
    626                 gfp |= GFP_DMA;
    627                 ret = NULL;
    628             }
    629         }
    630         else { //must always allocate below 16 mb
    631             gfp |= GFP_DMA;
    632         }
    633     }
    634     if(ret == NULL) {
    635         ret = (void *)__get_free_pages(gfp, __compat_get_order(size));
    636     }
    637 
    638     if (ret != NULL) {
    639         memset(ret, 0, size);
    640         *dma_handle = virt_to_bus(ret);
    641     }
    642     return ret;
     617        if (hwdev == NULL || hwdev->dma_mask != 0xffffffff) {
     618                //try not to exhaust low memory (< 16mb) so allocate from the high region first
     619                //if that doesn't satisfy the dma mask requirement, then get it from the low
     620                //regino anyway
     621                if(hwdev->dma_mask > 0x00ffffff) {
     622                        order = __compat_get_order(size);
     623                        ret = (void *)__get_free_pages(gfp|GFP_DMAHIGHMEM, order);
     624                        *dma_handle = virt_to_bus(ret);
     625                        if(*dma_handle > hwdev->dma_mask) {
     626                                free_pages((unsigned long)ret, __compat_get_order(size));
     627                                //be sure and allocate below 16 mb
     628                                gfp |= GFP_DMA;
     629                                ret = NULL;
     630                        }
     631                }
     632                else { //must always allocate below 16 mb
     633                        gfp |= GFP_DMA;
     634                }
     635        }
     636        if(ret == NULL) {
     637                ret = (void *)__get_free_pages(gfp, __compat_get_order(size));
     638        }
     639
     640        if (ret != NULL) {
     641                memset(ret, 0, size);
     642                *dma_handle = virt_to_bus(ret);
     643        }
     644        return ret;
    643645}
    644646//******************************************************************************
    645647//******************************************************************************
    646648void pci_free_consistent(struct pci_dev *hwdev, long size,
    647                         void *vaddr, dma_addr_t dma_handle)
    648 {
    649     free_pages((unsigned long)vaddr, __compat_get_order(size));
     649                                                void *vaddr, dma_addr_t dma_handle)
     650{
     651        free_pages((unsigned long)vaddr, __compat_get_order(size));
    650652}
    651653//******************************************************************************
    … …  
    653655void pci_set_driver_data (struct pci_dev *dev, void *driver_data)
    654656{
    655     if (dev)
    656         dev->driver_data = driver_data;
     657        if (dev)
     658                dev->driver_data = driver_data;
    657659}
    658660//******************************************************************************
    … …  
    660662void *pci_get_driver_data (struct pci_dev *dev)
    661663{
    662     if (dev)
    663         return dev->driver_data;
    664     return 0;
     664        if (dev)
     665                return dev->driver_data;
     666        return 0;
    665667}
    666668//******************************************************************************
    … …  
    668670unsigned long pci_get_dma_mask (struct pci_dev *dev)
    669671{
    670     if (dev)
    671         return dev->dma_mask;
    672     return 0;
     672        if (dev)
     673                return dev->dma_mask;
     674        return 0;
    673675}
    674676//******************************************************************************
    … …  
    676678int release_resource(struct resource *newres)
    677679{
    678     return 0;
     680        return 0;
    679681}
    680682
    … …  
    683685int pci_set_latency_time(struct pci_dev *dev, int latency)
    684686{
    685     pci_write_config_byte(dev, PCI_LATENCY_TIMER, latency);
    686     return 0;
     687        pci_write_config_byte(dev, PCI_LATENCY_TIMER, latency);
     688        return 0;
    687689}
    688690
    … …  
    699701int pci_orig_save_state(struct pci_dev *dev, u32 *buffer)
    700702{
    701     int i;
    702     if (buffer) {
    703         /* XXX: 100% dword access ok here? */
    704         for (i = 0; i < 16; i++)
    705             pci_read_config_dword(dev, i * 4,&buffer[i]);
    706     }
    707     return 0;
     703        int i;
     704        if (buffer) {
     705                /* XXX: 100% dword access ok here? */
     706                for (i = 0; i < 16; i++)
     707                        pci_read_config_dword(dev, i * 4,&buffer[i]);
     708        }
     709        return 0;
    708710}
    709711
    … …  
    717719pci_orig_restore_state(struct pci_dev *dev, u32 *buffer)
    718720{
    719     int i;
    720 
    721     if (buffer) {
    722         for (i = 0; i < 16; i++)
    723             pci_write_config_dword(dev,i * 4, buffer[i]);
    724     }
    725     /*
    726     * otherwise, write the context information we know from bootup.
    727     * This works around a problem where warm-booting from Windows
    728     * combined with a D3(hot)->D0 transition causes PCI config
    729     * header data to be forgotten.
    730     */
    731     else {
    732         for (i = 0; i < 6; i ++)
    733             pci_write_config_dword(dev,
    734                                    PCI_BASE_ADDRESS_0 + (i * 4),
    735                                    dev->resource[i].start);
    736         pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
    737     }
    738     return 0;
     721        int i;
     722
     723        if (buffer) {
     724                for (i = 0; i < 16; i++)
     725                        pci_write_config_dword(dev,i * 4, buffer[i]);
     726        }
     727        /*
     728        * otherwise, write the context information we know from bootup.
     729        * This works around a problem where warm-booting from Windows
     730        * combined with a D3(hot)->D0 transition causes PCI config
     731        * header data to be forgotten.
     732        */
     733        else {
     734                for (i = 0; i < 6; i ++)
     735                        pci_write_config_dword(dev,
     736                                                                   PCI_BASE_ADDRESS_0 + (i * 4),
     737                                                                   dev->resource[i].start);
     738                pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
     739        }
     740        return 0;
    739741}
    740742
    741743struct saved_config_tbl {
    742     struct pci_dev *pci;
    743     u32 config[16];
     744        struct pci_dev *pci;
     745        u32 config[16];
    744746};
    745747static struct saved_config_tbl saved_tbl[16];
    … …  
    747749int pci_save_state(struct pci_dev *pci)
    748750{
    749     int i;
    750     /* FIXME: mutex needed for race? */
    751     for (i = 0; i < ARRAY_SIZE(saved_tbl); i++) {
    752         if (! saved_tbl[i].pci) {
    753             saved_tbl[i].pci = pci;
    754             pci_orig_save_state(pci, saved_tbl[i].config);
    755             return 1;
    756         }
    757     }
    758     printk(KERN_DEBUG "snd: no pci config space found!\n");
    759     return 0;
     751        int i;
     752        /* FIXME: mutex needed for race? */
     753        for (i = 0; i < ARRAY_SIZE(saved_tbl); i++) {
     754                if (! saved_tbl[i].pci) {
     755                        saved_tbl[i].pci = pci;
     756                        pci_orig_save_state(pci, saved_tbl[i].config);
     757                        return 1;
     758                }
     759        }
     760        printk(KERN_DEBUG "snd: no pci config space found!\n");
     761        return 0;
    760762}
    761763
    762764int pci_restore_state(struct pci_dev *pci)
    763765{
    764     int i;
    765     /* FIXME: mutex needed for race? */
    766     for (i = 0; i < ARRAY_SIZE(saved_tbl); i++) {
    767         if (saved_tbl[i].pci == pci) {
    768             saved_tbl[i].pci = NULL;
    769             pci_orig_restore_state(pci, saved_tbl[i].config);
    770             return 0;
    771         }
    772     }
    773     printk(KERN_DEBUG "snd: no saved pci config!\n");
    774     return 1;
     766        int i;
     767        /* FIXME: mutex needed for race? */
     768        for (i = 0; i < ARRAY_SIZE(saved_tbl); i++) {
     769                if (saved_tbl[i].pci == pci) {
     770                        saved_tbl[i].pci = NULL;
     771                        pci_orig_restore_state(pci, saved_tbl[i].config);
     772                        return 0;
     773                }
     774        }
     775        printk(KERN_DEBUG "snd: no saved pci config!\n");
     776        return 1;
    775777}
    776778
    777779void pci_disable_device(struct pci_dev *dev)
    778780{
    779     u16 pci_command;
    780 
    781     pci_read_config_word(dev, PCI_COMMAND, &pci_command);
    782     if (pci_command & PCI_COMMAND_MASTER) {
    783         pci_command &= ~PCI_COMMAND_MASTER;
    784         pci_write_config_word(dev, PCI_COMMAND, pci_command);
    785     }
     781        u16 pci_command;
     782
     783        pci_read_config_word(dev, PCI_COMMAND, &pci_command);
     784        if (pci_command & PCI_COMMAND_MASTER) {
     785                pci_command &= ~PCI_COMMAND_MASTER;
     786                pci_write_config_word(dev, PCI_COMMAND, pci_command);
     787        }
    786788}
    787789
    788790int pci_request_region(struct pci_dev *pdev, int bar, char *res_name)
    789791{
    790     int flags;
    791 
    792     if (pci_resource_len(pdev, bar) == 0)
    793         return 0;
    794     flags = pci_get_flags(pdev, bar);
    795     if (flags & IORESOURCE_IO) {
    796         if (check_region(pci_resource_start(pdev, bar), pci_resource_len(pdev, bar)))
    797             goto err_out;
    798         request_region(pci_resource_start(pdev, bar),
    799                        pci_resource_len(pdev, bar), res_name);
    800     }
    801     else if (flags & IORESOURCE_MEM) {
    802         if (check_mem_region(pci_resource_start(pdev, bar), pci_resource_len(pdev, bar)))
    803             goto err_out;
    804         request_mem_region(pci_resource_start(pdev, bar),
    805                            pci_resource_len(pdev, bar), res_name);
    806     }
    807 
    808     return 0;
     792        int flags;
     793
     794        if (pci_resource_len(pdev, bar) == 0)
     795                return 0;
     796        flags = pci_get_flags(pdev, bar);
     797        if (flags & IORESOURCE_IO) {
     798                if (check_region(pci_resource_start(pdev, bar), pci_resource_len(pdev, bar)))
     799                        goto err_out;
     800                request_region(pci_resource_start(pdev, bar),
     801                                           pci_resource_len(pdev, bar), res_name);
     802        }
     803        else if (flags & IORESOURCE_MEM) {
     804                if (check_mem_region(pci_resource_start(pdev, bar), pci_resource_len(pdev, bar)))
     805                        goto err_out;
     806                request_mem_region(pci_resource_start(pdev, bar),
     807                                                   pci_resource_len(pdev, bar), res_name);
     808        }
     809
     810        return 0;
    809811
    810812err_out:
    811     printk(KERN_WARNING "PCI: Unable to reserve %s region #%d:%lx@%lx for device %s\n",
    812            flags & IORESOURCE_IO ? "I/O" : "mem",
    813            bar + 1, /* PCI BAR # */
    814            pci_resource_len(pdev, bar), pci_resource_start(pdev, bar),
    815            res_name);
    816     return -EBUSY;
     813        printk(KERN_WARNING "PCI: Unable to reserve %s region #%d:%lx@%lx for device %s\n",
     814                   flags & IORESOURCE_IO ? "I/O" : "mem",
     815                   bar + 1, /* PCI BAR # */
     816                   pci_resource_len(pdev, bar), pci_resource_start(pdev, bar),
     817                   res_name);
     818        return -EBUSY;
    817819}
    818820
    819821void pci_release_region(struct pci_dev *pdev, int bar)
    820822{
    821     int flags;
    822 
    823     if (pci_resource_len(pdev, bar) == 0)
    824         return;
    825     flags = pci_get_flags(pdev, bar);
    826     if (flags & IORESOURCE_IO) {
    827         release_region(pci_resource_start(pdev, bar),
    828                        pci_resource_len(pdev, bar));
    829     }
    830     else if (flags & IORESOURCE_MEM) {
    831         release_mem_region(pci_resource_start(pdev, bar),
    832                            pci_resource_len(pdev, bar));
    833     }
     823        int flags;
     824
     825        if (pci_resource_len(pdev, bar) == 0)
     826                return;
     827        flags = pci_get_flags(pdev, bar);
     828        if (flags & IORESOURCE_IO) {
     829                release_region(pci_resource_start(pdev, bar),
     830                                           pci_resource_len(pdev, bar));
     831        }
     832        else if (flags & IORESOURCE_MEM) {
     833                release_mem_region(pci_resource_start(pdev, bar),
     834                                                   pci_resource_len(pdev, bar));
     835        }
    834836}
    835837
    836838int pci_request_regions(struct pci_dev *pdev, char *res_name)
    837839{
    838     int i;
    839 
    840     for (i = 0; i < 6; i++)
    841         if (pci_request_region(pdev, i, res_name))
    842             goto err;
    843     return 0;
    844     err:
    845         while (--i >= 0)
    846             pci_release_region(pdev, i);
    847         return -EBUSY;
     840        int i;
     841
     842        for (i = 0; i < 6; i++)
     843                if (pci_request_region(pdev, i, res_name))
     844                        goto err;
     845        return 0;
     846        err:
     847                while (--i >= 0)
     848                        pci_release_region(pdev, i);
     849                return -EBUSY;
    848850}
    849851
    850852void pci_release_regions(struct pci_dev *pdev)
    851853{
    852     int i;
    853     for (i = 0; i < 6; i++)
    854         pci_release_region(pdev, i);
     854        int i;
     855        for (i = 0; i < 6; i++)
     856                pci_release_region(pdev, i);
    855857}
    856858
    857859const struct pci_device_id * pci_match_device(const struct pci_device_id *ids, struct pci_dev *dev)
    858860{
    859     u16 subsystem_vendor, subsystem_device;
    860 
    861     pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &subsystem_vendor);
    862     pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &subsystem_device);
    863 
    864     while (ids->vendor || ids->subvendor || ids->class_mask) {
    865         if ((ids->vendor == PCI_ANY_ID || ids->vendor == dev->vendor) &&
    866             (ids->device == PCI_ANY_ID || ids->device == dev->device) &&
    867             (ids->subvendor == PCI_ANY_ID || ids->subvendor == subsystem_vendor) &&
    868             (ids->subdevice == PCI_ANY_ID || ids->subdevice == subsystem_device) &&
    869             !((ids->class ^ dev->_class) & ids->class_mask))
    870             return ids;
    871         ids++;
    872     }
    873     return NULL;
     861        u16 subsystem_vendor, subsystem_device;
     862
     863        pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &subsystem_vendor);
     864        pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &subsystem_device);
     865
     866        while (ids->vendor || ids->subvendor || ids->class_mask) {
     867                if ((ids->vendor == PCI_ANY_ID || ids->vendor == dev->vendor) &&
     868                        (ids->device == PCI_ANY_ID || ids->device == dev->device) &&
     869                        (ids->subvendor == PCI_ANY_ID || ids->subvendor == subsystem_vendor) &&
     870                        (ids->subdevice == PCI_ANY_ID || ids->subdevice == subsystem_device) &&
     871                        !((ids->class ^ dev->_class) & ids->class_mask))
     872                        return ids;
     873                ids++;
     874        }
     875        return NULL;
    874876}
    875877
    876878int snd_pci_dev_present(const struct pci_device_id *ids)
    877879{
    878     while (ids->vendor || ids->subvendor) {
    879         if (pci_find_device(ids->vendor, ids->subvendor, NULL))
    880             return 1;
    881         ids++;
    882     }
    883     return 0;
     880        while (ids->vendor || ids->subvendor) {
     881                if (pci_find_device(ids->vendor, ids->subvendor, NULL))
     882                        return 1;
     883                ids++;
     884        }
     885        return 0;
    884886}
    885887
    886888struct pci_driver_mapping {
    887     struct pci_dev *dev;
    888     struct pci_driver *drv;
    889     unsigned long dma_mask;
    890     void *driver_data;
    891     u32 saved_config[16];
     889        struct pci_dev *dev;
     890        struct pci_driver *drv;
     891        unsigned long dma_mask;
     892        void *driver_data;
     893        u32 saved_config[16];
    892894};
    893895
    … …  
    898900static struct pci_driver_mapping *get_pci_driver_mapping(struct pci_dev *dev)
    899901{
    900     int i;
    901 
    902     for (i = 0; i < PCI_MAX_MAPPINGS; i++)
    903         if (drvmap[i].dev == dev)
    904             return &drvmap[i];
    905     return NULL;
     902        int i;
     903
     904        for (i = 0; i < PCI_MAX_MAPPINGS; i++)
     905                if (drvmap[i].dev == dev)
     906                        return &drvmap[i];
     907        return NULL;
    906908}
    907909
    908910struct pci_driver *snd_pci_compat_get_pci_driver(struct pci_dev *dev)
    909911{
    910     struct pci_driver_mapping *map = get_pci_driver_mapping(dev);
    911     if (map)
    912         return map->drv;
    913     return NULL;
     912        struct pci_driver_mapping *map = get_pci_driver_mapping(dev);
     913        if (map)
     914                return map->drv;
     915        return NULL;
    914916}
    915917#if 0
    916918void * pci_get_drvdata (struct pci_dev *dev)
    917919{
    918     struct pci_driver_mapping *map = get_pci_driver_mapping(dev);
    919     if (map)
    920         return map->driver_data;
    921     return NULL;
     920        struct pci_driver_mapping *map = get_pci_driver_mapping(dev);
     921        if (map)
     922                return map->driver_data;
     923        return NULL;
    922924}
    923925
    … …  
    925927void pci_set_drvdata (struct pci_dev *dev, void *driver_data)
    926928{
    927     struct pci_driver_mapping *map = get_pci_driver_mapping(dev);
    928     if (map)
    929         map->driver_data = driver_data;
     929        struct pci_driver_mapping *map = get_pci_driver_mapping(dev);
     930        if (map)
     931                map->driver_data = driver_data;
    930932}
    931933#endif
    … …  
    936938OSSRET OSS32_APMResume()
    937939{
    938     int i;
    939     struct pci_driver *driver;
    940 
    941     dprintf(("OSS32_APMResume"));
    942 
    943     fSuspended = FALSE;
    944 
    945     for(i=0;i<MAX_PCI_DEVICES;i++)
    946     {
    947         if(pci_devices[i].devfn)
    948         {
    949             driver = pci_devices[i].pcidriver;
    950             if(driver && driver->resume) {
    951                 driver->resume(&pci_devices[i]);
    952             }
    953         }
    954     }
    955 
    956     return OSSERR_SUCCESS;
     940        int i;
     941        struct pci_driver *driver;
     942
     943        dprintf(("OSS32_APMResume"));
     944
     945        fSuspended = FALSE;
     946
     947        for(i=0;i<MAX_PCI_DEVICES;i++)
     948        {
     949                if(pci_devices[i].devfn)
     950                {
     951                        driver = pci_devices[i].pcidriver;
     952                        if(driver && driver->resume) {
     953                                driver->resume(&pci_devices[i]);
     954                        }
     955                }
     956        }
     957
     958        return OSSERR_SUCCESS;
    957959}
    958960//******************************************************************************
    … …  
    960962OSSRET OSS32_APMSuspend()
    961963{
    962     int i;
    963     struct pci_driver *driver;
    964 
    965     dprintf(("OSS32_APMSuspend"));
    966 
    967     fSuspended = TRUE;
    968 
    969     for(i=0;i<MAX_PCI_DEVICES;i++)
    970     {
    971         if(pci_devices[i].devfn)
    972         {
    973             driver = pci_devices[i].pcidriver;
    974             if(driver && driver->suspend) {
    975                 driver->suspend(&pci_devices[i], SNDRV_CTL_POWER_D3cold);
    976             }
    977         }
    978     }
    979 
    980     return OSSERR_SUCCESS;
    981 }
    982 
     964        int i;
     965        struct pci_driver *driver;
     966
     967        dprintf(("OSS32_APMSuspend"));
     968
     969        fSuspended = TRUE;
     970
     971        for(i=0;i<MAX_PCI_DEVICES;i++)
     972        {
     973                if(pci_devices[i].devfn)
     974                {
     975                        driver = pci_devices[i].pcidriver;
     976                        if(driver && driver->suspend) {
     977                                driver->suspend(&pci_devices[i], SNDRV_CTL_POWER_D3cold);
     978                        }
     979                }
     980        }
     981
     982        return OSSERR_SUCCESS;
     983}
     984

  • GPL/branches/uniaud32-2.1.x/uniaud.inc

    r516 r517  
    1313# ex RC3  GA  FIXPACK2 beta_47
    1414# Comment out to avoid a fixpack line in bldlevel
    15 FIXPACK = BETA SVNr516
     15FIXPACK = BETA SVNr517
    1616
    1717# ALSA BUILD VERSION
Note: See TracChangeset for help on using the changeset viewer.