Merge branch 'upstream-linus' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik...
authorLinus Torvalds <torvalds@woody.linux-foundation.org>
Mon, 26 Feb 2007 22:58:03 +0000 (14:58 -0800)
committerLinus Torvalds <torvalds@woody.linux-foundation.org>
Mon, 26 Feb 2007 22:58:03 +0000 (14:58 -0800)
* 'upstream-linus' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik/libata-dev: (51 commits)
  [libata] bump versions
  [libata] Trim trailing whitespace.
  [libata] sata_mv: Fix 50xx irq mask
  [libata] sata_mv: don't touch reserved bits in EDMA config register
  libata: Use new id_to_dma_mode function to tidy reporting in more drivers (minimally tested)
  pata_pcmcia: Fix oops in 2.6.21-rc1
  Add id_to_dma_mode function for printing DMA modes
  sata_promise: simplify port setup
  sata_promise: fix 20619 new EH merge error
  [libata] ACPI: remove needless ->qc_issue hook existence test
  sata_vsc: refactor vsc_sata_interrupt and hook up error handling
  sata_sil: ignore and clear spurious IRQs while executing commands by polling
  sata_mv: fix pci_enable_msi() error handling
  pata_amd: fix an obvious bug in cable detection
  [libata] ata_piix: remove duplicate PCI IDs
  sata_nv: complain on spurious completion notifiers
  libata: test major version in ata_id_is_sata()
  sata_nv: kill old private BMDMA helper functions
  libata: fix remaining ap->id
  ahci: consider SDB FIS containing spurious NCQ completions HSM violation (regenerated)
  ...

53 files changed:
drivers/ata/Kconfig
drivers/ata/Makefile
drivers/ata/ahci.c
drivers/ata/ata_generic.c
drivers/ata/ata_piix.c
drivers/ata/libata-acpi.c
drivers/ata/libata-core.c
drivers/ata/libata-eh.c
drivers/ata/libata-scsi.c
drivers/ata/libata-sff.c
drivers/ata/libata.h
drivers/ata/pata_ali.c
drivers/ata/pata_amd.c
drivers/ata/pata_cs5520.c
drivers/ata/pata_cs5530.c
drivers/ata/pata_hpt366.c
drivers/ata/pata_hpt37x.c
drivers/ata/pata_isapnp.c
drivers/ata/pata_it821x.c
drivers/ata/pata_ixp4xx_cf.c
drivers/ata/pata_legacy.c
drivers/ata/pata_oldpiix.c
drivers/ata/pata_opti.c
drivers/ata/pata_optidma.c
drivers/ata/pata_pcmcia.c
drivers/ata/pata_pdc2027x.c
drivers/ata/pata_pdc202xx_old.c
drivers/ata/pata_platform.c
drivers/ata/pata_qdi.c
drivers/ata/pata_rz1000.c
drivers/ata/pata_scc.c [new file with mode: 0644]
drivers/ata/pata_serverworks.c
drivers/ata/pata_sil680.c
drivers/ata/pata_sis.c
drivers/ata/pata_sl82c105.c
drivers/ata/pata_via.c
drivers/ata/pata_winbond.c
drivers/ata/pdc_adma.c
drivers/ata/sata_mv.c
drivers/ata/sata_nv.c
drivers/ata/sata_promise.c
drivers/ata/sata_qstor.c
drivers/ata/sata_sil.c
drivers/ata/sata_sil24.c
drivers/ata/sata_sis.c
drivers/ata/sata_svw.c
drivers/ata/sata_sx4.c
drivers/ata/sata_uli.c
drivers/ata/sata_via.c
drivers/ata/sata_vsc.c
drivers/ata/sis.h [new file with mode: 0644]
include/linux/ata.h
include/linux/libata.h

index 4af0a4bb578042fc7c58c6e4448ec01e88a1622c..d16b5b0c8b76b5d0bcacb9fbf5348e33e94492b2 100644 (file)
@@ -562,6 +562,15 @@ config PATA_IXP4XX_CF
 
          If unsure, say N.
 
+config PATA_SCC
+       tristate "Toshiba's Cell Reference Set IDE support"
+       depends on PCI && PPC_IBM_CELL_BLADE
+       help
+         This option enables support for the built-in IDE controller on
+         Toshiba Cell Reference Board.
+
+         If unsure, say N.
+
 endif
 endmenu
 
index 74298afbbaa7c354dd21fc9067a883f4326599e6..13d7397e0008080fe84dc020f69e7f10a5e2b870 100644 (file)
@@ -59,6 +59,7 @@ obj-$(CONFIG_PATA_WINBOND_VLB)        += pata_winbond.o
 obj-$(CONFIG_PATA_SIS)         += pata_sis.o
 obj-$(CONFIG_PATA_TRIFLEX)     += pata_triflex.o
 obj-$(CONFIG_PATA_IXP4XX_CF)   += pata_ixp4xx_cf.o
+obj-$(CONFIG_PATA_SCC)         += pata_scc.o
 obj-$(CONFIG_PATA_PLATFORM)    += pata_platform.o
 # Should be last but one libata driver
 obj-$(CONFIG_ATA_GENERIC)      += ata_generic.o
index 6a3543e062415cfa733e728fd327d3cbe851be14..6d932409aadda228c6d94c5cc8cacf954ee6c523 100644 (file)
@@ -46,7 +46,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME       "ahci"
-#define DRV_VERSION    "2.0"
+#define DRV_VERSION    "2.1"
 
 
 enum {
@@ -198,7 +198,6 @@ struct ahci_port_priv {
        void                    *rx_fis;
        dma_addr_t              rx_fis_dma;
        /* for NCQ spurious interrupt analysis */
-       int                     ncq_saw_spurious_sdb_cnt;
        unsigned int            ncq_saw_d2h:1;
        unsigned int            ncq_saw_dmas:1;
 };
@@ -1160,23 +1159,24 @@ static void ahci_host_intr(struct ata_port *ap)
                known_irq = 1;
        }
 
