Merge branch 'linus' into stackprotector

Conflicts:
	arch/x86/kernel/Makefile
	include/asm-x86/pda.h

1 files changed, 106 insertions, 48 deletions

diff --git a/include/linux/libata.h b/include/linux/libata.h
index e57e5d08312..947cf84e555 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -27,6 +27,7 @@
 #define __LINUX_LIBATA_H__
 
 #include <linux/delay.h>
+#include <linux/jiffies.h>
 #include <linux/interrupt.h>
 #include <linux/dma-mapping.h>
 #include <linux/scatterlist.h>
@@ -59,9 +60,9 @@
 
 /* note: prints function name for you */
 #ifdef ATA_DEBUG
-#define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
+#define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
 #ifdef ATA_VERBOSE_DEBUG
-#define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
+#define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
 #else
 #define VPRINTK(fmt, args...)
 #endif  /* ATA_VERBOSE_DEBUG */
@@ -70,7 +71,7 @@
 #define VPRINTK(fmt, args...)
 #endif  /* ATA_DEBUG */
 
-#define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
+#define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __func__, ## args)
 
 /* NEW: debug levels */
 #define HAVE_LIBATA_MSG 1
@@ -115,7 +116,7 @@ enum {
         /* tag ATA_MAX_QUEUE - 1 is reserved for internal commands */
         ATA_MAX_QUEUE           = 32,
         ATA_TAG_INTERNAL        = ATA_MAX_QUEUE - 1,
-        ATA_SHORT_PAUSE         = (HZ >> 6) + 1,
+        ATA_SHORT_PAUSE         = 16,
 
         ATAPI_MAX_DRAIN         = 16 << 10,
 
@@ -145,6 +146,7 @@ enum {
         ATA_DFLAG_SPUNDOWN      = (1 << 14), /* XXX: for spindown_compat */
         ATA_DFLAG_SLEEPING      = (1 << 15), /* device is sleeping */
         ATA_DFLAG_DUBIOUS_XFER  = (1 << 16), /* data transfer not verified */
+        ATA_DFLAG_NO_UNLOAD     = (1 << 17), /* device doesn't support unload */
         ATA_DFLAG_INIT_MASK     = (1 << 24) - 1,
 
         ATA_DFLAG_DETACH        = (1 << 24),
@@ -162,12 +164,14 @@ enum {
         ATA_DEV_NONE            = 9,    /* no device */
 
         /* struct ata_link flags */
+        ATA_LFLAG_NO_HRST       = (1 << 1), /* avoid hardreset */
         ATA_LFLAG_NO_SRST       = (1 << 2), /* avoid softreset */
         ATA_LFLAG_ASSUME_ATA    = (1 << 3), /* assume ATA class */
         ATA_LFLAG_ASSUME_SEMB   = (1 << 4), /* assume SEMB class */
         ATA_LFLAG_ASSUME_CLASS  = ATA_LFLAG_ASSUME_ATA | ATA_LFLAG_ASSUME_SEMB,
         ATA_LFLAG_NO_RETRY      = (1 << 5), /* don't retry this link */
         ATA_LFLAG_DISABLED      = (1 << 6), /* link is disabled */
+        ATA_LFLAG_SW_ACTIVITY   = (1 << 7), /* keep activity stats */
 
         /* struct ata_port flags */
         ATA_FLAG_SLAVE_POSS     = (1 << 0), /* host supports slave dev */
@@ -190,6 +194,10 @@ enum {
         ATA_FLAG_AN             = (1 << 18), /* controller supports AN */
         ATA_FLAG_PMP            = (1 << 19), /* controller supports PMP */
         ATA_FLAG_IPM            = (1 << 20), /* driver can handle IPM */
+        ATA_FLAG_EM             = (1 << 21), /* driver supports enclosure
+                                              * management */
+        ATA_FLAG_SW_ACTIVITY    = (1 << 22), /* driver supports sw activity
+                                              * led */
 
         /* The following flag belongs to ap->pflags but is kept in
          * ap->flags because it's referenced in many LLDs and will be
@@ -234,17 +242,17 @@ enum {
         /* bits 24:31 of host->flags are reserved for LLD specific flags */
 
         /* various lengths of time */
-        ATA_TMOUT_BOOT          = 30 * HZ,      /* heuristic */
-        ATA_TMOUT_BOOT_QUICK    = 7 * HZ,       /* heuristic */
-        ATA_TMOUT_INTERNAL      = 30 * HZ,
-        ATA_TMOUT_INTERNAL_QUICK = 5 * HZ,
+        ATA_TMOUT_BOOT          = 30000,        /* heuristic */
+        ATA_TMOUT_BOOT_QUICK    =  7000,        /* heuristic */
+        ATA_TMOUT_INTERNAL_QUICK = 5000,
+        ATA_TMOUT_MAX_PARK      = 30000,
 
         /* FIXME: GoVault needs 2s but we can't afford that without
          * parallel probing.  800ms is enough for iVDR disk
          * HHD424020F7SV00.  Increase to 2secs when parallel probing
          * is in place.
          */
-        ATA_TMOUT_FF_WAIT       = 4 * HZ / 5,
+        ATA_TMOUT_FF_WAIT       =  800,
 
         /* Spec mandates to wait for ">= 2ms" before checking status
          * after reset.  We wait 150ms, because that was the magic
@@ -256,14 +264,14 @@ enum {
          *
          * Old drivers/ide uses the 2mS rule and then waits for ready.
          */
-        ATA_WAIT_AFTER_RESET_MSECS = 150,
+        ATA_WAIT_AFTER_RESET    =  150,
 
         /* If PMP is supported, we have to do follow-up SRST.  As some
          * PMPs don't send D2H Reg FIS after hardreset, LLDs are
          * advised to wait only for the following duration before
          * doing SRST.
          */
-        ATA_TMOUT_PMP_SRST_WAIT = 1 * HZ,
+        ATA_TMOUT_PMP_SRST_WAIT = 1000,
 
         /* ATA bus states */
         BUS_UNKNOWN             = 0,
@@ -313,8 +321,11 @@ enum {
         ATA_EH_RESET            = ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
         ATA_EH_ENABLE_LINK      = (1 << 3),
         ATA_EH_LPM              = (1 << 4),  /* link power management action */
+        ATA_EH_PARK             = (1 << 5), /* unload heads and stop I/O */
 
-        ATA_EH_PERDEV_MASK      = ATA_EH_REVALIDATE,
+        ATA_EH_PERDEV_MASK      = ATA_EH_REVALIDATE | ATA_EH_PARK,
+        ATA_EH_ALL_ACTIONS      = ATA_EH_REVALIDATE | ATA_EH_RESET |
+                                  ATA_EH_ENABLE_LINK | ATA_EH_LPM,
 
         /* ata_eh_info->flags */
         ATA_EHI_HOTPLUGGED      = (1 << 0),  /* could have been hotplugged */
@@ -340,6 +351,11 @@ enum {
 
         SATA_PMP_RW_TIMEOUT     = 3000,         /* PMP read/write timeout */
 
+        /* This should match the actual table size of
+         * ata_eh_cmd_timeout_table in libata-eh.c.
+         */
+        ATA_EH_CMD_TIMEOUT_TABLE_SIZE = 5,
+
         /* Horkage types. May be set by libata or controller on drives
            (some horkage may be drive/controller pair dependant */
 
@@ -441,6 +457,16 @@ enum link_pm {
         MEDIUM_POWER,
 };
 extern struct device_attribute dev_attr_link_power_management_policy;
+extern struct device_attribute dev_attr_unload_heads;
+extern struct device_attribute dev_attr_em_message_type;
+extern struct device_attribute dev_attr_em_message;
+extern struct device_attribute dev_attr_sw_activity;
+
+enum sw_activity {
+        OFF,
+        BLINK_ON,
+        BLINK_OFF,
+};
 
 #ifdef CONFIG_ATA_SFF
 struct ata_ioports {
@@ -534,8 +560,8 @@ struct ata_ering {
 struct ata_device {
         struct ata_link         *link;
         unsigned int            devno;          /* 0 or 1 */
-        unsigned long           flags;          /* ATA_DFLAG_xxx */
         unsigned int            horkage;        /* List of broken features */
+        unsigned long           flags;          /* ATA_DFLAG_xxx */
         struct scsi_device      *sdev;          /* attached SCSI device */
 #ifdef CONFIG_ATA_ACPI
         acpi_handle             acpi_handle;
@@ -544,6 +570,7 @@ struct ata_device {
         /* n_sector is used as CLEAR_OFFSET, read comment above CLEAR_OFFSET */
         u64                     n_sectors;      /* size of device, if ATA */
         unsigned int            class;          /* ATA_DEV_xxx */
+        unsigned long           unpark_deadline;
 
         u8                      pio_mode;
         u8                      dma_mode;
@@ -597,10 +624,15 @@ struct ata_eh_info {
 struct ata_eh_context {
         struct ata_eh_info      i;
         int                     tries[ATA_MAX_DEVICES];
+        int                     cmd_timeout_idx[ATA_MAX_DEVICES]
+                                               [ATA_EH_CMD_TIMEOUT_TABLE_SIZE];
         unsigned int            classes[ATA_MAX_DEVICES];
         unsigned int            did_probe_mask;
+        unsigned int            unloaded_mask;
         unsigned int            saved_ncq_enabled;
         u8                      saved_xfer_mode[ATA_MAX_DEVICES];
+        /* timestamp for the last reset attempt or success */
+        unsigned long           last_reset;
 };
 
 struct ata_acpi_drive
@@ -623,6 +655,7 @@ struct ata_link {
 
         unsigned int            flags;          /* ATA_LFLAG_xxx */
 
+        u32                     saved_scontrol; /* SControl on probe */
         unsigned int            hw_sata_spd_limit;
         unsigned int            sata_spd_limit;
         unsigned int            sata_spd;       /* current SATA PHY speed */
@@ -663,7 +696,8 @@ struct ata_port {
         unsigned int            qc_active;
         int                     nr_active_links; /* #links with active qcs */
 
-        struct ata_link         link;   /* host default link */
+        struct ata_link         link;           /* host default link */
+        struct ata_link         *slave_link;    /* see ata_slave_link_init() */
 
         int                     nr_pmp_links;   /* nr of available PMP links */
         struct ata_link         *pmp_link;      /* array of PMP links */
@@ -684,6 +718,7 @@ struct ata_port {
         struct list_head        eh_done_q;
         wait_queue_head_t       eh_wait_q;
         int                     eh_tries;
+        struct completion       park_req_pending;
 
         pm_message_t            pm_mesg;
         int                     *pm_result;
@@ -692,6 +727,7 @@ struct ata_port {
         struct timer_list       fastdrain_timer;
         unsigned long           fastdrain_cnt;
 
+        int                     em_message_type;
         void                    *private_data;
 
 #ifdef CONFIG_ATA_ACPI
@@ -726,6 +762,7 @@ struct ata_port_operations {
         void (*set_piomode)(struct ata_port *ap, struct ata_device *dev);
         void (*set_dmamode)(struct ata_port *ap, struct ata_device *dev);
         int  (*set_mode)(struct ata_link *link, struct ata_device **r_failed_dev);
+        unsigned int (*read_id)(struct ata_device *dev, struct ata_taskfile *tf, u16 *id);
 
         void (*dev_config)(struct ata_device *dev);
 
@@ -745,8 +782,8 @@ struct ata_port_operations {
         /*
          * Optional features
          */
-        int  (*scr_read)(struct ata_port *ap, unsigned int sc_reg, u32 *val);
-        int  (*scr_write)(struct ata_port *ap, unsigned int sc_reg, u32 val);
+        int  (*scr_read)(struct ata_link *link, unsigned int sc_reg, u32 *val);
+        int  (*scr_write)(struct ata_link *link, unsigned int sc_reg, u32 val);
         void (*pmp_attach)(struct ata_port *ap);
         void (*pmp_detach)(struct ata_port *ap);
         int  (*enable_pm)(struct ata_port *ap, enum link_pm policy);
@@ -783,6 +820,12 @@ struct ata_port_operations {
         u8   (*bmdma_status)(struct ata_port *ap);
 #endif /* CONFIG_ATA_SFF */
 
+        ssize_t (*em_show)(struct ata_port *ap, char *buf);
+        ssize_t (*em_store)(struct ata_port *ap, const char *message,
+                            size_t size);
+        ssize_t (*sw_activity_show)(struct ata_device *dev, char *buf);
+        ssize_t (*sw_activity_store)(struct ata_device *dev,
+                                     enum sw_activity val);
         /*
          * Obsolete
          */
@@ -862,6 +905,7 @@ extern void ata_port_disable(struct ata_port *);
 extern struct ata_host *ata_host_alloc(struct device *dev, int max_ports);
 extern struct ata_host *ata_host_alloc_pinfo(struct device *dev,
                         const struct ata_port_info * const * ppi, int n_ports);
+extern int ata_slave_link_init(struct ata_port *ap);
 extern int ata_host_start(struct ata_host *host);
 extern int ata_host_register(struct ata_host *host,
                              struct scsi_host_template *sht);
@@ -887,16 +931,15 @@ extern int sata_scr_valid(struct ata_link *link);
 extern int sata_scr_read(struct ata_link *link, int reg, u32 *val);
 extern int sata_scr_write(struct ata_link *link, int reg, u32 val);
 extern int sata_scr_write_flush(struct ata_link *link, int reg, u32 val);
-extern int ata_link_online(struct ata_link *link);
-extern int ata_link_offline(struct ata_link *link);
+extern bool ata_link_online(struct ata_link *link);
+extern bool ata_link_offline(struct ata_link *link);
 #ifdef CONFIG_PM
 extern int ata_host_suspend(struct ata_host *host, pm_message_t mesg);
 extern void ata_host_resume(struct ata_host *host);
 #endif
 extern int ata_ratelimit(void);
 extern u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
-                             unsigned long interval_msec,
-                             unsigned long timeout_msec);
+                             unsigned long interval, unsigned long timeout);
 extern int atapi_cmd_type(u8 opcode);
 extern void ata_tf_to_fis(const struct ata_taskfile *tf,
                           u8 pmp, int is_cmd, u8 *fis);
@@ -922,6 +965,8 @@ extern void ata_id_string(const u16 *id, unsigned char *s,
                           unsigned int ofs, unsigned int len);
 extern void ata_id_c_string(const u16 *id, unsigned char *s,
                             unsigned int ofs, unsigned int len);
+extern unsigned int ata_do_dev_read_id(struct ata_device *dev,
+                                        struct ata_taskfile *tf, u16 *id);
 extern void ata_qc_complete(struct ata_queued_cmd *qc);
 extern int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active);
 extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
@@ -1064,6 +1109,7 @@ extern void ata_std_error_handler(struct ata_port *ap);
  */
 extern const struct ata_port_operations ata_base_port_ops;
 extern const struct ata_port_operations sata_port_ops;
+extern struct device_attribute *ata_common_sdev_attrs[];
 
 #define ATA_BASE_SHT(drv_name)                                  \
         .module                 = THIS_MODULE,                  \
@@ -1078,7 +1124,8 @@ extern const struct ata_port_operations sata_port_ops;
         .proc_name              = drv_name,                     \
         .slave_configure        = ata_scsi_slave_config,        \
         .slave_destroy          = ata_scsi_slave_destroy,       \
-        .bios_param             = ata_std_bios_param
+        .bios_param             = ata_std_bios_param,           \
+        .sdev_attrs             = ata_common_sdev_attrs
 
 #define ATA_NCQ_SHT(drv_name)                                   \
         ATA_BASE_SHT(drv_name),                                 \
@@ -1100,7 +1147,7 @@ static inline bool sata_pmp_attached(struct ata_port *ap)
 
 static inline int ata_is_host_link(const struct ata_link *link)
 {
-        return link == &link->ap->link;
+        return link == &link->ap->link || link == link->ap->slave_link;
 }
 #else /* CONFIG_SATA_PMP */
 static inline bool sata_pmp_supported(struct ata_port *ap)
@@ -1133,7 +1180,7 @@ static inline int sata_srst_pmp(struct ata_link *link)
         printk("%sata%u: "fmt, lv, (ap)->print_id , ##args)
 
 #define ata_link_printk(link, lv, fmt, args...) do { \
-        if (sata_pmp_attached((link)->ap)) \
+        if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link)    \
                 printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id,   \
                        (link)->pmp , ##args); \
         else \
@@ -1231,34 +1278,17 @@ static inline int ata_link_active(struct ata_link *link)
         return ata_tag_valid(link->active_tag) || link->sactive;
 }
 
-static inline struct ata_link *ata_port_first_link(struct ata_port *ap)
-{
-        if (sata_pmp_attached(ap))
-                return ap->pmp_link;
-        return &ap->link;
-}
+extern struct ata_link *__ata_port_next_link(struct ata_port *ap,
+                                             struct ata_link *link,
+                                             bool dev_only);
 
-static inline struct ata_link *ata_port_next_link(struct ata_link *link)
-{
-        struct ata_port *ap = link->ap;
-
-        if (ata_is_host_link(link)) {
-                if (!sata_pmp_attached(ap))
-                        return NULL;
-                return ap->pmp_link;
-        }
-
-        if (++link < ap->nr_pmp_links + ap->pmp_link)
-                return link;
-        return NULL;
-}
-
-#define __ata_port_for_each_link(lk, ap) \
-        for ((lk) = &(ap)->link; (lk); (lk) = ata_port_next_link(lk))
+#define __ata_port_for_each_link(link, ap) \
+        for ((link) = __ata_port_next_link((ap), NULL, false); (link); \
+             (link) = __ata_port_next_link((ap), (link), false))
 
 #define ata_port_for_each_link(link, ap) \
-        for ((link) = ata_port_first_link(ap); (link); \
-             (link) = ata_port_next_link(link))
+        for ((link) = __ata_port_next_link((ap), NULL, true); (link); \
+             (link) = __ata_port_next_link((ap), (link), true))
 
 #define ata_link_for_each_dev(dev, link) \
         for ((dev) = (link)->device; \
@@ -1389,6 +1419,34 @@ static inline int ata_check_ready(u8 status)
         return 0;
 }
 
+static inline unsigned long ata_deadline(unsigned long from_jiffies,
+                                         unsigned long timeout_msecs)
+{
+        return from_jiffies + msecs_to_jiffies(timeout_msecs);
+}
+
+/* Don't open code these in drivers as there are traps. Firstly the range may
+   change in future hardware and specs, secondly 0xFF means 'no DMA' but is
+   > UDMA_0. Dyma ddreigiau */
+
+static inline int ata_using_mwdma(struct ata_device *adev)
+{
+        if (adev->dma_mode >= XFER_MW_DMA_0 && adev->dma_mode <= XFER_MW_DMA_4)
+                return 1;
+        return 0;
+}
+
+static inline int ata_using_udma(struct ata_device *adev)
+{
+        if (adev->dma_mode >= XFER_UDMA_0 && adev->dma_mode <= XFER_UDMA_7)
+                return 1;
+        return 0;
+}
+
+static inline int ata_dma_enabled(struct ata_device *adev)
+{
+        return (adev->dma_mode == 0xFF ? 0 : 1);
+}
 
 /**************************************************************************
  * PMP - drivers/ata/libata-pmp.c