5 files changed, 187 insertions, 67 deletions

diff --git a/include/linux/ata.h b/include/linux/ata.h
index 206d859083ea..1cbeb434af9a 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -97,6 +97,9 @@ enum {
         ATA_DRQ                 = (1 << 3),     /* data request i/o */
         ATA_ERR                 = (1 << 0),     /* have an error */
         ATA_SRST                = (1 << 2),     /* software reset */
+        ATA_ICRC                = (1 << 7),     /* interface CRC error */
+        ATA_UNC                 = (1 << 6),     /* uncorrectable media error */
+        ATA_IDNF                = (1 << 4),     /* ID not found */
         ATA_ABORTED             = (1 << 2),     /* command aborted */
 
         /* ATA command block registers */
@@ -192,6 +195,16 @@ enum {
         SCR_ACTIVE              = 3,
         SCR_NOTIFICATION        = 4,
 
+        /* SError bits */
+        SERR_DATA_RECOVERED     = (1 << 0), /* recovered data error */
+        SERR_COMM_RECOVERED     = (1 << 1), /* recovered comm failure */
+        SERR_DATA               = (1 << 8), /* unrecovered data error */
+        SERR_PERSISTENT         = (1 << 9), /* persistent data/comm error */
+        SERR_PROTOCOL           = (1 << 10), /* protocol violation */
+        SERR_INTERNAL           = (1 << 11), /* host internal error */
+        SERR_PHYRDY_CHG         = (1 << 16), /* PHY RDY changed */
+        SERR_DEV_XCHG           = (1 << 26), /* device exchanged */
+
         /* struct ata_taskfile flags */
         ATA_TFLAG_LBA48         = (1 << 0), /* enable 48-bit LBA and "HOB" */
         ATA_TFLAG_ISADDR        = (1 << 1), /* enable r/w to nsect/lba regs */
diff --git a/include/linux/libata.h b/include/linux/libata.h
index bf86ee474533..db17723e23fb 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -108,7 +108,9 @@ enum {
         LIBATA_MAX_PRD          = ATA_MAX_PRD / 2,
         ATA_MAX_PORTS           = 8,
         ATA_DEF_QUEUE           = 1,
-        ATA_MAX_QUEUE           = 1,
+        /* tag ATA_MAX_QUEUE - 1 is reserved for internal commands */
+        ATA_MAX_QUEUE           = 2,
+        ATA_TAG_INTERNAL        = ATA_MAX_QUEUE - 1,
         ATA_MAX_SECTORS         = 200,  /* FIXME */
         ATA_MAX_BUS             = 2,
         ATA_DEF_BUSY_WAIT       = 10000,
@@ -149,11 +151,15 @@ enum {
         ATA_FLAG_PIO_POLLING    = (1 << 10), /* use polling PIO if LLD
                                               * doesn't handle PIO interrupts */
 
-        ATA_FLAG_DEBUGMSG       = (1 << 17),
-        ATA_FLAG_FLUSH_PORT_TASK = (1 << 18), /* flush port task */
+        ATA_FLAG_DEBUGMSG       = (1 << 14),
+        ATA_FLAG_FLUSH_PORT_TASK = (1 << 15), /* flush port task */
 
-        ATA_FLAG_DISABLED       = (1 << 19), /* port is disabled, ignore it */
-        ATA_FLAG_SUSPENDED      = (1 << 20), /* port is suspended */
+        ATA_FLAG_EH_PENDING     = (1 << 16), /* EH pending */
+        ATA_FLAG_FROZEN         = (1 << 17), /* port is frozen */
+        ATA_FLAG_RECOVERED      = (1 << 18), /* recovery action performed */
+
+        ATA_FLAG_DISABLED       = (1 << 22), /* port is disabled, ignore it */
+        ATA_FLAG_SUSPENDED      = (1 << 23), /* port is suspended (power) */
 
         /* bits 24:31 of ap->flags are reserved for LLDD specific flags */
 
@@ -163,7 +169,11 @@ enum {
         ATA_QCFLAG_SINGLE       = (1 << 2), /* no s/g, just a single buffer */
         ATA_QCFLAG_DMAMAP       = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
         ATA_QCFLAG_IO           = (1 << 3), /* standard IO command */
-        ATA_QCFLAG_EH_SCHEDULED = (1 << 4), /* EH scheduled */
+        ATA_QCFLAG_RESULT_TF    = (1 << 4), /* result TF requested */
+
+        ATA_QCFLAG_FAILED       = (1 << 16), /* cmd failed and is owned by EH */
+        ATA_QCFLAG_SENSE_VALID  = (1 << 17), /* sense data valid */
+        ATA_QCFLAG_EH_SCHEDULED = (1 << 18), /* EH scheduled (obsolete) */
 
         /* host set flags */
         ATA_HOST_SIMPLEX        = (1 << 0),     /* Host is simplex, one DMA channel per host_set only */
@@ -214,8 +224,29 @@ enum {
         ATA_PORT_PRIMARY        = (1 << 0),
         ATA_PORT_SECONDARY      = (1 << 1),
 
+        /* ering size */
+        ATA_ERING_SIZE          = 32,
+
+        /* desc_len for ata_eh_info and context */
+        ATA_EH_DESC_LEN         = 80,
+
+        /* reset / recovery action types */
+        ATA_EH_REVALIDATE       = (1 << 0),
+        ATA_EH_SOFTRESET        = (1 << 1),
+        ATA_EH_HARDRESET        = (1 << 2),
+
+        ATA_EH_RESET_MASK       = ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
+
+        /* ata_eh_info->flags */
+        ATA_EHI_DID_RESET       = (1 << 0), /* already reset this port */
+
+        /* max repeat if error condition is still set after ->error_handler */
+        ATA_EH_MAX_REPEAT       = 5,
+
         /* how hard are we gonna try to probe/recover devices */
         ATA_PROBE_MAX_TRIES     = 3,
+        ATA_EH_RESET_TRIES      = 3,
+        ATA_EH_DEV_TRIES        = 3,
 };
 
 enum hsm_task_states {
@@ -340,7 +371,7 @@ struct ata_queued_cmd {
         struct scatterlist      *__sg;
 
         unsigned int            err_mask;
-
+        struct ata_taskfile     result_tf;
         ata_qc_cb_t             complete_fn;
 
         void                    *private_data;
@@ -352,12 +383,24 @@ struct ata_host_stats {
         unsigned long           rw_reqbuf;
 };
 
+struct ata_ering_entry {
+        int                     is_io;
+        unsigned int            err_mask;
+        u64                     timestamp;
+};
+
+struct ata_ering {
+        int                     cursor;
+        struct ata_ering_entry  ring[ATA_ERING_SIZE];
+};
+
 struct ata_device {
+        struct ata_port         *ap;
         u64                     n_sectors;      /* size of device, if ATA */
         unsigned long           flags;          /* ATA_DFLAG_xxx */
         unsigned int            class;          /* ATA_DEV_xxx */
         unsigned int            devno;          /* 0 or 1 */
-        u16                     *id;            /* IDENTIFY xxx DEVICE data */
+        u16                     id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
         u8                      pio_mode;
         u8                      dma_mode;
         u8                      xfer_mode;
@@ -377,6 +420,24 @@ struct ata_device {
         u16                     cylinders;      /* Number of cylinders */
         u16                     heads;          /* Number of heads */
         u16                     sectors;        /* Number of sectors per track */
+
+        /* error history */
+        struct ata_ering        ering;
+};
+
+struct ata_eh_info {
+        struct ata_device       *dev;           /* offending device */
+        u32                     serror;         /* SError from LLDD */
+        unsigned int            err_mask;       /* port-wide err_mask */
+        unsigned int            action;         /* ATA_EH_* action mask */
+        unsigned int            flags;          /* ATA_EHI_* flags */
+        char                    desc[ATA_EH_DESC_LEN];
+        int                     desc_len;
+};
+
+struct ata_eh_context {
+        struct ata_eh_info      i;
+        int                     tries[ATA_MAX_DEVICES];
 };
 
 struct ata_port {
@@ -403,6 +464,11 @@ struct ata_port {
         unsigned int            cbl;    /* cable type; ATA_CBL_xxx */
         unsigned int            sata_spd_limit; /* SATA PHY speed limit */
 
+        /* record runtime error info, protected by host_set lock */
+        struct ata_eh_info      eh_info;
+        /* EH context owned by EH */
+        struct ata_eh_context   eh_context;
+
         struct ata_device       device[ATA_MAX_DEVICES];
 
         struct ata_queued_cmd   qcmd[ATA_MAX_QUEUE];
@@ -421,6 +487,8 @@ struct ata_port {
         struct list_head        eh_done_q;
 
         void                    *private_data;
+
+        u8                      sector_buf[ATA_SECT_SIZE]; /* owned by EH */
 };
 
 struct ata_port_operations {
@@ -454,7 +522,15 @@ struct ata_port_operations {
         void (*qc_prep) (struct ata_queued_cmd *qc);
         unsigned int (*qc_issue) (struct ata_queued_cmd *qc);
 
-        void (*eng_timeout) (struct ata_port *ap);
+        /* Error handlers.  ->error_handler overrides ->eng_timeout and
+         * indicates that new-style EH is in place.
+         */
+        void (*eng_timeout) (struct ata_port *ap); /* obsolete */
+
+        void (*freeze) (struct ata_port *ap);
+        void (*thaw) (struct ata_port *ap);
+        void (*error_handler) (struct ata_port *ap);
+        void (*post_internal_cmd) (struct ata_queued_cmd *qc);
 
         irqreturn_t (*irq_handler)(int, void *, struct pt_regs *);
         void (*irq_clear) (struct ata_port *);
@@ -500,7 +576,7 @@ extern void ata_port_probe(struct ata_port *);
 extern void __sata_phy_reset(struct ata_port *ap);
 extern void sata_phy_reset(struct ata_port *ap);
 extern void ata_bus_reset(struct ata_port *ap);
-extern int ata_set_sata_spd(struct ata_port *ap);
+extern int sata_set_spd(struct ata_port *ap);
 extern int ata_drive_probe_reset(struct ata_port *ap,
                         ata_probeinit_fn_t probeinit,
                         ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
@@ -509,8 +585,7 @@ extern void ata_std_probeinit(struct ata_port *ap);
 extern int ata_std_softreset(struct ata_port *ap, unsigned int *classes);
 extern int sata_std_hardreset(struct ata_port *ap, unsigned int *class);
 extern void ata_std_postreset(struct ata_port *ap, unsigned int *classes);
-extern int ata_dev_revalidate(struct ata_port *ap, struct ata_device *dev,
-                              int post_reset);
+extern int ata_dev_revalidate(struct ata_device *dev, int post_reset);
 extern void ata_port_disable(struct ata_port *);
 extern void ata_std_ports(struct ata_ioports *ioaddr);
 #ifdef CONFIG_PCI
@@ -526,14 +601,18 @@ extern void ata_host_set_remove(struct ata_host_set *host_set);
 extern int ata_scsi_detect(struct scsi_host_template *sht);
 extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
 extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
-extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
-extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);
 extern int ata_scsi_release(struct Scsi_Host *host);
 extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
+extern int sata_scr_valid(struct ata_port *ap);
+extern int sata_scr_read(struct ata_port *ap, int reg, u32 *val);
+extern int sata_scr_write(struct ata_port *ap, int reg, u32 val);
+extern int sata_scr_write_flush(struct ata_port *ap, int reg, u32 val);
+extern int ata_port_online(struct ata_port *ap);
+extern int ata_port_offline(struct ata_port *ap);
 extern int ata_scsi_device_resume(struct scsi_device *);
 extern int ata_scsi_device_suspend(struct scsi_device *, pm_message_t state);
-extern int ata_device_resume(struct ata_port *, struct ata_device *);
-extern int ata_device_suspend(struct ata_port *, struct ata_device *, pm_message_t state);
+extern int ata_device_resume(struct ata_device *);
+extern int ata_device_suspend(struct ata_device *, pm_message_t state);
 extern int ata_ratelimit(void);
 extern unsigned int ata_busy_sleep(struct ata_port *ap,
                                    unsigned long timeout_pat,
@@ -578,16 +657,22 @@ extern void ata_bmdma_start (struct ata_queued_cmd *qc);
 extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
 extern u8   ata_bmdma_status(struct ata_port *ap);
 extern void ata_bmdma_irq_clear(struct ata_port *ap);
-extern void __ata_qc_complete(struct ata_queued_cmd *qc);
-extern void ata_scsi_simulate(struct ata_port *ap, struct ata_device *dev,
-                              struct scsi_cmnd *cmd,
+extern void ata_bmdma_freeze(struct ata_port *ap);
+extern void ata_bmdma_thaw(struct ata_port *ap);
+extern void ata_bmdma_drive_eh(struct ata_port *ap,
+                               ata_reset_fn_t softreset,
+                               ata_reset_fn_t hardreset,
+                               ata_postreset_fn_t postreset);
+extern void ata_bmdma_error_handler(struct ata_port *ap);
+extern void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc);
+extern void ata_qc_complete(struct ata_queued_cmd *qc);
+extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
                               void (*done)(struct scsi_cmnd *));
 extern int ata_std_bios_param(struct scsi_device *sdev,
                               struct block_device *bdev,
                               sector_t capacity, int geom[]);
 extern int ata_scsi_slave_config(struct scsi_device *sdev);
-extern struct ata_device *ata_dev_pair(struct ata_port *ap, 
-                                       struct ata_device *adev);
+extern struct ata_device *ata_dev_pair(struct ata_device *adev);
 
 /*
  * Timing helpers
@@ -637,10 +722,46 @@ extern unsigned long ata_pci_default_filter(const struct ata_port *, struct ata_
  * EH
  */
 extern void ata_eng_timeout(struct ata_port *ap);
+
+extern void ata_port_schedule_eh(struct ata_port *ap);
+extern int ata_port_abort(struct ata_port *ap);
+extern int ata_port_freeze(struct ata_port *ap);
+
+extern void ata_eh_freeze_port(struct ata_port *ap);
+extern void ata_eh_thaw_port(struct ata_port *ap);
+
 extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
 extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);
 
+extern void ata_do_eh(struct ata_port *ap, ata_reset_fn_t softreset,
+                      ata_reset_fn_t hardreset, ata_postreset_fn_t postreset);
+
+/*
+ * printk helpers
+ */
+#define ata_port_printk(ap, lv, fmt, args...) \
+        printk(lv"ata%u: "fmt, (ap)->id , ##args)
+
+#define ata_dev_printk(dev, lv, fmt, args...) \
+        printk(lv"ata%u.%02u: "fmt, (dev)->ap->id, (dev)->devno , ##args)
 
+/*
+ * ata_eh_info helpers
+ */
+#define ata_ehi_push_desc(ehi, fmt, args...) do { \
+        (ehi)->desc_len += scnprintf((ehi)->desc + (ehi)->desc_len, \
+                                     ATA_EH_DESC_LEN - (ehi)->desc_len, \
+                                     fmt , ##args); \
+} while (0)
+
+#define ata_ehi_clear_desc(ehi) do { \
+        (ehi)->desc[0] = '\0'; \
+        (ehi)->desc_len = 0; \
+} while (0)
+
+/*
+ * qc helpers
+ */
 static inline int
 ata_sg_is_last(struct scatterlist *sg, struct ata_queued_cmd *qc)
 {
@@ -683,6 +804,11 @@ static inline unsigned int ata_tag_valid(unsigned int tag)
         return (tag < ATA_MAX_QUEUE) ? 1 : 0;
 }
 
+static inline unsigned int ata_tag_internal(unsigned int tag)
+{
+        return tag == ATA_MAX_QUEUE - 1;
+}
+
 static inline unsigned int ata_class_enabled(unsigned int class)
 {
         return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI;
@@ -791,20 +917,35 @@ static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
         qc->tf.ctl |= ATA_NIEN;
 }
 
-static inline struct ata_queued_cmd *ata_qc_from_tag (struct ata_port *ap,
-                                                      unsigned int tag)
+static inline struct ata_queued_cmd *__ata_qc_from_tag(struct ata_port *ap,
+                                                       unsigned int tag)
 {
         if (likely(ata_tag_valid(tag)))
                 return &ap->qcmd[tag];
         return NULL;
 }
 
-static inline void ata_tf_init(struct ata_port *ap, struct ata_taskfile *tf, unsigned int device)
+static inline struct ata_queued_cmd *ata_qc_from_tag(struct ata_port *ap,
+                                                     unsigned int tag)
+{
+        struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
+
+        if (unlikely(!qc) || !ap->ops->error_handler)
+                return qc;
+
+        if ((qc->flags & (ATA_QCFLAG_ACTIVE |
+                          ATA_QCFLAG_FAILED)) == ATA_QCFLAG_ACTIVE)
+                return qc;
+
+        return NULL;
+}
+
+static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf)
 {
         memset(tf, 0, sizeof(*tf));
 
-        tf->ctl = ap->ctl;
-        if (device == 0)
+        tf->ctl = dev->ap->ctl;
+        if (dev->devno == 0)
                 tf->device = ATA_DEVICE_OBS;
         else
                 tf->device = ATA_DEVICE_OBS | ATA_DEV1;
@@ -819,26 +960,11 @@ static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
         qc->nbytes = qc->curbytes = 0;
         qc->err_mask = 0;
 
-        ata_tf_init(qc->ap, &qc->tf, qc->dev->devno);
-}
-
-/**
- *      ata_qc_complete - Complete an active ATA command
- *      @qc: Command to complete
- *      @err_mask: ATA Status register contents
- *
- *      Indicate to the mid and upper layers that an ATA
- *      command has completed, with either an ok or not-ok status.
- *
- *      LOCKING:
- *      spin_lock_irqsave(host_set lock)
- */
-static inline void ata_qc_complete(struct ata_queued_cmd *qc)
-{
-        if (unlikely(qc->flags & ATA_QCFLAG_EH_SCHEDULED))
-                return;
+        ata_tf_init(qc->dev, &qc->tf);
 
-        __ata_qc_complete(qc);
+        /* init result_tf such that it indicates normal completion */
+        qc->result_tf.command = ATA_DRDY;
+        qc->result_tf.feature = 0;
 }
 
 /**
@@ -917,28 +1043,6 @@ static inline u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
         return status;
 }
 
-static inline u32 scr_read(struct ata_port *ap, unsigned int reg)
-{
-        return ap->ops->scr_read(ap, reg);
-}
-
-static inline void scr_write(struct ata_port *ap, unsigned int reg, u32 val)
-{
-        ap->ops->scr_write(ap, reg, val);
-}
-
-static inline void scr_write_flush(struct ata_port *ap, unsigned int reg,
-                                   u32 val)
-{
-        ap->ops->scr_write(ap, reg, val);
-        (void) ap->ops->scr_read(ap, reg);
-}
-
-static inline unsigned int sata_dev_present(struct ata_port *ap)
-{
-        return ((scr_read(ap, SCR_STATUS) & 0xf) == 0x3) ? 1 : 0;
-}
-
 static inline int ata_try_flush_cache(const struct ata_device *dev)
 {
         return ata_id_wcache_enabled(dev->id) ||
diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h
index 1ace1b9fe537..88c6c4da6c05 100644
--- a/include/scsi/scsi_cmnd.h
+++ b/include/scsi/scsi_cmnd.h
@@ -151,5 +151,6 @@ extern struct scsi_cmnd *scsi_get_command(struct scsi_device *, gfp_t);
 extern void scsi_put_command(struct scsi_cmnd *);
 extern void scsi_io_completion(struct scsi_cmnd *, unsigned int, unsigned int);
 extern void scsi_finish_command(struct scsi_cmnd *cmd);
+extern void scsi_req_abort_cmd(struct scsi_cmnd *cmd);
 
 #endif /* _SCSI_SCSI_CMND_H */
diff --git a/include/scsi/scsi_eh.h b/include/scsi/scsi_eh.h
index d160880b2a87..212c983a6a18 100644
--- a/include/scsi/scsi_eh.h
+++ b/include/scsi/scsi_eh.h
@@ -35,6 +35,7 @@ static inline int scsi_sense_valid(struct scsi_sense_hdr *sshdr)
 }
 
 
+extern void scsi_eh_wakeup(struct Scsi_Host *shost);
 extern void scsi_eh_finish_cmd(struct scsi_cmnd *scmd,
                                struct list_head *done_q);
 extern void scsi_eh_flush_done_q(struct list_head *done_q);
diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h
index de6ce541a046..a42efd6e4be8 100644
--- a/include/scsi/scsi_host.h
+++ b/include/scsi/scsi_host.h
@@ -472,6 +472,7 @@ struct Scsi_Host {
          */
         unsigned int host_busy;            /* commands actually active on low-level */
         unsigned int host_failed;          /* commands that failed. */
+        unsigned int host_eh_scheduled;    /* EH scheduled without command */
     
         unsigned short host_no;  /* Used for IOCTL_GET_IDLUN, /proc/scsi et al. */
         int resetting; /* if set, it means that last_reset is a valid value */