4 files changed, 158 insertions, 86 deletions

diff --git a/include/linux/ata.h b/include/linux/ata.h
index 0c4929fa34d3..32df2b6ef0e0 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -89,6 +89,7 @@ enum {
         ATA_ID_SPG              = 98,
         ATA_ID_LBA_CAPACITY_2   = 100,
         ATA_ID_SECTOR_SIZE      = 106,
+        ATA_ID_WWN              = 108,
         ATA_ID_LOGICAL_SECTOR_SIZE      = 117,  /* and 118 */
         ATA_ID_LAST_LUN         = 126,
         ATA_ID_DLF              = 128,
@@ -103,6 +104,7 @@ enum {
         ATA_ID_SERNO_LEN        = 20,
         ATA_ID_FW_REV_LEN       = 8,
         ATA_ID_PROD_LEN         = 40,
+        ATA_ID_WWN_LEN          = 8,
 
         ATA_PCI_CTL_OFS         = 2,
 
@@ -598,42 +600,42 @@ static inline bool ata_id_has_dipm(const u16 *id)
 }
 
 
-static inline int ata_id_has_fua(const u16 *id)
+static inline bool ata_id_has_fua(const u16 *id)
 {
         if ((id[ATA_ID_CFSSE] & 0xC000) != 0x4000)
-                return 0;
+                return false;
         return id[ATA_ID_CFSSE] & (1 << 6);
 }
 
-static inline int ata_id_has_flush(const u16 *id)
+static inline bool ata_id_has_flush(const u16 *id)
 {
         if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
-                return 0;
+                return false;
         return id[ATA_ID_COMMAND_SET_2] & (1 << 12);
 }
 
-static inline int ata_id_flush_enabled(const u16 *id)
+static inline bool ata_id_flush_enabled(const u16 *id)
 {
         if (ata_id_has_flush(id) == 0)
-                return 0;
+                return false;
         if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
-                return 0;
+                return false;
         return id[ATA_ID_CFS_ENABLE_2] & (1 << 12);
 }
 
-static inline int ata_id_has_flush_ext(const u16 *id)
+static inline bool ata_id_has_flush_ext(const u16 *id)
 {
         if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
-                return 0;
+                return false;
         return id[ATA_ID_COMMAND_SET_2] & (1 << 13);
 }
 
-static inline int ata_id_flush_ext_enabled(const u16 *id)
+static inline bool ata_id_flush_ext_enabled(const u16 *id)
 {
         if (ata_id_has_flush_ext(id) == 0)
-                return 0;
+                return false;
         if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
-                return 0;
+                return false;
         /*
          * some Maxtor disks have bit 13 defined incorrectly
          * so check bit 10 too
@@ -686,64 +688,64 @@ static inline u16 ata_id_logical_sector_offset(const u16 *id,
         return 0;
 }
 
-static inline int ata_id_has_lba48(const u16 *id)
+static inline bool ata_id_has_lba48(const u16 *id)
 {
         if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
-                return 0;
+                return false;
         if (!ata_id_u64(id, ATA_ID_LBA_CAPACITY_2))
-                return 0;
+                return false;
         return id[ATA_ID_COMMAND_SET_2] & (1 << 10);
 }
 
-static inline int ata_id_lba48_enabled(const u16 *id)
+static inline bool ata_id_lba48_enabled(const u16 *id)
 {
         if (ata_id_has_lba48(id) == 0)
-                return 0;
+                return false;
         if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
-                return 0;
+                return false;
         return id[ATA_ID_CFS_ENABLE_2] & (1 << 10);
 }
 
-static inline int ata_id_hpa_enabled(const u16 *id)
+static inline bool ata_id_hpa_enabled(const u16 *id)
 {
         /* Yes children, word 83 valid bits cover word 82 data */
         if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
-                return 0;
+                return false;
         /* And 87 covers 85-87 */
         if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
-                return 0;
+                return false;
         /* Check command sets enabled as well as supported */
         if ((id[ATA_ID_CFS_ENABLE_1] & (1 << 10)) == 0)
-                return 0;
+                return false;
         return id[ATA_ID_COMMAND_SET_1] & (1 << 10);
 }
 
-static inline int ata_id_has_wcache(const u16 *id)
+static inline bool ata_id_has_wcache(const u16 *id)
 {
         /* Yes children, word 83 valid bits cover word 82 data */
         if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
-                return 0;
+                return false;
         return id[ATA_ID_COMMAND_SET_1] & (1 << 5);
 }
 
-static inline int ata_id_has_pm(const u16 *id)
+static inline bool ata_id_has_pm(const u16 *id)
 {
         if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
-                return 0;
+                return false;
         return id[ATA_ID_COMMAND_SET_1] & (1 << 3);
 }
 
-static inline int ata_id_rahead_enabled(const u16 *id)
+static inline bool ata_id_rahead_enabled(const u16 *id)
 {
         if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
-                return 0;
+                return false;
         return id[ATA_ID_CFS_ENABLE_1] & (1 << 6);
 }
 
-static inline int ata_id_wcache_enabled(const u16 *id)
+static inline bool ata_id_wcache_enabled(const u16 *id)
 {
         if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
-                return 0;
+                return false;
         return id[ATA_ID_CFS_ENABLE_1] & (1 << 5);
 }
 
@@ -773,7 +775,7 @@ static inline unsigned int ata_id_major_version(const u16 *id)
         return mver;
 }
 