-       if (status & PORT_IRQ_SDB_FIS &&
-                  pp->ncq_saw_spurious_sdb_cnt < 10) {
+       if (status & PORT_IRQ_SDB_FIS) {
                /* SDB FIS containing spurious completions might be
-                * dangerous, we need to know more about them.  Print
-                * more of it.
-                */
+                * dangerous, whine and fail commands with HSM
+                * violation.  EH will turn off NCQ after several such
+                * failures.
+                */
                const __le32 *f = pp->rx_fis + RX_FIS_SDB;
 
-               ata_port_printk(ap, KERN_INFO, "Spurious SDB FIS during NCQ "
-                               "issue=0x%x SAct=0x%x FIS=%08x:%08x%s\n",
-                               readl(port_mmio + PORT_CMD_ISSUE),
-                               readl(port_mmio + PORT_SCR_ACT),
-                               le32_to_cpu(f[0]), le32_to_cpu(f[1]),
-                               pp->ncq_saw_spurious_sdb_cnt < 10 ?
-                               "" : ", shutting up");
+               ata_ehi_push_desc(ehi, "spurious completion during NCQ "
+                                 "issue=0x%x SAct=0x%x FIS=%08x:%08x",
+                                 readl(port_mmio + PORT_CMD_ISSUE),
+                                 readl(port_mmio + PORT_SCR_ACT),
+                                 le32_to_cpu(f[0]), le32_to_cpu(f[1]));
+
+               ehi->err_mask |= AC_ERR_HSM;
+               ehi->action |= ATA_EH_SOFTRESET;
+               ata_port_freeze(ap);
 
-               pp->ncq_saw_spurious_sdb_cnt++;
                known_irq = 1;
        }
 
index be66ea08da551f16fa76459510e8cc75fa65f0f1..f48b4883c9306cbc32d94ecc6fd888425e7dbbe8 100644 (file)
@@ -26,7 +26,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME "ata_generic"
-#define DRV_VERSION "0.2.10"
+#define DRV_VERSION "0.2.11"
 
 /*
  *     A generic parallel ATA driver using libata
@@ -90,10 +90,10 @@ static int generic_set_mode(struct ata_port *ap, struct ata_device **unused)
                        /* We do need the right mode information for DMA or PIO
                           and this comes from the current configuration flags */
                        if (dma_enabled & (1 << (5 + i))) {
-                               dev->xfer_mode = XFER_MW_DMA_0;
-                               dev->xfer_shift = ATA_SHIFT_MWDMA;
+                               ata_id_to_dma_mode(dev, XFER_MW_DMA_0);
                                dev->flags &= ~ATA_DFLAG_PIO;
                        } else {
+                               ata_dev_printk(dev, KERN_INFO, "configured for PIO\n");
                                dev->xfer_mode = XFER_PIO_0;
                                dev->xfer_shift = ATA_SHIFT_PIO;
                                dev->flags |= ATA_DFLAG_PIO;
index 4d716c7347e70c9bf8195db78ec5377a605db57d..61572d8c78ad7fae3280080fccd424f85f050cb3 100644 (file)
@@ -93,7 +93,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME       "ata_piix"
-#define DRV_VERSION    "2.00ac7"
+#define DRV_VERSION    "2.10"
 
 enum {
        PIIX_IOCFG              = 0x54, /* IDE I/O configuration register */
@@ -169,8 +169,6 @@ static const struct pci_device_id piix_pci_tbl[] = {
        /* Intel PIIX4 for the 430TX/440BX/MX chipset: UDMA 33 */
        /* Also PIIX4E (fn3 rev 2) and PIIX4M (fn3 rev 3) */
        { 0x8086, 0x7111, PCI_ANY_ID, PCI_ANY_ID, 0, 0, piix_pata_33 },
-       { 0x8086, 0x24db, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
-       { 0x8086, 0x25a2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
        /* Intel PIIX4 */
        { 0x8086, 0x7199, PCI_ANY_ID, PCI_ANY_ID, 0, 0, piix_pata_33 },
        /* Intel PIIX4 */
index b4e8be5d292c9293310e8a7b6fe9ead8ce2baeea..d14a48e75f1b50414c3cbfba2afff82ce8c853d2 100644 (file)
@@ -294,9 +294,8 @@ static int do_drive_get_GTF(struct ata_port *ap, int ix,
                return 0;
 
        if (ata_msg_probe(ap))
-               ata_dev_printk(atadev, KERN_DEBUG,
-                       "%s: ENTER: ap->id: %d, port#: %d\n",
-                       __FUNCTION__, ap->id, ap->port_no);
+               ata_dev_printk(atadev, KERN_DEBUG, "%s: ENTER: port#: %d\n",
+                              __FUNCTION__, ap->port_no);
 
        if (!ata_dev_enabled(atadev) || (ap->flags & ATA_FLAG_DISABLED)) {
                if (ata_msg_probe(ap))
@@ -456,6 +455,9 @@ static void taskfile_load_raw(struct ata_port *ap,
                                struct ata_device *atadev,
                                const struct taskfile_array *gtf)
 {
+       struct ata_taskfile tf;
+       unsigned int err;
+
        if (ata_msg_probe(ap))
                ata_dev_printk(atadev, KERN_DEBUG, "%s: (0x1f1-1f7): hex: "
                        "%02x %02x %02x %02x %02x %02x %02x\n",
@@ -468,35 +470,25 @@ static void taskfile_load_raw(struct ata_port *ap,
            && (gtf->tfa[6] == 0))
                return;
 
-       if (ap->ops->qc_issue) {
-               struct ata_taskfile tf;
-               unsigned int err;
-
-               ata_tf_init(atadev, &tf);
-
-               /* convert gtf to tf */
-               tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; /* TBD */
-               tf.protocol = atadev->class == ATA_DEV_ATAPI ?
-                       ATA_PROT_ATAPI_NODATA : ATA_PROT_NODATA;
-               tf.feature = gtf->tfa[0];       /* 0x1f1 */
-               tf.nsect   = gtf->tfa[1];       /* 0x1f2 */
-               tf.lbal    = gtf->tfa[2];       /* 0x1f3 */
-               tf.lbam    = gtf->tfa[3];       /* 0x1f4 */
-               tf.lbah    = gtf->tfa[4];       /* 0x1f5 */
-               tf.device  = gtf->tfa[5];       /* 0x1f6 */
-               tf.command = gtf->tfa[6];       /* 0x1f7 */
-
-               err = ata_exec_internal(atadev, &tf, NULL, DMA_NONE, NULL, 0);
-               if (err && ata_msg_probe(ap))
-                       ata_dev_printk(atadev, KERN_ERR,
-                               "%s: ata_exec_internal failed: %u\n",
-                               __FUNCTION__, err);
-       } else
-               if (ata_msg_warn(ap))
-                       ata_dev_printk(atadev, KERN_WARNING,
-                               "%s: SATA driver is missing qc_issue function"
-                               " entry points\n",
-                               __FUNCTION__);
+       ata_tf_init(atadev, &tf);
+
+       /* convert gtf to tf */
+       tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; /* TBD */
+       tf.protocol = atadev->class == ATA_DEV_ATAPI ?
+               ATA_PROT_ATAPI_NODATA : ATA_PROT_NODATA;
+       tf.feature = gtf->tfa[0];       /* 0x1f1 */
+       tf.nsect   = gtf->tfa[1];       /* 0x1f2 */
+       tf.lbal    = gtf->tfa[2];       /* 0x1f3 */
+       tf.lbam    = gtf->tfa[3];       /* 0x1f4 */
+       tf.lbah    = gtf->tfa[4];       /* 0x1f5 */
+       tf.device  = gtf->tfa[5];       /* 0x1f6 */
+       tf.command = gtf->tfa[6];       /* 0x1f7 */
+
+       err = ata_exec_internal(atadev, &tf, NULL, DMA_NONE, NULL, 0);
+       if (err && ata_msg_probe(ap))
+               ata_dev_printk(atadev, KERN_ERR,
+                       "%s: ata_exec_internal failed: %u\n",
+                       __FUNCTION__, err);
 }
 
 /**
@@ -521,9 +513,8 @@ static int do_drive_set_taskfiles(struct ata_port *ap,
        struct taskfile_array   *gtf;
 
        if (ata_msg_probe(ap))
-               ata_dev_printk(atadev, KERN_DEBUG,
-                       "%s: ENTER: ap->id: %d, port#: %d\n",
-                       __FUNCTION__, ap->id, ap->port_no);
+               ata_dev_printk(atadev, KERN_DEBUG, "%s: ENTER: port#: %d\n",
+                              __FUNCTION__, ap->port_no);
 
        if (noacpi || !(ap->cbl == ATA_CBL_SATA))
                return 0;
@@ -627,9 +618,8 @@ int ata_acpi_push_id(struct ata_port *ap, unsigned int ix)
                return 0;
 
        if (ata_msg_probe(ap))
-               ata_dev_printk(atadev, KERN_DEBUG,
-                       "%s: ap->id: %d, ix = %d, port#: %d\n",
-                       __FUNCTION__, ap->id, ix, ap->port_no);
+               ata_dev_printk(atadev, KERN_DEBUG, "%s: ix = %d, port#: %d\n",
+                              __FUNCTION__, ix, ap->port_no);
 
        /* Don't continue if not a SATA device. */
        if (!(ap->cbl == ATA_CBL_SATA)) {
@@ -685,9 +675,8 @@ int ata_acpi_push_id(struct ata_port *ap, unsigned int ix)
        if (err < 0) {
                if (ata_msg_probe(ap))
                        ata_dev_printk(atadev, KERN_DEBUG,
-                               "ata%u(%u): %s _SDD error: status = 0x%x\n",
-                               ap->id, ap->device->devno,
-                               __FUNCTION__, status);
+                                      "%s _SDD error: status = 0x%x\n",
+                                      __FUNCTION__, status);
        }
 
        /* always return success */
index e900c5edefc4a55af483513dddbfdbc1129d7101..c8d44a7c403fe1171d762e7cba511dfb2d97f383 100644 (file)
@@ -59,7 +59,7 @@
 
 #include "libata.h"
 
-#define DRV_VERSION    "2.10"  /* must be exactly four chars */
+#define DRV_VERSION    "2.20"  /* must be exactly four chars */
 
 
 /* debounce timing parameters in msecs { interval, duration, timeout } */
@@ -72,7 +72,7 @@ static unsigned int ata_dev_init_params(struct ata_device *dev,
 static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
 static void ata_dev_xfermask(struct ata_device *dev);
 
-static unsigned int ata_unique_id = 1;
+static unsigned int ata_print_id = 1;
 static struct workqueue_struct *ata_wq;
 
 struct workqueue_struct *ata_aux_wq;
@@ -315,9 +315,7 @@ int ata_build_rw_tf(struct ata_taskfile *tf, struct ata_device *dev,
        tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
        tf->flags |= tf_flags;
 
-       if ((dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ_OFF |
-                          ATA_DFLAG_NCQ)) == ATA_DFLAG_NCQ &&
-           likely(tag != ATA_TAG_INTERNAL)) {
+       if (ata_ncq_enabled(dev) && likely(tag != ATA_TAG_INTERNAL)) {
                /* yay, NCQ */
                if (!lba_48_ok(block, n_block))
                        return -ERANGE;
@@ -600,6 +598,8 @@ void ata_dev_disable(struct ata_device *dev)
 {
        if (ata_dev_enabled(dev) && ata_msg_drv(dev->ap)) {
                ata_dev_printk(dev, KERN_WARNING, "disabled\n");
+               ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 |
+                                            ATA_DNXFER_QUIET);
                dev->class++;
        }
 }
@@ -708,7 +708,7 @@ unsigned int ata_dev_classify(const struct ata_taskfile *tf)
  *     Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE.
  */
 
-static unsigned int
+unsigned int
 ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
 {
        struct ata_taskfile tf;
@@ -823,6 +823,48 @@ static u64 ata_id_n_sectors(const u16 *id)
        }
 }
 
+/**
+ *     ata_id_to_dma_mode      -       Identify DMA mode from id block
+ *     @dev: device to identify
+ *     @mode: mode to assume if we cannot tell
+ *
+ *     Set up the timing values for the device based upon the identify
+ *     reported values for the DMA mode. This function is used by drivers
+ *     which rely upon firmware configured modes, but wish to report the
+ *     mode correctly when possible.
+ *
+ *     In addition we emit similarly formatted messages to the default
+ *     ata_dev_set_mode handler, in order to provide consistency of
+ *     presentation.
+ */
+
+void ata_id_to_dma_mode(struct ata_device *dev, u8 unknown)
+{
+       unsigned int mask;
+       u8 mode;
+
+       /* Pack the DMA modes */
+       mask = ((dev->id[63] >> 8) << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA;
+       if (dev->id[53] & 0x04)
+               mask |= ((dev->id[88] >> 8) << ATA_SHIFT_UDMA) & ATA_MASK_UDMA;
+
+       /* Select the mode in use */
+       mode = ata_xfer_mask2mode(mask);
+
+       if (mode != 0) {
+               ata_dev_printk(dev, KERN_INFO, "configured for %s\n",
+                      ata_mode_string(mask));
+       } else {
+               /* SWDMA perhaps ? */
+               mode = unknown;
+               ata_dev_printk(dev, KERN_INFO, "configured for DMA\n");
+       }
+
+       /* Configure the device reporting */
+       dev->xfer_mode = mode;
+       dev->xfer_shift = ata_xfer_mode2shift(mode);
+}
+
 /**
  *     ata_noop_dev_select - Select device 0/1 on ATA bus
  *     @ap: ATA channel to manipulate
@@ -891,8 +933,8 @@ void ata_dev_select(struct ata_port *ap, unsigned int device,
                           unsigned int wait, unsigned int can_sleep)
 {
        if (ata_msg_probe(ap))
-               ata_port_printk(ap, KERN_INFO, "ata_dev_select: ENTER, ata%u: "
-                               "device %u, wait %u\n", ap->id, device, wait);
+               ata_port_printk(ap, KERN_INFO, "ata_dev_select: ENTER, "
+                               "device %u, wait %u\n", device, wait);
 
        if (wait)
                ata_wait_idle(ap);
@@ -1392,8 +1434,7 @@ int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
        int rc;
 
        if (ata_msg_ctl(ap))
-               ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER, host %u, dev %u\n",
-                              __FUNCTION__, ap->id, dev->devno);
+               ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __FUNCTION__);
 
        ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
 
@@ -1430,7 +1471,7 @@ int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
        if (err_mask) {
                if (err_mask & AC_ERR_NODEV_HINT) {
                        DPRINTK("ata%u.%d: NODEV after polling detection\n",
-                               ap->id, dev->devno);
+                               ap->print_id, dev->devno);
                        return -ENOENT;
                }
 
@@ -1558,15 +1599,13 @@ int ata_dev_configure(struct ata_device *dev)
        int rc;
 
        if (!ata_dev_enabled(dev) && ata_msg_info(ap)) {
-               ata_dev_printk(dev, KERN_INFO,
-                              "%s: ENTER/EXIT (host %u, dev %u) -- nodev\n",
-                              __FUNCTION__, ap->id, dev->devno);
+               ata_dev_printk(dev, KERN_INFO, "%s: ENTER/EXIT -- nodev\n",
+                              __FUNCTION__);
                return 0;
        }
 
        if (ata_msg_probe(ap))
-               ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER, host %u, dev %u\n",
-                              __FUNCTION__, ap->id, dev->devno);
+               ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __FUNCTION__);
 
        /* set _SDD */
        rc = ata_acpi_push_id(ap, dev->devno);
@@ -1610,8 +1649,9 @@ int ata_dev_configure(struct ata_device *dev)
        if (dev->class == ATA_DEV_ATA) {
                if (ata_id_is_cfa(id)) {
                        if (id[162] & 1) /* CPRM may make this media unusable */
-                               ata_dev_printk(dev, KERN_WARNING, "ata%u: device %u  supports DRM functions and may not be fully accessable.\n",
-                                       ap->id, dev->devno);
+                               ata_dev_printk(dev, KERN_WARNING,
+                                              "supports DRM functions and may "
+                                              "not be fully accessable.\n");
                        snprintf(revbuf, 7, "CFA");
                }
                else
@@ -1679,7 +1719,7 @@ int ata_dev_configure(struct ata_device *dev)
                                        "%s: %s, %s, max %s\n",
                                        revbuf, modelbuf, fwrevbuf,
                                        ata_mode_string(xfer_mask));
-                               ata_dev_printk(dev, KERN_INFO, 
+                               ata_dev_printk(dev, KERN_INFO,
                                        "%Lu sectors, multi %u, CHS %u/%u/%u\n",
                                        (unsigned long long)dev->n_sectors,
                                        dev->multi_count, dev->cylinders,
@@ -1778,7 +1818,7 @@ int ata_bus_probe(struct ata_port *ap)
 {
        unsigned int classes[ATA_MAX_DEVICES];
        int tries[ATA_MAX_DEVICES];
-       int i, rc, down_xfermask;
+       int i, rc;
        struct ata_device *dev;
 
        ata_port_probe(ap);
@@ -1787,8 +1827,6 @@ int ata_bus_probe(struct ata_port *ap)
                tries[i] = ATA_PROBE_MAX_TRIES;
 
  retry:
-       down_xfermask = 0;
-
        /* reset and determine device classes */
        ap->ops->phy_reset(ap);
 
@@ -1836,10 +1874,8 @@ int ata_bus_probe(struct ata_port *ap)
 
        /* configure transfer mode */
        rc = ata_set_mode(ap, &dev);
-       if (rc) {
-               down_xfermask = 1;
+       if (rc)
                goto fail;
-       }
 
        for (i = 0; i < ATA_MAX_DEVICES; i++)
                if (ata_dev_enabled(&ap->device[i]))
@@ -1851,25 +1887,29 @@ int ata_bus_probe(struct ata_port *ap)
        return -ENODEV;
 
  fail:
+       tries[dev->devno]--;
+
        switch (rc) {
        case -EINVAL:
-       case -ENODEV:
+               /* eeek, something went very wrong, give up */
                tries[dev->devno] = 0;
                break;
+
+       case -ENODEV:
+               /* give it just one more chance */
+               tries[dev->devno] = min(tries[dev->devno], 1);
        case -EIO:
-               sata_down_spd_limit(ap);
-               /* fall through */
-       default:
-               tries[dev->devno]--;
-               if (down_xfermask &&
-                   ata_down_xfermask_limit(dev, tries[dev->devno] == 1))
-                       tries[dev->devno] = 0;
+               if (tries[dev->devno] == 1) {
+                       /* This is the last chance, better to slow
+                        * down than lose it.
+                        */
+                       sata_down_spd_limit(ap);
+                       ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
+               }
        }
 
-       if (!tries[dev->devno]) {
-               ata_down_xfermask_limit(dev, 1);
+       if (!tries[dev->devno])
                ata_dev_disable(dev);
-       }
 
        goto retry;
 }
@@ -2300,7 +2340,7 @@ int ata_timing_compute(struct ata_device *adev, unsigned short speed,
 /**
  *     ata_down_xfermask_limit - adjust dev xfer masks downward
  *     @dev: Device to adjust xfer masks
- *     @force_pio0: Force PIO0
+ *     @sel: ATA_DNXFER_* selector
  *
  *     Adjust xfer masks of @dev downward.  Note that this function
  *     does not apply the change.  Invoking ata_set_mode() afterwards
@@ -2312,37 +2352,78 @@ int ata_timing_compute(struct ata_device *adev, unsigned short speed,
  *     RETURNS:
  *     0 on success, negative errno on failure
  */
-int ata_down_xfermask_limit(struct ata_device *dev, int force_pio0)
+int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel)
 {
-       unsigned long xfer_mask;
-       int highbit;
+       char buf[32];
+       unsigned int orig_mask, xfer_mask;
+       unsigned int pio_mask, mwdma_mask, udma_mask;
+       int quiet, highbit;
 
-       xfer_mask = ata_pack_xfermask(dev->pio_mask, dev->mwdma_mask,
-                                     dev->udma_mask);
+       quiet = !!(sel & ATA_DNXFER_QUIET);
+       sel &= ~ATA_DNXFER_QUIET;
 
-       if (!xfer_mask)
-               goto fail;
-       /* don't gear down to MWDMA from UDMA, go directly to PIO */
-       if (xfer_mask & ATA_MASK_UDMA)
-               xfer_mask &= ~ATA_MASK_MWDMA;
+       xfer_mask = orig_mask = ata_pack_xfermask(dev->pio_mask,
+                                                 dev->mwdma_mask,
+                                                 dev->udma_mask);
+       ata_unpack_xfermask(xfer_mask, &pio_mask, &mwdma_mask, &udma_mask);
 
-       highbit = fls(xfer_mask) - 1;
-       xfer_mask &= ~(1 << highbit);
-       if (force_pio0)
-               xfer_mask &= 1 << ATA_SHIFT_PIO;
-       if (!xfer_mask)
-               goto fail;
+       switch (sel) {
+       case ATA_DNXFER_PIO:
+               highbit = fls(pio_mask) - 1;
+               pio_mask &= ~(1 << highbit);
+               break;
+
+       case ATA_DNXFER_DMA:
+               if (udma_mask) {
+                       highbit = fls(udma_mask) - 1;
+                       udma_mask &= ~(1 << highbit);
+                       if (!udma_mask)
+                               return -ENOENT;
+               } else if (mwdma_mask) {
+                       highbit = fls(mwdma_mask) - 1;
+                       mwdma_mask &= ~(1 << highbit);
+                       if (!mwdma_mask)
+                               return -ENOENT;
+               }
+               break;
+
+       case ATA_DNXFER_40C:
+               udma_mask &= ATA_UDMA_MASK_40C;
+               break;
+
+       case ATA_DNXFER_FORCE_PIO0:
+               pio_mask &= 1;
+       case ATA_DNXFER_FORCE_PIO:
+               mwdma_mask = 0;
+               udma_mask = 0;
+               break;
+
+       default:
+               BUG();
+       }
+
+       xfer_mask &= ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
+
+       if (!(xfer_mask & ATA_MASK_PIO) || xfer_mask == orig_mask)
+               return -ENOENT;
+
+       if (!quiet) {
+               if (xfer_mask & (ATA_MASK_MWDMA | ATA_MASK_UDMA))
+                       snprintf(buf, sizeof(buf), "%s:%s",
+                                ata_mode_string(xfer_mask),
+                                ata_mode_string(xfer_mask & ATA_MASK_PIO));
+               else
+                       snprintf(buf, sizeof(buf), "%s",
+                                ata_mode_string(xfer_mask));
+
+               ata_dev_printk(dev, KERN_WARNING,
+                              "limiting speed to %s\n", buf);
+       }
 
        ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
                            &dev->udma_mask);
 
-       ata_dev_printk(dev, KERN_WARNING, "limiting speed to %s\n",
-                      ata_mode_string(xfer_mask));
-
        return 0;
-
- fail:
-       return -EINVAL;
 }
 
 static int ata_dev_set_mode(struct ata_device *dev)
@@ -2609,7 +2690,7 @@ static unsigned int ata_bus_softreset(struct ata_port *ap,
 {
        struct ata_ioports *ioaddr = &ap->ioaddr;
 
-       DPRINTK("ata%u: bus reset via SRST\n", ap->id);
+       DPRINTK("ata%u: bus reset via SRST\n", ap->print_id);
 
        /* software reset.  causes dev0 to be selected */
        iowrite8(ap->ctl, ioaddr->ctl_addr);
@@ -2669,7 +2750,7 @@ void ata_bus_reset(struct ata_port *ap)
        u8 err;
        unsigned int dev0, dev1 = 0, devmask = 0;
 
-       DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no);
+       DPRINTK("ENTER, host %u, port %u\n", ap->print_id, ap->port_no);
 
        /* determine if device 0/1 are present */
        if (ap->flags & ATA_FLAG_SATA_RESET)
@@ -3256,7 +3337,6 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
        { "WPI CDD-820",        NULL,           ATA_HORKAGE_NODMA },
        { "SAMSUNG CD-ROM SC-148C", NULL,       ATA_HORKAGE_NODMA },
        { "SAMSUNG CD-ROM SC",  NULL,           ATA_HORKAGE_NODMA },
-       { "SanDisk SDP3B-64",   NULL,           ATA_HORKAGE_NODMA },
        { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA },
        { "_NEC DV5800A",       NULL,           ATA_HORKAGE_NODMA },
        { "SAMSUNG CD-ROM SN-124","N001",       ATA_HORKAGE_NODMA },
@@ -3739,7 +3819,7 @@ static int ata_sg_setup(struct ata_queued_cmd *qc)
        struct scatterlist *lsg = &sg[qc->n_elem - 1];
        int n_elem, pre_n_elem, dir, trim_sg = 0;
 
-       VPRINTK("ENTER, ata%u\n", ap->id);
+       VPRINTK("ENTER, ata%u\n", ap->print_id);
        WARN_ON(!(qc->flags & ATA_QCFLAG_SG));
 
        /* we must lengthen transfers to end on a 32-bit boundary */
@@ -4140,7 +4220,7 @@ static void atapi_pio_bytes(struct ata_queued_cmd *qc)
        if (do_write != i_write)
                goto err_out;
 
-       VPRINTK("ata%u: xfering %d bytes\n", ap->id, bytes);
+       VPRINTK("ata%u: xfering %d bytes\n", ap->print_id, bytes);
 
        __atapi_pio_bytes(qc, bytes);
 
@@ -4257,7 +4337,7 @@ int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
 
 fsm_start:
        DPRINTK("ata%u: protocol %d task_state %d (dev_stat 0x%X)\n",
-               ap->id, qc->tf.protocol, ap->hsm_task_state, status);
+               ap->print_id, qc->tf.protocol, ap->hsm_task_state, status);
 
        switch (ap->hsm_task_state) {
        case HSM_ST_FIRST:
@@ -4290,8 +4370,8 @@ fsm_start:
                 * let the EH abort the command or reset the device.
                 */
                if (unlikely(status & (ATA_ERR | ATA_DF))) {
-                       printk(KERN_WARNING "ata%d: DRQ=1 with device error, dev_stat 0x%X\n",
-                              ap->id, status);
+                       ata_port_printk(ap, KERN_WARNING, "DRQ=1 with device "
+                                       "error, dev_stat 0x%X\n", status);
                        qc->err_mask |= AC_ERR_HSM;
                        ap->hsm_task_state = HSM_ST_ERR;
                        goto fsm_start;
@@ -4348,8 +4428,9 @@ fsm_start:
                         * let the EH abort the command or reset the device.
                         */
                        if (unlikely(status & (ATA_ERR | ATA_DF))) {
-                               printk(KERN_WARNING "ata%d: DRQ=1 with device error, dev_stat 0x%X\n",
-                                      ap->id, status);
+                               ata_port_printk(ap, KERN_WARNING, "DRQ=1 with "
+                                               "device error, dev_stat 0x%X\n",
+                                               status);
                                qc->err_mask |= AC_ERR_HSM;
                                ap->hsm_task_state = HSM_ST_ERR;
                                goto fsm_start;
@@ -4435,7 +4516,7 @@ fsm_start:
 
                /* no more data to transfer */
                DPRINTK("ata%u: dev %u command complete, drv_stat 0x%x\n",
-                       ap->id, qc->dev->devno, status);
+                       ap->print_id, qc->dev->devno, status);
 
                WARN_ON(qc->err_mask);
 
@@ -4977,7 +5058,7 @@ inline unsigned int ata_host_intr (struct ata_port *ap,
        u8 status, host_stat = 0;
 
        VPRINTK("ata%u: protocol %d task_state %d\n",
-               ap->id, qc->tf.protocol, ap->hsm_task_state);
+               ap->print_id, qc->tf.protocol, ap->hsm_task_state);
 
        /* Check whether we are expecting interrupt in this state */
        switch (ap->hsm_task_state) {
@@ -4998,7 +5079,8 @@ inline unsigned int ata_host_intr (struct ata_port *ap,
                    qc->tf.protocol == ATA_PROT_ATAPI_DMA) {
                        /* check status of DMA engine */
                        host_stat = ap->ops->bmdma_status(ap);
-                       VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
+                       VPRINTK("ata%u: host_stat 0x%X\n",
+                               ap->print_id, host_stat);
 
                        /* if it's not our irq... */
                        if (!(host_stat & ATA_DMA_INTR))
@@ -5457,7 +5539,7 @@ void ata_port_init(struct ata_port *ap, struct ata_host *host,
 
        ap->lock = &host->lock;
        ap->flags = ATA_FLAG_DISABLED;
-       ap->id = ata_unique_id++;
+       ap->print_id = ata_print_id++;
        ap->ctl = ATA_DEVCTL_OBS;
        ap->host = host;
        ap->dev = ent->dev;
@@ -5528,7 +5610,7 @@ static void ata_port_init_shost(struct ata_port *ap, struct Scsi_Host *shost)
 {
        ap->scsi_host = shost;
 
-       shost->unique_id = ap->id;
+       shost->unique_id = ap->print_id;
        shost->max_id = 16;
        shost->max_lun = 1;
        shost->max_channel = 1;
@@ -5792,9 +5874,9 @@ int ata_device_add(const struct ata_probe_ent *ent)
                        /* wait for EH to finish */
                        ata_port_wait_eh(ap);
                } else {
-                       DPRINTK("ata%u: bus probe begin\n", ap->id);
+                       DPRINTK("ata%u: bus probe begin\n", ap->print_id);
                        rc = ata_bus_probe(ap);
-                       DPRINTK("ata%u: bus probe end\n", ap->id);
+                       DPRINTK("ata%u: bus probe end\n", ap->print_id);
 
                        if (rc) {
                                /* FIXME: do something useful here?
@@ -5905,11 +5987,7 @@ ata_probe_ent_alloc(struct device *dev, const struct ata_port_info *port)
 {
        struct ata_probe_ent *probe_ent;
 
-       /* XXX - the following if can go away once all LLDs are managed */
-       if (!list_empty(&dev->devres_head))
-               probe_ent = devm_kzalloc(dev, sizeof(*probe_ent), GFP_KERNEL);
-       else
-               probe_ent = kzalloc(sizeof(*probe_ent), GFP_KERNEL);
+       probe_ent = devm_kzalloc(dev, sizeof(*probe_ent), GFP_KERNEL);
        if (!probe_ent) {
                printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
                       kobject_name(&(dev->kobj)));
@@ -6015,11 +6093,10 @@ int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
 void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg)
 {
        pci_save_state(pdev);
+       pci_disable_device(pdev);
 
-       if (mesg.event == PM_EVENT_SUSPEND) {
-               pci_disable_device(pdev);
+       if (mesg.event == PM_EVENT_SUSPEND)
                pci_set_power_state(pdev, PCI_D3hot);
-       }
 }
 
 int ata_pci_device_do_resume(struct pci_dev *pdev)
@@ -6241,6 +6318,7 @@ EXPORT_SYMBOL_GPL(ata_bmdma_drive_eh);
 EXPORT_SYMBOL_GPL(ata_bmdma_error_handler);
 EXPORT_SYMBOL_GPL(ata_bmdma_post_internal_cmd);
 EXPORT_SYMBOL_GPL(ata_port_probe);
+EXPORT_SYMBOL_GPL(ata_dev_disable);
 EXPORT_SYMBOL_GPL(sata_set_spd);
 EXPORT_SYMBOL_GPL(sata_phy_debounce);
 EXPORT_SYMBOL_GPL(sata_phy_resume);
@@ -6275,6 +6353,7 @@ EXPORT_SYMBOL_GPL(ata_host_suspend);
 EXPORT_SYMBOL_GPL(ata_host_resume);
 EXPORT_SYMBOL_GPL(ata_id_string);
 EXPORT_SYMBOL_GPL(ata_id_c_string);
+EXPORT_SYMBOL_GPL(ata_id_to_dma_mode);
 EXPORT_SYMBOL_GPL(ata_device_blacklisted);
 EXPORT_SYMBOL_GPL(ata_scsi_simulate);
 
@@ -6311,3 +6390,4 @@ EXPORT_SYMBOL_GPL(ata_irq_on);
 EXPORT_SYMBOL_GPL(ata_dummy_irq_on);
 EXPORT_SYMBOL_GPL(ata_irq_ack);
 EXPORT_SYMBOL_GPL(ata_dummy_irq_ack);
+EXPORT_SYMBOL_GPL(ata_dev_try_classify);
index 52c85af7fe9912492cd9353a4d92f78e3a600e9c..cad0d6db6df59e44c2d699882fbac55c01667f70 100644 (file)
 
 #include "libata.h"
 
+enum {
+       ATA_EH_SPDN_NCQ_OFF             = (1 << 0),
+       ATA_EH_SPDN_SPEED_DOWN          = (1 << 1),
+       ATA_EH_SPDN_FALLBACK_TO_PIO     = (1 << 2),
+};
+
 static void __ata_port_freeze(struct ata_port *ap);
 static void ata_eh_finish(struct ata_port *ap);
 static void ata_eh_handle_port_suspend(struct ata_port *ap);
@@ -65,12 +71,9 @@ static void ata_ering_record(struct ata_ering *ering, int is_io,
        ent->timestamp = get_jiffies_64();
 }
 
-static struct ata_ering_entry * ata_ering_top(struct ata_ering *ering)
+static void ata_ering_clear(struct ata_ering *ering)
 {
-       struct ata_ering_entry *ent = &ering->ring[ering->cursor];
-       if (!ent->err_mask)
-               return NULL;
-       return ent;
+       memset(ering, 0, sizeof(*ering));
 }
 
 static int ata_ering_map(struct ata_ering *ering,
@@ -585,7 +588,7 @@ static void __ata_port_freeze(struct ata_port *ap)
 
        ap->pflags |= ATA_PFLAG_FROZEN;
 
-       DPRINTK("ata%u port frozen\n", ap->id);
+       DPRINTK("ata%u port frozen\n", ap->print_id);
 }
 
 /**
@@ -658,7 +661,7 @@ void ata_eh_thaw_port(struct ata_port *ap)
 
        spin_unlock_irqrestore(ap->lock, flags);
 
-       DPRINTK("ata%u port thawed\n", ap->id);
+       DPRINTK("ata%u port thawed\n", ap->print_id);
 }
 
 static void ata_eh_scsidone(struct scsi_cmnd *scmd)
@@ -1159,87 +1162,99 @@ static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc,
        return action;
 }
 
-static int ata_eh_categorize_ering_entry(struct ata_ering_entry *ent)
+static int ata_eh_categorize_error(int is_io, unsigned int err_mask)
 {
-       if (ent->err_mask & (AC_ERR_ATA_BUS | AC_ERR_TIMEOUT))
+       if (err_mask & AC_ERR_ATA_BUS)
                return 1;
 
-       if (ent->is_io) {
-               if (ent->err_mask & AC_ERR_HSM)
-                       return 1;
-               if ((ent->err_mask &
-                    (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV)
+       if (err_mask & AC_ERR_TIMEOUT)
+               return 2;
+
+       if (is_io) {
+               if (err_mask & AC_ERR_HSM)
                        return 2;
+               if ((err_mask &
+                    (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV)
+                       return 3;
        }
 
        return 0;
 }
 
-struct speed_down_needed_arg {
+struct speed_down_verdict_arg {
        u64 since;
-       int nr_errors[3];
+       int nr_errors[4];
 };
 
-static int speed_down_needed_cb(struct ata_ering_entry *ent, void *void_arg)
+static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg)
 {
-       struct speed_down_needed_arg *arg = void_arg;
+       struct speed_down_verdict_arg *arg = void_arg;
+       int cat = ata_eh_categorize_error(ent->is_io, ent->err_mask);
 
        if (ent->timestamp < arg->since)
                return -1;
 
-       arg->nr_errors[ata_eh_categorize_ering_entry(ent)]++;
+       arg->nr_errors[cat]++;
        return 0;
 }
 
 /**
- *     ata_eh_speed_down_needed - Determine wheter speed down is necessary
+ *     ata_eh_speed_down_verdict - Determine speed down verdict
  *     @dev: Device of interest
  *
  *     This function examines error ring of @dev and determines
- *     whether speed down is necessary.  Speed down is necessary if
- *     there have been more than 3 of Cat-1 errors or 10 of Cat-2
- *     errors during last 15 minutes.
+ *     whether NCQ needs to be turned off, transfer speed should be
+ *     stepped down, or falling back to PIO is necessary.
  *
- *     Cat-1 errors are ATA_BUS, TIMEOUT for any command and HSM
- *     violation for known supported commands.
+ *     Cat-1 is ATA_BUS error for any command.
  *
- *     Cat-2 errors are unclassified DEV error for known supported
+ *     Cat-2 is TIMEOUT for any command or HSM violation for known
+ *     supported commands.
+ *
+ *     Cat-3 is is unclassified DEV error for known supported
  *     command.
  *
+ *     NCQ needs to be turned off if there have been more than 3
+ *     Cat-2 + Cat-3 errors during last 10 minutes.
+ *
+ *     Speed down is necessary if there have been more than 3 Cat-1 +
+ *     Cat-2 errors or 10 Cat-3 errors during last 10 minutes.
+ *
+ *     Falling back to PIO mode is necessary if there have been more
+ *     than 10 Cat-1 + Cat-2 + Cat-3 errors during last 5 minutes.
+ *
  *     LOCKING:
  *     Inherited from caller.
  *
  *     RETURNS:
- *     1 if speed down is necessary, 0 otherwise
+ *     OR of ATA_EH_SPDN_* flags.
  */
-static int ata_eh_speed_down_needed(struct ata_device *dev)
+static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev)
 {
-       const u64 interval = 15LLU * 60 * HZ;
-       static const int err_limits[3] = { -1, 3, 10 };
-       struct speed_down_needed_arg arg;
-       struct ata_ering_entry *ent;
-       int err_cat;
-       u64 j64;
+       const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ;
+       u64 j64 = get_jiffies_64();
+       struct speed_down_verdict_arg arg;
+       unsigned int verdict = 0;
 
-       ent = ata_ering_top(&dev->ering);
-       if (!ent)
-               return 0;
+       /* scan past 10 mins of error history */
+       memset(&arg, 0, sizeof(arg));
+       arg.since = j64 - min(j64, j10mins);
+       ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
 
-       err_cat = ata_eh_categorize_ering_entry(ent);
-       if (err_cat == 0)
-               return 0;
+       if (arg.nr_errors[2] + arg.nr_errors[3] > 3)
+               verdict |= ATA_EH_SPDN_NCQ_OFF;
+       if (arg.nr_errors[1] + arg.nr_errors[2] > 3 || arg.nr_errors[3] > 10)
+               verdict |= ATA_EH_SPDN_SPEED_DOWN;
 
+       /* scan past 3 mins of error history */
        memset(&arg, 0, sizeof(arg));
+       arg.since = j64 - min(j64, j5mins);
+       ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
 
-       j64 = get_jiffies_64();
-       if (j64 >= interval)
-               arg.since = j64 - interval;
-       else
-               arg.since = 0;
-
-       ata_ering_map(&dev->ering, speed_down_needed_cb, &arg);
+       if (arg.nr_errors[1] + arg.nr_errors[2] + arg.nr_errors[3] > 10)
+               verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO;
 
-       return arg.nr_errors[err_cat] > err_limits[err_cat];
+       return verdict;
 }
 
 /**
@@ -1257,31 +1272,80 @@ static int ata_eh_speed_down_needed(struct ata_device *dev)
  *     Kernel thread context (may sleep).
  *
  *     RETURNS:
- *     0 on success, -errno otherwise
+ *     Determined recovery action.
  */
-static int ata_eh_speed_down(struct ata_device *dev, int is_io,
-                            unsigned int err_mask)
+static unsigned int ata_eh_speed_down(struct ata_device *dev, int is_io,
+                                     unsigned int err_mask)
 {
-       if (!err_mask)
+       unsigned int verdict;
+       unsigned int action = 0;
+
+       /* don't bother if Cat-0 error */
+       if (ata_eh_categorize_error(is_io, err_mask) == 0)
                return 0;
 
        /* record error and determine whether speed down is necessary */
        ata_ering_record(&dev->ering, is_io, err_mask);
+       verdict = ata_eh_speed_down_verdict(dev);
 
-       if (!ata_eh_speed_down_needed(dev))
-               return 0;
+       /* turn off NCQ? */
+       if ((verdict & ATA_EH_SPDN_NCQ_OFF) &&
+           (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ |
+                          ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) {
+               dev->flags |= ATA_DFLAG_NCQ_OFF;
+               ata_dev_printk(dev, KERN_WARNING,
+                              "NCQ disabled due to excessive errors\n");
+               goto done;
+       }
 
-       /* speed down SATA link speed if possible */
-       if (sata_down_spd_limit(dev->ap) == 0)
-               return ATA_EH_HARDRESET;
+       /* speed down? */
+       if (verdict & ATA_EH_SPDN_SPEED_DOWN) {
+               /* speed down SATA link speed if possible */
+               if (sata_down_spd_limit(dev->ap) == 0) {
+                       action |= ATA_EH_HARDRESET;
+                       goto done;
+               }
 
-       /* lower transfer mode */
-       if (ata_down_xfermask_limit(dev, 0) == 0)
-               return ATA_EH_SOFTRESET;
+               /* lower transfer mode */
+               if (dev->spdn_cnt < 2) {
+                       static const int dma_dnxfer_sel[] =
+                               { ATA_DNXFER_DMA, ATA_DNXFER_40C };
+                       static const int pio_dnxfer_sel[] =
+                               { ATA_DNXFER_PIO, ATA_DNXFER_FORCE_PIO0 };
+                       int sel;
+
+                       if (dev->xfer_shift != ATA_SHIFT_PIO)
+                               sel = dma_dnxfer_sel[dev->spdn_cnt];
+                       else
+                               sel = pio_dnxfer_sel[dev->spdn_cnt];
+
+                       dev->spdn_cnt++;
+
+                       if (ata_down_xfermask_limit(dev, sel) == 0) {
+                               action |= ATA_EH_SOFTRESET;
+                               goto done;
+                       }
+               }
+       }
+
+       /* Fall back to PIO?  Slowing down to PIO is meaningless for
+        * SATA.  Consider it only for PATA.
+        */
+       if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) &&
+           (dev->ap->cbl != ATA_CBL_SATA) &&
+           (dev->xfer_shift != ATA_SHIFT_PIO)) {
+               if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) {
+                       dev->spdn_cnt = 0;
+                       action |= ATA_EH_SOFTRESET;
+                       goto done;
+               }
+       }
 
-       ata_dev_printk(dev, KERN_ERR,
-                      "speed down requested but no transfer mode left\n");
        return 0;
+ done:
+       /* device has been slowed down, blow error history */
+       ata_ering_clear(&dev->ering);
+       return action;
 }
 
 /**
@@ -1964,7 +2028,7 @@ static int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
 {
        struct ata_eh_context *ehc = &ap->eh_context;
        struct ata_device *dev;
-       int down_xfermask, i, rc;
+       int i, rc;
 
        DPRINTK("ENTER\n");
 
@@ -1993,7 +2057,6 @@ static int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
        }
 
  retry:
-       down_xfermask = 0;
        rc = 0;
 
        /* if UNLOADING, finish immediately */
@@ -2038,10 +2101,8 @@ static int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
        /* configure transfer mode if necessary */
        if (ehc->i.flags & ATA_EHI_SETMODE) {
                rc = ata_set_mode(ap, &dev);
-               if (rc) {
-                       down_xfermask = 1;
+               if (rc)
                        goto dev_fail;
-               }
                ehc->i.flags &= ~ATA_EHI_SETMODE;
        }
 
@@ -2053,20 +2114,27 @@ static int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
        goto out;
 
  dev_fail:
+       ehc->tries[dev->devno]--;
+
        switch (rc) {
-       case -ENODEV:
-               /* device missing, schedule probing */
-               ehc->i.probe_mask |= (1 << dev->devno);
        case -EINVAL:
+               /* eeek, something went very wrong, give up */
                ehc->tries[dev->devno] = 0;
                break;
+
+       case -ENODEV:
+               /* device missing or wrong IDENTIFY data, schedule probing */
+               ehc->i.probe_mask |= (1 << dev->devno);
+               /* give it just one more chance */
+               ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1);
        case -EIO:
-               sata_down_spd_limit(ap);
-       default:
-               ehc->tries[dev->devno]--;
-               if (down_xfermask &&
-                   ata_down_xfermask_limit(dev, ehc->tries[dev->devno] == 1))
-                       ehc->tries[dev->devno] = 0;
+               if (ehc->tries[dev->devno] == 1) {
+                       /* This is the last chance, better to slow
+                        * down than lose it.
+                        */
+                       sata_down_spd_limit(ap);
+                       ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
+               }
        }
 
        if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) {
index 0009818a4306e7fb5e18c717f81d57256ebda337..00a9a6c8f83c159648b0124951a801c11599b6bf 100644 (file)
@@ -333,6 +333,7 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
        scsi_cmd[8]  = args[3];
        scsi_cmd[10] = args[4];
        scsi_cmd[12] = args[5];
+       scsi_cmd[13] = args[6] & 0x0f;
        scsi_cmd[14] = args[0];
 
        /* Good values for timeout and retries?  Values below
@@ -781,7 +782,7 @@ static void ata_gen_passthru_sense(struct ata_queued_cmd *qc)
         */
        if (qc->err_mask ||
            tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
-               ata_to_sense_error(qc->ap->id, tf->command, tf->feature,
+               ata_to_sense_error(qc->ap->print_id, tf->command, tf->feature,
                                   &sb[1], &sb[2], &sb[3], verbose);
                sb[1] &= 0x0f;
        }
@@ -854,7 +855,7 @@ static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
         */
        if (qc->err_mask ||
            tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
-               ata_to_sense_error(qc->ap->id, tf->command, tf->feature,
+               ata_to_sense_error(qc->ap->print_id, tf->command, tf->feature,
                                   &sb[1], &sb[2], &sb[3], verbose);
                sb[1] &= 0x0f;
        }
@@ -986,29 +987,32 @@ int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth)
        struct ata_port *ap = ata_shost_to_port(sdev->host);
        struct ata_device *dev;
        unsigned long flags;
-       int max_depth;
 
-       if (queue_depth < 1)
+       if (queue_depth < 1 || queue_depth == sdev->queue_depth)
                return sdev->queue_depth;
 
        dev = ata_scsi_find_dev(ap, sdev);
        if (!dev || !ata_dev_enabled(dev))
                return sdev->queue_depth;
 
-       max_depth = min(sdev->host->can_queue, ata_id_queue_depth(dev->id));
-       max_depth = min(ATA_MAX_QUEUE - 1, max_depth);
-       if (queue_depth > max_depth)
-               queue_depth = max_depth;
-
-       scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, queue_depth);
-
+       /* NCQ enabled? */
        spin_lock_irqsave(ap->lock, flags);
-       if (queue_depth > 1)
-               dev->flags &= ~ATA_DFLAG_NCQ_OFF;
-       else
+       dev->flags &= ~ATA_DFLAG_NCQ_OFF;
+       if (queue_depth == 1 || !ata_ncq_enabled(dev)) {
                dev->flags |= ATA_DFLAG_NCQ_OFF;
+               queue_depth = 1;
+       }
        spin_unlock_irqrestore(ap->lock, flags);
 
+       /* limit and apply queue depth */
+       queue_depth = min(queue_depth, sdev->host->can_queue);
+       queue_depth = min(queue_depth, ata_id_queue_depth(dev->id));
+       queue_depth = min(queue_depth, ATA_MAX_QUEUE - 1);
+
+       if (sdev->queue_depth == queue_depth)
+               return -EINVAL;
+
+       scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, queue_depth);
        return queue_depth;
 }
 
@@ -1469,7 +1473,7 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
        }
 
        if (need_sense && !ap->ops->error_handler)
-               ata_dump_status(ap->id, &qc->result_tf);
+               ata_dump_status(ap->print_id, &qc->result_tf);
 
        qc->scsidone(cmd);
 
@@ -1495,11 +1499,9 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
 static int ata_scmd_need_defer(struct ata_device *dev, int is_io)
 {
        struct ata_port *ap = dev->ap;
+       int is_ncq = is_io && ata_ncq_enabled(dev);
 
-       if (!(dev->flags & ATA_DFLAG_NCQ))
-               return 0;
-
-       if (is_io) {
+       if (is_ncq) {
                if (!ata_tag_valid(ap->active_tag))
                        return 0;
        } else {
@@ -2774,7 +2776,7 @@ static inline void ata_scsi_dump_cdb(struct ata_port *ap,
        u8 *scsicmd = cmd->cmnd;
 
        DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
-               ap->id,
+               ap->print_id,
                scsidev->channel, scsidev->id, scsidev->lun,
                scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
                scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
@@ -3234,7 +3236,7 @@ struct ata_port *ata_sas_port_alloc(struct ata_host *host,
 
        ata_port_init(ap, host, ent, 0);
        ap->lock = shost->host_lock;
-       kfree(ent);
+       devm_kfree(host->dev, ent);
        return ap;
 }
 EXPORT_SYMBOL_GPL(ata_sas_port_alloc);
index 16bc3e35bdd4e196eae43be264a1e758dfcf84d9..2ffcca063d80adc3405ab16c484ab7da8788a5d5 100644 (file)
@@ -175,7 +175,7 @@ void ata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
  */
 void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf)
 {
-       DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
+       DPRINTK("ata%u: cmd 0x%X\n", ap->print_id, tf->command);
 
        iowrite8(tf->command, ap->ioaddr.command_addr);
        ata_pause(ap);
@@ -521,7 +521,7 @@ void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc)
 static int ata_resources_present(struct pci_dev *pdev, int port)
 {
        int i;
-       
+
        /* Check the PCI resources for this channel are enabled */
        port = port * 2;
        for (i = 0; i < 2; i ++) {
@@ -531,7 +531,7 @@ static int ata_resources_present(struct pci_dev *pdev, int port)
        }
        return 1;
 }
-               
+
 /**
  *     ata_pci_init_native_mode - Initialize native-mode driver
  *     @pdev:  pci device to be initialized
@@ -576,7 +576,7 @@ ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port, int
 
        probe_ent->irq = pdev->irq;
        probe_ent->irq_flags = IRQF_SHARED;
-       
+
        /* Discard disabled ports. Some controllers show their
           unused channels this way */
        if (ata_resources_present(pdev, 0) == 0)
index 0ad7781d72a3b0f4e282da04dc606f48032d60cf..c42671493e8c4bf035d141b3d69b3e3702453ede 100644 (file)
@@ -41,6 +41,15 @@ struct ata_scsi_args {
 enum {
        /* flags for ata_dev_read_id() */
        ATA_READID_POSTRESET    = (1 << 0), /* reading ID after reset */
+
+       /* selector for ata_down_xfermask_limit() */
+       ATA_DNXFER_PIO          = 0,    /* speed down PIO */
+       ATA_DNXFER_DMA          = 1,    /* speed down DMA */
+       ATA_DNXFER_40C          = 2,    /* apply 40c cable limit */
+       ATA_DNXFER_FORCE_PIO    = 3,    /* force PIO */
+       ATA_DNXFER_FORCE_PIO0   = 4,    /* force PIO0 */
+
+       ATA_DNXFER_QUIET        = (1 << 31),
 };
 
 extern struct workqueue_struct *ata_aux_wq;
@@ -69,7 +78,7 @@ extern int ata_dev_revalidate(struct ata_device *dev, unsigned int flags);
 extern int ata_dev_configure(struct ata_device *dev);
 extern int sata_down_spd_limit(struct ata_port *ap);
 extern int sata_set_spd_needed(struct ata_port *ap);
-extern int ata_down_xfermask_limit(struct ata_device *dev, int force_pio0);
+extern int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel);
 extern int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev);
 extern void ata_sg_clean(struct ata_queued_cmd *qc);
 extern void ata_qc_free(struct ata_queued_cmd *qc);
@@ -150,7 +159,5 @@ extern void ata_qc_schedule_eh(struct ata_queued_cmd *qc);
 /* libata-sff.c */
 extern u8 ata_irq_on(struct ata_port *ap);
 
-/* pata_sis.c */
-extern struct ata_port_info sis_info133;
 
 #endif /* __LIBATA_H__ */
index ab44d18850f6eed706b0576624c8d92359ef13e0..a90ed00c07e071f053b609f1032a9d681815bd75 100644 (file)
@@ -34,7 +34,7 @@
 #include <linux/dmi.h>
 
 #define DRV_NAME "pata_ali"
-#define DRV_VERSION "0.7.2"
+#define DRV_VERSION "0.7.3"
 
 /*
  *     Cable special cases
index 619e44b04032ea0bada67d42ff73b81b81fb6893..3c760d0f4717e7fab436ee44e9b61452a87793ca 100644 (file)
@@ -25,7 +25,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME "pata_amd"
-#define DRV_VERSION "0.2.7"
+#define DRV_VERSION "0.2.8"
 
 /**
  *     timing_setup            -       shared timing computation and load
@@ -128,7 +128,7 @@ static void timing_setup(struct ata_port *ap, struct ata_device *adev, int offse
 
 static int amd_pre_reset(struct ata_port *ap)
 {
-       static const u32 bitmask[2] = {0x03, 0xC0};
+       static const u32 bitmask[2] = {0x03, 0x0C};
        static const struct pci_bits amd_enable_bits[] = {
                { 0x40, 1, 0x02, 0x02 },
                { 0x40, 1, 0x01, 0x01 }
@@ -247,7 +247,7 @@ static void amd133_set_dmamode(struct ata_port *ap, struct ata_device *adev)
  */
 
 static int nv_pre_reset(struct ata_port *ap) {
-       static const u8 bitmask[2] = {0x03, 0xC0};
+       static const u8 bitmask[2] = {0x03, 0x0C};
        static const struct pci_bits nv_enable_bits[] = {
                { 0x50, 1, 0x02, 0x02 },
                { 0x50, 1, 0x01, 0x01 }
index 1ce8fcfd7826e08c32c90c130125c6013c7cb895..c1334c6c4156f6a6e4267731fdf29850f4d9a5d2 100644 (file)
@@ -41,7 +41,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME       "pata_cs5520"
-#define DRV_VERSION    "0.6.3"
+#define DRV_VERSION    "0.6.4"
 
 struct pio_clocks
 {
@@ -325,6 +325,30 @@ static int cs5520_reinit_one(struct pci_dev *pdev)
                pci_write_config_byte(pdev, 0x60, pcicfg | 0x40);
        return ata_pci_device_resume(pdev);
 }
+
+/**
+ *     cs5520_pci_device_suspend       -       device suspend
+ *     @pdev: PCI device
+ *
+ *     We have to cut and waste bits from the standard method because
+ *     the 5520 is a bit odd and not just a pure ATA device. As a result
+ *     we must not disable it. The needed code is short and this avoids
+ *     chip specific mess in the core code.
+ */
+
+static int cs5520_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg)
+{
+       struct ata_host *host = dev_get_drvdata(&pdev->dev);
+       int rc = 0;
+
+       rc = ata_host_suspend(host, mesg);
+       if (rc)
+               return rc;
+
+       pci_save_state(pdev);
+       return 0;
+}
+
 /* For now keep DMA off. We can set it for all but A rev CS5510 once the
    core ATA code can handle it */
 
@@ -340,7 +364,7 @@ static struct pci_driver cs5520_pci_driver = {
        .id_table       = pata_cs5520,
        .probe          = cs5520_init_one,
        .remove         = cs5520_remove_one,
-       .suspend        = ata_pci_device_suspend,
+       .suspend        = cs5520_pci_device_suspend,
        .resume         = cs5520_reinit_one,
 };
 
index 3d7b7d87ec6f3a49647a0b5a6a9ab0ff4e4703bf..78c7cdfff69d2b6802200b2b0948e8f8e35ab430 100644 (file)
@@ -35,7 +35,7 @@
 #include <linux/dmi.h>
 
 #define DRV_NAME       "pata_cs5530"
-#define DRV_VERSION    "0.7.1"
+#define DRV_VERSION    "0.7.2"
 
 static void __iomem *cs5530_port_base(struct ata_port *ap)
 {
index 27d724b5eea2c138a54c5314290f3b031fdf4a9f..e7d33c628a61367a7831dfaacef62d049c4af0bd 100644 (file)
@@ -27,7 +27,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME       "pata_hpt366"
-#define DRV_VERSION    "0.5.3"
+#define DRV_VERSION    "0.6.0"
 
 struct hpt_clock {
        u8      xfer_speed;
index 4ffc392052c02f1a2dfb4769d06cace005e84abd..f331eeeafa0f39d75302023953c676910d446e64 100644 (file)
@@ -25,7 +25,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME       "pata_hpt37x"
-#define DRV_VERSION    "0.5.2"
+#define DRV_VERSION    "0.6.0"
 
 struct hpt_clock {
        u8      xfer_speed;
index 1bf5ec18b2e31490b350eb041773f04b265ad099..d5f2e85e28f326c1a57cd864727258acc0fb8772 100644 (file)
@@ -17,7 +17,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME "pata_isapnp"
-#define DRV_VERSION "0.1.5"
+#define DRV_VERSION "0.2.0"
 
 static struct scsi_host_template isapnp_sht = {
        .module                 = THIS_MODULE,
index 73394c75be4254fac5c0624c7b0ea23747279fdc..903137a6da5e999e9a6d019c0c6538a27b19bfa4 100644 (file)
@@ -80,7 +80,7 @@
 
 
 #define DRV_NAME "pata_it821x"
-#define DRV_VERSION "0.3.3"
+#define DRV_VERSION "0.3.4"
 
 struct it821x_dev
 {
@@ -503,10 +503,12 @@ static int it821x_smart_set_mode(struct ata_port *ap, struct ata_device **unused
                        /* We do need the right mode information for DMA or PIO
                           and this comes from the current configuration flags */
                        if (dma_enabled & (1 << (5 + i))) {
+                               ata_dev_printk(dev, KERN_INFO, "configured for DMA\n");
                                dev->xfer_mode = XFER_MW_DMA_0;
                                dev->xfer_shift = ATA_SHIFT_MWDMA;
                                dev->flags &= ~ATA_DFLAG_PIO;
                        } else {
+                               ata_dev_printk(dev, KERN_INFO, "configured for PIO\n");
                                dev->xfer_mode = XFER_PIO_0;
                                dev->xfer_shift = ATA_SHIFT_PIO;
                                dev->flags |= ATA_DFLAG_PIO;
index 3222ac7b945d43637295ed8f9d349df8ce937367..9a0523b5c947ce6c73c1b17d5c49ad51c91f2518 100644 (file)
 #include <scsi/scsi_host.h>
 
 #define DRV_NAME       "pata_ixp4xx_cf"
-#define DRV_VERSION    "0.1.1ac1"
+#define DRV_VERSION    "0.1.2"
 
-static int ixp4xx_set_mode(struct ata_port *ap, struct ata_device *adev)
+static int ixp4xx_set_mode(struct ata_port *ap, struct ata_device **error)
 {
        int i;
 
        for (i = 0; i < ATA_MAX_DEVICES; i++) {
                struct ata_device *dev = &ap->device[i];
-               if (ata_dev_enabled(dev)) {
+               if (ata_dev_ready(dev)) {
+                       ata_dev_printk(dev, KERN_INFO, "configured for PIO0\n");
                        dev->pio_mode = XFER_PIO_0;
                        dev->xfer_mode = XFER_PIO_0;
                        dev->xfer_shift = ATA_SHIFT_PIO;
index 98c1fee4b305a92f3d92f08506010d861ee027c4..6ee61c67163ac248e9a3f0c89e7138b09333afff 100644 (file)
@@ -64,7 +64,7 @@
 #include <linux/platform_device.h>
 
 #define DRV_NAME "pata_legacy"
-#define DRV_VERSION "0.5.3"
+#define DRV_VERSION "0.5.4"
 
 #define NR_HOST 6
 
index 45215aa05e72b92a8b2b7d3c7be6804d5e2cbd0c..2389107a20062728bf6011fa9202c685ec9c1db7 100644 (file)
@@ -25,7 +25,7 @@
 #include <linux/ata.h>
 
 #define DRV_NAME       "pata_oldpiix"
-#define DRV_VERSION    "0.5.3"
+#define DRV_VERSION    "0.5.4"
 
 /**
  *     oldpiix_pre_reset               -       probe begin
@@ -209,10 +209,9 @@ static unsigned int oldpiix_qc_issue_prot(struct ata_queued_cmd *qc)
        struct ata_device *adev = qc->dev;
 
        if (adev != ap->private_data) {
+               oldpiix_set_piomode(ap, adev);
                if (adev->dma_mode)
                        oldpiix_set_dmamode(ap, adev);
-               else if (adev->pio_mode)
-                       oldpiix_set_piomode(ap, adev);
        }
        return ata_qc_issue_prot(qc);
 }
index da1aa148b37d9f69b5d91c88b57608f1e7d65461..1b3cd5369f0322be2ca23bfb2ea4bdcb8051e637 100644 (file)
@@ -34,7 +34,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME "pata_opti"
-#define DRV_VERSION "0.2.7"
+#define DRV_VERSION "0.2.8"
 
 enum {
        READ_REG        = 0,    /* index of Read cycle timing register */
index d80b36e209cc52bc6de595d414caecb32163a975..b76c976e505caa8d14b8c33f6a171947ec62654d 100644 (file)
@@ -33,7 +33,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME "pata_optidma"
-#define DRV_VERSION "0.2.3"
+#define DRV_VERSION "0.2.4"
 
 enum {
        READ_REG        = 0,    /* index of Read cycle timing register */
index 8928a6dfac50351a291f514a3bf575eea72aede7..103720f873c8f31d8384b0f54b5b97975c2ad3bb 100644 (file)
@@ -42,7 +42,7 @@
 
 
 #define DRV_NAME "pata_pcmcia"
-#define DRV_VERSION "0.2.11"
+#define DRV_VERSION "0.3.0"
 
 /*
  *     Private data structure to glue stuff together
@@ -319,14 +319,17 @@ static void pcmcia_remove_one(struct pcmcia_device *pdev)
 static struct pcmcia_device_id pcmcia_devices[] = {
        PCMCIA_DEVICE_FUNC_ID(4),
        PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000),        /* Hitachi */
+       PCMCIA_DEVICE_MANF_CARD(0x000a, 0x0000),        /* I-O Data CFA */
+       PCMCIA_DEVICE_MANF_CARD(0x001c, 0x0001),        /* Mitsubishi CFA */
        PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704),
-       PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401),
+       PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401),        /* SanDisk CFA */
        PCMCIA_DEVICE_MANF_CARD(0x0098, 0x0000),        /* Toshiba */
        PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x002d),
        PCMCIA_DEVICE_MANF_CARD(0x00ce, 0x0000),        /* Samsung */
        PCMCIA_DEVICE_MANF_CARD(0x0319, 0x0000),        /* Hitachi */
        PCMCIA_DEVICE_MANF_CARD(0x2080, 0x0001),
-       PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200),        /* Lexar */
+       PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0100),        /* Viking CFA */
+       PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200),        /* Lexar, Viking CFA */
        PCMCIA_DEVICE_PROD_ID123("Caravelle", "PSC-IDE ", "PSC000", 0x8c36137c, 0xd0693ab8, 0x2768a9f0),
        PCMCIA_DEVICE_PROD_ID123("CDROM", "IDE", "MCD-601p", 0x1b9179ca, 0xede88951, 0x0d902f74),
        PCMCIA_DEVICE_PROD_ID123("PCMCIA", "IDE CARD", "F1", 0x281f1c5d, 0x1907960c, 0xf7fde8b9),
index 61537873d28ef133d4dc5efab882b7efc2c3714c..93bcdadb7be3a17c8ff82f00dc5a7425cf3c9d26 100644 (file)
@@ -35,7 +35,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME       "pata_pdc2027x"
-#define DRV_VERSION    "0.74-ac5"
+#define DRV_VERSION    "0.8"
 #undef PDC_DEBUG
 
 #ifdef PDC_DEBUG
index 6dd63413a523475c82f45cd5c03746b9b13c01b2..80685388c2bdacbd26965749fca8a5fc01595c31 100644 (file)
@@ -21,7 +21,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME "pata_pdc202xx_old"
-#define DRV_VERSION "0.2.3"
+#define DRV_VERSION "0.3.0"
 
 /**
  *     pdc2024x_pre_reset              -       probe begin
index 479a326114e0ca4132740f2e619a793a9ef5046b..02ea95fcba694e85d9fc307047b7a7466203e392 100644 (file)
@@ -42,6 +42,7 @@ static int pata_platform_set_mode(struct ata_port *ap, struct ata_device **unuse
                        dev->pio_mode = dev->xfer_mode = XFER_PIO_0;
                        dev->xfer_shift = ATA_SHIFT_PIO;
                        dev->flags |= ATA_DFLAG_PIO;
+                       ata_dev_printk(dev, KERN_INFO, "configured for PIO\n");
                }
        }
        return 0;
index 4362141976adfa41af697adcbede81f4b1fdb44d..c2f87da603366dd588bdd264d0488a6506995fbf 100644 (file)
@@ -26,7 +26,7 @@
 #include <linux/platform_device.h>
 
 #define DRV_NAME "pata_qdi"
-#define DRV_VERSION "0.2.4"
+#define DRV_VERSION "0.3.0"
 
 #define NR_HOST 4      /* Two 6580s */
 
index 71a2bac09e0d90ee7638d9ecc129d7ef1141b5d7..60fc598f765de3da8935e0f07536bf5b1702eeba 100644 (file)
@@ -71,6 +71,7 @@ static int rz1000_set_mode(struct ata_port *ap, struct ata_device **unused)
                        dev->xfer_mode = XFER_PIO_0;
                        dev->xfer_shift = ATA_SHIFT_PIO;
                        dev->flags |= ATA_DFLAG_PIO;
+                       ata_dev_printk(dev, KERN_INFO, "configured for PIO\n");
                }
        }
        return 0;
diff --git a/drivers/ata/pata_scc.c b/drivers/ata/pata_scc.c
new file mode 100644 (file)
index 0000000..4586609
--- /dev/null
@@ -0,0 +1,1228 @@
+/*
+ * Support for IDE interfaces on Celleb platform
+ *
+ * (C) Copyright 2006 TOSHIBA CORPORATION
+ *
+ * This code is based on drivers/ata/ata_piix.c:
+ *  Copyright 2003-2005 Red Hat Inc
+ *  Copyright 2003-2005 Jeff Garzik
+ *  Copyright (C) 1998-1999 Andrzej Krzysztofowicz, Author and Maintainer
+ *  Copyright (C) 1998-2000 Andre Hedrick <andre@linux-ide.org>
+ *  Copyright (C) 2003 Red Hat Inc <alan@redhat.com>
+ *
+ * and drivers/ata/ahci.c:
+ *  Copyright 2004-2005 Red Hat, Inc.
+ *
+ * and drivers/ata/libata-core.c:
+ *  Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
+ *  Copyright 2003-2004 Jeff Garzik
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/blkdev.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <scsi/scsi_host.h>
+#include <linux/libata.h>
+
+#define DRV_NAME               "pata_scc"
+#define DRV_VERSION            "0.1"
+
+#define PCI_DEVICE_ID_TOSHIBA_SCC_ATA          0x01b4
+
+/* PCI BARs */
+#define SCC_CTRL_BAR           0
+#define SCC_BMID_BAR           1
+
+/* offset of CTRL registers */
+#define SCC_CTL_PIOSHT         0x000
+#define SCC_CTL_PIOCT          0x004
+#define SCC_CTL_MDMACT         0x008
+#define SCC_CTL_MCRCST         0x00C
+#define SCC_CTL_SDMACT         0x010
+#define SCC_CTL_SCRCST         0x014
+#define SCC_CTL_UDENVT         0x018
+#define SCC_CTL_TDVHSEL        0x020
+#define SCC_CTL_MODEREG        0x024
+#define SCC_CTL_ECMODE         0xF00
+#define SCC_CTL_MAEA0          0xF50
+#define SCC_CTL_MAEC0          0xF54
+#define SCC_CTL_CCKCTRL        0xFF0
+
+/* offset of BMID registers */
+#define SCC_DMA_CMD            0x000
+#define SCC_DMA_STATUS         0x004
+#define SCC_DMA_TABLE_OFS      0x008
+#define SCC_DMA_INTMASK        0x010
+#define SCC_DMA_INTST          0x014
+#define SCC_DMA_PTERADD        0x018
+#define SCC_REG_CMD_ADDR       0x020
+#define SCC_REG_DATA           0x000
+#define SCC_REG_ERR            0x004
+#define SCC_REG_FEATURE        0x004
+#define SCC_REG_NSECT          0x008
+#define SCC_REG_LBAL           0x00C
+#define SCC_REG_LBAM           0x010
+#define SCC_REG_LBAH           0x014
+#define SCC_REG_DEVICE         0x018
+#define SCC_REG_STATUS         0x01C
+#define SCC_REG_CMD            0x01C
+#define SCC_REG_ALTSTATUS      0x020
+
+/* register value */
+#define TDVHSEL_MASTER         0x00000001
+#define TDVHSEL_SLAVE          0x00000004
+
+#define MODE_JCUSFEN           0x00000080
+
+#define ECMODE_VALUE           0x01
+
+#define CCKCTRL_ATARESET       0x00040000
+#define CCKCTRL_BUFCNT         0x00020000
+#define CCKCTRL_CRST           0x00010000
+#define CCKCTRL_OCLKEN         0x00000100
+#define CCKCTRL_ATACLKOEN      0x00000002
+#define CCKCTRL_LCLKEN         0x00000001
+
+#define QCHCD_IOS_SS           0x00000001
+
+#define QCHSD_STPDIAG          0x00020000
+
+#define INTMASK_MSK            0xD1000012
+#define INTSTS_SERROR          0x80000000
+#define INTSTS_PRERR           0x40000000
+#define INTSTS_RERR            0x10000000
+#define INTSTS_ICERR           0x01000000
+#define INTSTS_BMSINT          0x00000010
+#define INTSTS_BMHE            0x00000008
+#define INTSTS_IOIRQS          0x00000004
+#define INTSTS_INTRQ           0x00000002
+#define INTSTS_ACTEINT         0x00000001
+
+
+/* PIO transfer mode table */
+/* JCHST */
+static const unsigned long JCHSTtbl[2][7] = {
+       {0x0E, 0x05, 0x02, 0x03, 0x02, 0x00, 0x00},     /* 100MHz */
+       {0x13, 0x07, 0x04, 0x04, 0x03, 0x00, 0x00}      /* 133MHz */
+};
+
+/* JCHHT */
+static const unsigned long JCHHTtbl[2][7] = {
+       {0x0E, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00},     /* 100MHz */
+       {0x13, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00}      /* 133MHz */
+};
+
+/* JCHCT */
+static const unsigned long JCHCTtbl[2][7] = {
+       {0x1D, 0x1D, 0x1C, 0x0B, 0x06, 0x00, 0x00},     /* 100MHz */
+       {0x27, 0x26, 0x26, 0x0E, 0x09, 0x00, 0x00}      /* 133MHz */
+};
+
+/* DMA transfer mode  table */
+/* JCHDCTM/JCHDCTS */
+static const unsigned long JCHDCTxtbl[2][7] = {
+       {0x0A, 0x06, 0x04, 0x03, 0x01, 0x00, 0x00},     /* 100MHz */
+       {0x0E, 0x09, 0x06, 0x04, 0x02, 0x01, 0x00}      /* 133MHz */
+};
+
+/* JCSTWTM/JCSTWTS  */
+static const unsigned long JCSTWTxtbl[2][7] = {
+       {0x06, 0x04, 0x03, 0x02, 0x02, 0x02, 0x00},     /* 100MHz */
+       {0x09, 0x06, 0x04, 0x02, 0x02, 0x02, 0x02}      /* 133MHz */
+};
+
+/* JCTSS */
+static const unsigned long JCTSStbl[2][7] = {
+       {0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x00},     /* 100MHz */
+       {0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05}      /* 133MHz */
+};
+
+/* JCENVT */
+static const unsigned long JCENVTtbl[2][7] = {
+       {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00},     /* 100MHz */
+       {0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}      /* 133MHz */
+};
+
+/* JCACTSELS/JCACTSELM */
+static const unsigned long JCACTSELtbl[2][7] = {
+       {0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00},     /* 100MHz */
+       {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}      /* 133MHz */
+};
+
+static const struct pci_device_id scc_pci_tbl[] = {
+       {PCI_VENDOR_ID_TOSHIBA_2, PCI_DEVICE_ID_TOSHIBA_SCC_ATA,
+        PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+       { }     /* terminate list */
+};
+
+/**
+ *     scc_set_piomode - Initialize host controller PATA PIO timings
+ *     @ap: Port whose timings we are configuring
+ *     @adev: um
+ *
+ *     Set PIO mode for device.
+ *
+ *     LOCKING:
+ *     None (inherited from caller).
+ */
+
+static void scc_set_piomode (struct ata_port *ap, struct ata_device *adev)
+{
+       unsigned int pio = adev->pio_mode - XFER_PIO_0;
+       void __iomem *ctrl_base = ap->host->iomap[SCC_CTRL_BAR];
+       void __iomem *cckctrl_port = ctrl_base + SCC_CTL_CCKCTRL;
+       void __iomem *piosht_port = ctrl_base + SCC_CTL_PIOSHT;
+       void __iomem *pioct_port = ctrl_base + SCC_CTL_PIOCT;
+       unsigned long reg;
+       int offset;
+
+       reg = in_be32(cckctrl_port);
+       if (reg & CCKCTRL_ATACLKOEN)
+               offset = 1;     /* 133MHz */
+       else
+               offset = 0;     /* 100MHz */
+
+       reg = JCHSTtbl[offset][pio] << 16 | JCHHTtbl[offset][pio];
+       out_be32(piosht_port, reg);
+       reg = JCHCTtbl[offset][pio];
+       out_be32(pioct_port, reg);
+}
+
+/**
+ *     scc_set_dmamode - Initialize host controller PATA DMA timings
+ *     @ap: Port whose timings we are configuring
+ *     @adev: um
+ *     @udma: udma mode, 0 - 6
+ *
+ *     Set UDMA mode for device.
+ *
+ *     LOCKING:
+ *     None (inherited from caller).
+ */
+
+static void scc_set_dmamode (struct ata_port *ap, struct ata_device *adev)
+{
+       unsigned int udma = adev->dma_mode;
+       unsigned int is_slave = (adev->devno != 0);
+       u8 speed = udma;
+       void __iomem *ctrl_base = ap->host->iomap[SCC_CTRL_BAR];
+       void __iomem *cckctrl_port = ctrl_base + SCC_CTL_CCKCTRL;
+       void __iomem *mdmact_port = ctrl_base + SCC_CTL_MDMACT;
+       void __iomem *mcrcst_port = ctrl_base + SCC_CTL_MCRCST;
+       void __iomem *sdmact_port = ctrl_base + SCC_CTL_SDMACT;
+       void __iomem *scrcst_port = ctrl_base + SCC_CTL_SCRCST;
+       void __iomem *udenvt_port = ctrl_base + SCC_CTL_UDENVT;
+       void __iomem *tdvhsel_port = ctrl_base + SCC_CTL_TDVHSEL;
+       int offset, idx;
+
+       if (in_be32(cckctrl_port) & CCKCTRL_ATACLKOEN)
+               offset = 1;     /* 133MHz */
+       else
+               offset = 0;     /* 100MHz */
+
+       if (speed >= XFER_UDMA_0)
+               idx = speed - XFER_UDMA_0;
+       else
+               return;
+
+       if (is_slave) {
+               out_be32(sdmact_port, JCHDCTxtbl[offset][idx]);
+               out_be32(scrcst_port, JCSTWTxtbl[offset][idx]);
+               out_be32(tdvhsel_port,
+                        (in_be32(tdvhsel_port) & ~TDVHSEL_SLAVE) | (JCACTSELtbl[offset][idx] << 2));
+       } else {
+               out_be32(mdmact_port, JCHDCTxtbl[offset][idx]);
+               out_be32(mcrcst_port, JCSTWTxtbl[offset][idx]);
+               out_be32(tdvhsel_port,
+                        (in_be32(tdvhsel_port) & ~TDVHSEL_MASTER) | JCACTSELtbl[offset][idx]);
+       }
+       out_be32(udenvt_port,
+                JCTSStbl[offset][idx] << 16 | JCENVTtbl[offset][idx]);
+}
+
+/**
+ *     scc_tf_load - send taskfile registers to host controller
+ *     @ap: Port to which output is sent
+ *     @tf: ATA taskfile register set
+ *
+ *     Note: Original code is ata_tf_load().
+ */
+
+static void scc_tf_load (struct ata_port *ap, const struct ata_taskfile *tf)
+{
+       struct ata_ioports *ioaddr = &ap->ioaddr;
+       unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
+
+       if (tf->ctl != ap->last_ctl) {
+               out_be32(ioaddr->ctl_addr, tf->ctl);
+               ap->last_ctl = tf->ctl;
+               ata_wait_idle(ap);
+       }
+
+       if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
+               out_be32(ioaddr->feature_addr, tf->hob_feature);
+               out_be32(ioaddr->nsect_addr, tf->hob_nsect);
+               out_be32(ioaddr->lbal_addr, tf->hob_lbal);
+               out_be32(ioaddr->lbam_addr, tf->hob_lbam);
+               out_be32(ioaddr->lbah_addr, tf->hob_lbah);
+               VPRINTK("hob: feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
+                       tf->hob_feature,
+                       tf->hob_nsect,
+                       tf->hob_lbal,
+                       tf->hob_lbam,
+                       tf->hob_lbah);
+       }
+
+       if (is_addr) {
+               out_be32(ioaddr->feature_addr, tf->feature);
+               out_be32(ioaddr->nsect_addr, tf->nsect);
+               out_be32(ioaddr->lbal_addr, tf->lbal);
+               out_be32(ioaddr->lbam_addr, tf->lbam);
+               out_be32(ioaddr->lbah_addr, tf->lbah);
+               VPRINTK("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
+                       tf->feature,
+                       tf->nsect,
+                       tf->lbal,
+                       tf->lbam,
+                       tf->lbah);
+       }
+
+       if (tf->flags & ATA_TFLAG_DEVICE) {
+               out_be32(ioaddr->device_addr, tf->device);
+               VPRINTK("device 0x%X\n", tf->device);
+       }
+
+       ata_wait_idle(ap);
+}
+
+/**
+ *     scc_check_status - Read device status reg & clear interrupt
+ *     @ap: port where the device is
+ *
+ *     Note: Original code is ata_check_status().
+ */
+
+static u8 scc_check_status (struct ata_port *ap)
+{
+       return in_be32(ap->ioaddr.status_addr);
+}
+
+/**
+ *     scc_tf_read - input device's ATA taskfile shadow registers
+ *     @ap: Port from which input is read
+ *     @tf: ATA taskfile register set for storing input
+ *
+ *     Note: Original code is ata_tf_read().
+ */
+
+static void scc_tf_read (struct ata_port *ap, struct ata_taskfile *tf)
+{
+       struct ata_ioports *ioaddr = &ap->ioaddr;
+
+       tf->command = scc_check_status(ap);
+       tf->feature = in_be32(ioaddr->error_addr);
+       tf->nsect = in_be32(ioaddr->nsect_addr);
+       tf->lbal = in_be32(ioaddr->lbal_addr);
+       tf->lbam = in_be32(ioaddr->lbam_addr);
+       tf->lbah = in_be32(ioaddr->lbah_addr);
+       tf->device = in_be32(ioaddr->device_addr);
+
+       if (tf->flags & ATA_TFLAG_LBA48) {
+               out_be32(ioaddr->ctl_addr, tf->ctl | ATA_HOB);
+               tf->hob_feature = in_be32(ioaddr->error_addr);
+               tf->hob_nsect = in_be32(ioaddr->nsect_addr);
+               tf->hob_lbal = in_be32(ioaddr->lbal_addr);
+               tf->hob_lbam = in_be32(ioaddr->lbam_addr);
+               tf->hob_lbah = in_be32(ioaddr->lbah_addr);
+       }
+}
+
+/**
+ *     scc_exec_command - issue ATA command to host controller
+ *     @ap: port to which command is being issued
+ *     @tf: ATA taskfile register set
+ *
+ *     Note: Original code is ata_exec_command().
+ */
+
+static void scc_exec_command (struct ata_port *ap,
+                             const struct ata_taskfile *tf)
+{
+       DPRINTK("ata%u: cmd 0x%X\n", ap->print_id, tf->command);
+
+       out_be32(ap->ioaddr.command_addr, tf->command);
+       ata_pause(ap);
+}
+
+/**
+ *     scc_check_altstatus - Read device alternate status reg
+ *     @ap: port where the device is
+ */
+
+static u8 scc_check_altstatus (struct ata_port *ap)
+{
+       return in_be32(ap->ioaddr.altstatus_addr);
+}
+
+/**
+ *     scc_std_dev_select - Select device 0/1 on ATA bus
+ *     @ap: ATA channel to manipulate
+ *     @device: ATA device (numbered from zero) to select
+ *
+ *     Note: Original code is ata_std_dev_select().
+ */
+
+static void scc_std_dev_select (struct ata_port *ap, unsigned int device)
+{
+       u8 tmp;
+
+       if (device == 0)
+               tmp = ATA_DEVICE_OBS;
+       else
+               tmp = ATA_DEVICE_OBS | ATA_DEV1;
+
+       out_be32(ap->ioaddr.device_addr, tmp);
+       ata_pause(ap);
+}
+
+/**
+ *     scc_bmdma_setup - Set up PCI IDE BMDMA transaction
+ *     @qc: Info associated with this ATA transaction.
+ *
+ *     Note: Original code is ata_bmdma_setup().
+ */
+
+static void scc_bmdma_setup (struct ata_queued_cmd *qc)
+{
+       struct ata_port *ap = qc->ap;
+       unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
+       u8 dmactl;
+       void __iomem *mmio = ap->ioaddr.bmdma_addr;
+
+       /* load PRD table addr */
+       out_be32(mmio + SCC_DMA_TABLE_OFS, ap->prd_dma);
+
+       /* specify data direction, triple-check start bit is clear */
+       dmactl = in_be32(mmio + SCC_DMA_CMD);
+       dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
+       if (!rw)
+               dmactl |= ATA_DMA_WR;
+       out_be32(mmio + SCC_DMA_CMD, dmactl);
+
+       /* issue r/w command */
+       ap->ops->exec_command(ap, &qc->tf);
+}
+
+/**
+ *     scc_bmdma_start - Start a PCI IDE BMDMA transaction
+ *     @qc: Info associated with this ATA transaction.
+ *
+ *     Note: Original code is ata_bmdma_start().
+ */
+
+static void scc_bmdma_start (struct ata_queued_cmd *qc)
+{
+       struct ata_port *ap = qc->ap;
+       u8 dmactl;
+       void __iomem *mmio = ap->ioaddr.bmdma_addr;
+
+       /* start host DMA transaction */
+       dmactl = in_be32(mmio + SCC_DMA_CMD);
+       out_be32(mmio + SCC_DMA_CMD, dmactl | ATA_DMA_START);
+}
+
+/**
+ *     scc_devchk - PATA device presence detection
+ *     @ap: ATA channel to examine
+ *     @device: Device to examine (starting at zero)
+ *
+ *     Note: Original code is ata_devchk().
+ */
+
+static unsigned int scc_devchk (struct ata_port *ap,
+                               unsigned int device)
+{
+       struct ata_ioports *ioaddr = &ap->ioaddr;
+       u8 nsect, lbal;
+
+       ap->ops->dev_select(ap, device);
+
+       out_be32(ioaddr->nsect_addr, 0x55);
+       out_be32(ioaddr->lbal_addr, 0xaa);
+
+       out_be32(ioaddr->nsect_addr, 0xaa);
+       out_be32(ioaddr->lbal_addr, 0x55);
+
+       out_be32(ioaddr->nsect_addr, 0x55);
+       out_be32(ioaddr->lbal_addr, 0xaa);
+
+       nsect = in_be32(ioaddr->nsect_addr);
+       lbal = in_be32(ioaddr->lbal_addr);
+
+       if ((nsect == 0x55) && (lbal == 0xaa))
+               return 1;       /* we found a device */
+
+       return 0;               /* nothing found */
+}
+
+/**
+ *     scc_bus_post_reset - PATA device post reset
+ *
+ *     Note: Original code is ata_bus_post_reset().
+ */
+
+static void scc_bus_post_reset (struct ata_port *ap, unsigned int devmask)
+{
+       struct ata_ioports *ioaddr = &ap->ioaddr;
+       unsigned int dev0 = devmask & (1 << 0);
+       unsigned int dev1 = devmask & (1 << 1);
+       unsigned long timeout;
+
+       /* if device 0 was found in ata_devchk, wait for its
+        * BSY bit to clear
+        */
+       if (dev0)
+               ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
+
+       /* if device 1 was found in ata_devchk, wait for
+        * register access, then wait for BSY to clear
+        */
+       timeout = jiffies + ATA_TMOUT_BOOT;
+       while (dev1) {
+               u8 nsect, lbal;
+
+               ap->ops->dev_select(ap, 1);
+               nsect = in_be32(ioaddr->nsect_addr);
+               lbal = in_be32(ioaddr->lbal_addr);
+               if ((nsect == 1) && (lbal == 1))
+                       break;
+               if (time_after(jiffies, timeout)) {
+                       dev1 = 0;
+                       break;
+               }
+               msleep(50);     /* give drive a breather */
+       }
+       if (dev1)
+               ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
+
+       /* is all this really necessary? */
+       ap->ops->dev_select(ap, 0);
+       if (dev1)
+               ap->ops->dev_select(ap, 1);
+       if (dev0)
+               ap->ops->dev_select(ap, 0);
+}
+
+/**
+ *     scc_bus_softreset - PATA device software reset
+ *
+ *     Note: Original code is ata_bus_softreset().
+ */
+
+static unsigned int scc_bus_softreset (struct ata_port *ap,
+                                      unsigned int devmask)
+{
+       struct ata_ioports *ioaddr = &ap->ioaddr;
+
+       DPRINTK("ata%u: bus reset via SRST\n", ap->print_id);
+
+       /* software reset.  causes dev0 to be selected */
+       out_be32(ioaddr->ctl_addr, ap->ctl);
+       udelay(20);
+       out_be32(ioaddr->ctl_addr, ap->ctl | ATA_SRST);
+       udelay(20);
+       out_be32(ioaddr->ctl_addr, ap->ctl);
+
+       /* spec mandates ">= 2ms" before checking status.
+        * We wait 150ms, because that was the magic delay used for
+        * ATAPI devices in Hale Landis's ATADRVR, for the period of time
+        * between when the ATA command register is written, and then
+        * status is checked.  Because waiting for "a while" before
+        * checking status is fine, post SRST, we perform this magic
+        * delay here as well.
+        *
+        * Old drivers/ide uses the 2mS rule and then waits for ready
+        */
+       msleep(150);
+
+       /* Before we perform post reset processing we want to see if
+        * the bus shows 0xFF because the odd clown forgets the D7
+        * pulldown resistor.
+        */
+       if (scc_check_status(ap) == 0xFF)
+               return 0;
+
+       scc_bus_post_reset(ap, devmask);
+
+       return 0;
+}
+
+/**
+ *     scc_std_softreset - reset host port via ATA SRST
+ *     @ap: port to reset
+ *     @classes: resulting classes of attached devices
+ *
+ *     Note: Original code is ata_std_softreset().
+ */
+
+static int scc_std_softreset (struct ata_port *ap, unsigned int *classes)
+{
+       unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
+       unsigned int devmask = 0, err_mask;
+       u8 err;
+
+       DPRINTK("ENTER\n");
+
+       if (ata_port_offline(ap)) {
+               classes[0] = ATA_DEV_NONE;
+               goto out;
+       }
+
+       /* determine if device 0/1 are present */
+       if (scc_devchk(ap, 0))
+               devmask |= (1 << 0);
+       if (slave_possible && scc_devchk(ap, 1))
+               devmask |= (1 << 1);
+
+       /* select device 0 again */
+       ap->ops->dev_select(ap, 0);
+
+       /* issue bus reset */
+       DPRINTK("about to softreset, devmask=%x\n", devmask);
+       err_mask = scc_bus_softreset(ap, devmask);
+       if (err_mask) {
+               ata_port_printk(ap, KERN_ERR, "SRST failed (err_mask=0x%x)\n",
+                               err_mask);
+               return -EIO;
+       }
+
+       /* determine by signature whether we have ATA or ATAPI devices */
+       classes[0] = ata_dev_try_classify(ap, 0, &err);
+       if (slave_possible && err != 0x81)
+               classes[1] = ata_dev_try_classify(ap, 1, &err);
+
+ out:
+       DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
+       return 0;
+}
+
+/**
+ *     scc_bmdma_stop - Stop PCI IDE BMDMA transfer
+ *     @qc: Command we are ending DMA for
+ */
+
+static void scc_bmdma_stop (struct ata_queued_cmd *qc)
+{
+       struct ata_port *ap = qc->ap;
+       void __iomem *ctrl_base = ap->host->iomap[SCC_CTRL_BAR];
+       void __iomem *bmid_base = ap->host->iomap[SCC_BMID_BAR];
+       u32 reg;
+
+       while (1) {
+               reg = in_be32(bmid_base + SCC_DMA_INTST);
+
+               if (reg & INTSTS_SERROR) {
+                       printk(KERN_WARNING "%s: SERROR\n", DRV_NAME);
+                       out_be32(bmid_base + SCC_DMA_INTST, INTSTS_SERROR|INTSTS_BMSINT);
+                       out_be32(bmid_base + SCC_DMA_CMD,
+                                in_be32(bmid_base + SCC_DMA_CMD) & ~ATA_DMA_START);
+                       continue;
+               }
+
+               if (reg & INTSTS_PRERR) {
+                       u32 maea0, maec0;
+                       maea0 = in_be32(ctrl_base + SCC_CTL_MAEA0);
+                       maec0 = in_be32(ctrl_base + SCC_CTL_MAEC0);
+                       printk(KERN_WARNING "%s: PRERR [addr:%x cmd:%x]\n", DRV_NAME, maea0, maec0);
+                       out_be32(bmid_base + SCC_DMA_INTST, INTSTS_PRERR|INTSTS_BMSINT);
+                       out_be32(bmid_base + SCC_DMA_CMD,
+                                in_be32(bmid_base + SCC_DMA_CMD) & ~ATA_DMA_START);
+                       continue;
+               }
+
+               if (reg & INTSTS_RERR) {
+                       printk(KERN_WARNING "%s: Response Error\n", DRV_NAME);
+                       out_be32(bmid_base + SCC_DMA_INTST, INTSTS_RERR|INTSTS_BMSINT);
+                       out_be32(bmid_base + SCC_DMA_CMD,
+                                in_be32(bmid_base + SCC_DMA_CMD) & ~ATA_DMA_START);
+                       continue;
+               }
+
+               if (reg & INTSTS_ICERR) {
+                       out_be32(bmid_base + SCC_DMA_CMD,
+                                in_be32(bmid_base + SCC_DMA_CMD) & ~ATA_DMA_START);
+                       printk(KERN_WARNING "%s: Illegal Configuration\n", DRV_NAME);
+                       out_be32(bmid_base + SCC_DMA_INTST, INTSTS_ICERR|INTSTS_BMSINT);
+                       continue;
+               }
+
+               if (reg & INTSTS_BMSINT) {
+                       unsigned int classes;
+                       printk(KERN_WARNING "%s: Internal Bus Error\n", DRV_NAME);
+                       out_be32(bmid_base + SCC_DMA_INTST, INTSTS_BMSINT);
+                       /* TBD: SW reset */
+                       scc_std_softreset(ap, &classes);
+                       continue;
+               }
+
+               if (reg & INTSTS_BMHE) {
+                       out_be32(bmid_base + SCC_DMA_INTST, INTSTS_BMHE);
+                       continue;
+               }
+
+               if (reg & INTSTS_ACTEINT) {
+                       out_be32(bmid_base + SCC_DMA_INTST, INTSTS_ACTEINT);
+                       continue;
+               }
+
+               if (reg & INTSTS_IOIRQS) {
+                       out_be32(bmid_base + SCC_DMA_INTST, INTSTS_IOIRQS);
+                       continue;
+               }
+               break;
+       }
+
+       /* clear start/stop bit */
+       out_be32(bmid_base + SCC_DMA_CMD,
+                in_be32(bmid_base + SCC_DMA_CMD) & ~ATA_DMA_START);
+
+       /* one-PIO-cycle guaranteed wait, per spec, for HDMA1:0 transition */
+       ata_altstatus(ap);      /* dummy read */
+}
+
+/**
+ *     scc_bmdma_status - Read PCI IDE BMDMA status
+ *     @ap: Port associated with this ATA transaction.
+ */
+
+static u8 scc_bmdma_status (struct ata_port *ap)
+{
+       u8 host_stat;
+       void __iomem *mmio = ap->ioaddr.bmdma_addr;
+
+       host_stat = in_be32(mmio + SCC_DMA_STATUS);
+
+       /* Workaround for PTERADD: emulate DMA_INTR when
+        * - IDE_STATUS[ERR] = 1
+        * - INT_STATUS[INTRQ] = 1
+        * - DMA_STATUS[IORACTA] = 1
+        */
+       if (!(host_stat & ATA_DMA_INTR)) {
+               u32 int_status = in_be32(mmio + SCC_DMA_INTST);
+               if (ata_altstatus(ap) & ATA_ERR &&
+                   int_status & INTSTS_INTRQ &&
+                   host_stat & ATA_DMA_ACTIVE)
+                       host_stat |= ATA_DMA_INTR;
+       }
+
+       return host_stat;
+}
+
+/**
+ *     scc_data_xfer - Transfer data by PIO
+ *     @adev: device for this I/O
+ *     @buf: data buffer
+ *     @buflen: buffer length
+ *     @write_data: read/write
+ *
+ *     Note: Original code is ata_data_xfer().
+ */
+
+static void scc_data_xfer (struct ata_device *adev, unsigned char *buf,
+                          unsigned int buflen, int write_data)
+{
+       struct ata_port *ap = adev->ap;
+       unsigned int words = buflen >> 1;
+       unsigned int i;
+       u16 *buf16 = (u16 *) buf;
+       void __iomem *mmio = ap->ioaddr.data_addr;
+
+       /* Transfer multiple of 2 bytes */
+       if (write_data) {
+               for (i = 0; i < words; i++)
+                       out_be32(mmio, cpu_to_le16(buf16[i]));
+       } else {
+               for (i = 0; i < words; i++)
+                       buf16[i] = le16_to_cpu(in_be32(mmio));
+       }
+
+       /* Transfer trailing 1 byte, if any. */
+       if (unlikely(buflen & 0x01)) {
+               u16 align_buf[1] = { 0 };
+               unsigned char *trailing_buf = buf + buflen - 1;
+
+               if (write_data) {
+                       memcpy(align_buf, trailing_buf, 1);
+                       out_be32(mmio, cpu_to_le16(align_buf[0]));
+               } else {
+                       align_buf[0] = le16_to_cpu(in_be32(mmio));
+                       memcpy(trailing_buf, align_buf, 1);
+               }
+       }
+}
+
+/**
+ *     scc_irq_on - Enable interrupts on a port.
+ *     @ap: Port on which interrupts are enabled.
+ *
+ *     Note: Original code is ata_irq_on().
+ */
+
+static u8 scc_irq_on (struct ata_port *ap)
+{
+       struct ata_ioports *ioaddr = &ap->ioaddr;
+       u8 tmp;
+
+       ap->ctl &= ~ATA_NIEN;
+       ap->last_ctl = ap->ctl;
+
+       out_be32(ioaddr->ctl_addr, ap->ctl);
+       tmp = ata_wait_idle(ap);
+
+       ap->ops->irq_clear(ap);
+
+       return tmp;
+}
+
+/**
+ *     scc_irq_ack - Acknowledge a device interrupt.
+ *     @ap: Port on which interrupts are enabled.
+ *
+ *     Note: Original code is ata_irq_ack().
+ */
+
+static u8 scc_irq_ack (struct ata_port *ap, unsigned int chk_drq)
+{
+       unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
+       u8 host_stat, post_stat, status;
+
+       status = ata_busy_wait(ap, bits, 1000);
+       if (status & bits)
+               if (ata_msg_err(ap))
+                       printk(KERN_ERR "abnormal status 0x%X\n", status);
+
+       /* get controller status; clear intr, err bits */
+       host_stat = in_be32(ap->ioaddr.bmdma_addr + SCC_DMA_STATUS);
+       out_be32(ap->ioaddr.bmdma_addr + SCC_DMA_STATUS,
+                host_stat | ATA_DMA_INTR | ATA_DMA_ERR);
+
+       post_stat = in_be32(ap->ioaddr.bmdma_addr + SCC_DMA_STATUS);
+
+       if (ata_msg_intr(ap))
+               printk(KERN_INFO "%s: irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
+                      __FUNCTION__,
+                      host_stat, post_stat, status);
+
+       return status;
+}
+
+/**
+ *     scc_bmdma_freeze - Freeze BMDMA controller port
+ *     @ap: port to freeze
+ *
+ *     Note: Original code is ata_bmdma_freeze().
+ */
+
+static void scc_bmdma_freeze (struct ata_port *ap)
+{
+       struct ata_ioports *ioaddr = &ap->ioaddr;
+
+       ap->ctl |= ATA_NIEN;
+       ap->last_ctl = ap->ctl;
+
+       out_be32(ioaddr->ctl_addr, ap->ctl);
+
+       /* Under certain circumstances, some controllers raise IRQ on
+        * ATA_NIEN manipulation.  Also, many controllers fail to mask
+        * previously pending IRQ on ATA_NIEN assertion.  Clear it.
+        */
+       ata_chk_status(ap);
+
+       ap->ops->irq_clear(ap);
+}
+
+/**
+ *     scc_pata_prereset - prepare for reset
+ *     @ap: ATA port to be reset
+ */
+
+static int scc_pata_prereset (struct ata_port *ap)
+{
+       ap->cbl = ATA_CBL_PATA80;
+       return ata_std_prereset(ap);
+}
+
+/**
+ *     scc_std_postreset - standard postreset callback
+ *     @ap: the target ata_port
+ *     @classes: classes of attached devices
+ *
+ *     Note: Original code is ata_std_postreset().
+ */
+
+static void scc_std_postreset (struct ata_port *ap, unsigned int *classes)
+{
+       DPRINTK("ENTER\n");
+
+       /* re-enable interrupts */
+       if (!ap->ops->error_handler)
+               ap->ops->irq_on(ap);
+
+       /* is double-select really necessary? */
+       if (classes[0] != ATA_DEV_NONE)
+               ap->ops->dev_select(ap, 1);
+       if (classes[1] != ATA_DEV_NONE)
+               ap->ops->dev_select(ap, 0);
+
+       /* bail out if no device is present */
+       if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
+               DPRINTK("EXIT, no device\n");
+               return;
+       }
+
+       /* set up device control */
+       if (ap->ioaddr.ctl_addr)
+               out_be32(ap->ioaddr.ctl_addr, ap->ctl);
+
+       DPRINTK("EXIT\n");
+}
+
+/**
+ *     scc_error_handler - Stock error handler for BMDMA controller
+ *     @ap: port to handle error for
+ */
+
+static void scc_error_handler (struct ata_port *ap)
+{
+       ata_bmdma_drive_eh(ap, scc_pata_prereset, scc_std_softreset, NULL,
+                          scc_std_postreset);
+}
+
+/**
+ *     scc_bmdma_irq_clear - Clear PCI IDE BMDMA interrupt.
+ *     @ap: Port associated with this ATA transaction.
+ *
+ *     Note: Original code is ata_bmdma_irq_clear().
+ */
+
+static void scc_bmdma_irq_clear (struct ata_port *ap)
+{
+       void __iomem *mmio = ap->ioaddr.bmdma_addr;
+
+       if (!mmio)
+               return;
+
+       out_be32(mmio + SCC_DMA_STATUS, in_be32(mmio + SCC_DMA_STATUS));
+}
+
+/**
+ *     scc_port_start - Set port up for dma.
+ *     @ap: Port to initialize
+ *
+ *     Allocate space for PRD table using ata_port_start().
+ *     Set PRD table address for PTERADD. (PRD Transfer End Read)
+ */
+
+static int scc_port_start (struct ata_port *ap)
+{
+       void __iomem *mmio = ap->ioaddr.bmdma_addr;
+       int rc;
+
+       rc = ata_port_start(ap);
+       if (rc)
+               return rc;
+
+       out_be32(mmio + SCC_DMA_PTERADD, ap->prd_dma);
+       return 0;
+}
+
+/**
+ *     scc_port_stop - Undo scc_port_start()
+ *     @ap: Port to shut down
+ *
+ *     Reset PTERADD.
+ */
+
+static void scc_port_stop (struct ata_port *ap)
+{
+       void __iomem *mmio = ap->ioaddr.bmdma_addr;
+
+       out_be32(mmio + SCC_DMA_PTERADD, 0);
+}
+
+static struct scsi_host_template scc_sht = {
+       .module                 = THIS_MODULE,
+       .name                   = DRV_NAME,
+       .ioctl                  = ata_scsi_ioctl,
+       .queuecommand           = ata_scsi_queuecmd,
+       .can_queue              = ATA_DEF_QUEUE,
+       .this_id                = ATA_SHT_THIS_ID,
+       .sg_tablesize           = LIBATA_MAX_PRD,
+       .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
+       .emulated               = ATA_SHT_EMULATED,
+       .use_clustering         = ATA_SHT_USE_CLUSTERING,
+       .proc_name              = DRV_NAME,
+       .dma_boundary           = ATA_DMA_BOUNDARY,
+       .slave_configure        = ata_scsi_slave_config,
+       .slave_destroy          = ata_scsi_slave_destroy,
+       .bios_param             = ata_std_bios_param,
+       .resume                 = ata_scsi_device_resume,
+       .suspend                = ata_scsi_device_suspend,
+};
+
+static const struct ata_port_operations scc_pata_ops = {
+       .port_disable           = ata_port_disable,
+       .set_piomode            = scc_set_piomode,
+       .set_dmamode            = scc_set_dmamode,
+       .mode_filter            = ata_pci_default_filter,
+
+       .tf_load                = scc_tf_load,
+       .tf_read                = scc_tf_read,
+       .exec_command           = scc_exec_command,
+       .check_status           = scc_check_status,
+       .check_altstatus        = scc_check_altstatus,
+       .dev_select             = scc_std_dev_select,
+
+       .bmdma_setup            = scc_bmdma_setup,
+       .bmdma_start            = scc_bmdma_start,
+       .bmdma_stop             = scc_bmdma_stop,
+       .bmdma_status           = scc_bmdma_status,
+       .data_xfer              = scc_data_xfer,
+
+       .qc_prep                = ata_qc_prep,
+       .qc_issue               = ata_qc_issue_prot,
+
+       .freeze                 = scc_bmdma_freeze,
+       .error_handler          = scc_error_handler,
+       .post_internal_cmd      = scc_bmdma_stop,
+
+       .irq_handler            = ata_interrupt,
+       .irq_clear              = scc_bmdma_irq_clear,
+       .irq_on                 = scc_irq_on,
+       .irq_ack                = scc_irq_ack,
+
+       .port_start             = scc_port_start,
+       .port_stop              = scc_port_stop,
+};
+
+static struct ata_port_info scc_port_info[] = {
+       {
+               .sht            = &scc_sht,
+               .flags          = ATA_FLAG_SLAVE_POSS | ATA_FLAG_MMIO | ATA_FLAG_NO_LEGACY,
+               .pio_mask       = 0x1f, /* pio0-4 */
+               .mwdma_mask     = 0x00,
+               .udma_mask      = ATA_UDMA6,
+               .port_ops       = &scc_pata_ops,
+       },
+};
+
+/**
+ *     scc_reset_controller - initialize SCC PATA controller.
+ */
+
+static int scc_reset_controller(struct ata_probe_ent *probe_ent)
+{
+       void __iomem *ctrl_base = probe_ent->iomap[SCC_CTRL_BAR];
+       void __iomem *bmid_base = probe_ent->iomap[SCC_BMID_BAR];
+       void __iomem *cckctrl_port = ctrl_base + SCC_CTL_CCKCTRL;
+       void __iomem *mode_port = ctrl_base + SCC_CTL_MODEREG;
+       void __iomem *ecmode_port = ctrl_base + SCC_CTL_ECMODE;
+       void __iomem *intmask_port = bmid_base + SCC_DMA_INTMASK;
+       void __iomem *dmastatus_port = bmid_base + SCC_DMA_STATUS;
+       u32 reg = 0;
+
+       out_be32(cckctrl_port, reg);
+       reg |= CCKCTRL_ATACLKOEN;
+       out_be32(cckctrl_port, reg);
+       reg |= CCKCTRL_LCLKEN | CCKCTRL_OCLKEN;
+       out_be32(cckctrl_port, reg);
+       reg |= CCKCTRL_CRST;
+       out_be32(cckctrl_port, reg);
+
+       for (;;) {
+               reg = in_be32(cckctrl_port);
+               if (reg & CCKCTRL_CRST)
+                       break;
+               udelay(5000);
+       }
+
+       reg |= CCKCTRL_ATARESET;
+       out_be32(cckctrl_port, reg);
+       out_be32(ecmode_port, ECMODE_VALUE);
+       out_be32(mode_port, MODE_JCUSFEN);
+       out_be32(intmask_port, INTMASK_MSK);
+
+       if (in_be32(dmastatus_port) & QCHSD_STPDIAG) {
+               printk(KERN_WARNING "%s: failed to detect 80c cable. (PDIAG# is high)\n", DRV_NAME);
+               return -EIO;
+       }
+
+       return 0;
+}
+
+/**
+ *     scc_setup_ports - initialize ioaddr with SCC PATA port offsets.
+ *     @ioaddr: IO address structure to be initialized
+ *     @base: base address of BMID region
+ */
+
+static void scc_setup_ports (struct ata_ioports *ioaddr, void __iomem *base)
+{
+       ioaddr->cmd_addr = base + SCC_REG_CMD_ADDR;
+       ioaddr->altstatus_addr = ioaddr->cmd_addr + SCC_REG_ALTSTATUS;
+       ioaddr->ctl_addr = ioaddr->cmd_addr + SCC_REG_ALTSTATUS;
+       ioaddr->bmdma_addr = base;
+       ioaddr->data_addr = ioaddr->cmd_addr + SCC_REG_DATA;
+       ioaddr->error_addr = ioaddr->cmd_addr + SCC_REG_ERR;
+       ioaddr->feature_addr = ioaddr->cmd_addr + SCC_REG_FEATURE;
+       ioaddr->nsect_addr = ioaddr->cmd_addr + SCC_REG_NSECT;
+       ioaddr->lbal_addr = ioaddr->cmd_addr + SCC_REG_LBAL;
+       ioaddr->lbam_addr = ioaddr->cmd_addr + SCC_REG_LBAM;
+       ioaddr->lbah_addr = ioaddr->cmd_addr + SCC_REG_LBAH;
+       ioaddr->device_addr = ioaddr->cmd_addr + SCC_REG_DEVICE;
+       ioaddr->status_addr = ioaddr->cmd_addr + SCC_REG_STATUS;
+       ioaddr->command_addr = ioaddr->cmd_addr + SCC_REG_CMD;
+}
+
+static int scc_host_init(struct ata_probe_ent *probe_ent)
+{
+       struct pci_dev *pdev = to_pci_dev(probe_ent->dev);
+       int rc;
+
+       rc = scc_reset_controller(probe_ent);
+       if (rc)
+               return rc;
+
+       probe_ent->n_ports = 1;
+
+       rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
+       if (rc)
+               return rc;
+       rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
+       if (rc)
+               return rc;
+
+       scc_setup_ports(&probe_ent->port[0], probe_ent->iomap[SCC_BMID_BAR]);
+
+       pci_set_master(pdev);
+
+       return 0;
+}
+
+/**
+ *     scc_init_one - Register SCC PATA device with kernel services
+ *     @pdev: PCI device to register
+ *     @ent: Entry in scc_pci_tbl matching with @pdev
+ *
+ *     LOCKING:
+ *     Inherited from PCI layer (may sleep).
+ *
+ *     RETURNS:
+ *     Zero on success, or -ERRNO value.
+ */
+
+static int scc_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+       static int printed_version;
+       unsigned int board_idx = (unsigned int) ent->driver_data;
+       struct device *dev = &pdev->dev;
+       struct ata_probe_ent *probe_ent;
+       int rc;
+
+       if (!printed_version++)
+               dev_printk(KERN_DEBUG, &pdev->dev,
+                          "version " DRV_VERSION "\n");
+
+       rc = pcim_enable_device(pdev);
+       if (rc)
+               return rc;
+
+       rc = pcim_iomap_regions(pdev, (1 << SCC_CTRL_BAR) | (1 << SCC_BMID_BAR), DRV_NAME);
+       if (rc == -EBUSY)
+               pcim_pin_device(pdev);
+       if (rc)
+               return rc;
+
+       probe_ent = devm_kzalloc(dev, sizeof(*probe_ent), GFP_KERNEL);
+       if (!probe_ent)
+               return -ENOMEM;
+
+       probe_ent->dev = dev;
+       INIT_LIST_HEAD(&probe_ent->node);
+
+       probe_ent->sht          = scc_port_info[board_idx].sht;
+       probe_ent->port_flags   = scc_port_info[board_idx].flags;
+       probe_ent->pio_mask     = scc_port_info[board_idx].pio_mask;
+       probe_ent->udma_mask    = scc_port_info[board_idx].udma_mask;
+       probe_ent->port_ops     = scc_port_info[board_idx].port_ops;
+
+       probe_ent->irq = pdev->irq;
+       probe_ent->irq_flags = IRQF_SHARED;
+       probe_ent->iomap = pcim_iomap_table(pdev);
+
+       rc = scc_host_init(probe_ent);
+       if (rc)
+               return rc;
+
+       if (!ata_device_add(probe_ent))
+               return -ENODEV;
+
+       devm_kfree(dev, probe_ent);
+       return 0;
+}
+
+static struct pci_driver scc_pci_driver = {
+       .name                   = DRV_NAME,
+       .id_table               = scc_pci_tbl,
+       .probe                  = scc_init_one,
+       .remove                 = ata_pci_remove_one,
+#ifdef CONFIG_PM
+       .suspend                = ata_pci_device_suspend,
+       .resume                 = ata_pci_device_resume,
+#endif
+};
+
+static int __init scc_init (void)
+{
+       int rc;
+
+       DPRINTK("pci_register_driver\n");
+       rc = pci_register_driver(&scc_pci_driver);
+       if (rc)
+               return rc;
+
+       DPRINTK("done\n");
+       return 0;
+}
+
+static void __exit scc_exit (void)
+{
+       pci_unregister_driver(&scc_pci_driver);
+}
+
+module_init(scc_init);
+module_exit(scc_exit);
+
+MODULE_AUTHOR("Toshiba corp");
+MODULE_DESCRIPTION("SCSI low-level driver for Toshiba SCC PATA controller");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(pci, scc_pci_tbl);
+MODULE_VERSION(DRV_VERSION);
index ad5b43fef3d1a94914d090fc88476ed100a0e2a1..dde7eb9f72bbfd6f3f17d5cb8d32cbd0da0eedae 100644 (file)
@@ -41,7 +41,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME "pata_serverworks"
-#define DRV_VERSION "0.3.9"
+#define DRV_VERSION "0.4.0"
 
 #define SVWKS_CSB5_REVISION_NEW        0x92 /* min PCI_REVISION_ID for UDMA5 (A2.0) */
 #define SVWKS_CSB6_REVISION    0xa0 /* min PCI_REVISION_ID for UDMA4 (A1.0) */
index ed79fabe025c1e5beed1811da7a447d07205f873..1cb67b221c2835332c2ffd1857f66af90bd9b3c2 100644 (file)
@@ -33,7 +33,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME "pata_sil680"
-#define DRV_VERSION "0.4.1"
+#define DRV_VERSION "0.4.5"
 
 /**
  *     sil680_selreg           -       return register base
@@ -139,10 +139,13 @@ static void sil680_set_piomode(struct ata_port *ap, struct ata_device *adev)
 
        unsigned long tfaddr = sil680_selreg(ap, 0x02);
        unsigned long addr = sil680_seldev(ap, adev, 0x04);
+       unsigned long addr_mask = 0x80 + 4 * ap->port_no;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
        int pio = adev->pio_mode - XFER_PIO_0;
        int lowest_pio = pio;
+       int port_shift = 4 * adev->devno;
        u16 reg;
+       u8 mode;
 
        struct ata_device *pair = ata_dev_pair(adev);
 
@@ -153,10 +156,17 @@ static void sil680_set_piomode(struct ata_port *ap, struct ata_device *adev)
        pci_write_config_word(pdev, tfaddr, speed_t[lowest_pio]);
 
        pci_read_config_word(pdev, tfaddr-2, &reg);
+       pci_read_config_byte(pdev, addr_mask, &mode);
+
        reg &= ~0x0200;                 /* Clear IORDY */
-       if (ata_pio_need_iordy(adev))
+       mode &= ~(3 << port_shift);     /* Clear IORDY and DMA bits */
+
+       if (ata_pio_need_iordy(adev)) {
                reg |= 0x0200;          /* Enable IORDY */
+               mode |= 1 << port_shift;
+       }
        pci_write_config_word(pdev, tfaddr-2, reg);
+       pci_write_config_byte(pdev, addr_mask, mode);
 }
 
 /**
index 560103d55b2e9a09e784ea6882fc0d0fc5e7149a..be300923b27ee6ced10959973c66d2a8903e733c 100644 (file)
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
 #include <linux/ata.h>
-#include "libata.h"
+#include "sis.h"
 
-#undef DRV_NAME                /* already defined in libata.h, for libata-core */
 #define DRV_NAME       "pata_sis"
-#define DRV_VERSION    "0.4.5"
+#define DRV_VERSION    "0.5.0"
 
 struct sis_chipset {
        u16 device;                     /* PCI host ID */
@@ -151,7 +150,7 @@ static int sis_66_pre_reset(struct ata_port *ap)
 
        if (!pci_test_config_bits(pdev, &sis_enable_bits[ap->port_no])) {
                ata_port_disable(ap);
-               printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
+               ata_port_printk(ap, KERN_INFO, "port disabled. ignoring.\n");
                return 0;
        }
        /* Older chips keep cable detect in bits 4/5 of reg 0x48 */
@@ -197,7 +196,7 @@ static int sis_old_pre_reset(struct ata_port *ap)
 
        if (!pci_test_config_bits(pdev, &sis_enable_bits[ap->port_no])) {
                ata_port_disable(ap);
-               printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
+               ata_port_printk(ap, KERN_INFO, "port disabled. ignoring.\n");
                return 0;
        }
        ap->cbl = ATA_CBL_PATA40;
index 96e890fd645b671247069881385de1c36d0abdb0..13e81f0ef1f7eaa33dab399c96cbfe65569e76d2 100644 (file)
@@ -7,6 +7,13 @@
  *             SL82C105/Winbond 553 IDE driver
  *
  * and in part on the documentation and errata sheet
+ *
+ *
+ * Note: The controller like many controllers has shared timings for
+ * PIO and DMA. We thus flip to the DMA timings in dma_start and flip back
+ * in the dma_stop function. Thus we actually don't need a set_dmamode
+ * method as the PIO method is always called and will set the right PIO
+ * timing parameters.
  */
 
 #include <linux/kernel.h>
@@ -19,7 +26,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME "pata_sl82c105"
-#define DRV_VERSION "0.2.3"
+#define DRV_VERSION "0.3.0"
 
 enum {
        /*
@@ -125,33 +132,6 @@ static void sl82c105_configure_dmamode(struct ata_port *ap, struct ata_device *a
        pci_read_config_word(pdev, timing, &dummy);
 }
 
-/**
- *     sl82c105_set_dmamode    -       set initial DMA mode data
- *     @ap: ATA interface
- *     @adev: ATA device
- *
- *     Called to do the DMA mode setup. This replaces the PIO timings
- *     for the device in question. Set appropriate PIO timings not DMA
- *     timings at this point.
- */
-
-static void sl82c105_set_dmamode(struct ata_port *ap, struct ata_device *adev)
-{
-       switch(adev->dma_mode) {
-               case XFER_MW_DMA_0:
-                       sl82c105_configure_piomode(ap, adev, 0);
-                       break;
-               case XFER_MW_DMA_1:
-                       sl82c105_configure_piomode(ap, adev, 3);
-                       break;
-               case XFER_MW_DMA_2:
-                       sl82c105_configure_piomode(ap, adev, 4);
-                       break;
-               default:
-                       BUG();
-       }
-}
-
 /**
  *     sl82c105_reset_engine   -       Reset the DMA engine
  *     @ap: ATA interface
@@ -222,7 +202,7 @@ static void sl82c105_bmdma_stop(struct ata_queued_cmd *qc)
 
        /* This will redo the initial setup of the DMA device to matching
           PIO timings */
-       sl82c105_set_dmamode(ap, qc->dev);
+       sl82c105_set_piomode(ap, qc->dev);
 }
 
 static struct scsi_host_template sl82c105_sht = {
@@ -246,7 +226,6 @@ static struct scsi_host_template sl82c105_sht = {
 static struct ata_port_operations sl82c105_port_ops = {
        .port_disable   = ata_port_disable,
        .set_piomode    = sl82c105_set_piomode,
-       .set_dmamode    = sl82c105_set_dmamode,
        .mode_filter    = ata_pci_default_filter,
 
        .tf_load        = ata_tf_load,
index 220fcd6c549296b82154b6f3d7b5a5da1953b337..20fc2d0dcfa1e88e1b9f84159796031b1fc1f207 100644 (file)
@@ -170,7 +170,7 @@ static int via_pre_reset(struct ata_port *ap)
                ap->cbl = ATA_CBL_PATA40;
        else
                ap->cbl = ATA_CBL_PATA_UNK;
-               
+
 
        return ata_std_prereset(ap);
 }
index 0888b4f19f4c900467a158fa0d1bd6c03ad9210a..6c111035fc84da35b2ffa7e4bcf42fcb4951a960 100644 (file)
@@ -17,7 +17,7 @@
 #include <linux/platform_device.h>
 
 #define DRV_NAME "pata_winbond"
-#define DRV_VERSION "0.0.1"
+#define DRV_VERSION "0.0.2"
 
 #define NR_HOST 4      /* Two winbond controllers, two channels each */
 
index 857ac23217ab0895f095700b5db9c529a9f67fb5..5dd3ca8b5f29fb273303810d488c318d80ce7287 100644 (file)
@@ -44,7 +44,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME       "pdc_adma"
-#define DRV_VERSION    "0.04"
+#define DRV_VERSION    "0.05"
 
 /* macro to calculate base address for ATA regs */
 #define ADMA_ATA_REGS(base,port_no)    ((base) + ((port_no) * 0x40))
@@ -498,7 +498,7 @@ static inline unsigned int adma_intr_mmio(struct ata_host *host)
                                if ((status & ATA_BUSY))
                                        continue;
                                DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
-                                       ap->id, qc->tf.protocol, status);
+                                       ap->print_id, qc->tf.protocol, status);
 
                                /* complete taskfile transaction */
                                pp->state = adma_state_idle;
index d689df52eae3790a8027aaa21bc140bd3112d3ae..a65ba636aaa8eeb0ddb66b160f4a5749409c1106 100644 (file)
@@ -35,7 +35,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME       "sata_mv"
-#define DRV_VERSION    "0.7"
+#define DRV_VERSION    "0.8"
 
 enum {
        /* BAR's are enumerated in terms of pci_resource_start() terms */
@@ -137,14 +137,19 @@ enum {
        PCI_ERR                 = (1 << 18),
        TRAN_LO_DONE            = (1 << 19),    /* 6xxx: IRQ coalescing */
        TRAN_HI_DONE            = (1 << 20),    /* 6xxx: IRQ coalescing */
+       PORTS_0_3_COAL_DONE     = (1 << 8),
+       PORTS_4_7_COAL_DONE     = (1 << 17),
        PORTS_0_7_COAL_DONE     = (1 << 21),    /* 6xxx: IRQ coalescing */
        GPIO_INT                = (1 << 22),
        SELF_INT                = (1 << 23),
        TWSI_INT                = (1 << 24),
        HC_MAIN_RSVD            = (0x7f << 25), /* bits 31-25 */
+       HC_MAIN_RSVD_5          = (0x1fff << 19), /* bits 31-19 */
        HC_MAIN_MASKED_IRQS     = (TRAN_LO_DONE | TRAN_HI_DONE |
                                   PORTS_0_7_COAL_DONE | GPIO_INT | TWSI_INT |
                                   HC_MAIN_RSVD),
+       HC_MAIN_MASKED_IRQS_5   = (PORTS_0_3_COAL_DONE | PORTS_4_7_COAL_DONE |
+                                  HC_MAIN_RSVD_5),
 
        /* SATAHC registers */
        HC_CFG_OFS              = 0,
@@ -814,23 +819,27 @@ static void mv_edma_cfg(struct mv_host_priv *hpriv, void __iomem *port_mmio)
        u32 cfg = readl(port_mmio + EDMA_CFG_OFS);
 
        /* set up non-NCQ EDMA configuration */
-       cfg &= ~0x1f;           /* clear queue depth */
-       cfg &= ~EDMA_CFG_NCQ;   /* clear NCQ mode */
        cfg &= ~(1 << 9);       /* disable equeue */
 
-       if (IS_GEN_I(hpriv))
+       if (IS_GEN_I(hpriv)) {
+               cfg &= ~0x1f;           /* clear queue depth */
                cfg |= (1 << 8);        /* enab config burst size mask */
+       }
 
-       else if (IS_GEN_II(hpriv))
+       else if (IS_GEN_II(hpriv)) {
+               cfg &= ~0x1f;           /* clear queue depth */
                cfg |= EDMA_CFG_RD_BRST_EXT | EDMA_CFG_WR_BUFF_LEN;
+               cfg &= ~(EDMA_CFG_NCQ | EDMA_CFG_NCQ_GO_ON_ERR); /* clear NCQ */
+       }
 
        else if (IS_GEN_IIE(hpriv)) {
-               cfg |= (1 << 23);       /* dis RX PM port mask */
-               cfg &= ~(1 << 16);      /* dis FIS-based switching (for now) */
+               cfg |= (1 << 23);       /* do not mask PM field in rx'd FIS */
+               cfg |= (1 << 22);       /* enab 4-entry host queue cache */
                cfg &= ~(1 << 19);      /* dis 128-entry queue (for now?) */
                cfg |= (1 << 18);       /* enab early completion */
-               cfg |= (1 << 17);       /* enab host q cache */
-               cfg |= (1 << 22);       /* enab cutthrough */
+               cfg |= (1 << 17);       /* enab cut-through (dis stor&forwrd) */
+               cfg &= ~(1 << 16);      /* dis FIS-based switching (for now) */
+               cfg &= ~(EDMA_CFG_NCQ | EDMA_CFG_NCQ_GO_ON_ERR); /* clear NCQ */
        }
 
        writelfl(cfg, port_mmio + EDMA_CFG_OFS);
@@ -1276,7 +1285,7 @@ static void mv_err_intr(struct ata_port *ap, int reset_allowed)
                pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
        }
        DPRINTK(KERN_ERR "ata%u: port error; EDMA err cause: 0x%08x "
-               "SERR: 0x%08x\n", ap->id, edma_err_cause, serr);
+               "SERR: 0x%08x\n", ap->print_id, edma_err_cause, serr);
 
        /* Clear EDMA now that SERR cleanup done */
        writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
@@ -2052,7 +2061,7 @@ static void mv_port_init(struct ata_ioports *port,  void __iomem *port_mmio)
        port->altstatus_addr = port->ctl_addr = shd_base + SHD_CTL_AST_OFS;
 
        /* unused: */
-       port->cmd_addr = port->bmdma_addr = port->scr_addr = 0;
+       port->cmd_addr = port->bmdma_addr = port->scr_addr = NULL;
 
        /* Clear any currently outstanding port interrupt conditions */
        serr_ofs = mv_scr_offset(SCR_ERROR);
@@ -2240,7 +2249,11 @@ static int mv_init_host(struct pci_dev *pdev, struct ata_probe_ent *probe_ent,
 
        /* and unmask interrupt generation for host regs */
        writelfl(PCI_UNMASK_ALL_IRQS, mmio + PCI_IRQ_MASK_OFS);
-       writelfl(~HC_MAIN_MASKED_IRQS, mmio + HC_MAIN_IRQ_MASK_OFS);
+
+       if (IS_50XX(hpriv))
+               writelfl(~HC_MAIN_MASKED_IRQS_5, mmio + HC_MAIN_IRQ_MASK_OFS);
+       else
+               writelfl(~HC_MAIN_MASKED_IRQS, mmio + HC_MAIN_IRQ_MASK_OFS);
 
        VPRINTK("HC MAIN IRQ cause/mask=0x%08x/0x%08x "
                "PCI int cause/mask=0x%08x/0x%08x\n",
@@ -2347,7 +2360,7 @@ static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                return rc;
 
        /* Enable interrupts */
-       if (msi && !pci_enable_msi(pdev))
+       if (msi && pci_enable_msi(pdev))
                pci_intx(pdev, 1);
 
        mv_dump_pci_cfg(pdev, 0x68);
index ab92f208dae2f955b9aef79d214707e90c1b10f0..30eed12b3631882e5b79aee5fffe4b97bc576e9a 100644 (file)
@@ -219,6 +219,7 @@ struct nv_adma_port_priv {
        void __iomem *          gen_block;
        void __iomem *          notifier_clear_block;
        u8                      flags;
+       int                     last_issue_ncq;
 };
 
 struct nv_host_priv {
@@ -254,10 +255,7 @@ static int nv_adma_port_suspend(struct ata_port *ap, pm_message_t mesg);
 static int nv_adma_port_resume(struct ata_port *ap);
 static void nv_adma_error_handler(struct ata_port *ap);
 static void nv_adma_host_stop(struct ata_host *host);
-static void nv_adma_bmdma_setup(struct ata_queued_cmd *qc);
-static void nv_adma_bmdma_start(struct ata_queued_cmd *qc);
-static void nv_adma_bmdma_stop(struct ata_queued_cmd *qc);
-static u8 nv_adma_bmdma_status(struct ata_port *ap);
+static void nv_adma_post_internal_cmd(struct ata_queued_cmd *qc);
 
 enum nv_host_type
 {
@@ -432,16 +430,16 @@ static const struct ata_port_operations nv_adma_ops = {
        .exec_command           = ata_exec_command,
        .check_status           = ata_check_status,
        .dev_select             = ata_std_dev_select,
-       .bmdma_setup            = nv_adma_bmdma_setup,
-       .bmdma_start            = nv_adma_bmdma_start,
-       .bmdma_stop             = nv_adma_bmdma_stop,
-       .bmdma_status           = nv_adma_bmdma_status,
+       .bmdma_setup            = ata_bmdma_setup,
+       .bmdma_start            = ata_bmdma_start,
+       .bmdma_stop             = ata_bmdma_stop,
+       .bmdma_status           = ata_bmdma_status,
        .qc_prep                = nv_adma_qc_prep,
        .qc_issue               = nv_adma_qc_issue,
        .freeze                 = nv_ck804_freeze,
        .thaw                   = nv_ck804_thaw,
        .error_handler          = nv_adma_error_handler,
-       .post_internal_cmd      = nv_adma_bmdma_stop,
+       .post_internal_cmd      = nv_adma_post_internal_cmd,
        .data_xfer              = ata_data_xfer,
        .irq_handler            = nv_adma_interrupt,
        .irq_clear              = nv_adma_irq_clear,
@@ -661,30 +659,31 @@ static unsigned int nv_adma_tf_to_cpb(struct ata_taskfile *tf, __le16 *cpb)
 {
        unsigned int idx = 0;
 
-       cpb[idx++] = cpu_to_le16((ATA_REG_DEVICE << 8) | tf->device | WNB);
-
-       if ((tf->flags & ATA_TFLAG_LBA48) == 0) {
-               cpb[idx++] = cpu_to_le16(IGN);
-               cpb[idx++] = cpu_to_le16(IGN);
-               cpb[idx++] = cpu_to_le16(IGN);
-               cpb[idx++] = cpu_to_le16(IGN);
-               cpb[idx++] = cpu_to_le16(IGN);
-       }
-       else {
-               cpb[idx++] = cpu_to_le16((ATA_REG_ERR   << 8) | tf->hob_feature);
-               cpb[idx++] = cpu_to_le16((ATA_REG_NSECT << 8) | tf->hob_nsect);
-               cpb[idx++] = cpu_to_le16((ATA_REG_LBAL  << 8) | tf->hob_lbal);
-               cpb[idx++] = cpu_to_le16((ATA_REG_LBAM  << 8) | tf->hob_lbam);
-               cpb[idx++] = cpu_to_le16((ATA_REG_LBAH  << 8) | tf->hob_lbah);
+       if(tf->flags & ATA_TFLAG_ISADDR) {
+               if (tf->flags & ATA_TFLAG_LBA48) {
+                       cpb[idx++] = cpu_to_le16((ATA_REG_ERR   << 8) | tf->hob_feature | WNB);
+                       cpb[idx++] = cpu_to_le16((ATA_REG_NSECT << 8) | tf->hob_nsect);
+                       cpb[idx++] = cpu_to_le16((ATA_REG_LBAL  << 8) | tf->hob_lbal);
+                       cpb[idx++] = cpu_to_le16((ATA_REG_LBAM  << 8) | tf->hob_lbam);
+                       cpb[idx++] = cpu_to_le16((ATA_REG_LBAH  << 8) | tf->hob_lbah);
+                       cpb[idx++] = cpu_to_le16((ATA_REG_ERR    << 8) | tf->feature);
+               } else
+                       cpb[idx++] = cpu_to_le16((ATA_REG_ERR    << 8) | tf->feature | WNB);
+
+               cpb[idx++] = cpu_to_le16((ATA_REG_NSECT  << 8) | tf->nsect);
+               cpb[idx++] = cpu_to_le16((ATA_REG_LBAL   << 8) | tf->lbal);
+               cpb[idx++] = cpu_to_le16((ATA_REG_LBAM   << 8) | tf->lbam);
+               cpb[idx++] = cpu_to_le16((ATA_REG_LBAH   << 8) | tf->lbah);
        }
-       cpb[idx++] = cpu_to_le16((ATA_REG_ERR    << 8) | tf->feature);
-       cpb[idx++] = cpu_to_le16((ATA_REG_NSECT  << 8) | tf->nsect);
-       cpb[idx++] = cpu_to_le16((ATA_REG_LBAL   << 8) | tf->lbal);
-       cpb[idx++] = cpu_to_le16((ATA_REG_LBAM   << 8) | tf->lbam);
-       cpb[idx++] = cpu_to_le16((ATA_REG_LBAH   << 8) | tf->lbah);
+
+       if(tf->flags & ATA_TFLAG_DEVICE)
+               cpb[idx++] = cpu_to_le16((ATA_REG_DEVICE << 8) | tf->device);
 
        cpb[idx++] = cpu_to_le16((ATA_REG_CMD    << 8) | tf->command | CMDEND);
 
+       while(idx < 12)
+               cpb[idx++] = cpu_to_le16(IGN);
+
        return idx;
 }
 
@@ -741,6 +740,17 @@ static int nv_adma_check_cpb(struct ata_port *ap, int cpb_num, int force_err)
                        DPRINTK("Completing qc from tag %d with err_mask %u\n",cpb_num,
                                qc->err_mask);
                        ata_qc_complete(qc);
+               } else {
+                       struct ata_eh_info *ehi = &ap->eh_info;
+                       /* Notifier bits set without a command may indicate the drive
+                          is misbehaving. Raise host state machine violation on this
+                          condition. */
+                       ata_port_printk(ap, KERN_ERR, "notifier for tag %d with no command?\n",
+                               cpb_num);
+                       ehi->err_mask |= AC_ERR_HSM;
+                       ehi->action |= ATA_EH_SOFTRESET;
+                       ata_port_freeze(ap);
+                       return 1;
                }
        }
        return 0;
@@ -852,22 +862,14 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
 
                        if (status & (NV_ADMA_STAT_DONE |
                                      NV_ADMA_STAT_CPBERR)) {
+                               u32 check_commands = notifier | notifier_error;
+                               int pos, error = 0;
                                /** Check CPBs for completed commands */
-
-                               if (ata_tag_valid(ap->active_tag)) {
-                                       /* Non-NCQ command */
-                                       nv_adma_check_cpb(ap, ap->active_tag,
-                                               notifier_error & (1 << ap->active_tag));
-                               } else {
-                                       int pos, error = 0;
-                                       u32 active = ap->sactive;
-
-                                       while ((pos = ffs(active)) && !error) {
-                                               pos--;
-                                               error = nv_adma_check_cpb(ap, pos,
-                                                       notifier_error & (1 << pos) );
-                                               active &= ~(1 << pos );
-                                       }
+                               while ((pos = ffs(check_commands)) && !error) {
+                                       pos--;
+                                       error = nv_adma_check_cpb(ap, pos,
+                                               notifier_error & (1 << pos) );
+                                       check_commands &= ~(1 << pos );
                                }
                        }
                }
@@ -905,73 +907,12 @@ static void nv_adma_irq_clear(struct ata_port *ap)
        iowrite8(ioread8(dma_stat_addr), dma_stat_addr);
 }
 
-static void nv_adma_bmdma_setup(struct ata_queued_cmd *qc)
-{
-       struct ata_port *ap = qc->ap;
-       unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
-       struct nv_adma_port_priv *pp = ap->private_data;
-       u8 dmactl;
-
-       if(!(pp->flags & NV_ADMA_PORT_REGISTER_MODE)) {
-               WARN_ON(1);
-               return;
-       }
-
-       /* load PRD table addr. */
-       iowrite32(ap->prd_dma, ap->ioaddr.bmdma_addr + ATA_DMA_TABLE_OFS);
-
-       /* specify data direction, triple-check start bit is clear */
-       dmactl = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
-       dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
-       if (!rw)
-               dmactl |= ATA_DMA_WR;
-
-       iowrite8(dmactl, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
-
-       /* issue r/w command */
-       ata_exec_command(ap, &qc->tf);
-}
-
-static void nv_adma_bmdma_start(struct ata_queued_cmd *qc)
-{
-       struct ata_port *ap = qc->ap;
-       struct nv_adma_port_priv *pp = ap->private_data;
-       u8 dmactl;
-
-       if(!(pp->flags & NV_ADMA_PORT_REGISTER_MODE)) {
-               WARN_ON(1);
-               return;
-       }
-
-       /* start host DMA transaction */
-       dmactl = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
-       iowrite8(dmactl | ATA_DMA_START,
-                ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
-}
-
-static void nv_adma_bmdma_stop(struct ata_queued_cmd *qc)
-{
-       struct ata_port *ap = qc->ap;
-       struct nv_adma_port_priv *pp = ap->private_data;
-
-       if(!(pp->flags & NV_ADMA_PORT_REGISTER_MODE))
-               return;
-
-       /* clear start/stop bit */
-       iowrite8(ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD) & ~ATA_DMA_START,
-                ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
-
-       /* one-PIO-cycle guaranteed wait, per spec, for HDMA1:0 transition */
-       ata_altstatus(ap);        /* dummy read */
-}
-
-static u8 nv_adma_bmdma_status(struct ata_port *ap)
+static void nv_adma_post_internal_cmd(struct ata_queued_cmd *qc)
 {
-       struct nv_adma_port_priv *pp = ap->private_data;
-
-       WARN_ON(!(pp->flags & NV_ADMA_PORT_REGISTER_MODE));
+       struct nv_adma_port_priv *pp = qc->ap->private_data;
 
-       return ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
+       if(pp->flags & NV_ADMA_PORT_REGISTER_MODE)
+               ata_bmdma_post_internal_cmd(qc);
 }
 
 static int nv_adma_port_start(struct ata_port *ap)
@@ -1040,14 +981,15 @@ static int nv_adma_port_start(struct ata_port *ap)
 
        /* clear GO for register mode, enable interrupt */
        tmp = readw(mmio + NV_ADMA_CTL);
-       writew( (tmp & ~NV_ADMA_CTL_GO) | NV_ADMA_CTL_AIEN, mmio + NV_ADMA_CTL);
+       writew( (tmp & ~NV_ADMA_CTL_GO) | NV_ADMA_CTL_AIEN |
+                NV_ADMA_CTL_HOTPLUG_IEN, mmio + NV_ADMA_CTL);
 
        tmp = readw(mmio + NV_ADMA_CTL);
        writew(tmp | NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
-       readl( mmio + NV_ADMA_CTL );    /* flush posted write */
+       readw( mmio + NV_ADMA_CTL );    /* flush posted write */
        udelay(1);
        writew(tmp & ~NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
-       readl( mmio + NV_ADMA_CTL );    /* flush posted write */
+       readw( mmio + NV_ADMA_CTL );    /* flush posted write */
 
        return 0;
 }
@@ -1099,14 +1041,15 @@ static int nv_adma_port_resume(struct ata_port *ap)
 
        /* clear GO for register mode, enable interrupt */
        tmp = readw(mmio + NV_ADMA_CTL);
-       writew((tmp & ~NV_ADMA_CTL_GO) | NV_ADMA_CTL_AIEN, mmio + NV_ADMA_CTL);
+       writew( (tmp & ~NV_ADMA_CTL_GO) | NV_ADMA_CTL_AIEN |
+                NV_ADMA_CTL_HOTPLUG_IEN, mmio + NV_ADMA_CTL);
 
        tmp = readw(mmio + NV_ADMA_CTL);
        writew(tmp | NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
-       readl( mmio + NV_ADMA_CTL );    /* flush posted write */
+       readw( mmio + NV_ADMA_CTL );    /* flush posted write */
        udelay(1);
        writew(tmp & ~NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
-       readl( mmio + NV_ADMA_CTL );    /* flush posted write */
+       readw( mmio + NV_ADMA_CTL );    /* flush posted write */
 
        return 0;
 }
@@ -1163,11 +1106,7 @@ static void nv_adma_fill_aprd(struct ata_queued_cmd *qc,
                              int idx,
                              struct nv_adma_prd *aprd)
 {
-       u8 flags;
-
-       memset(aprd, 0, sizeof(struct nv_adma_prd));
-
-       flags = 0;
+       u8 flags = 0;
        if (qc->tf.flags & ATA_TFLAG_WRITE)
                flags |= NV_APRD_WRITE;
        if (idx == qc->n_elem - 1)
@@ -1178,6 +1117,7 @@ static void nv_adma_fill_aprd(struct ata_queued_cmd *qc,
        aprd->addr  = cpu_to_le64(((u64)sg_dma_address(sg)));
        aprd->len   = cpu_to_le32(((u32)sg_dma_len(sg))); /* len in bytes */
        aprd->flags = flags;
+       aprd->packet_len = 0;
 }
 
 static void nv_adma_fill_sg(struct ata_queued_cmd *qc, struct nv_adma_cpb *cpb)
@@ -1198,6 +1138,8 @@ static void nv_adma_fill_sg(struct ata_queued_cmd *qc, struct nv_adma_cpb *cpb)
        }
        if (idx > 5)
                cpb->next_aprd = cpu_to_le64(((u64)(pp->aprd_dma + NV_ADMA_SGTBL_SZ * qc->tag)));
+       else
+               cpb->next_aprd = cpu_to_le64(0);
 }
 
 static int nv_adma_use_reg_mode(struct ata_queued_cmd *qc)
@@ -1230,7 +1172,10 @@ static void nv_adma_qc_prep(struct ata_queued_cmd *qc)
                return;
        }
 
-       memset(cpb, 0, sizeof(struct nv_adma_cpb));
+       cpb->resp_flags = NV_CPB_RESP_DONE;
+       wmb();
+       cpb->ctl_flags = 0;
+       wmb();
 
        cpb->len                = 3;
        cpb->tag                = qc->tag;
@@ -1254,12 +1199,15 @@ static void nv_adma_qc_prep(struct ata_queued_cmd *qc)
           finished filling in all of the contents */
        wmb();
        cpb->ctl_flags = ctl_flags;
+       wmb();
+       cpb->resp_flags = 0;
 }
 
 static unsigned int nv_adma_qc_issue(struct ata_queued_cmd *qc)
 {
        struct nv_adma_port_priv *pp = qc->ap->private_data;
        void __iomem *mmio = pp->ctl_block;
+       int curr_ncq = (qc->tf.protocol == ATA_PROT_NCQ);
 
        VPRINTK("ENTER\n");
 
@@ -1274,6 +1222,14 @@ static unsigned int nv_adma_qc_issue(struct ata_queued_cmd *qc)
        /* write append register, command tag in lower 8 bits
           and (number of cpbs to append -1) in top 8 bits */
        wmb();
+
+       if(curr_ncq != pp->last_issue_ncq) {
+               /* Seems to need some delay before switching between NCQ and non-NCQ
+                  commands, else we get command timeouts and such. */
+               udelay(20);
+               pp->last_issue_ncq = curr_ncq;
+       }
+
        writew(qc->tag, mmio + NV_ADMA_APPEND);
 
        DPRINTK("Issued tag %u\n",qc->tag);
@@ -1447,6 +1403,30 @@ static void nv_adma_error_handler(struct ata_port *ap)
                int i;
                u16 tmp;
 
+               if(ata_tag_valid(ap->active_tag) || ap->sactive) {
+                       u32 notifier = readl(mmio + NV_ADMA_NOTIFIER);
+                       u32 notifier_error = readl(mmio + NV_ADMA_NOTIFIER_ERROR);
+                       u32 gen_ctl = readl(pp->gen_block + NV_ADMA_GEN_CTL);
+                       u32 status = readw(mmio + NV_ADMA_STAT);
+                       u8 cpb_count = readb(mmio + NV_ADMA_CPB_COUNT);
+                       u8 next_cpb_idx = readb(mmio + NV_ADMA_NEXT_CPB_IDX);
+
+                       ata_port_printk(ap, KERN_ERR, "EH in ADMA mode, notifier 0x%X "
+                               "notifier_error 0x%X gen_ctl 0x%X status 0x%X "
+                               "next cpb count 0x%X next cpb idx 0x%x\n",
+                               notifier, notifier_error, gen_ctl, status,
+                               cpb_count, next_cpb_idx);
+
+                       for( i=0;i<NV_ADMA_MAX_CPBS;i++) {
+                               struct nv_adma_cpb *cpb = &pp->cpb[i];
+                               if( (ata_tag_valid(ap->active_tag) && i == ap->active_tag) ||
+                                   ap->sactive & (1 << i) )
+                                       ata_port_printk(ap, KERN_ERR,
+                                               "CPB %d: ctl_flags 0x%x, resp_flags 0x%x\n",
+                                               i, cpb->ctl_flags, cpb->resp_flags);
+                       }
+               }
+
                /* Push us back into port register mode for error handling. */
                nv_adma_register_mode(ap);
 
@@ -1460,10 +1440,10 @@ static void nv_adma_error_handler(struct ata_port *ap)
                /* Reset channel */
                tmp = readw(mmio + NV_ADMA_CTL);
                writew(tmp | NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
-               readl( mmio + NV_ADMA_CTL );    /* flush posted write */
+               readw( mmio + NV_ADMA_CTL );    /* flush posted write */
                udelay(1);
                writew(tmp & ~NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
-               readl( mmio + NV_ADMA_CTL );    /* flush posted write */
+               readw( mmio + NV_ADMA_CTL );    /* flush posted write */
        }
 
        ata_bmdma_drive_eh(ap, ata_std_prereset, ata_std_softreset,
index cf9ed8c3930155bf87cd0d08c63c1ee84d977539..2339813ce9f646caf678172bbb85e045d157f2c7 100644 (file)
@@ -45,7 +45,7 @@
 #include "sata_promise.h"
 
 #define DRV_NAME       "sata_promise"
-#define DRV_VERSION    "1.05"
+#define DRV_VERSION    "2.00"
 
 
 enum {
@@ -218,6 +218,7 @@ static const struct ata_port_operations pdc_pata_ops = {
        .freeze                 = pdc_freeze,
        .thaw                   = pdc_thaw,
        .error_handler          = pdc_error_handler,
+       .post_internal_cmd      = pdc_post_internal_cmd,
        .data_xfer              = ata_data_xfer,
        .irq_handler            = pdc_interrupt,
        .irq_clear              = pdc_irq_clear,
@@ -776,7 +777,8 @@ static int pdc_old_check_atapi_dma(struct ata_queued_cmd *qc)
        return pdc_check_atapi_dma(qc);
 }
 
-static void pdc_ata_setup_port(struct ata_ioports *port, void __iomem *base)
+static void pdc_ata_setup_port(struct ata_ioports *port, void __iomem *base,
+                              void __iomem *scr_addr)
 {
        port->cmd_addr          = base;
        port->data_addr         = base;
@@ -791,6 +793,7 @@ static void pdc_ata_setup_port(struct ata_ioports *port, void __iomem *base)
        port->status_addr       = base + 0x1c;
        port->altstatus_addr    =
        port->ctl_addr          = base + 0x38;
+       port->scr_addr          = scr_addr;
 }
 
 
@@ -903,11 +906,8 @@ static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
 
        base = probe_ent->iomap[PDC_MMIO_BAR];
 
-       pdc_ata_setup_port(&probe_ent->port[0], base + 0x200);
-       pdc_ata_setup_port(&probe_ent->port[1], base + 0x280);
-
-       probe_ent->port[0].scr_addr = base + 0x400;
-       probe_ent->port[1].scr_addr = base + 0x500;
+       pdc_ata_setup_port(&probe_ent->port[0], base + 0x200, base + 0x400);
+       pdc_ata_setup_port(&probe_ent->port[1], base + 0x280, base + 0x500);
 
        /* notice 4-port boards */
        switch (board_idx) {
@@ -916,12 +916,8 @@ static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
                /* Fall through */
        case board_20319:
                        probe_ent->n_ports = 4;
-
-               pdc_ata_setup_port(&probe_ent->port[2], base + 0x300);
-               pdc_ata_setup_port(&probe_ent->port[3], base + 0x380);
-
-               probe_ent->port[2].scr_addr = base + 0x600;
-               probe_ent->port[3].scr_addr = base + 0x700;
+               pdc_ata_setup_port(&probe_ent->port[2], base + 0x300, base + 0x600);
+               pdc_ata_setup_port(&probe_ent->port[3], base + 0x380, base + 0x700);
                break;
        case board_2057x:
                hp->flags |= PDC_FLAG_GEN_II;
@@ -931,7 +927,7 @@ static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
                tmp = readb(base + PDC_FLASH_CTL+1);
                if (!(tmp & 0x80)) {
                        probe_ent->n_ports = 3;
-                       pdc_ata_setup_port(&probe_ent->port[2], base + 0x300);
+                       pdc_ata_setup_port(&probe_ent->port[2], base + 0x300, NULL);
                        hp->port_flags[2] = ATA_FLAG_SLAVE_POSS;
                        printk(KERN_INFO DRV_NAME " PATA port found\n");
                } else
@@ -941,12 +937,8 @@ static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
                break;
        case board_20619:
                probe_ent->n_ports = 4;
-
-               pdc_ata_setup_port(&probe_ent->port[2], base + 0x300);
-               pdc_ata_setup_port(&probe_ent->port[3], base + 0x380);
-
-               probe_ent->port[2].scr_addr = base + 0x600;
-               probe_ent->port[3].scr_addr = base + 0x700;
+               pdc_ata_setup_port(&probe_ent->port[2], base + 0x300, NULL);
+               pdc_ata_setup_port(&probe_ent->port[3], base + 0x380, NULL);
                break;
        default:
                BUG();
index 6097d8f2a0c0aea71891bbff9c9c7b5b1fa11e47..8786b45f291b8d62af9ddb6fd3bc585d7c659201 100644 (file)
@@ -39,7 +39,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME       "sata_qstor"
-#define DRV_VERSION    "0.06"
+#define DRV_VERSION    "0.07"
 
 enum {
        QS_MMIO_BAR             = 4,
@@ -446,7 +446,7 @@ static inline unsigned int qs_intr_mmio(struct ata_host *host)
                                if ((status & ATA_BUSY))
                                        continue;
                                DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
-                                       ap->id, qc->tf.protocol, status);
+                                       ap->print_id, qc->tf.protocol, status);
 
                                /* complete taskfile transaction */
                                pp->state = qs_state_idle;
index dca3d3749f0626cbc2d79798ecda01502b1452e3..f7179c646bef6aaa8b1bb75f10dc8d9027a4a7bd 100644 (file)
@@ -46,7 +46,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME       "sata_sil"
-#define DRV_VERSION    "2.0"
+#define DRV_VERSION    "2.1"
 
 enum {
        SIL_MMIO_BAR            = 5,
@@ -339,7 +339,7 @@ static inline void __iomem *sil_scr_addr(struct ata_port *ap, unsigned int sc_re
                break;
        }
 
-       return 0;
+       return NULL;
 }
 
 static u32 sil_scr_read (struct ata_port *ap, unsigned int sc_reg)
@@ -386,9 +386,15 @@ static void sil_host_intr(struct ata_port *ap, u32 bmdma2)
                goto freeze;
        }
 
-       if (unlikely(!qc || qc->tf.ctl & ATA_NIEN))
+       if (unlikely(!qc))
                goto freeze;
 
+       if (unlikely(qc->tf.flags & ATA_TFLAG_POLLING)) {
+               /* this sometimes happens, just clear IRQ */
+               ata_chk_status(ap);
+               return;
+       }
+
        /* Check whether we are expecting interrupt in this state */
        switch (ap->hsm_task_state) {
        case HSM_ST_FIRST:
index e65e8d55da3e9b36dea407bc6993b724a8ebf1db..5d083f43f90d19624b6260624c44bd1bb7e2767e 100644 (file)
@@ -30,7 +30,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME       "sata_sil24"
-#define DRV_VERSION    "0.3"
+#define DRV_VERSION    "0.8"
 
 /*
  * Port request block (PRB) 32 bytes
index 49c9e2bd706f9ad1f9367f78d481c1fb8139f668..1879e0cd56aab7cac280d54d674c6acd8a03e07b 100644 (file)
@@ -40,9 +40,8 @@
 #include <linux/device.h>
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
-#include "libata.h"
+#include "sis.h"
 
-#undef DRV_NAME                /* already defined in libata.h, for libata-core */
 #define DRV_NAME       "sata_sis"
 #define DRV_VERSION    "0.7"
 
@@ -310,7 +309,7 @@ static int sis_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                case 0x10:
                        ppi[1] = &sis_info133;
                        break;
-                       
+
                case 0x30:
                        ppi[0] = &sis_info133;
                        break;
index 4e4289994204ea0409c982ae66cc15a9862051fd..b121195cc598c6a9f4dccd6bbe21580e187ad7c9 100644 (file)
@@ -53,7 +53,7 @@
 #endif /* CONFIG_PPC_OF */
 
 #define DRV_NAME       "sata_svw"
-#define DRV_VERSION    "2.0"
+#define DRV_VERSION    "2.1"
 
 enum {
        K2_FLAG_NO_ATAPI_DMA            = (1 << 29),
index 0ebd77b080d68396b4bc37987b45037004374a8e..1a081c3a8c06a24b3cd4ba51e6d643435ed2ca21 100644 (file)
@@ -44,7 +44,7 @@
 #include "sata_promise.h"
 
 #define DRV_NAME       "sata_sx4"
-#define DRV_VERSION    "0.9"
+#define DRV_VERSION    "0.10"
 
 
 enum {
@@ -421,7 +421,7 @@ static void pdc20621_dma_prep(struct ata_queued_cmd *qc)
 
        WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP));
 
-       VPRINTK("ata%u: ENTER\n", ap->id);
+       VPRINTK("ata%u: ENTER\n", ap->print_id);
 
        /* hard-code chip #0 */
        mmio += PDC_CHIP0_OFS;
@@ -478,7 +478,7 @@ static void pdc20621_nodata_prep(struct ata_queued_cmd *qc)
        unsigned int portno = ap->port_no;
        unsigned int i;
 
-       VPRINTK("ata%u: ENTER\n", ap->id);
+       VPRINTK("ata%u: ENTER\n", ap->print_id);
 
        /* hard-code chip #0 */
        mmio += PDC_CHIP0_OFS;
@@ -605,7 +605,7 @@ static void pdc20621_packet_start(struct ata_queued_cmd *qc)
        /* hard-code chip #0 */
        mmio += PDC_CHIP0_OFS;
 
-       VPRINTK("ata%u: ENTER\n", ap->id);
+       VPRINTK("ata%u: ENTER\n", ap->print_id);
 
        wmb();                  /* flush PRD, pkt writes */
 
@@ -672,7 +672,7 @@ static inline unsigned int pdc20621_host_intr( struct ata_port *ap,
 
                /* step two - DMA from DIMM to host */
                if (doing_hdma) {
-                       VPRINTK("ata%u: read hdma, 0x%x 0x%x\n", ap->id,
+                       VPRINTK("ata%u: read hdma, 0x%x 0x%x\n", ap->print_id,
                                readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT));
                        /* get drive status; clear intr; complete txn */
                        qc->err_mask |= ac_err_mask(ata_wait_idle(ap));
@@ -683,7 +683,7 @@ static inline unsigned int pdc20621_host_intr( struct ata_port *ap,
                /* step one - exec ATA command */
                else {
                        u8 seq = (u8) (port_no + 1 + 4);
-                       VPRINTK("ata%u: read ata, 0x%x 0x%x\n", ap->id,
+                       VPRINTK("ata%u: read ata, 0x%x 0x%x\n", ap->print_id,
                                readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT));
 
                        /* submit hdma pkt */
@@ -698,7 +698,7 @@ static inline unsigned int pdc20621_host_intr( struct ata_port *ap,
                /* step one - DMA from host to DIMM */
                if (doing_hdma) {
                        u8 seq = (u8) (port_no + 1);
-                       VPRINTK("ata%u: write hdma, 0x%x 0x%x\n", ap->id,
+                       VPRINTK("ata%u: write hdma, 0x%x 0x%x\n", ap->print_id,
                                readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT));
 
                        /* submit ata pkt */
@@ -711,7 +711,7 @@ static inline unsigned int pdc20621_host_intr( struct ata_port *ap,
 
                /* step two - execute ATA command */
                else {
-                       VPRINTK("ata%u: write ata, 0x%x 0x%x\n", ap->id,
+                       VPRINTK("ata%u: write ata, 0x%x 0x%x\n", ap->print_id,
                                readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT));
                        /* get drive status; clear intr; complete txn */
                        qc->err_mask |= ac_err_mask(ata_wait_idle(ap));
index 80131eec68f4cfe95aa028c2533b9cc883f92d87..d659ace80f4f6c985f6da071a61b9d42ff93b8a5 100644 (file)
@@ -36,7 +36,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME       "sata_uli"
-#define DRV_VERSION    "1.0"
+#define DRV_VERSION    "1.1"
 
 enum {
        uli_5289                = 0,
index baca6d79bb0bc426eda80fe358555a35c246981e..598e6a26a481a7934d8ae14121e395844c1f22dd 100644 (file)
@@ -46,7 +46,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME       "sata_via"
-#define DRV_VERSION    "2.0"
+#define DRV_VERSION    "2.1"
 
 enum board_ids_enum {
        vt6420,
@@ -60,7 +60,7 @@ enum {
        SATA_PATA_SHARING       = 0x49, /* PATA/SATA sharing func ctrl */
        PATA_UDMA_TIMING        = 0xB3, /* PATA timing for DMA/ cable detect */
        PATA_PIO_TIMING         = 0xAB, /* PATA timing register */
-       
+
        PORT0                   = (1 << 1),
        PORT1                   = (1 << 0),
        ALL_PORTS               = PORT0 | PORT1,
@@ -151,7 +151,7 @@ static const struct ata_port_operations vt6420_sata_ops = {
 
 static const struct ata_port_operations vt6421_pata_ops = {
        .port_disable           = ata_port_disable,
-       
+
        .set_piomode            = vt6421_set_pio_mode,
        .set_dmamode            = vt6421_set_dma_mode,
 
@@ -185,7 +185,7 @@ static const struct ata_port_operations vt6421_pata_ops = {
 
 static const struct ata_port_operations vt6421_sata_ops = {
        .port_disable           = ata_port_disable,
-       
+
        .tf_load                = ata_tf_load,
        .tf_read                = ata_tf_read,
        .check_status           = ata_check_status,
@@ -423,16 +423,21 @@ static struct ata_probe_ent *vt6420_init_probe_ent(struct pci_dev *pdev)
 {
        struct ata_probe_ent *probe_ent;
        struct ata_port_info *ppi[2];
-       void __iomem * const *iomap;
+       void __iomem *bar5;
 
        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)
                return NULL;
 
-       iomap = pcim_iomap_table(pdev);
-       probe_ent->port[0].scr_addr = svia_scr_addr(iomap[5], 0);
-       probe_ent->port[1].scr_addr = svia_scr_addr(iomap[5], 1);
+       bar5 = pcim_iomap(pdev, 5, 0);
+       if (!bar5) {
+               dev_printk(KERN_ERR, &pdev->dev, "failed to iomap PCI BAR 5\n");
+               return NULL;
+       }
+
+       probe_ent->port[0].scr_addr = svia_scr_addr(bar5, 0);
+       probe_ent->port[1].scr_addr = svia_scr_addr(bar5, 1);
 
        return probe_ent;
 }
@@ -460,6 +465,13 @@ static struct ata_probe_ent *vt6421_init_probe_ent(struct pci_dev *pdev)
        probe_ent->mwdma_mask   = 0x07;
        probe_ent->udma_mask    = 0x7f;
 
+       for (i = 0; i < 6; i++)
+               if (!pcim_iomap(pdev, i, 0)) {
+                       dev_printk(KERN_ERR, &pdev->dev,
+                                  "failed to iomap PCI BAR %d\n", i);
+                       return NULL;
+               }
+
        for (i = 0; i < N_PORTS; i++)
                vt6421_init_addrs(probe_ent, pcim_iomap_table(pdev), i);
 
@@ -522,7 +534,7 @@ static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
        if (rc)
                return rc;
 
-       rc = pcim_iomap_regions(pdev, 0x1f, DRV_NAME);
+       rc = pci_request_regions(pdev, DRV_NAME);
        if (rc) {
                pcim_pin_device(pdev);
                return rc;
index 2fd037bde090d92641a954d82d2017ce3aa375ca..170bad1b415b01765276b7578f6675804e7afb6d 100644 (file)
@@ -47,7 +47,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME       "sata_vsc"
-#define DRV_VERSION    "2.0"
+#define DRV_VERSION    "2.1"
 
 enum {
        VSC_MMIO_BAR                    = 0,
@@ -98,10 +98,6 @@ enum {
                              VSC_SATA_INT_PHY_CHANGE),
 };
 
-#define is_vsc_sata_int_err(port_idx, int_status) \
-        (int_status & (VSC_SATA_INT_ERROR << (8 * port_idx)))
-
-
 static u32 vsc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)
 {
        if (sc_reg > SCR_CONTROL)
@@ -119,6 +115,28 @@ static void vsc_sata_scr_write (struct ata_port *ap, unsigned int sc_reg,
 }
 
 
+static void vsc_freeze(struct ata_port *ap)
+{
+       void __iomem *mask_addr;
+
+       mask_addr = ap->host->iomap[VSC_MMIO_BAR] +
+               VSC_SATA_INT_MASK_OFFSET + ap->port_no;
+
+       writeb(0, mask_addr);
+}
+
+
+static void vsc_thaw(struct ata_port *ap)
+{
+       void __iomem *mask_addr;
+
+       mask_addr = ap->host->iomap[VSC_MMIO_BAR] +
+               VSC_SATA_INT_MASK_OFFSET + ap->port_no;
+
+       writeb(0xff, mask_addr);
+}
+
+
 static void vsc_intr_mask_update(struct ata_port *ap, u8 ctl)
 {
        void __iomem *mask_addr;
@@ -203,6 +221,36 @@ static void vsc_sata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
         }
 }
 
+static inline void vsc_error_intr(u8 port_status, struct ata_port *ap)
+{
+       if (port_status & (VSC_SATA_INT_PHY_CHANGE | VSC_SATA_INT_ERROR_M))
+               ata_port_freeze(ap);
+       else
+               ata_port_abort(ap);
+}
+
+static void vsc_port_intr(u8 port_status, struct ata_port *ap)
+{
+       struct ata_queued_cmd *qc;
+       int handled = 0;
+
+       if (unlikely(port_status & VSC_SATA_INT_ERROR)) {
+               vsc_error_intr(port_status, ap);
+               return;
+       }
+
+       qc = ata_qc_from_tag(ap, ap->active_tag);
+       if (qc && likely(!(qc->tf.flags & ATA_TFLAG_POLLING)))
+               handled = ata_host_intr(ap, qc);
+
+       /* We received an interrupt during a polled command,
+        * or some other spurious condition.  Interrupt reporting
+        * with this hardware is fairly reliable so it is safe to
+        * simply clear the interrupt
+        */
+       if (unlikely(!handled))
+               ata_chk_status(ap);
+}
 
 /*
  * vsc_sata_interrupt
@@ -214,59 +262,36 @@ static irqreturn_t vsc_sata_interrupt (int irq, void *dev_instance)
        struct ata_host *host = dev_instance;
        unsigned int i;
        unsigned int handled = 0;
-       u32 int_status;
-
-       spin_lock(&host->lock);
+       u32 status;
 
-       int_status = readl(host->iomap[VSC_MMIO_BAR] +
-                          VSC_SATA_INT_STAT_OFFSET);
+       status = readl(host->iomap[VSC_MMIO_BAR] + VSC_SATA_INT_STAT_OFFSET);
 
-       for (i = 0; i < host->n_ports; i++) {
-               if (int_status & ((u32) 0xFF << (8 * i))) {
-                       struct ata_port *ap;
+       if (unlikely(status == 0xffffffff || status == 0)) {
+               if (status)
+                       dev_printk(KERN_ERR, host->dev,
+                               ": IRQ status == 0xffffffff, "
+                               "PCI fault or device removal?\n");
+               goto out;
+       }
 
-                       ap = host->ports[i];
+       spin_lock(&host->lock);
 
-                       if (is_vsc_sata_int_err(i, int_status)) {
-                               u32 err_status;
-                               printk(KERN_DEBUG "%s: ignoring interrupt(s)\n", __FUNCTION__);
-                               err_status = ap ? vsc_sata_scr_read(ap, SCR_ERROR) : 0;
-                               vsc_sata_scr_write(ap, SCR_ERROR, err_status);
-                               handled++;
-                       }
+       for (i = 0; i < host->n_ports; i++) {
+               u8 port_status = (status >> (8 * i)) & 0xff;
+               if (port_status) {
+                       struct ata_port *ap = host->ports[i];
 
                        if (ap && !(ap->flags & ATA_FLAG_DISABLED)) {
-                               struct ata_queued_cmd *qc;
-
-                               qc = ata_qc_from_tag(ap, ap->active_tag);
-                               if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
-                                       handled += ata_host_intr(ap, qc);
-                               else if (is_vsc_sata_int_err(i, int_status)) {
-                                       /*
-                                        * On some chips (i.e. Intel 31244), an error
-                                        * interrupt will sneak in at initialization
-                                        * time (phy state changes).  Clearing the SCR
-                                        * error register is not required, but it prevents
-                                        * the phy state change interrupts from recurring
-                                        * later.
-                                        */
-                                       u32 err_status;
-                                       err_status = vsc_sata_scr_read(ap, SCR_ERROR);
-                                       printk(KERN_DEBUG "%s: clearing interrupt, "
-                                              "status %x; sata err status %x\n",
-                                              __FUNCTION__,
-                                              int_status, err_status);
-                                       vsc_sata_scr_write(ap, SCR_ERROR, err_status);
-                                       /* Clear interrupt status */
-                                       ata_chk_status(ap);
-                                       handled++;
-                               }
-                       }
+                               vsc_port_intr(port_status, ap);
+                               handled++;
+                       } else
+                               dev_printk(KERN_ERR, host->dev,
+                                       ": interrupt from disabled port %d\n", i);
                }
        }
 
        spin_unlock(&host->lock);
-
+out:
        return IRQ_RETVAL(handled);
 }
 
@@ -304,8 +329,8 @@ static const struct ata_port_operations vsc_sata_ops = {
        .qc_prep                = ata_qc_prep,
        .qc_issue               = ata_qc_issue_prot,
        .data_xfer              = ata_data_xfer,
-       .freeze                 = ata_bmdma_freeze,
-       .thaw                   = ata_bmdma_thaw,
+       .freeze                 = vsc_freeze,
+       .thaw                   = vsc_thaw,
        .error_handler          = ata_bmdma_error_handler,
        .post_internal_cmd      = ata_bmdma_post_internal_cmd,
        .irq_handler            = vsc_sata_interrupt,
diff --git a/drivers/ata/sis.h b/drivers/ata/sis.h
new file mode 100644 (file)
index 0000000..231da8f
--- /dev/null
@@ -0,0 +1,5 @@
+
+struct ata_port_info;
+
+/* pata_sis.c */
+extern struct ata_port_info sis_info133;
index 272736e37990b7d96b71d7f4b0972ee2d7033d77..c331da2da5f7af3c90b783efac81e2184a27b7c7 100644 (file)
@@ -282,7 +282,6 @@ struct ata_taskfile {
 };
 
 #define ata_id_is_ata(id)      (((id)[0] & (1 << 15)) == 0)
-#define ata_id_is_sata(id)     ((id)[93] == 0)
 #define ata_id_rahead_enabled(id) ((id)[85] & (1 << 6))
 #define ata_id_wcache_enabled(id) ((id)[85] & (1 << 5))
 #define ata_id_hpa_enabled(id) ((id)[85] & (1 << 10))
@@ -324,6 +323,11 @@ static inline unsigned int ata_id_major_version(const u16 *id)
        return mver;
 }
 
+static inline int ata_id_is_sata(const u16 *id)
+{
+       return ata_id_major_version(id) >= 5 && id[93] == 0;
+}
+
 static inline int ata_id_current_chs_valid(const u16 *id)
 {
        /* For ATA-1 devices, if the INITIALIZE DEVICE PARAMETERS command
@@ -350,7 +354,7 @@ static inline int ata_id_is_cfa(const u16 *id)
 
 static inline int ata_drive_40wire(const u16 *dev_id)
 {
-       if (ata_id_major_version(dev_id) >= 5 && ata_id_is_sata(dev_id))
+       if (ata_id_is_sata(dev_id))
                return 0;       /* SATA */
        if ((dev_id[93] & 0xE000) == 0x6000)
                return 0;       /* 80 wire */
index 86762a9f52ba19bb4622662264750d8c6b943646..045fb3a72d59f532123ccd5ecf1e1492a1ea67bf 100644 (file)
@@ -495,6 +495,7 @@ struct ata_device {
 
        /* error history */
        struct ata_ering        ering;
+       int                     spdn_cnt;
        unsigned int            horkage;        /* List of broken features */
 #ifdef CONFIG_SATA_ACPI
        /* ACPI objects info */
@@ -535,8 +536,8 @@ struct ata_port {
        spinlock_t              *lock;
        unsigned long           flags;  /* ATA_FLAG_xxx */
        unsigned int            pflags; /* ATA_PFLAG_xxx */
-       unsigned int            id;     /* unique id req'd by scsi midlyr */
-       unsigned int            port_no; /* unique port #; from zero */
+       unsigned int            print_id; /* user visible unique port ID */
+       unsigned int            port_no; /* 0 based port no. inside the host */
 
        struct ata_prd          *prd;    /* our SG list */
        dma_addr_t              prd_dma; /* and its DMA mapping */
@@ -759,6 +760,7 @@ extern void ata_port_queue_task(struct ata_port *ap, work_func_t fn,
 extern u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
                             unsigned long interval_msec,
                             unsigned long timeout_msec);
+extern unsigned int ata_dev_try_classify(struct ata_port *, unsigned int, u8 *);
 
 /*
  * Default driver ops implementations
@@ -786,10 +788,12 @@ extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf,
 extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
                 unsigned int n_elem);
 extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
+extern void ata_dev_disable(struct ata_device *adev);
 extern void ata_id_string(const u16 *id, unsigned char *s,
                          unsigned int ofs, unsigned int len);
 extern void ata_id_c_string(const u16 *id, unsigned char *s,
                            unsigned int ofs, unsigned int len);
+extern void ata_id_to_dma_mode(struct ata_device *dev, u8 unknown);
 extern unsigned long ata_device_blacklisted(const struct ata_device *dev);
 extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
 extern void ata_bmdma_start (struct ata_queued_cmd *qc);
@@ -890,10 +894,10 @@ extern void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
  * printk helpers
  */
 #define ata_port_printk(ap, lv, fmt, args...) \
-       printk(lv"ata%u: "fmt, (ap)->id , ##args)
+       printk(lv"ata%u: "fmt, (ap)->print_id , ##args)
 
 #define ata_dev_printk(dev, lv, fmt, args...) \
-       printk(lv"ata%u.%02u: "fmt, (dev)->ap->id, (dev)->devno , ##args)
+       printk(lv"ata%u.%02u: "fmt, (dev)->ap->print_id, (dev)->devno , ##args)
 
 /*
  * ata_eh_info helpers
@@ -1031,6 +1035,21 @@ static inline u8 ata_chk_status(struct ata_port *ap)
        return ap->ops->check_status(ap);
 }
 
+/**
+ *     ata_ncq_enabled - Test whether NCQ is enabled
+ *     @dev: ATA device to test for
+ *
+ *     LOCKING:
+ *     spin_lock_irqsave(host lock)
+ *
+ *     RETURNS:
+ *     1 if NCQ is enabled for @dev, 0 otherwise.
+ */
+static inline int ata_ncq_enabled(struct ata_device *dev)
+{
+       return (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ_OFF |
+                             ATA_DFLAG_NCQ)) == ATA_DFLAG_NCQ;
+}
 
 /**
  *     ata_pause - Flush writes and pause 400 nanoseconds.