Most of these contributed by that mysterious figger known as A.C.
Signed-off-by: Jeff Garzik <jeff@garzik.org>
 
        if (!pci_test_config_bits(pdev, &piix_enable_bits[ap->port_no]))
                return -ENOENT;
-               
+
        ap->cbl = ATA_CBL_PATA40;
        return ata_std_prereset(ap);
 }
 
        int rc;
 
        DPRINTK("ENTER\n");
-       
+
        if (ent->irq == 0) {
                dev_printk(KERN_ERR, dev, "is not available: No interrupt assigned.\n");
                return 0;
 
  *     Perform the setup on the device that must be done both at boot
  *     and at resume time.
  */
- 
+
 static void ali_init_chipset(struct pci_dev *pdev)
 {
        u8 rev, tmp;
                port_info[0] = port_info[1] = &info_c5;
 
        ali_init_chipset(pdev);
-       
+
        isa_bridge = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
        if (isa_bridge && rev >= 0x20 && rev < 0xC2) {
                /* Are we paired with a UDMA capable chip */
 
  *     Do any reconfiguration work needed by a resume from RAM. We need
  *     to restore DMA mode support on BIOSen which disabled it
  */
- 
+
 static int cs5520_reinit_one(struct pci_dev *pdev)
 {
        u8 pcicfg;
 
  *     Perform the chip initialisation work that is shared between both
  *     setup and resume paths
  */
- 
+
 static int cs5530_init_chip(void)
 {
        struct pci_dev *master_0 = NULL, *cs5530_0 = NULL, *dev = NULL;
                .port_ops = &cs5530_port_ops
        };
        static struct ata_port_info *port_info[2] = { &info, &info };
-       
+
        /* Chip initialisation */
        if (cs5530_init_chip())
                return -ENODEV;
-               
+
        if (cs5530_is_palmax())
                port_info[1] = &info_palmax_secondary;
 
                BUG();
        return ata_pci_device_resume(pdev);
 }
-       
+
 static const struct pci_device_id cs5530[] = {
        { PCI_VDEVICE(CYRIX, PCI_DEVICE_ID_CYRIX_5530_IDE), },
 
 
 
        if (!pci_test_config_bits(pdev, &hpt36x_enable_bits[ap->port_no]))
                return -ENOENT;
-               
+
        pci_read_config_byte(pdev, 0x5A, &ata66);
        if (ata66 & (1 << ap->port_no))
                ap->cbl = ATA_CBL_PATA40;
 
        };
        if (!pci_test_config_bits(pdev, &hpt37x_enable_bits[ap->port_no]))
                return -ENOENT;
-               
+
        pci_read_config_byte(pdev, 0x5B, &scr2);
        pci_write_config_byte(pdev, 0x5B, scr2 & ~0x01);
        /* Cable register now active */
 
        if (!pci_test_config_bits(pdev, &hpt37x_enable_bits[ap->port_no]))
                return -ENOENT;
-               
+
        /* Do the extra channel work */
        pci_read_config_word(pdev, 0x52, &mcr3);
        pci_read_config_word(pdev, 0x56, &mcr6);
 
  *
  *     Perform the setup required at boot and on resume.
  */
- 
+
 static void hpt3x3_init_chipset(struct pci_dev *dev)
 {
        u16 cmd;
 
 static int jmicron_reinit_one(struct pci_dev *pdev)
 {
        u32 reg;
-       
+
        switch(pdev->device) {
                case PCI_DEVICE_ID_JMICRON_JMB368:
                        break;
 
        for(i = 0; i <= 0x0F; i++)
                printk("%02X:%02X ", i, readb(barp + i));
        printk("\n");
-       
+
        devices = readl(barp + 0x0C);
        pci_iounmap(pdev, barp);
-       
+
        if ((pdev->device == 0x6145) && (ap->port_no == 0) &&
            (!(devices & 0x10)))        /* PATA enable ? */
                return -ENOENT;
 
 {
        /* Force master latency timer to 64 PCI clocks */
        pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0x40);
-       
+
        switch (pdev->device)
        {
                case PCI_DEVICE_ID_SERVERWORKS_OSB4IDE:
 
  *     is powered up on boot and when we resume in case we resumed from RAM.
  *     Returns the final clock settings.
  */
- 
+
 static u8 sil680_init_chip(struct pci_dev *pdev)
 {
        u32 class_rev   = 0;
 
        struct sis_chipset *chipset = NULL;
 
        static struct sis_chipset sis_chipsets[] = {
-       
+
                { 0x0968, &sis_info133 },
                { 0x0966, &sis_info133 },
                { 0x0965, &sis_info133 },
 
 static void via_config_fifo(struct pci_dev *pdev, unsigned int flags)
 {
        u8 enable;
-       
+
        /* 0x40 low bits indicate enabled channels */
        pci_read_config_byte(pdev, 0x40 , &enable);
        enable &= 3;
-       
+
        if (flags & VIA_SET_FIFO) {
                static const u8 fifo_setting[4] = {0x00, 0x60, 0x00, 0x20};
                u8 fifo;
 
        /* Initialise the FIFO for the enabled channels. */
        via_config_fifo(pdev, config->flags);
-       
+
        /* Clock set up */
        switch(config->flags & VIA_UDMA) {
                case VIA_UDMA_NONE:
        u32 timing;
        struct ata_host *host = dev_get_drvdata(&pdev->dev);
        const struct via_isa_bridge *config = host->private_data;
-       
+
        via_config_fifo(pdev, config->flags);
 
        if ((config->flags & VIA_UDMA) == VIA_UDMA_66) {
                timing &= ~0x80008;
                pci_write_config_dword(pdev, 0x50, timing);
        }
-       return ata_pci_device_resume(pdev);     
+       return ata_pci_device_resume(pdev);
 }
 
 static const struct pci_device_id via[] = {
 
  *    Support for the Winbond 83759A when operating in advanced mode.
  *    Multichip mode is not currently supported.
  */
- 
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/pci.h>
        int timing = 0x88 + (ap->port_no * 4) + (adev->devno * 2);
 
        reg = winbond_readcfg(winbond->config, 0x81);
-       
+
        /* Get the timing data in cycles */
        if (reg & 0x40)         /* Fast VLB bus, assume 50MHz */
                ata_timing_compute(adev, adev->pio_mode, &t, 20000, 1000);
        recovery = (FIT(t.recover, 1, 15) + 1) & 0x0F;
        timing = (active << 4) | recovery;
        winbond_writecfg(winbond->config, timing, reg);
-       
+
        /* Load the setup timing */
-       
+
        reg = 0x35;
        if (adev->class != ATA_DEV_ATA)
                reg |= 0x08;    /* FIFO off */
        winbond_writecfg(port, 0x85, reg);
 
        reg = winbond_readcfg(port, 0x81);
-       
+
        if (!(reg & 0x03))              /* Disabled */
                return 0;
 
        for (i = 0; i < 2 ; i ++) {
 
-               if (reg & (1 << i)) {           
+               if (reg & (1 << i)) {
                        /*
                         *      Fill in a probe structure first of all
                         */
                        ae.pio_mask = 0x1F;
 
                        ae.sht = &winbond_sht;
-       
+
                        ae.n_ports = 1;
                        ae.irq = 14 + i;
                        ae.irq_flags = 0;
 
        int ct = 0;
        int i;
-       
+
        if (probe_winbond == 0)
                return -ENODEV;
 
 
 
        if (!(pp->flags & NV_ADMA_PORT_REGISTER_MODE))
                return;
-               
+
        WARN_ON(pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE);
 
        tmp = readw(mmio + NV_ADMA_CTL);
                /* Subtract 1 since an extra entry may be needed for padding, see
                   libata-scsi.c */
                sg_tablesize = LIBATA_MAX_PRD - 1;
-               
+
                /* Since the legacy DMA engine is in use, we need to disable ADMA
                   on the port. */
                adma_enable = 0;
                sg_tablesize = NV_ADMA_SGTBL_TOTAL_LEN;
                adma_enable = 1;
        }
-       
+
        pci_read_config_dword(pdev, NV_MCP_SATA_CFG_20, ¤t_reg);
 
        if(ap->port_no == 1)
        else
                config_mask = NV_MCP_SATA_CFG_20_PORT0_EN |
                              NV_MCP_SATA_CFG_20_PORT0_PWB_EN;
-       
+
        if(adma_enable) {
                new_reg = current_reg | config_mask;
                pp->flags &= ~NV_ADMA_ATAPI_SETUP_COMPLETE;
                new_reg = current_reg & ~config_mask;
                pp->flags |= NV_ADMA_ATAPI_SETUP_COMPLETE;
        }
-       
+
        if(current_reg != new_reg)
                pci_write_config_dword(pdev, NV_MCP_SATA_CFG_20, new_reg);
-       
+
        blk_queue_bounce_limit(sdev->request_queue, bounce_limit);
        blk_queue_segment_boundary(sdev->request_queue, segment_boundary);
        blk_queue_max_hw_segments(sdev->request_queue, sg_tablesize);
                        handled++; /* irq handled if we got here */
                }
        }
-       
+
        if(notifier_clears[0] || notifier_clears[1]) {
                /* Note: Both notifier clear registers must be written
                   if either is set, even if one is zero, according to NVIDIA. */
-               writel(notifier_clears[0], 
+               writel(notifier_clears[0],
                        nv_adma_notifier_clear_block(host->ports[0]));
-               writel(notifier_clears[1], 
+               writel(notifier_clears[1],
                        nv_adma_notifier_clear_block(host->ports[1]));
        }
 
 
                        pi.flags |= ATA_FLAG_SLAVE_POSS;
                }
                break;
-       
+
        case 0x0182:
        case 0x0183:
                pci_read_config_dword ( pdev, 0x6C, &val);
 
 {
        struct ata_probe_ent *probe_ent;
        struct ata_port_info *ppi[2];
-       
+
        ppi[0] = ppi[1] = &vt6420_port_info;
        probe_ent = ata_pci_init_native_mode(pdev, ppi, ATA_PORT_PRIMARY | ATA_PORT_SECONDARY);
        if (!probe_ent)
 
         * most devices.
         */
        ATA_SPINUP_WAIT         = 8000,
-       
+
        /* Horkage types. May be set by libata or controller on drives
           (some horkage may be drive/controller pair dependant */