]> Pileus Git - ~andy/linux/blobdiff - drivers/ide/setup-pci.c
ide: update/add my Copyrights
[~andy/linux] / drivers / ide / setup-pci.c
index 25fd090532206197212576093088ebbcbeced62b..8ff5a0ef10adc35bc4e50c7dc4892b03fcf91617 100644 (file)
@@ -1,9 +1,8 @@
 /*
- *  linux/drivers/ide/setup-pci.c              Version 1.10    2002/08/19
+ *  Copyright (C) 1998-2000  Andre Hedrick <andre@linux-ide.org>
+ *  Copyright (C) 1995-1998  Mark Lord
+ *  Copyright (C)      2007  Bartlomiej Zolnierkiewicz
  *
- *  Copyright (c) 1998-2000  Andre Hedrick <andre@linux-ide.org>
- *
- *  Copyright (c) 1995-1998  Mark Lord
  *  May be copied or modified under the terms of the GNU General Public License
  */
 
@@ -140,6 +139,16 @@ static int ide_setup_pci_baseregs (struct pci_dev *dev, const char *name)
 }
 
 #ifdef CONFIG_BLK_DEV_IDEDMA_PCI
+static void ide_pci_clear_simplex(unsigned long dma_base, const char *name)
+{
+       u8 dma_stat = inb(dma_base + 2);
+
+       outb(dma_stat & 0x60, dma_base + 2);
+       dma_stat = inb(dma_base + 2);
+       if (dma_stat & 0x80)
+               printk(KERN_INFO "%s: simplex device: DMA forced\n", name);
+}
+
 /**
  *     ide_get_or_set_dma_base         -       setup BMIBA
  *     @d: IDE port info
@@ -152,8 +161,9 @@ static int ide_setup_pci_baseregs (struct pci_dev *dev, const char *name)
 
 static unsigned long ide_get_or_set_dma_base(const struct ide_port_info *d, ide_hwif_t *hwif)
 {
-       unsigned long   dma_base = 0;
-       struct pci_dev  *dev = hwif->pci_dev;
+       struct pci_dev *dev = to_pci_dev(hwif->dev);
+       unsigned long dma_base = 0;
+       u8 dma_stat = 0;
 
        if (hwif->mmio)
                return hwif->dma_base;
@@ -165,57 +175,39 @@ static unsigned long ide_get_or_set_dma_base(const struct ide_port_info *d, ide_
 
                dma_base = pci_resource_start(dev, baridx);
 
-               if (dma_base == 0)
+               if (dma_base == 0) {
                        printk(KERN_ERR "%s: DMA base is invalid\n", d->name);
+                       return 0;
+               }
        }
 
-       if ((d->host_flags & IDE_HFLAG_CS5520) == 0 && dma_base) {
-               u8 simplex_stat = 0;
-               dma_base += hwif->channel ? 8 : 0;
-
-               switch(dev->device) {
-                       case PCI_DEVICE_ID_AL_M5219:
-                       case PCI_DEVICE_ID_AL_M5229:
-                       case PCI_DEVICE_ID_AMD_VIPER_7409:
-                       case PCI_DEVICE_ID_CMD_643:
-                       case PCI_DEVICE_ID_SERVERWORKS_CSB5IDE:
-                       case PCI_DEVICE_ID_REVOLUTION:
-                               simplex_stat = inb(dma_base + 2);
-                               outb(simplex_stat & 0x60, dma_base + 2);
-                               simplex_stat = inb(dma_base + 2);
-                               if (simplex_stat & 0x80) {
-                                       printk(KERN_INFO "%s: simplex device: "
-                                                        "DMA forced\n",
-                                                        d->name);
-                               }
-                               break;
-                       default:
-                               /*
-                                * If the device claims "simplex" DMA,
-                                * this means only one of the two interfaces
-                                * can be trusted with DMA at any point in time.
-                                * So we should enable DMA only on one of the
-                                * two interfaces.
-                                */
-                               simplex_stat = hwif->INB(dma_base + 2);
-                               if (simplex_stat & 0x80) {
-                                       /* simplex device? */
-/*
- *     At this point we haven't probed the drives so we can't make the
- *     appropriate decision. Really we should defer this problem
- *     until we tune the drive then try to grab DMA ownership if we want
- *     to be the DMA end. This has to be become dynamic to handle hot
- *     plug.
- */
-                                       if (hwif->mate && hwif->mate->dma_base) {
-                                               printk(KERN_INFO "%s: simplex device: "
-                                                                "DMA disabled\n",
-                                                                d->name);
-                                               dma_base = 0;
-                                       }
-                               }
-               }
+       if (hwif->channel)
+               dma_base += 8;
+
+       if (d->host_flags & IDE_HFLAG_CS5520)
+               goto out;
+
+       if (d->host_flags & IDE_HFLAG_CLEAR_SIMPLEX) {
+               ide_pci_clear_simplex(dma_base, d->name);
+               goto out;
        }