-static inline int ata_id_is_sata(const u16 *id)
+static inline bool ata_id_is_sata(const u16 *id)
 {
         /*
          * See if word 93 is 0 AND drive is at least ATA-5 compatible
@@ -782,37 +784,40 @@ static inline int ata_id_is_sata(const u16 *id)
          * 0x0000 and 0xffff along with the earlier ATA revisions...
          */
         if (id[ATA_ID_HW_CONFIG] == 0 && (short)id[ATA_ID_MAJOR_VER] >= 0x0020)
-                return 1;
-        return 0;
+                return true;
+        return false;
 }
 
-static inline int ata_id_has_tpm(const u16 *id)
+static inline bool ata_id_has_tpm(const u16 *id)
 {
         /* The TPM bits are only valid on ATA8 */
         if (ata_id_major_version(id) < 8)
-                return 0;
+                return false;
         if ((id[48] & 0xC000) != 0x4000)
-                return 0;
+                return false;
         return id[48] & (1 << 0);
 }
 
-static inline int ata_id_has_dword_io(const u16 *id)
+static inline bool ata_id_has_dword_io(const u16 *id)
 {
         /* ATA 8 reuses this flag for "trusted" computing */
         if (ata_id_major_version(id) > 7)
-                return 0;
-        if (id[ATA_ID_DWORD_IO] & (1 << 0))
-                return 1;
-        return 0;
+                return false;
+        return id[ATA_ID_DWORD_IO] & (1 << 0);
 }
 
-static inline int ata_id_has_unload(const u16 *id)
+static inline bool ata_id_has_unload(const u16 *id)
 {
         if (ata_id_major_version(id) >= 7 &&
             (id[ATA_ID_CFSSE] & 0xC000) == 0x4000 &&
             id[ATA_ID_CFSSE] & (1 << 13))
-                return 1;
-        return 0;
+                return true;
+        return false;
+}
+
+static inline bool ata_id_has_wwn(const u16 *id)
+{
+        return (id[ATA_ID_CSF_DEFAULT] & 0xC100) == 0x4100;
 }
 
 static inline int ata_id_form_factor(const u16 *id)
@@ -843,25 +848,25 @@ static inline int ata_id_rotation_rate(const u16 *id)
         return val;
 }
 
-static inline int ata_id_has_trim(const u16 *id)
+static inline bool ata_id_has_trim(const u16 *id)
 {
         if (ata_id_major_version(id) >= 7 &&
             (id[ATA_ID_DATA_SET_MGMT] & 1))
-                return 1;
-        return 0;
+                return true;
+        return false;
 }
 
-static inline int ata_id_has_zero_after_trim(const u16 *id)
+static inline bool ata_id_has_zero_after_trim(const u16 *id)
 {
         /* DSM supported, deterministic read, and read zero after trim set */
         if (ata_id_has_trim(id) &&
             (id[ATA_ID_ADDITIONAL_SUPP] & 0x4020) == 0x4020)
-                return 1;
+                return true;
 
-        return 0;
+        return false;
 }
 
-static inline int ata_id_current_chs_valid(const u16 *id)
+static inline bool ata_id_current_chs_valid(const u16 *id)
 {
         /* For ATA-1 devices, if the INITIALIZE DEVICE PARAMETERS command
            has not been issued to the device then the values of
@@ -873,11 +878,11 @@ static inline int ata_id_current_chs_valid(const u16 *id)
                 id[ATA_ID_CUR_SECTORS];    /* sectors in current translation */
 }
 
