libata: update ata_dev_try_classify() arguments

Make ata_dev_try_classify() take a pointer to ata_device instead of
ata_port/port_number combination for consistency and add @present
argument.  @present indicates whether the device seems present during
reset.  It's the result of TF access during softreset and link
onlineness during hardreset.  @present will be used to improve
diagnostic failure handling.

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

diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index b01b5a897dcfdb78ac5710f06b5e221c13da040c..ea8c07b04f294c30da6b346a3944d58864cbd0e4 100644 (file)
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -701,8 +701,8 @@ unsigned int ata_dev_classify(const struct ata_taskfile *tf)
 
 /**
  *     ata_dev_try_classify - Parse returned ATA device signature
- *     @ap: ATA channel to examine
- *     @device: Device to examine (starting at zero)
+ *     @dev: ATA device to classify (starting at zero)
+ *     @present: device seems present
  *     @r_err: Value of error register on completion
  *
  *     After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
@@ -720,15 +720,15 @@ unsigned int ata_dev_classify(const struct ata_taskfile *tf)
  *     RETURNS:
  *     Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE.
  */
-
-unsigned int
-ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
+unsigned int ata_dev_try_classify(struct ata_device *dev, int present,
+                                 u8 *r_err)
 {
+       struct ata_port *ap = dev->link->ap;
        struct ata_taskfile tf;
        unsigned int class;
        u8 err;
 
-       ap->ops->dev_select(ap, device);
+       ap->ops->dev_select(ap, dev->devno);
 
        memset(&tf, 0, sizeof(tf));
 
@@ -738,12 +738,12 @@ ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
                *r_err = err;
 
        /* see if device passed diags: if master then continue and warn later */
-       if (err == 0 && device == 0)
+       if (err == 0 && dev->devno == 0)
                /* diagnostic fail : do nothing _YET_ */
-               ap->link.device[device].horkage |= ATA_HORKAGE_DIAGNOSTIC;
+               dev->horkage |= ATA_HORKAGE_DIAGNOSTIC;
        else if (err == 1)
                /* do nothing */ ;
-       else if ((device == 0) && (err == 0x81))
+       else if ((dev->devno == 0) && (err == 0x81))
                /* do nothing */ ;
        else
                return ATA_DEV_NONE;
@@ -3238,9 +3238,9 @@ void ata_bus_reset(struct ata_port *ap)
        /*
         * determine by signature whether we have ATA or ATAPI devices
         */
-       device[0].class = ata_dev_try_classify(ap, 0, &err);
+       device[0].class = ata_dev_try_classify(&device[0], dev0, &err);
        if ((slave_possible) && (err != 0x81))
-               device[1].class = ata_dev_try_classify(ap, 1, &err);
+               device[1].class = ata_dev_try_classify(&device[1], dev1, &err);
 
        /* is double-select really necessary? */
        if (device[1].class != ATA_DEV_NONE)
@@ -3479,9 +3479,11 @@ int ata_std_softreset(struct ata_link *link, unsigned int *classes,
        }
 
        /* determine by signature whether we have ATA or ATAPI devices */
-       classes[0] = ata_dev_try_classify(ap, 0, &err);
+       classes[0] = ata_dev_try_classify(&link->device[0],
+                                         devmask & (1 << 0), &err);
        if (slave_possible && err != 0x81)
-               classes[1] = ata_dev_try_classify(ap, 1, &err);
+               classes[1] = ata_dev_try_classify(&link->device[1],
+                                                 devmask & (1 << 1), &err);
 
  out:
        DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
@@ -3600,7 +3602,7 @@ int sata_std_hardreset(struct ata_link *link, unsigned int *class,
 
        ap->ops->dev_select(ap, 0);     /* probably unnecessary */
 
-       *class = ata_dev_try_classify(ap, 0, NULL);
+       *class = ata_dev_try_classify(link->device, 1, NULL);
 
        DPRINTK("EXIT, class=%u\n", *class);
        return 0;

diff --git a/drivers/ata/pata_scc.c b/drivers/ata/pata_scc.c
index 2153def3f345d0cb7d4646f0772076bfd6f68e7d..941b72bec836ed9db1c09ea97e72ca3535583e3b 100644 (file)
--- a/drivers/ata/pata_scc.c
+++ b/drivers/ata/pata_scc.c
@@ -636,9 +636,11 @@ static int scc_std_softreset (struct ata_port *ap, unsigned int *classes,
        }
 
        /* determine by signature whether we have ATA or ATAPI devices */
-       classes[0] = ata_dev_try_classify(ap, 0, &err);
+       classes[0] = ata_dev_try_classify(&ap->link.device[0],
+                                         devmask & (1 << 0), &err);
        if (slave_possible && err != 0x81)
-               classes[1] = ata_dev_try_classify(ap, 1, &err);
+               classes[1] = ata_dev_try_classify(&ap->link.device[1],
+                                                 devmask & (1 << 1), &err);
 
  out:
        DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);

diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index 08077efa9afdd2d71e25012eb816e4d139d10914..4df8311968e9e3f04325a7823cc53d78c21f1754 100644 (file)
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -2248,7 +2248,7 @@ comreset_retry:
         */
 
        /* finally, read device signature from TF registers */
-       *class = ata_dev_try_classify(ap, 0, NULL);
+       *class = ata_dev_try_classify(ap->link.device, 1, NULL);
 
        writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
 

diff --git a/include/linux/libata.h b/include/linux/libata.h
index 49da62d0c83bdc5514b0b85ead344e93701b929c..3ab2196c651af5908551d6f542b437546cfe876c 100644 (file)
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -781,7 +781,8 @@ 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 *);
+extern unsigned int ata_dev_try_classify(struct ata_device *dev, int present,
+                                        u8 *r_err);
 
 /*
  * Default driver ops implementations