libata-link: linkify reset

Make reset methods and related functions deal with ata_link instead of
ata_port.

* ata_do_reset()
* ata_eh_reset()
* all prereset/reset/postreset methods and related functions

This patch introduces no behavior change.

Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>

diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 6e5f69a3a0c25d23ed7ed3eefde51096ee016080..e38ae12d014809bc07001648357c3ad9724a602d 100644 (file)
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -1042,9 +1042,10 @@ static int ahci_exec_polled_cmd(struct ata_port *ap, int pmp,
        return 0;
 }
 
-static int ahci_do_softreset(struct ata_port *ap, unsigned int *class,
+static int ahci_do_softreset(struct ata_link *link, unsigned int *class,
                             int pmp, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        const char *reason = NULL;
        unsigned long now, msecs;
        struct ata_taskfile tf;
@@ -1052,7 +1053,7 @@ static int ahci_do_softreset(struct ata_port *ap, unsigned int *class,
 
        DPRINTK("ENTER\n");
 
-       if (ata_link_offline(&ap->link)) {
+       if (ata_link_offline(link)) {
                DPRINTK("PHY reports no device\n");
                *class = ATA_DEV_NONE;
                return 0;
@@ -1061,10 +1062,10 @@ static int ahci_do_softreset(struct ata_port *ap, unsigned int *class,
        /* prepare for SRST (AHCI-1.1 10.4.1) */
        rc = ahci_kick_engine(ap, 1);
        if (rc)
-               ata_port_printk(ap, KERN_WARNING,
+               ata_link_printk(link, KERN_WARNING,
                                "failed to reset engine (errno=%d)", rc);
 
-       ata_tf_init(ap->link.device, &tf);
+       ata_tf_init(link->device, &tf);
 
        /* issue the first D2H Register FIS */
        msecs = 0;
@@ -1109,19 +1110,20 @@ static int ahci_do_softreset(struct ata_port *ap, unsigned int *class,
        return 0;
 
  fail:
-       ata_port_printk(ap, KERN_ERR, "softreset failed (%s)\n", reason);
+       ata_link_printk(link, KERN_ERR, "softreset failed (%s)\n", reason);
        return rc;
 }
 
-static int ahci_softreset(struct ata_port *ap, unsigned int *class,
+static int ahci_softreset(struct ata_link *link, unsigned int *class,
                          unsigned long deadline)
 {
-       return ahci_do_softreset(ap, class, 0, deadline);
+       return ahci_do_softreset(link, class, 0, deadline);
 }
 
-static int ahci_hardreset(struct ata_port *ap, unsigned int *class,
+static int ahci_hardreset(struct ata_link *link, unsigned int *class,
                          unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        struct ahci_port_priv *pp = ap->private_data;
        u8 *d2h_fis = pp->rx_fis + RX_FIS_D2H_REG;
        struct ata_taskfile tf;
@@ -1132,15 +1134,15 @@ static int ahci_hardreset(struct ata_port *ap, unsigned int *class,
        ahci_stop_engine(ap);
 
        /* clear D2H reception area to properly wait for D2H FIS */
-       ata_tf_init(ap->link.device, &tf);
+       ata_tf_init(link->device, &tf);
        tf.command = 0x80;
        ata_tf_to_fis(&tf, 0, 0, d2h_fis);
 
-       rc = sata_std_hardreset(ap, class, deadline);
+       rc = sata_std_hardreset(link, class, deadline);
 
        ahci_start_engine(ap);
 
-       if (rc == 0 && ata_link_online(&ap->link))
+       if (rc == 0 && ata_link_online(link))
                *class = ahci_dev_classify(ap);
        if (*class == ATA_DEV_UNKNOWN)
                *class = ATA_DEV_NONE;
@@ -1149,9 +1151,10 @@ static int ahci_hardreset(struct ata_port *ap, unsigned int *class,
        return rc;
 }
 
-static int ahci_vt8251_hardreset(struct ata_port *ap, unsigned int *class,
+static int ahci_vt8251_hardreset(struct ata_link *link, unsigned int *class,
                                 unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        u32 serror;
        int rc;
 
@@ -1159,7 +1162,7 @@ static int ahci_vt8251_hardreset(struct ata_port *ap, unsigned int *class,
 
        ahci_stop_engine(ap);
 
-       rc = sata_port_hardreset(ap, sata_ehc_deb_timing(&ap->link.eh_context),
+       rc = sata_link_hardreset(link, sata_ehc_deb_timing(&link->eh_context),
                                 deadline);
 
        /* vt8251 needs SError cleared for the port to operate */
@@ -1176,12 +1179,13 @@ static int ahci_vt8251_hardreset(struct ata_port *ap, unsigned int *class,
        return rc ?: -EAGAIN;
 }
 
-static void ahci_postreset(struct ata_port *ap, unsigned int *class)
+static void ahci_postreset(struct ata_link *link, unsigned int *class)
 {
+       struct ata_port *ap = link->ap;
        void __iomem *port_mmio = ahci_port_base(ap);
        u32 new_tmp, tmp;
 
-       ata_std_postreset(ap, class);
+       ata_std_postreset(link, class);
 
        /* Make sure port's ATAPI bit is set appropriately */
        new_tmp = tmp = readl(port_mmio + PORT_CMD);

diff --git a/drivers/ata/ata_piix.c b/drivers/ata/ata_piix.c
index 92c2d5082bef45e97030b22c0e8d1b1a2f926b05..03fe493026ebbfd375b9be1820929eef446e06b4 100644 (file)
--- a/drivers/ata/ata_piix.c
+++ b/drivers/ata/ata_piix.c
@@ -657,19 +657,20 @@ static int ich_pata_cable_detect(struct ata_port *ap)
 
 /**
  *     piix_pata_prereset - prereset for PATA host controller
- *     @ap: Target port
+ *     @link: Target link
  *     @deadline: deadline jiffies for the operation
  *
  *     LOCKING:
  *     None (inherited from caller).
  */
-static int piix_pata_prereset(struct ata_port *ap, unsigned long deadline)
+static int piix_pata_prereset(struct ata_link *link, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
        if (!pci_test_config_bits(pdev, &piix_enable_bits[ap->port_no]))
                return -ENOENT;
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 static void piix_pata_error_handler(struct ata_port *ap)

diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 6f99dee6b6d26edfb08eda455408b5964151211a..73f66f4e1eeb85cccedda0c08cd084da1534f7ec 100644 (file)
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -3306,10 +3306,10 @@ int sata_link_resume(struct ata_link *link, const unsigned long *params,
 
 /**
  *     ata_std_prereset - prepare for reset
- *     @ap: ATA port to be reset
+ *     @link: ATA link to be reset
  *     @deadline: deadline jiffies for the operation
  *
- *     @ap is about to be reset.  Initialize it.  Failure from
+ *     @link is about to be reset.  Initialize it.  Failure from
  *     prereset makes libata abort whole reset sequence and give up
  *     that port, so prereset should be best-effort.  It does its
  *     best to prepare for reset sequence but if things go wrong, it
@@ -3321,9 +3321,9 @@ int sata_link_resume(struct ata_link *link, const unsigned long *params,
  *     RETURNS:
  *     0 on success, -errno otherwise.
  */
-int ata_std_prereset(struct ata_port *ap, unsigned long deadline)
+int ata_std_prereset(struct ata_link *link, unsigned long deadline)
 {
-       struct ata_link *link = &ap->link;
+       struct ata_port *ap = link->ap;
        struct ata_eh_context *ehc = &link->eh_context;
        const unsigned long *timing = sata_ehc_deb_timing(ehc);
        int rc;
@@ -3342,7 +3342,7 @@ int ata_std_prereset(struct ata_port *ap, unsigned long deadline)
                rc = sata_link_resume(link, timing, deadline);
                /* whine about phy resume failure but proceed */
                if (rc && rc != -EOPNOTSUPP)
-                       ata_port_printk(ap, KERN_WARNING, "failed to resume "
+                       ata_link_printk(link, KERN_WARNING, "failed to resume "
                                        "link for reset (errno=%d)\n", rc);
        }
 
@@ -3352,7 +3352,7 @@ int ata_std_prereset(struct ata_port *ap, unsigned long deadline)
        if (!(ap->flags & ATA_FLAG_SKIP_D2H_BSY) && !ata_link_offline(link)) {
                rc = ata_wait_ready(ap, deadline);
                if (rc && rc != -ENODEV) {
-                       ata_port_printk(ap, KERN_WARNING, "device not ready "
+                       ata_link_printk(link, KERN_WARNING, "device not ready "
                                        "(errno=%d), forcing hardreset\n", rc);
                        ehc->i.action |= ATA_EH_HARDRESET;
                }
@@ -3363,7 +3363,7 @@ int ata_std_prereset(struct ata_port *ap, unsigned long deadline)
 
 /**
  *     ata_std_softreset - reset host port via ATA SRST
- *     @ap: port to reset
+ *     @link: ATA link to reset
  *     @classes: resulting classes of attached devices
  *     @deadline: deadline jiffies for the operation
  *
@@ -3375,10 +3375,10 @@ int ata_std_prereset(struct ata_port *ap, unsigned long deadline)
  *     RETURNS:
  *     0 on success, -errno otherwise.
  */
-int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
+int ata_std_softreset(struct ata_link *link, unsigned int *classes,
                      unsigned long deadline)
 {
-       struct ata_link *link = &ap->link;
+       struct ata_port *ap = link->ap;
        unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
        unsigned int devmask = 0;
        int rc;
@@ -3405,7 +3405,7 @@ int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
        rc = ata_bus_softreset(ap, devmask, deadline);
        /* if link is occupied, -ENODEV too is an error */
        if (rc && (rc != -ENODEV || sata_scr_valid(link))) {
-               ata_port_printk(ap, KERN_ERR, "SRST failed (errno=%d)\n", rc);
+               ata_link_printk(link, KERN_ERR, "SRST failed (errno=%d)\n", rc);
                return rc;
        }
 
@@ -3420,12 +3420,12 @@ int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
 }
 
 /**
- *     sata_port_hardreset - reset port via SATA phy reset
- *     @ap: port to reset
+ *     sata_link_hardreset - reset link via SATA phy reset
+ *     @link: link to reset
  *     @timing: timing parameters { interval, duratinon, timeout } in msec
  *     @deadline: deadline jiffies for the operation
  *
- *     SATA phy-reset host port using DET bits of SControl register.
+ *     SATA phy-reset @link using DET bits of SControl register.
  *
  *     LOCKING:
  *     Kernel thread context (may sleep)
@@ -3433,10 +3433,9 @@ int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
  *     RETURNS:
  *     0 on success, -errno otherwise.
  */
-int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
+int sata_link_hardreset(struct ata_link *link, const unsigned long *timing,
                        unsigned long deadline)
 {
-       struct ata_link *link = &ap->link;
        u32 scontrol;
        int rc;
 
@@ -3482,7 +3481,7 @@ int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
 
 /**
  *     sata_std_hardreset - reset host port via SATA phy reset
- *     @ap: port to reset
+ *     @link: link to reset
  *     @class: resulting class of attached device
  *     @deadline: deadline jiffies for the operation
  *
@@ -3495,19 +3494,19 @@ int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
  *     RETURNS:
  *     0 on success, -errno otherwise.
  */
-int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
+int sata_std_hardreset(struct ata_link *link, unsigned int *class,
                       unsigned long deadline)
 {
-       struct ata_link *link = &ap->link;
+       struct ata_port *ap = link->ap;
        const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
        int rc;
 
        DPRINTK("ENTER\n");
 
        /* do hardreset */
-       rc = sata_port_hardreset(ap, timing, deadline);
+       rc = sata_link_hardreset(link, timing, deadline);
        if (rc) {
-               ata_port_printk(ap, KERN_ERR,
+               ata_link_printk(link, KERN_ERR,
                                "COMRESET failed (errno=%d)\n", rc);
                return rc;
        }
@@ -3525,7 +3524,7 @@ int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
        rc = ata_wait_ready(ap, deadline);
        /* link occupied, -ENODEV too is an error */
        if (rc) {
-               ata_port_printk(ap, KERN_ERR,
+               ata_link_printk(link, KERN_ERR,
                                "COMRESET failed (errno=%d)\n", rc);
                return rc;
        }
@@ -3540,7 +3539,7 @@ int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
 
 /**
  *     ata_std_postreset - standard postreset callback
- *     @ap: the target ata_port
+ *     @link: the target ata_link
  *     @classes: classes of attached devices
  *
  *     This function is invoked after a successful reset.  Note that
@@ -3550,9 +3549,9 @@ int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
  *     LOCKING:
  *     Kernel thread context (may sleep)
  */
-void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
+void ata_std_postreset(struct ata_link *link, unsigned int *classes)
 {
-       struct ata_link *link = &ap->link;
+       struct ata_port *ap = link->ap;
        u32 serror;
 
        DPRINTK("ENTER\n");
@@ -6946,7 +6945,7 @@ EXPORT_SYMBOL_GPL(__sata_phy_reset);
 EXPORT_SYMBOL_GPL(ata_bus_reset);
 EXPORT_SYMBOL_GPL(ata_std_prereset);
 EXPORT_SYMBOL_GPL(ata_std_softreset);
-EXPORT_SYMBOL_GPL(sata_port_hardreset);
+EXPORT_SYMBOL_GPL(sata_link_hardreset);
 EXPORT_SYMBOL_GPL(sata_std_hardreset);
 EXPORT_SYMBOL_GPL(ata_std_postreset);
 EXPORT_SYMBOL_GPL(ata_dev_classify);

diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index fc4b6413b192b950dbc174ba2d5499b012ee3442..0a9ce34a0e6433ec75a06d62fd9cc822e690f42c 100644 (file)
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -1737,16 +1737,16 @@ static void ata_eh_report(struct ata_port *ap)
        }
 }
 
-static int ata_do_reset(struct ata_port *ap, ata_reset_fn_t reset,
+static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset,
                        unsigned int *classes, unsigned long deadline)
 {
        struct ata_device *dev;
        int rc;
 
-       ata_link_for_each_dev(dev, &ap->link)
+       ata_link_for_each_dev(dev, link)
                classes[dev->devno] = ATA_DEV_UNKNOWN;
 
-       rc = reset(ap, classes, deadline);
+       rc = reset(link, classes, deadline);
        if (rc)
                return rc;
 
@@ -1754,12 +1754,12 @@ static int ata_do_reset(struct ata_port *ap, ata_reset_fn_t reset,
         * is complete and convert all ATA_DEV_UNKNOWN to
         * ATA_DEV_NONE.
         */
-       ata_link_for_each_dev(dev, &ap->link)
+       ata_link_for_each_dev(dev, link)
                if (classes[dev->devno] != ATA_DEV_UNKNOWN)
                        break;
 
        if (dev) {
-               ata_link_for_each_dev(dev, &ap->link) {
+               ata_link_for_each_dev(dev, link) {
                        if (classes[dev->devno] == ATA_DEV_UNKNOWN)
                                classes[dev->devno] = ATA_DEV_NONE;
                }
@@ -1780,11 +1780,10 @@ static int ata_eh_followup_srst_needed(int rc, int classify,
        return 0;
 }
 
-static int ata_eh_reset(struct ata_port *ap, int classify,
+static int ata_eh_reset(struct ata_link *link, int classify,
                        ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
                        ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
 {
-       struct ata_link *link = &ap->link;
        struct ata_eh_context *ehc = &link->eh_context;
        unsigned int *classes = ehc->classes;
        int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
@@ -1810,10 +1809,10 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
                ehc->i.action |= ATA_EH_HARDRESET;
 
        if (prereset) {
-               rc = prereset(ap, jiffies + ATA_EH_PRERESET_TIMEOUT);
+               rc = prereset(link, jiffies + ATA_EH_PRERESET_TIMEOUT);
                if (rc) {
                        if (rc == -ENOENT) {
-                               ata_port_printk(ap, KERN_DEBUG,
+                               ata_link_printk(link, KERN_DEBUG,
                                                "port disabled. ignoring.\n");
                                ehc->i.action &= ~ATA_EH_RESET_MASK;
 
@@ -1822,7 +1821,7 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
 
                                rc = 0;
                        } else
-                               ata_port_printk(ap, KERN_ERR,
+                               ata_link_printk(link, KERN_ERR,
                                        "prereset failed (errno=%d)\n", rc);
                        goto out;
                }
@@ -1854,7 +1853,7 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
 
        /* shut up during boot probing */
        if (verbose)
-               ata_port_printk(ap, KERN_INFO, "%s resetting port\n",
+               ata_link_printk(link, KERN_INFO, "%s resetting link\n",
                                reset == softreset ? "soft" : "hard");
 
        /* mark that this EH session started with reset */
@@ -1863,7 +1862,7 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
        else
                ehc->i.flags |= ATA_EHI_DID_SOFTRESET;
 
-       rc = ata_do_reset(ap, reset, classes, deadline);
+       rc = ata_do_reset(link, reset, classes, deadline);
 
        if (reset == hardreset &&
            ata_eh_followup_srst_needed(rc, classify, classes)) {
@@ -1871,7 +1870,7 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
                reset = softreset;
 
                if (!reset) {
-                       ata_port_printk(ap, KERN_ERR,
+                       ata_link_printk(link, KERN_ERR,
                                        "follow-up softreset required "
                                        "but no softreset avaliable\n");
                        rc = -EINVAL;
@@ -1879,11 +1878,11 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
                }
 
                ata_eh_about_to_do(link, NULL, ATA_EH_RESET_MASK);
-               rc = ata_do_reset(ap, reset, classes, deadline);
+               rc = ata_do_reset(link, reset, classes, deadline);
 
                if (rc == 0 && classify &&
                    classes[0] == ATA_DEV_UNKNOWN) {
-                       ata_port_printk(ap, KERN_ERR,
+                       ata_link_printk(link, KERN_ERR,
                                        "classification failed\n");
                        rc = -EINVAL;
                        goto out;
@@ -1896,7 +1895,7 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
                if (time_before(now, deadline)) {
                        unsigned long delta = deadline - jiffies;
 
-                       ata_port_printk(ap, KERN_WARNING, "reset failed "
+                       ata_link_printk(link, KERN_WARNING, "reset failed "
                                "(errno=%d), retrying in %u secs\n",
                                rc, (jiffies_to_msecs(delta) + 999) / 1000);
 
@@ -1925,7 +1924,7 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
                        link->sata_spd = (sstatus >> 4) & 0xf;
 
                if (postreset)
-                       postreset(ap, classes);
+                       postreset(link, classes);
 
                /* reset successful, schedule revalidation */
                ata_eh_done(link, NULL, ehc->i.action & ATA_EH_RESET_MASK);
@@ -2202,7 +2201,7 @@ static int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
        if (ehc->i.action & ATA_EH_RESET_MASK) {
                ata_eh_freeze_port(ap);
 
-               rc = ata_eh_reset(ap, ata_port_nr_vacant(ap), prereset,
+               rc = ata_eh_reset(&ap->link, ata_port_nr_vacant(ap), prereset,
                                  softreset, hardreset, postreset);
                if (rc) {
                        ata_port_printk(ap, KERN_ERR,

diff --git a/drivers/ata/pata_amd.c b/drivers/ata/pata_amd.c
index 04048fcf6305ef7e9423c7e38e9563f56535225b..d0cebe16a8ee2baf9a3178f01fa5d67d4a96afc4 100644 (file)
--- a/drivers/ata/pata_amd.c
+++ b/drivers/ata/pata_amd.c
@@ -119,27 +119,28 @@ static void timing_setup(struct ata_port *ap, struct ata_device *adev, int offse
 }
 
 /**
- *     amd_probe_init          -       perform reset handling
- *     @ap: ATA port
+ *     amd_pre_reset           -       perform reset handling
+ *     @link: ATA link
  *     @deadline: deadline jiffies for the operation
  *
  *     Reset sequence checking enable bits to see which ports are
  *     active.
  */
 
-static int amd_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int amd_pre_reset(struct ata_link *link, unsigned long deadline)
 {
        static const struct pci_bits amd_enable_bits[] = {
                { 0x40, 1, 0x02, 0x02 },
                { 0x40, 1, 0x01, 0x01 }
        };
 
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
        if (!pci_test_config_bits(pdev, &amd_enable_bits[ap->port_no]))
                return -ENOENT;
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 static void amd_error_handler(struct ata_port *ap)
@@ -221,25 +222,26 @@ static void amd133_set_dmamode(struct ata_port *ap, struct ata_device *adev)
 
 /**
  *     nv_probe_init   -       cable detection
- *     @ap: ATA port
+ *     @lin: ATA link
  *
  *     Perform cable detection. The BIOS stores this in PCI config
  *     space for us.
  */
 
-static int nv_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int nv_pre_reset(struct ata_link *link, unsigned long deadline)
 {
        static const struct pci_bits nv_enable_bits[] = {
                { 0x50, 1, 0x02, 0x02 },
                { 0x50, 1, 0x01, 0x01 }
        };
 
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
        if (!pci_test_config_bits(pdev, &nv_enable_bits[ap->port_no]))
                return -ENOENT;
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 static void nv_error_handler(struct ata_port *ap)

diff --git a/drivers/ata/pata_artop.c b/drivers/ata/pata_artop.c
index b5352ebecef93a9cf047b5f6cdb3cd4dc1a10c50..361f2fca7e549e4137a969fa9244991ad35b4e51 100644 (file)
--- a/drivers/ata/pata_artop.c
+++ b/drivers/ata/pata_artop.c
@@ -40,8 +40,9 @@
 
 static int clock = 0;
 
-static int artop6210_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int artop6210_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
        const struct pci_bits artop_enable_bits[] = {
                { 0x4AU, 1U, 0x02UL, 0x02UL },  /* port 0 */
@@ -51,7 +52,7 @@ static int artop6210_pre_reset(struct ata_port *ap, unsigned long deadline)
        if (!pci_test_config_bits(pdev, &artop_enable_bits[ap->port_no]))
                return -ENOENT;
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -71,27 +72,28 @@ static void artop6210_error_handler(struct ata_port *ap)
 
 /**
  *     artop6260_pre_reset     -       check for 40/80 pin
- *     @ap: Port
+ *     @link: link
  *     @deadline: deadline jiffies for the operation
  *
  *     The ARTOP hardware reports the cable detect bits in register 0x49.
  *     Nothing complicated needed here.
  */
 
-static int artop6260_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int artop6260_pre_reset(struct ata_link *link, unsigned long deadline)
 {
        static const struct pci_bits artop_enable_bits[] = {
                { 0x4AU, 1U, 0x02UL, 0x02UL },  /* port 0 */
                { 0x4AU, 1U, 0x04UL, 0x04UL },  /* port 1 */
        };
 
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
        /* Odd numbered device ids are the units with enable bits (the -R cards) */
        if (pdev->device % 1 && !pci_test_config_bits(pdev, &artop_enable_bits[ap->port_no]))
                return -ENOENT;
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 /**

diff --git a/drivers/ata/pata_atiixp.c b/drivers/ata/pata_atiixp.c
index 86f85a2cab7e3a8edd54244f995232e85919cea4..656f4d0a5728254c5de964552ee5a365e5c86464 100644 (file)
--- a/drivers/ata/pata_atiixp.c
+++ b/drivers/ata/pata_atiixp.c
@@ -33,8 +33,9 @@ enum {
        ATIIXP_IDE_UDMA_MODE    = 0x56
 };
 
-static int atiixp_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int atiixp_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        static const struct pci_bits atiixp_enable_bits[] = {
                { 0x48, 1, 0x01, 0x00 },
                { 0x48, 1, 0x08, 0x00 }
@@ -44,7 +45,7 @@ static int atiixp_pre_reset(struct ata_port *ap, unsigned long deadline)
        if (!pci_test_config_bits(pdev, &atiixp_enable_bits[ap->port_no]))
                return -ENOENT;
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 static void atiixp_error_handler(struct ata_port *ap)

diff --git a/drivers/ata/pata_efar.c b/drivers/ata/pata_efar.c
index c8ba59c5611429749b0fc06779acc12e592254bd..9f6fae6e38bfe071420496f4c0afba2be399840a 100644 (file)
--- a/drivers/ata/pata_efar.c
+++ b/drivers/ata/pata_efar.c
@@ -26,25 +26,26 @@
 
 /**
  *     efar_pre_reset  -       Enable bits
- *     @ap: Port
+ *     @link: ATA link
  *     @deadline: deadline jiffies for the operation
  *
  *     Perform cable detection for the EFAR ATA interface. This is
  *     different to the PIIX arrangement
  */
 
-static int efar_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int efar_pre_reset(struct ata_link *link, unsigned long deadline)
 {
        static const struct pci_bits efar_enable_bits[] = {
                { 0x41U, 1U, 0x80UL, 0x80UL },  /* port 0 */
                { 0x43U, 1U, 0x80UL, 0x80UL },  /* port 1 */
        };
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
        if (!pci_test_config_bits(pdev, &efar_enable_bits[ap->port_no]))
                return -ENOENT;
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 /**

diff --git a/drivers/ata/pata_hpt37x.c b/drivers/ata/pata_hpt37x.c
index c5ddd937dbf21a438af2cbe8fb0f2c385b88a774..1a4d0ad68d182c4eb9054874106dbabf444ead2a 100644 (file)
--- a/drivers/ata/pata_hpt37x.c
+++ b/drivers/ata/pata_hpt37x.c
@@ -304,15 +304,16 @@ static unsigned long hpt370a_filter(struct ata_device *adev, unsigned long mask)
 
 /**
  *     hpt37x_pre_reset        -       reset the hpt37x bus
- *     @ap: ATA port to reset
+ *     @link: ATA link to reset
  *     @deadline: deadline jiffies for the operation
  *
  *     Perform the initial reset handling for the 370/372 and 374 func 0
  */
 
-static int hpt37x_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int hpt37x_pre_reset(struct ata_link *link, unsigned long deadline)
 {
        u8 scr2, ata66;
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
        static const struct pci_bits hpt37x_enable_bits[] = {
                { 0x50, 1, 0x04, 0x04 },
@@ -337,7 +338,7 @@ static int hpt37x_pre_reset(struct ata_port *ap, unsigned long deadline)
        pci_write_config_byte(pdev, 0x50 + 4 * ap->port_no, 0x37);
        udelay(100);
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -352,7 +353,7 @@ static void hpt37x_error_handler(struct ata_port *ap)
        ata_bmdma_drive_eh(ap, hpt37x_pre_reset, ata_std_softreset, NULL, ata_std_postreset);
 }
 
-static int hpt374_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int hpt374_pre_reset(struct ata_link *link, unsigned long deadline)
 {
        static const struct pci_bits hpt37x_enable_bits[] = {
                { 0x50, 1, 0x04, 0x04 },
@@ -360,6 +361,7 @@ static int hpt374_pre_reset(struct ata_port *ap, unsigned long deadline)
        };
        u16 mcr3, mcr6;
        u8 ata66;
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
        if (!pci_test_config_bits(pdev, &hpt37x_enable_bits[ap->port_no]))
@@ -387,7 +389,7 @@ static int hpt374_pre_reset(struct ata_port *ap, unsigned long deadline)
        pci_write_config_byte(pdev, 0x50 + 4 * ap->port_no, 0x37);
        udelay(100);
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 /**

diff --git a/drivers/ata/pata_hpt3x2n.c b/drivers/ata/pata_hpt3x2n.c
index f8f234bfc8ce2bc1ef075fccedd6df98d52fec2f..739a89180eb9b87d7e66407a8b35afecac935aba 100644 (file)
--- a/drivers/ata/pata_hpt3x2n.c
+++ b/drivers/ata/pata_hpt3x2n.c
@@ -141,21 +141,22 @@ static int hpt3x2n_cable_detect(struct ata_port *ap)
 
 /**
  *     hpt3x2n_pre_reset       -       reset the hpt3x2n bus
- *     @ap: ATA port to reset
+ *     @link: ATA link to reset
  *     @deadline: deadline jiffies for the operation
  *
  *     Perform the initial reset handling for the 3x2n series controllers.
  *     Reset the hardware and state machine,
  */
 
-static int hpt3xn_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int hpt3xn_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
        /* Reset the state machine */
        pci_write_config_byte(pdev, 0x50 + 4 * ap->port_no, 0x37);
        udelay(100);
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 /**

diff --git a/drivers/ata/pata_it8213.c b/drivers/ata/pata_it8213.c
index b8af55e8915695a45538522092e1f387ce9ce483..1daf1e19bdfc52490c44f4b6078f24a598571952 100644 (file)
--- a/drivers/ata/pata_it8213.c
+++ b/drivers/ata/pata_it8213.c
@@ -23,23 +23,24 @@
 
 /**
  *     it8213_pre_reset        -       check for 40/80 pin
- *     @ap: Port
+ *     @link: link
  *     @deadline: deadline jiffies for the operation
  *
  *     Filter out ports by the enable bits before doing the normal reset
  *     and probe.
  */
 
-static int it8213_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int it8213_pre_reset(struct ata_link *link, unsigned long deadline)
 {
        static const struct pci_bits it8213_enable_bits[] = {
                { 0x41U, 1U, 0x80UL, 0x80UL },  /* port 0 */
        };
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
        if (!pci_test_config_bits(pdev, &it8213_enable_bits[ap->port_no]))
                return -ENOENT;
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 /**

diff --git a/drivers/ata/pata_jmicron.c b/drivers/ata/pata_jmicron.c
index 4d67f238eee25ddf5f0e6ee917f7b8b0141de9b3..1619b86b74af5d78357ab7af0df9bb7b7bc648a0 100644 (file)
--- a/drivers/ata/pata_jmicron.c
+++ b/drivers/ata/pata_jmicron.c
@@ -29,7 +29,7 @@ typedef enum {
 
 /**
  *     jmicron_pre_reset       -       check for 40/80 pin
- *     @ap: Port
+ *     @link: ATA link
  *     @deadline: deadline jiffies for the operation
  *
  *     Perform the PATA port setup we need.
@@ -39,9 +39,9 @@ typedef enum {
  *     and setup here. We assume that has been done by init_one and the
  *     BIOS.
  */
-
-static int jmicron_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int jmicron_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
        u32 control;
        u32 control5;
@@ -103,7 +103,7 @@ static int jmicron_pre_reset(struct ata_port *ap, unsigned long deadline)
                ap->cbl = ATA_CBL_SATA;
                break;
        }
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 /**

diff --git a/drivers/ata/pata_marvell.c b/drivers/ata/pata_marvell.c
index b45506f1ef73e0db979a1614ffaa58048a63f721..b4dd18f3fa5d63ef33a0b674ed77dfc02d9e5709 100644 (file)
--- a/drivers/ata/pata_marvell.c
+++ b/drivers/ata/pata_marvell.c
@@ -24,14 +24,15 @@
 
 /**
  *     marvell_pre_reset       -       check for 40/80 pin
- *     @ap: Port
+ *     @link: link
  *     @deadline: deadline jiffies for the operation
  *
  *     Perform the PATA port setup we need.
  */
 
-static int marvell_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int marvell_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
        u32 devices;
        void __iomem *barp;
@@ -54,7 +55,7 @@ static int marvell_pre_reset(struct ata_port *ap, unsigned long deadline)
            (!(devices & 0x10)))        /* PATA enable ? */
                return -ENOENT;
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 static int marvell_cable_detect(struct ata_port *ap)

diff --git a/drivers/ata/pata_mpiix.c b/drivers/ata/pata_mpiix.c
index 4ea42838297e68701343d86e7b05cd727b801128..36c964b9e7dafc949dd0ea423ea7d840f354bb44 100644 (file)
--- a/drivers/ata/pata_mpiix.c
+++ b/drivers/ata/pata_mpiix.c
@@ -46,15 +46,16 @@ enum {
        SECONDARY = (1 << 14)
 };
 
-static int mpiix_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int mpiix_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
        static const struct pci_bits mpiix_enable_bits = { 0x6D, 1, 0x80, 0x80 };
 
        if (!pci_test_config_bits(pdev, &mpiix_enable_bits))
                return -ENOENT;
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 /**

diff --git a/drivers/ata/pata_ns87410.c b/drivers/ata/pata_ns87410.c
index 2f5d714ebfc4d5c7c844e2405e0ccb6b4bf3d193..65a217727718995c3f3760450ac5debffaa6febb 100644 (file)
--- a/drivers/ata/pata_ns87410.c
+++ b/drivers/ata/pata_ns87410.c
@@ -32,14 +32,15 @@
 
 /**
  *     ns87410_pre_reset               -       probe begin
- *     @ap: ATA port
+ *     @link: ATA link
  *     @deadline: deadline jiffies for the operation
  *
  *     Check enabled ports
  */
 
-static int ns87410_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int ns87410_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
        static const struct pci_bits ns87410_enable_bits[] = {
                { 0x43, 1, 0x08, 0x08 },
@@ -49,7 +50,7 @@ static int ns87410_pre_reset(struct ata_port *ap, unsigned long deadline)
        if (!pci_test_config_bits(pdev, &ns87410_enable_bits[ap->port_no]))
                return -ENOENT;
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 /**

diff --git a/drivers/ata/pata_oldpiix.c b/drivers/ata/pata_oldpiix.c
index 091a70a0ef1cf0cd391e16e83568cf01103b7dad..5b2c86fe9fc2ef3cd415ac01dfad252007864290 100644 (file)
--- a/drivers/ata/pata_oldpiix.c
+++ b/drivers/ata/pata_oldpiix.c
@@ -29,14 +29,15 @@
 
 /**
  *     oldpiix_pre_reset               -       probe begin
- *     @ap: ATA port
+ *     @link: ATA link
  *     @deadline: deadline jiffies for the operation
  *
  *     Set up cable type and use generic probe init
  */
 
-static int oldpiix_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int oldpiix_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
        static const struct pci_bits oldpiix_enable_bits[] = {
                { 0x41U, 1U, 0x80UL, 0x80UL },  /* port 0 */
@@ -46,7 +47,7 @@ static int oldpiix_pre_reset(struct ata_port *ap, unsigned long deadline)
        if (!pci_test_config_bits(pdev, &oldpiix_enable_bits[ap->port_no]))
                return -ENOENT;
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 /**

diff --git a/drivers/ata/pata_opti.c b/drivers/ata/pata_opti.c
index 458bf67f766fd246cf89539f13bc54b175322e13..5770c7755a62cccb42db4e23cac8fe5ee131021e 100644 (file)
--- a/drivers/ata/pata_opti.c
+++ b/drivers/ata/pata_opti.c
@@ -46,14 +46,15 @@ enum {
 
 /**
  *     opti_pre_reset          -       probe begin
- *     @ap: ATA port
+ *     @link: ATA link
  *     @deadline: deadline jiffies for the operation
  *
  *     Set up cable type and use generic probe init
  */
 
-static int opti_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int opti_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
        static const struct pci_bits opti_enable_bits[] = {
                { 0x45, 1, 0x80, 0x00 },
@@ -63,7 +64,7 @@ static int opti_pre_reset(struct ata_port *ap, unsigned long deadline)
        if (!pci_test_config_bits(pdev, &opti_enable_bits[ap->port_no]))
                return -ENOENT;
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 /**

diff --git a/drivers/ata/pata_optidma.c b/drivers/ata/pata_optidma.c
index f8234d7fd825e923708b6beec8b17f240738518c..39fcba800077319d3afd5dc65f7480bd7bc1488b 100644 (file)
--- a/drivers/ata/pata_optidma.c
+++ b/drivers/ata/pata_optidma.c
@@ -47,14 +47,15 @@ static int pci_clock;       /* 0 = 33 1 = 25 */
 
 /**
  *     optidma_pre_reset               -       probe begin
- *     @ap: ATA port
+ *     @link: ATA link
  *     @deadline: deadline jiffies for the operation
  *
  *     Set up cable type and use generic probe init
  */
 
-static int optidma_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int optidma_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
        static const struct pci_bits optidma_enable_bits = {
                0x40, 1, 0x08, 0x00
@@ -63,7 +64,7 @@ static int optidma_pre_reset(struct ata_port *ap, unsigned long deadline)
        if (ap->port_no && !pci_test_config_bits(pdev, &optidma_enable_bits))
                return -ENOENT;
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 /**

diff --git a/drivers/ata/pata_pdc2027x.c b/drivers/ata/pata_pdc2027x.c
index 83c90cabc7ff3b6114f200d630f3c7ad92005e31..ba39efbe540546d61f3f2fee9dadbcb2f5a63d3a 100644 (file)
--- a/drivers/ata/pata_pdc2027x.c
+++ b/drivers/ata/pata_pdc2027x.c
@@ -300,7 +300,7 @@ static inline int pdc2027x_port_enabled(struct ata_port *ap)
 
 /**
  *     pdc2027x_prereset - prereset for PATA host controller
- *     @ap: Target port
+ *     @link: Target link
  *     @deadline: deadline jiffies for the operation
  *
  *     Probeinit including cable detection.
@@ -309,12 +309,12 @@ static inline int pdc2027x_port_enabled(struct ata_port *ap)
  *     None (inherited from caller).
  */
 
-static int pdc2027x_prereset(struct ata_port *ap, unsigned long deadline)
+static int pdc2027x_prereset(struct ata_link *link, unsigned long deadline)
 {
        /* Check whether port enabled */
-       if (!pdc2027x_port_enabled(ap))
+       if (!pdc2027x_port_enabled(link->ap))
                return -ENOENT;
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 /**

diff --git a/drivers/ata/pata_sil680.c b/drivers/ata/pata_sil680.c
index 40395804a66fef72b3f280f1d7af87c7d4e6a32f..45515a22d856ebac01e51d870071c4e19560237f 100644 (file)
--- a/drivers/ata/pata_sil680.c
+++ b/drivers/ata/pata_sil680.c
@@ -95,15 +95,16 @@ static int sil680_cable_detect(struct ata_port *ap) {
 
 /**
  *     sil680_bus_reset        -       reset the SIL680 bus
- *     @ap: ATA port to reset
+ *     @link: ATA link to reset
  *     @deadline: deadline jiffies for the operation
  *
  *     Perform the SIL680 housekeeping when doing an ATA bus reset
  */
 
-static int sil680_bus_reset(struct ata_port *ap,unsigned int *classes,
+static int sil680_bus_reset(struct ata_link *link, unsigned int *classes,
                            unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
        unsigned long addr = sil680_selreg(ap, 0);
        u8 reset;
@@ -112,7 +113,7 @@ static int sil680_bus_reset(struct ata_port *ap,unsigned int *classes,
        pci_write_config_byte(pdev, addr, reset | 0x03);
        udelay(25);
        pci_write_config_byte(pdev, addr, reset);
-       return ata_std_softreset(ap, classes, deadline);
+       return ata_std_softreset(link, classes, deadline);
 }
 
 static void sil680_error_handler(struct ata_port *ap)

diff --git a/drivers/ata/pata_sis.c b/drivers/ata/pata_sis.c
index 9d6f81d52e186da0dc7090245b66951d102b2f96..b72227676f004fc1c691b32d78543a714ad83471 100644 (file)
--- a/drivers/ata/pata_sis.c
+++ b/drivers/ata/pata_sis.c
@@ -133,19 +133,20 @@ static int sis_66_cable_detect(struct ata_port *ap)
 
 /**
  *     sis_pre_reset           -       probe begin
- *     @ap: ATA port
+ *     @link: ATA link
  *     @deadline: deadline jiffies for the operation
  *
  *     Set up cable type and use generic probe init
  */
 
-static int sis_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int sis_pre_reset(struct ata_link *link, unsigned long deadline)
 {
        static const struct pci_bits sis_enable_bits[] = {
                { 0x4aU, 1U, 0x02UL, 0x02UL },  /* port 0 */
                { 0x4aU, 1U, 0x04UL, 0x04UL },  /* port 1 */
        };
 
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
        if (!pci_test_config_bits(pdev, &sis_enable_bits[ap->port_no]))
@@ -154,7 +155,7 @@ static int sis_pre_reset(struct ata_port *ap, unsigned long deadline)
        /* Clear the FIFO settings. We can't enable the FIFO until
           we know we are poking at a disk */
        pci_write_config_byte(pdev, 0x4B, 0);
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 

diff --git a/drivers/ata/pata_sl82c105.c b/drivers/ata/pata_sl82c105.c
index c0f43bb25956d15a7bfdf4188038c952d35cd3d0..375c3705dc43002adb51c0ba89cc405c03bc1404 100644 (file)
--- a/drivers/ata/pata_sl82c105.c
+++ b/drivers/ata/pata_sl82c105.c
@@ -43,23 +43,24 @@ enum {
 
 /**
  *     sl82c105_pre_reset              -       probe begin
- *     @ap: ATA port
+ *     @link: ATA link
  *     @deadline: deadline jiffies for the operation
  *
  *     Set up cable type and use generic probe init
  */
 
-static int sl82c105_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int sl82c105_pre_reset(struct ata_link *link, unsigned long deadline)
 {
        static const struct pci_bits sl82c105_enable_bits[] = {
                { 0x40, 1, 0x01, 0x01 },
                { 0x40, 1, 0x10, 0x10 }
        };
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
        if (ap->port_no && !pci_test_config_bits(pdev, &sl82c105_enable_bits[ap->port_no]))
                return -ENOENT;
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 

diff --git a/drivers/ata/pata_triflex.c b/drivers/ata/pata_triflex.c
index af21f443db6e4e080226aaa12ce11ea6f4e69280..bc4b6f6be96362821f6b39d82bbd04290bccf87f 100644 (file)
--- a/drivers/ata/pata_triflex.c
+++ b/drivers/ata/pata_triflex.c
@@ -47,25 +47,26 @@
 
 /**
  *     triflex_prereset                -       probe begin
- *     @ap: ATA port
+ *     @link: ATA link
  *     @deadline: deadline jiffies for the operation
  *
  *     Set up cable type and use generic probe init
  */
 
-static int triflex_prereset(struct ata_port *ap, unsigned long deadline)
+static int triflex_prereset(struct ata_link *link, unsigned long deadline)
 {
        static const struct pci_bits triflex_enable_bits[] = {
                { 0x80, 1, 0x01, 0x01 },
                { 0x80, 1, 0x02, 0x02 }
        };
 
+       struct ata_port *ap = link->ap;
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
        if (!pci_test_config_bits(pdev, &triflex_enable_bits[ap->port_no]))
                return -ENOENT;
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 

diff --git a/drivers/ata/pata_via.c b/drivers/ata/pata_via.c
index f143db4559e0d5ad1cd4e3ec80d95b7708c2f471..b612808a319e2cc7da01bedb6d5b202ced8699ef 100644 (file)
--- a/drivers/ata/pata_via.c
+++ b/drivers/ata/pata_via.c
@@ -187,8 +187,9 @@ static int via_cable_detect(struct ata_port *ap) {
        return ATA_CBL_PATA40;
 }
 
-static int via_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int via_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        const struct via_isa_bridge *config = ap->host->private_data;
 
        if (!(config->flags & VIA_NO_ENABLES)) {
@@ -201,7 +202,7 @@ static int via_pre_reset(struct ata_port *ap, unsigned long deadline)
                        return -ENOENT;
        }
 
-       return ata_std_prereset(ap, deadline);
+       return ata_std_prereset(link, deadline);
 }
 
 

diff --git a/drivers/ata/sata_inic162x.c b/drivers/ata/sata_inic162x.c
index f2b1bea934bc19180501eea3c04ec05062b98871..95caba0f910e94a6b6695a4805ad542aca1ea745 100644 (file)
--- a/drivers/ata/sata_inic162x.c
+++ b/drivers/ata/sata_inic162x.c
@@ -417,12 +417,13 @@ static void inic_thaw(struct ata_port *ap)
  * SRST and SControl hardreset don't give valid signature on this
  * controller.  Only controller specific hardreset mechanism works.
  */
-static int inic_hardreset(struct ata_port *ap, unsigned int *class,
+static int inic_hardreset(struct ata_link *link, unsigned int *class,
                          unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        void __iomem *port_base = inic_port_base(ap);
        void __iomem *idma_ctl = port_base + PORT_IDMA_CTL;
-       const unsigned long *timing = sata_ehc_deb_timing(&ap->link.eh_context);
+       const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
        u16 val;
        int rc;
 
@@ -435,15 +436,15 @@ static int inic_hardreset(struct ata_port *ap, unsigned int *class,
        msleep(1);
        writew(val & ~IDMA_CTL_RST_ATA, idma_ctl);
 
-       rc = sata_link_resume(&ap->link, timing, deadline);
+       rc = sata_link_resume(link, timing, deadline);
        if (rc) {
-               ata_port_printk(ap, KERN_WARNING, "failed to resume "
+               ata_link_printk(link, KERN_WARNING, "failed to resume "
                                "link after reset (errno=%d)\n", rc);
                return rc;
        }
 
        *class = ATA_DEV_NONE;
-       if (ata_link_online(&ap->link)) {
+       if (ata_link_online(link)) {
                struct ata_taskfile tf;
 
                /* wait a while before checking status */
@@ -452,7 +453,7 @@ static int inic_hardreset(struct ata_port *ap, unsigned int *class,
                rc = ata_wait_ready(ap, deadline);
                /* link occupied, -ENODEV too is an error */
                if (rc) {
-                       ata_port_printk(ap, KERN_WARNING, "device not ready "
+                       ata_link_printk(link, KERN_WARNING, "device not ready "
                                        "after hardreset (errno=%d)\n", rc);
                        return rc;
                }

diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index 8e63c60adafff56586ca0c6b416faab36fea66dc..56784ce10544b4e4a2a29f368a1c89fb3790cd1b 100644 (file)
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -2266,10 +2266,11 @@ comreset_retry:
        VPRINTK("EXIT\n");
 }
 
-static int mv_prereset(struct ata_port *ap, unsigned long deadline)
+static int mv_prereset(struct ata_link *link, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        struct mv_port_priv *pp = ap->private_data;
-       struct ata_eh_context *ehc = &ap->link.eh_context;
+       struct ata_eh_context *ehc = &link->eh_context;
        int rc;
 
        rc = mv_stop_dma(ap);
@@ -2285,7 +2286,7 @@ static int mv_prereset(struct ata_port *ap, unsigned long deadline)
        if (ehc->i.action & ATA_EH_HARDRESET)
                return 0;
 
-       if (ata_link_online(&ap->link))
+       if (ata_link_online(link))
                rc = ata_wait_ready(ap, deadline);
        else
                rc = -ENODEV;
@@ -2293,9 +2294,10 @@ static int mv_prereset(struct ata_port *ap, unsigned long deadline)
        return rc;
 }
 
-static int mv_hardreset(struct ata_port *ap, unsigned int *class,
+static int mv_hardreset(struct ata_link *link, unsigned int *class,
                        unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        struct mv_host_priv *hpriv = ap->host->private_data;
        void __iomem *mmio = ap->host->iomap[MV_PRIMARY_BAR];
 
@@ -2308,16 +2310,17 @@ static int mv_hardreset(struct ata_port *ap, unsigned int *class,
        return 0;
 }
 
-static void mv_postreset(struct ata_port *ap, unsigned int *classes)
+static void mv_postreset(struct ata_link *link, unsigned int *classes)
 {
+       struct ata_port *ap = link->ap;
        u32 serr;
 
        /* print link status */
-       sata_print_link_status(&ap->link);
+       sata_print_link_status(link);
 
        /* clear SError */
-       sata_scr_read(&ap->link, SCR_ERROR, &serr);
-       sata_scr_write_flush(&ap->link, SCR_ERROR, serr);
+       sata_scr_read(link, SCR_ERROR, &serr);
+       sata_scr_write_flush(link, SCR_ERROR, serr);
 
        /* bail out if no device is present */
        if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {

diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index df4d50dcffbc99c6b9d5a1444e6546ed449c5467..67ba0f75f1e9c1e49837c3c795800d64eb4525d8 100644 (file)
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -1459,7 +1459,7 @@ static void nv_ck804_thaw(struct ata_port *ap)
        writeb(mask, mmio_base + NV_INT_ENABLE_CK804);
 }
 
-static int nv_hardreset(struct ata_port *ap, unsigned int *class,
+static int nv_hardreset(struct ata_link *link, unsigned int *class,
                        unsigned long deadline)
 {
        unsigned int dummy;
@@ -1468,7 +1468,7 @@ static int nv_hardreset(struct ata_port *ap, unsigned int *class,
         * some controllers.  Don't classify on hardreset.  For more
         * info, see http://bugme.osdl.org/show_bug.cgi?id=3352
         */
-       return sata_std_hardreset(ap, &dummy, deadline);
+       return sata_std_hardreset(link, &dummy, deadline);
 }
 
 static void nv_error_handler(struct ata_port *ap)

diff --git a/drivers/ata/sata_sil24.c b/drivers/ata/sata_sil24.c
index 0cd40d5215feda89895ff77f2fd8b7912eda5fbe..869e414d7ed322d820d6b24a6ae0dd5fc0febe9f 100644 (file)
--- a/drivers/ata/sata_sil24.c
+++ b/drivers/ata/sata_sil24.c
@@ -583,9 +583,10 @@ static int sil24_exec_polled_cmd(struct ata_port *ap, int pmp,
        return rc;
 }
 
-static int sil24_do_softreset(struct ata_port *ap, unsigned int *class,
+static int sil24_do_softreset(struct ata_link *link, unsigned int *class,
                              int pmp, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        unsigned long timeout_msec = 0;
        struct ata_taskfile tf;
        const char *reason;
@@ -593,7 +594,7 @@ static int sil24_do_softreset(struct ata_port *ap, unsigned int *class,
 
        DPRINTK("ENTER\n");
 
-       if (ata_link_offline(&ap->link)) {
+       if (ata_link_offline(link)) {
                DPRINTK("PHY reports no device\n");
                *class = ATA_DEV_NONE;
                goto out;
@@ -609,7 +610,7 @@ static int sil24_do_softreset(struct ata_port *ap, unsigned int *class,
        if (time_after(deadline, jiffies))
                timeout_msec = jiffies_to_msecs(deadline - jiffies);
 
-       ata_tf_init(ap->link.device, &tf);      /* doesn't really matter */
+       ata_tf_init(link->device, &tf); /* doesn't really matter */
        rc = sil24_exec_polled_cmd(ap, pmp, &tf, 0, PRB_CTRL_SRST,
                                   timeout_msec);
        if (rc == -EBUSY) {
@@ -631,29 +632,30 @@ static int sil24_do_softreset(struct ata_port *ap, unsigned int *class,
        return 0;
 
  err:
-       ata_port_printk(ap, KERN_ERR, "softreset failed (%s)\n", reason);
+       ata_link_printk(link, KERN_ERR, "softreset failed (%s)\n", reason);
        return -EIO;
 }
 
-static int sil24_softreset(struct ata_port *ap, unsigned int *class,
+static int sil24_softreset(struct ata_link *link, unsigned int *class,
                           unsigned long deadline)
 {
-       return sil24_do_softreset(ap, class, 0, deadline);
+       return sil24_do_softreset(link, class, 0, deadline);
 }
 
-static int sil24_hardreset(struct ata_port *ap, unsigned int *class,
+static int sil24_hardreset(struct ata_link *link, unsigned int *class,
                           unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        void __iomem *port = ap->ioaddr.cmd_addr;
        const char *reason;
        int tout_msec, rc;
        u32 tmp;
 
        /* sil24 does the right thing(tm) without any protection */
-       sata_set_spd(&ap->link);
+       sata_set_spd(link);
 
        tout_msec = 100;
-       if (ata_link_online(&ap->link))
+       if (ata_link_online(link))
                tout_msec = 5000;
 
        writel(PORT_CS_DEV_RST, port + PORT_CTRL_STAT);
@@ -663,14 +665,14 @@ static int sil24_hardreset(struct ata_port *ap, unsigned int *class,
        /* SStatus oscillates between zero and valid status after
         * DEV_RST, debounce it.
         */
-       rc = sata_link_debounce(&ap->link, sata_deb_timing_long, deadline);
+       rc = sata_link_debounce(link, sata_deb_timing_long, deadline);
        if (rc) {
                reason = "PHY debouncing failed";
                goto err;
        }
 
        if (tmp & PORT_CS_DEV_RST) {
-               if (ata_link_offline(&ap->link))
+               if (ata_link_offline(link))
                        return 0;
                reason = "link not ready";
                goto err;
@@ -685,7 +687,7 @@ static int sil24_hardreset(struct ata_port *ap, unsigned int *class,
        return -EAGAIN;
 
  err:
-       ata_port_printk(ap, KERN_ERR, "hardreset failed (%s)\n", reason);
+       ata_link_printk(link, KERN_ERR, "hardreset failed (%s)\n", reason);
        return -EIO;
 }
 

diff --git a/drivers/ata/sata_via.c b/drivers/ata/sata_via.c
index 78a6833af71385b1cfc9f91d0649b92cf7d5378d..690280660b815d610b8978b897a1f6e531c5e77b 100644 (file)
--- a/drivers/ata/sata_via.c
+++ b/drivers/ata/sata_via.c
@@ -276,7 +276,7 @@ static void svia_noop_freeze(struct ata_port *ap)
 
 /**
  *     vt6420_prereset - prereset for vt6420
- *     @ap: target ATA port
+ *     @link: target ATA link
  *     @deadline: deadline jiffies for the operation
  *
  *     SCR registers on vt6420 are pieces of shit and may hang the
@@ -294,8 +294,9 @@ static void svia_noop_freeze(struct ata_port *ap)
  *     RETURNS:
  *     0 on success, -errno otherwise.
  */
-static int vt6420_prereset(struct ata_port *ap, unsigned long deadline)
+static int vt6420_prereset(struct ata_link *link, unsigned long deadline)
 {
+       struct ata_port *ap = link->ap;
        struct ata_eh_context *ehc = &ap->link.eh_context;
        unsigned long timeout = jiffies + (HZ * 5);
        u32 sstatus, scontrol;

diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index affd77aafb239417b3741e373316bb8a69ed129e..9350fbf39f77fbb2ebc732a3ad820ff834ec0c87 100644 (file)
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -3829,18 +3829,18 @@ static int ipr_device_reset(struct ipr_ioa_cfg *ioa_cfg,
 
 /**
  * ipr_sata_reset - Reset the SATA port
- * @ap:                SATA port to reset
+ * @link:      SATA link to reset
  * @classes:   class of the attached device
  *
- * This function issues a SATA phy reset to the affected ATA port.
+ * This function issues a SATA phy reset to the affected ATA link.
  *
  * Return value:
  *     0 on success / non-zero on failure
  **/
-static int ipr_sata_reset(struct ata_port *ap, unsigned int *classes,
+static int ipr_sata_reset(struct ata_link *link, unsigned int *classes,
                                unsigned long deadline)
 {
-       struct ipr_sata_port *sata_port = ap->private_data;
+       struct ipr_sata_port *sata_port = link->ap->private_data;
        struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
        struct ipr_resource_entry *res;
        unsigned long lock_flags = 0;

diff --git a/include/linux/libata.h b/include/linux/libata.h
index e7882ba63e7839a6902083215a33654b4e8315cb..25444dafae5002b4f9a73e2664955adfc90b0912 100644 (file)
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -333,14 +333,15 @@ enum ata_completion_errors {
 struct scsi_device;
 struct ata_port_operations;
 struct ata_port;
+struct ata_link;
 struct ata_queued_cmd;
 
 /* typedefs */
 typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);
-typedef int (*ata_prereset_fn_t)(struct ata_port *ap, unsigned long deadline);
-typedef int (*ata_reset_fn_t)(struct ata_port *ap, unsigned int *classes,
+typedef int (*ata_prereset_fn_t)(struct ata_link *link, unsigned long deadline);
+typedef int (*ata_reset_fn_t)(struct ata_link *link, unsigned int *classes,
                              unsigned long deadline);
-typedef void (*ata_postreset_fn_t)(struct ata_port *ap, unsigned int *classes);
+typedef void (*ata_postreset_fn_t)(struct ata_link *link, unsigned int *classes);
 
 struct ata_ioports {
        void __iomem            *cmd_addr;
@@ -706,14 +707,14 @@ extern int sata_link_debounce(struct ata_link *link,
                        const unsigned long *params, unsigned long deadline);
 extern int sata_link_resume(struct ata_link *link, const unsigned long *params,
                            unsigned long deadline);
-extern int ata_std_prereset(struct ata_port *ap, unsigned long deadline);
-extern int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
+extern int ata_std_prereset(struct ata_link *link, unsigned long deadline);
+extern int ata_std_softreset(struct ata_link *link, unsigned int *classes,
                             unsigned long deadline);
-extern int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
-                              unsigned long deadline);
-extern int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
+extern int sata_link_hardreset(struct ata_link *link,
+                       const unsigned long *timing, unsigned long deadline);
+extern int sata_std_hardreset(struct ata_link *link, unsigned int *class,
                              unsigned long deadline);
-extern void ata_std_postreset(struct ata_port *ap, unsigned int *classes);
+extern void ata_std_postreset(struct ata_link *link, unsigned int *classes);
 extern void ata_port_disable(struct ata_port *);
 extern void ata_std_ports(struct ata_ioports *ioaddr);
 #ifdef CONFIG_PCI