-static inline int ata_id_is_cfa(const u16 *id)
+static inline bool ata_id_is_cfa(const u16 *id)
 {
         if ((id[ATA_ID_CONFIG] == 0x848A) ||    /* Traditional CF */
             (id[ATA_ID_CONFIG] == 0x844A))      /* Delkin Devices CF */
-                return 1;
+                return true;
         /*
          * CF specs don't require specific value in the word 0 anymore and yet
          * they forbid to report the ATA version in the word 80 and require the
@@ -886,44 +891,40 @@ static inline int ata_id_is_cfa(const u16 *id)
          * and while those that don't indicate CFA feature support need some
          * sort of quirk list, it seems impractical for the ones that do...
          */
-        if ((id[ATA_ID_COMMAND_SET_2] & 0xC004) == 0x4004)
-                return 1;
-        return 0;
+        return (id[ATA_ID_COMMAND_SET_2] & 0xC004) == 0x4004;
 }
 
-static inline int ata_id_is_ssd(const u16 *id)
+static inline bool ata_id_is_ssd(const u16 *id)
 {
         return id[ATA_ID_ROT_SPEED] == 0x01;
 }
 
-static inline int ata_id_pio_need_iordy(const u16 *id, const u8 pio)
+static inline bool ata_id_pio_need_iordy(const u16 *id, const u8 pio)
 {
         /* CF spec. r4.1 Table 22 says no IORDY on PIO5 and PIO6. */
         if (pio > 4 && ata_id_is_cfa(id))
-                return 0;
+                return false;
         /* For PIO3 and higher it is mandatory. */
         if (pio > 2)
-                return 1;
+                return true;
         /* Turn it on when possible. */
-        if (ata_id_has_iordy(id))
-                return 1;
-        return 0;
+        return ata_id_has_iordy(id);
 }
 
-static inline int ata_drive_40wire(const u16 *dev_id)
+static inline bool ata_drive_40wire(const u16 *dev_id)
 {
         if (ata_id_is_sata(dev_id))
-                return 0;       /* SATA */
+                return false;   /* SATA */
         if ((dev_id[ATA_ID_HW_CONFIG] & 0xE000) == 0x6000)
-                return 0;       /* 80 wire */
-        return 1;
+                return false;   /* 80 wire */
+        return true;
 }
 
-static inline int ata_drive_40wire_relaxed(const u16 *dev_id)
+static inline bool ata_drive_40wire_relaxed(const u16 *dev_id)
 {
         if ((dev_id[ATA_ID_HW_CONFIG] & 0x2000) == 0x2000)
-                return 0;       /* 80 wire */
-        return 1;
+                return false;   /* 80 wire */
+        return true;
 }
 
 static inline int atapi_cdb_len(const u16 *dev_id)
@@ -936,12 +937,12 @@ static inline int atapi_cdb_len(const u16 *dev_id)
         }
 }
 
-static inline int atapi_command_packet_set(const u16 *dev_id)
+static inline bool atapi_command_packet_set(const u16 *dev_id)
 {
         return (dev_id[ATA_ID_CONFIG] >> 8) & 0x1f;
 }
 
-static inline int atapi_id_dmadir(const u16 *dev_id)
+static inline bool atapi_id_dmadir(const u16 *dev_id)
 {
         return ata_id_major_version(dev_id) >= 7 && (dev_id[62] & 0x8000);
 }
@@ -954,13 +955,13 @@ static inline int atapi_id_dmadir(const u16 *dev_id)
  *
  * It is called only once for each device.
  */
-static inline int ata_id_is_lba_capacity_ok(u16 *id)
+static inline bool ata_id_is_lba_capacity_ok(u16 *id)
 {
         unsigned long lba_sects, chs_sects, head, tail;
 
         /* No non-LBA info .. so valid! */
         if (id[ATA_ID_CYLS] == 0)
-                return 1;
+                return true;
 
         lba_sects = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
 
@@ -975,13 +976,13 @@ static inline int ata_id_is_lba_capacity_ok(u16 *id)
             id[ATA_ID_SECTORS] == 63 &&
             (id[ATA_ID_HEADS] == 15 || id[ATA_ID_HEADS] == 16) &&
             (lba_sects >= 16383 * 63 * id[ATA_ID_HEADS]))