+
+       /*
+        * If the device claims "simplex" DMA, this means that only one of
+        * the two interfaces can be trusted with DMA at any point in time
+        * (so we should enable DMA only on one of the two interfaces).
+        *
+        * FIXME: At this point we haven't probed the drives so we can't make
+        * the appropriate decision.  Really we should defer this problem until
+        * we tune the drive then try to grab DMA ownership if we want to be
+        * the DMA end.  This has to be become dynamic to handle hot-plug.
+        */
+       dma_stat = hwif->INB(dma_base + 2);
+       if ((dma_stat & 0x80) && hwif->mate && hwif->mate->dma_base) {
+               printk(KERN_INFO "%s: simplex device: DMA disabled\n", d->name);
+               dma_base = 0;
+       }
+out:
        return dma_base;
 }
 #endif /* CONFIG_BLK_DEV_IDEDMA_PCI */
@@ -359,6 +351,8 @@ static ide_hwif_t *ide_hwif_configure(struct pci_dev *dev, const struct ide_port
        unsigned long ctl = 0, base = 0;
        ide_hwif_t *hwif;
        u8 bootable = (d->host_flags & IDE_HFLAG_BOOTABLE) ? 1 : 0;
+       u8 oldnoprobe = 0;
+       struct hw_regs_s hw;
 
        if ((d->host_flags & IDE_HFLAG_ISA_PORTS) == 0) {
                /*  Possibly we should fail if these checks report true */
@@ -381,26 +375,25 @@ static ide_hwif_t *ide_hwif_configure(struct pci_dev *dev, const struct ide_port
        }
        if ((hwif = ide_match_hwif(base, bootable, d->name)) == NULL)
                return NULL;    /* no room in ide_hwifs[] */
-       if (hwif->io_ports[IDE_DATA_OFFSET] != base ||
-           hwif->io_ports[IDE_CONTROL_OFFSET] != (ctl | 2)) {
-               hw_regs_t hw;
-
-               memset(&hw, 0, sizeof(hw));
-#ifndef CONFIG_IDE_ARCH_OBSOLETE_INIT
-               ide_std_init_ports(&hw, base, ctl | 2);
-#else
-               ide_init_hwif_ports(&hw, base, ctl | 2, NULL);
-#endif
-               memcpy(hwif->io_ports, hw.io_ports, sizeof(hwif->io_ports));
-               hwif->noprobe = !hwif->io_ports[IDE_DATA_OFFSET];
-       }
-       hwif->chipset = d->chipset ? d->chipset : ide_pci;
-       hwif->pci_dev = dev;
+
+       memset(&hw, 0, sizeof(hw));
+       hw.irq = hwif->irq ? hwif->irq : irq;
+       hw.dev = &dev->dev;
+       hw.chipset = d->chipset ? d->chipset : ide_pci;
+       ide_std_init_ports(&hw, base, ctl | 2);
+
+       if (hwif->io_ports[IDE_DATA_OFFSET] == base &&
+           hwif->io_ports[IDE_CONTROL_OFFSET] == (ctl | 2))
+               oldnoprobe = hwif->noprobe;
+
+       ide_init_port_hw(hwif, &hw);
+
+       hwif->noprobe = oldnoprobe;
+
+       hwif->dev = &dev->dev;
        hwif->cds = d;
        hwif->channel = port;
 
-       if (!hwif->irq)
-               hwif->irq = irq;
        if (mate) {
                hwif->mate = mate;
                mate->mate = hwif;
@@ -446,7 +439,7 @@ static void ide_hwif_setup_dma(struct pci_dev *dev, const struct ide_port_info *
                        if (d->init_dma) {
                                d->init_dma(hwif, dma_base);
                        } else {
-                               ide_setup_dma(hwif, dma_base, 8);
+                               ide_setup_dma(hwif, dma_base);
                        }
                } else {
                        printk(KERN_INFO "%s: %s Bus-Master DMA disabled "
@@ -535,12 +528,8 @@ void ide_pci_setup_ports(struct pci_dev *dev, const struct ide_port_info *d, int
                if ((hwif = ide_hwif_configure(dev, d, mate, port, pciirq)) == NULL)
                        continue;
 
-               /* setup proper ancestral information */
-               hwif->gendev.parent = &dev->dev;
-
                *(idx + port) = hwif->index;
 
-               
                if (d->init_iops)
                        d->init_iops(hwif);
 
@@ -551,8 +540,6 @@ void ide_pci_setup_ports(struct pci_dev *dev, const struct ide_port_info *d, int
                    (d->host_flags & IDE_HFLAG_FORCE_LEGACY_IRQS))
                        hwif->irq = port ? 15 : 14;
 
-               hwif->fixup = d->fixup;
-
                hwif->host_flags = d->host_flags;
                hwif->pio_mask = d->pio_mask;
 
@@ -699,104 +686,3 @@ out:
 }
 
 EXPORT_SYMBOL_GPL(ide_setup_pci_devices);
-
-#ifdef CONFIG_IDEPCI_PCIBUS_ORDER
-/*
- *     Module interfaces
- */
-static int pre_init = 1;               /* Before first ordered IDE scan */
-static LIST_HEAD(ide_pci_drivers);
-
-/*
- *     __ide_pci_register_driver       -       attach IDE driver
- *     @driver: pci driver
- *     @module: owner module of the driver
- *
- *     Registers a driver with the IDE layer. The IDE layer arranges that
- *     boot time setup is done in the expected device order and then 
- *     hands the controllers off to the core PCI code to do the rest of
- *     the work.
- *
- *     Returns are the same as for pci_register_driver
- */
-
-int __ide_pci_register_driver(struct pci_driver *driver, struct module *module,
-                             const char *mod_name)
-{
-       if(!pre_init)
-               return __pci_register_driver(driver, module, mod_name);
-       driver->driver.owner = module;
-       list_add_tail(&driver->node, &ide_pci_drivers);
-       return 0;
-}
-
-EXPORT_SYMBOL_GPL(__ide_pci_register_driver);
-
-/**
- *     ide_scan_pcidev         -       find an IDE driver for a device
- *     @dev: PCI device to check
- *
- *     Look for an IDE driver to handle the device we are considering.
- *     This is only used during boot up to get the ordering correct. After
- *     boot up the pci layer takes over the job.
- */
-static int __init ide_scan_pcidev(struct pci_dev *dev)
-{
-       struct list_head *l;
-       struct pci_driver *d;
-       
-       list_for_each(l, &ide_pci_drivers) {
-               d = list_entry(l, struct pci_driver, node);
-               if (d->id_table) {
-                       const struct pci_device_id *id = pci_match_id(d->id_table,
-                                                                     dev);
-                       if (id != NULL && d->probe(dev, id) >= 0) {
-                               dev->driver = d;
-                               pci_dev_get(dev);
-                               return 1;
-                       }
-               }
-       }
-       return 0;
-}
-
-/**
- *     ide_scan_pcibus         -       perform the initial IDE driver scan
- *     @scan_direction: set for reverse order scanning
- *
- *     Perform the initial bus rather than driver ordered scan of the
- *     PCI drivers. After this all IDE pci handling becomes standard
- *     module ordering not traditionally ordered.
- */
-       
-void __init ide_scan_pcibus (int scan_direction)
-{
-       struct pci_dev *dev = NULL;
-       struct pci_driver *d;
-       struct list_head *l, *n;
-
-       pre_init = 0;
-       if (!scan_direction)
-               while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL)
-                       ide_scan_pcidev(dev);
-       else
-               while ((dev = pci_get_device_reverse(PCI_ANY_ID, PCI_ANY_ID, dev))
-                      != NULL)
-                       ide_scan_pcidev(dev);
-       
-       /*
-        *      Hand the drivers over to the PCI layer now we
-        *      are post init.
-        */
-
-       list_for_each_safe(l, n, &ide_pci_drivers) {
-               list_del(l);
-               d = list_entry(l, struct pci_driver, node);
-               if (__pci_register_driver(d, d->driver.owner, d->driver.mod_name))
-                       printk(KERN_ERR "%s: failed to register driver for %s\n",
-                              __FUNCTION__, d->driver.mod_name);
-       }
-}
-#endif