-                return 1;
+                return true;
 
         chs_sects = id[ATA_ID_CYLS] * id[ATA_ID_HEADS] * id[ATA_ID_SECTORS];
 
         /* perform a rough sanity check on lba_sects: within 10% is OK */
         if (lba_sects - chs_sects < chs_sects/10)
-                return 1;
+                return true;
 
         /* some drives have the word order reversed */
         head = (lba_sects >> 16) & 0xffff;
@@ -990,10 +991,10 @@ static inline int ata_id_is_lba_capacity_ok(u16 *id)
 
         if (lba_sects - chs_sects < chs_sects/10) {
                 *(__le32 *)&id[ATA_ID_LBA_CAPACITY] = __cpu_to_le32(lba_sects);
-                return 1;       /* LBA capacity is (now) good */
+                return true;    /* LBA capacity is (now) good */
         }
 
-        return 0;       /* LBA capacity value may be bad */
+        return false;   /* LBA capacity value may be bad */
 }
 
 static inline void ata_id_to_hd_driveid(u16 *id)
@@ -1051,19 +1052,19 @@ static inline int is_multi_taskfile(struct ata_taskfile *tf)
                (tf->command == ATA_CMD_WRITE_MULTI_FUA_EXT);
 }
 
-static inline int ata_ok(u8 status)
+static inline bool ata_ok(u8 status)
 {
         return ((status & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ | ATA_ERR))
                         == ATA_DRDY);
 }
 
-static inline int lba_28_ok(u64 block, u32 n_block)
+static inline bool lba_28_ok(u64 block, u32 n_block)
 {
         /* check the ending block number: must be LESS THAN 0x0fffffff */
         return ((block + n_block) < ((1 << 28) - 1)) && (n_block <= 256);
 }
 
-static inline int lba_48_ok(u64 block, u32 n_block)
+static inline bool lba_48_ok(u64 block, u32 n_block)
 {
         /* check the ending block number */
         return ((block + n_block - 1) < ((u64)1 << 48)) && (n_block <= 65536);
diff --git a/include/linux/libata.h b/include/linux/libata.h
index c9c5d7ad1a2b..c71f46960f39 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -179,10 +179,6 @@ enum {
         ATA_FLAG_SLAVE_POSS     = (1 << 0), /* host supports slave dev */
                                             /* (doesn't imply presence) */
         ATA_FLAG_SATA           = (1 << 1),
-        ATA_FLAG_NO_LEGACY      = (1 << 2), /* no legacy mode check */
-        ATA_FLAG_MMIO           = (1 << 3), /* use MMIO, not PIO */
-        ATA_FLAG_SRST           = (1 << 4), /* (obsolete) use ATA SRST, not E.D.D. */
-        ATA_FLAG_SATA_RESET     = (1 << 5), /* (obsolete) use COMRESET */
         ATA_FLAG_NO_ATAPI       = (1 << 6), /* No ATAPI support */
         ATA_FLAG_PIO_DMA        = (1 << 7), /* PIO cmds via DMA */
         ATA_FLAG_PIO_LBA48      = (1 << 8), /* Host DMA engine is LBA28 only */
@@ -198,7 +194,6 @@ enum {
         ATA_FLAG_ACPI_SATA      = (1 << 17), /* need native SATA ACPI layout */
         ATA_FLAG_AN             = (1 << 18), /* controller supports AN */
         ATA_FLAG_PMP            = (1 << 19), /* controller supports PMP */
-        ATA_FLAG_LPM            = (1 << 20), /* driver can handle LPM */
         ATA_FLAG_EM             = (1 << 21), /* driver supports enclosure
                                               * management */
         ATA_FLAG_SW_ACTIVITY    = (1 << 22), /* driver supports sw activity
@@ -1050,6 +1045,8 @@ extern int ata_scsi_change_queue_depth(struct scsi_device *sdev,
                                        int queue_depth, int reason);
 extern struct ata_device *ata_dev_pair(struct ata_device *adev);
 extern int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);
+extern void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap);
+extern void ata_scsi_cmd_error_handler(struct Scsi_Host *host, struct ata_port *ap, struct list_head *eh_q);
 
 extern int ata_cable_40wire(struct ata_port *ap);
 extern int ata_cable_80wire(struct ata_port *ap);
@@ -1613,6 +1610,9 @@ extern void ata_sff_irq_on(struct ata_port *ap);
 extern void ata_sff_irq_clear(struct ata_port *ap);
 extern int ata_sff_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
                             u8 status, int in_wq);
+extern void ata_sff_queue_work(struct work_struct *work);
+extern void ata_sff_queue_delayed_work(struct delayed_work *dwork,
+                unsigned long delay);
 extern void ata_sff_queue_pio_task(struct ata_link *link, unsigned long delay);
 extern unsigned int ata_sff_qc_issue(struct ata_queued_cmd *qc);
 extern bool ata_sff_qc_fill_rtf(struct ata_queued_cmd *qc);
diff --git a/include/linux/pata_arasan_cf_data.h b/include/linux/pata_arasan_cf_data.h
new file mode 100644
index 000000000000..a6ee9aa898bb
--- /dev/null
+++ b/include/linux/pata_arasan_cf_data.h
@@ -0,0 +1,49 @@
+/*
+ * include/linux/pata_arasan_cf_data.h
+ *
+ * Arasan Compact Flash host controller platform data header file
+ *
+ * Copyright (C) 2011 ST Microelectronics
+ * Viresh Kumar <viresh.kumar@st.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifndef _PATA_ARASAN_CF_DATA_H
+#define _PATA_ARASAN_CF_DATA_H
+
+#include <linux/platform_device.h>
+
+struct arasan_cf_pdata {
+        u8 cf_if_clk;
+        #define CF_IF_CLK_100M                  (0x0)
+        #define CF_IF_CLK_75M                   (0x1)
+        #define CF_IF_CLK_66M                   (0x2)
+        #define CF_IF_CLK_50M                   (0x3)
+        #define CF_IF_CLK_40M                   (0x4)
+        #define CF_IF_CLK_33M                   (0x5)
+        #define CF_IF_CLK_25M                   (0x6)
+        #define CF_IF_CLK_125M                  (0x7)
+        #define CF_IF_CLK_150M                  (0x8)
+        #define CF_IF_CLK_166M                  (0x9)
+        #define CF_IF_CLK_200M                  (0xA)
+        /*
+         * Platform specific incapabilities of CF controller is handled via
+         * quirks
+         */
+        u32 quirk;
+        #define CF_BROKEN_PIO                   (1)
+        #define CF_BROKEN_MWDMA                 (1 << 1)
+        #define CF_BROKEN_UDMA                  (1 << 2)
+        /* This is platform specific data for the DMA controller */
+        void *dma_priv;
+};
+
+static inline void
+set_arasan_cf_pdata(struct platform_device *pdev, struct arasan_cf_pdata *data)
+{
+        pdev->dev.platform_data = data;
+}
+#endif /* _PATA_ARASAN_CF_DATA_H */
diff --git a/include/scsi/sas_ata.h b/include/scsi/sas_ata.h
index c583193ae929..9c159f74c6d0 100644
--- a/include/scsi/sas_ata.h
+++ b/include/scsi/sas_ata.h
@@ -39,6 +39,11 @@ int sas_ata_init_host_and_port(struct domain_device *found_dev,
                                struct scsi_target *starget);
 
 void sas_ata_task_abort(struct sas_task *task);
+void sas_ata_strategy_handler(struct Scsi_Host *shost);
+int sas_ata_timed_out(struct scsi_cmnd *cmd, struct sas_task *task,
+                      enum blk_eh_timer_return *rtn);
+int sas_ata_eh(struct Scsi_Host *shost, struct list_head *work_q,
+               struct list_head *done_q);
 
 #else
 
@@ -55,6 +60,23 @@ static inline int sas_ata_init_host_and_port(struct domain_device *found_dev,
 static inline void sas_ata_task_abort(struct sas_task *task)
 {
 }
+
+static inline void sas_ata_strategy_handler(struct Scsi_Host *shost)
+{
+}
+
+static inline int sas_ata_timed_out(struct scsi_cmnd *cmd,
+                                    struct sas_task *task,
+                                    enum blk_eh_timer_return *rtn)
+{
+        return 0;
+}
+static inline int sas_ata_eh(struct Scsi_Host *shost, struct list_head *work_q,
+                             struct list_head *done_q)
+{
+        return 0;
+}
+
 #endif
 
 #endif /* _SAS_ATA_H_ */