29 files changed, 375 insertions, 237 deletions
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 63035d71a6..164c7d9514 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -704,8 +704,8 @@ static int ata_dev_set_dipm(struct ata_device *dev, enum link_pm policy)
 /**
 *      ata_dev_enable_pm - enable SATA interface power management
- *      @device - device to enable ipm for
+ *      @dev:  device to enable power management
- *      @policy - the link power management policy
+ *      @policy: the link power management policy
 *
 *      Enable SATA Interface power management.  This will enable
 *      Device Interface Power Management (DIPM) for min_power
@@ -735,9 +735,10 @@ enable_pm_out:
        return /* rc */;        /* hopefully we can use 'rc' eventually */
 }
+#ifdef CONFIG_PM
 /**
 *      ata_dev_disable_pm - disable SATA interface power management
- *      @device - device to enable ipm for
+ *      @dev: device to disable power management
 *
 *      Disable SATA Interface power management.  This will disable
 *      Device Interface Power Management (DIPM) without changing
@@ -755,6 +756,7 @@ static void ata_dev_disable_pm(struct ata_device *dev)
        if (ap->ops->disable_pm)
                ap->ops->disable_pm(ap);
 }
+#endif  /* CONFIG_PM */
 void ata_lpm_schedule(struct ata_port *ap, enum link_pm policy)
 {
@@ -764,6 +766,7 @@ void ata_lpm_schedule(struct ata_port *ap, enum link_pm policy)
        ata_port_schedule_eh(ap);
 }
+#ifdef CONFIG_PM
 static void ata_lpm_enable(struct ata_host *host)
 {
        struct ata_link *link;
@@ -789,6 +792,7 @@ static void ata_lpm_disable(struct ata_host *host)
                ata_lpm_schedule(ap, ap->pm_policy);
        }
 }
+#endif  /* CONFIG_PM */
 /**
@@ -2300,6 +2304,10 @@ int ata_dev_configure(struct ata_device *dev)
                dev->max_sectors = ATA_MAX_SECTORS;
        }
+        if ((dev->class == ATA_DEV_ATAPI) &&
+            (atapi_command_packet_set(id) == TYPE_TAPE))
+                dev->max_sectors = ATA_MAX_SECTORS_TAPE;
        if (dev->horkage & ATA_HORKAGE_MAX_SEC_128)
                dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128,
                                         dev->max_sectors);
@@ -2743,17 +2751,27 @@ int sata_down_spd_limit(struct ata_link *link)
 static int __sata_set_spd_needed(struct ata_link *link, u32 *scontrol)
 {
-        u32 spd, limit;
+        struct ata_link *host_link = &link->ap->link;
+        u32 limit, target, spd;
+        limit = link->sata_spd_limit;
-        if (link->sata_spd_limit == UINT_MAX)
+        /* Don't configure downstream link faster than upstream link.
-                limit = 0;
+         * It doesn't speed up anything and some PMPs choke on such
+         * configuration.
+         */
+        if (!ata_is_host_link(link) && host_link->sata_spd)
+                limit &= (1 << host_link->sata_spd) - 1;
+        if (limit == UINT_MAX)
+                target = 0;
        else
-                limit = fls(link->sata_spd_limit);
+                target = fls(limit);
        spd = (*scontrol >> 4) & 0xf;
-        *scontrol = (*scontrol & ~0xf0) | ((limit & 0xf) << 4);
+        *scontrol = (*scontrol & ~0xf0) | ((target & 0xf) << 4);
-        return spd != limit;
+        return spd != target;
 }
 /**
@@ -2776,7 +2794,7 @@ int sata_set_spd_needed(struct ata_link *link)
        u32 scontrol;
        if (sata_scr_read(link, SCR_CONTROL, &scontrol))
-                return 0;
+                return 1;
        return __sata_set_spd_needed(link, &scontrol);
 }
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index 8d64f8fd8f..ed8813b222 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -1747,6 +1747,7 @@ static void ata_eh_link_autopsy(struct ata_link *link)
 {
        struct ata_port *ap = link->ap;
        struct ata_eh_context *ehc = &link->eh_context;
+        struct ata_device *dev;
        unsigned int all_err_mask = 0;
        int tag, is_io = 0;
        u32 serror;
@@ -1818,18 +1819,24 @@ static void ata_eh_link_autopsy(struct ata_link *link)
                 (!is_io && (all_err_mask & ~AC_ERR_DEV)))
                ehc->i.action |= ATA_EH_REVALIDATE;
-        /* if we have offending qcs and the associated failed device */
+        /* If we have offending qcs and the associated failed device,
+         * perform per-dev EH action only on the offending device.
+         */
        if (ehc->i.dev) {
-                /* speed down */
-                ehc->i.action |= ata_eh_speed_down(ehc->i.dev, is_io,
-                                                   all_err_mask);
-                /* perform per-dev EH action only on the offending device */
                ehc->i.dev_action[ehc->i.dev->devno] |=
                        ehc->i.action & ATA_EH_PERDEV_MASK;
                ehc->i.action &= ~ATA_EH_PERDEV_MASK;
        }
+        /* consider speeding down */
+        dev = ehc->i.dev;
+        if (!dev && ata_link_max_devices(link) == 1 &&
+            ata_dev_enabled(link->device))
+                dev = link->device;
+        if (dev)
+                ehc->i.action |= ata_eh_speed_down(dev, is_io, all_err_mask);
        DPRINTK("EXIT\n");
 }
@@ -2065,16 +2072,19 @@ 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)
 {
+        const int max_tries = ARRAY_SIZE(ata_eh_reset_timeouts);
        struct ata_port *ap = link->ap;
        struct ata_eh_context *ehc = &link->eh_context;
        unsigned int *classes = ehc->classes;
+        unsigned int lflags = link->flags;
        int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
        int try = 0;
        struct ata_device *dev;
-        unsigned long deadline;
+        unsigned long deadline, now;
        unsigned int tmp_action;
        ata_reset_fn_t reset;
        unsigned long flags;
+        u32 sstatus;
        int rc;
        /* about to reset */
@@ -2106,7 +2116,7 @@ int ata_eh_reset(struct ata_link *link, int classify,
        /* Determine which reset to use and record in ehc->i.action.
         * prereset() may examine and modify it.
         */
-        if (softreset && (!hardreset || (!(link->flags & ATA_LFLAG_NO_SRST) &&
+        if (softreset && (!hardreset || (!(lflags & ATA_LFLAG_NO_SRST) &&
                                         !sata_set_spd_needed(link) &&
                                         !(ehc->i.action & ATA_EH_HARDRESET))))
                tmp_action = ATA_EH_SOFTRESET;
@@ -2181,82 +2191,64 @@ int ata_eh_reset(struct ata_link *link, int classify,
                                        "follow-up softreset required "
                                        "but no softreset avaliable\n");
                        rc = -EINVAL;
-                        goto out;
+                        goto fail;
                }
                ata_eh_about_to_do(link, NULL, ATA_EH_RESET_MASK);
                rc = ata_do_reset(link, reset, classes, deadline);
-                if (rc == 0 && classify && classes[0] == ATA_DEV_UNKNOWN &&
-                    !(link->flags & ATA_LFLAG_ASSUME_CLASS)) {
-                        ata_link_printk(link, KERN_ERR,
-                                        "classification failed\n");
-                        rc = -EINVAL;
-                        goto out;
-                }
        }
-        /* if we skipped follow-up srst, clear rc */
+        /* -EAGAIN can happen if we skipped followup SRST */
-        if (rc == -EAGAIN)
+        if (rc && rc != -EAGAIN)
-                rc = 0;
+                goto fail;
-        if (rc && rc != -ERESTART && try < ARRAY_SIZE(ata_eh_reset_timeouts)) {
-                unsigned long now = jiffies;
-                if (time_before(now, deadline)) {
-                        unsigned long delta = deadline - jiffies;
-                        ata_link_printk(link, KERN_WARNING, "reset failed "
-                                "(errno=%d), retrying in %u secs\n",
-                                rc, (jiffies_to_msecs(delta) + 999) / 1000);
-                        while (delta)
+        /* was classification successful? */
-                                delta = schedule_timeout_uninterruptible(delta);
+        if (classify && classes[0] == ATA_DEV_UNKNOWN &&
+            !(lflags & ATA_LFLAG_ASSUME_CLASS)) {
+                if (try < max_tries) {
+                        ata_link_printk(link, KERN_WARNING,
+                                        "classification failed\n");
+                        rc = -EINVAL;
+                        goto fail;
                }
-                if (rc == -EPIPE ||
+                ata_link_printk(link, KERN_WARNING,
-                    try == ARRAY_SIZE(ata_eh_reset_timeouts) - 1)
+                                "classfication failed, assuming ATA\n");
-                        sata_down_spd_limit(link);
+                lflags |= ATA_LFLAG_ASSUME_ATA;
-                if (hardreset)
-                        reset = hardreset;
-                goto retry;
        }
-        if (rc == 0) {
+        ata_link_for_each_dev(dev, link) {
-                u32 sstatus;
+                /* After the reset, the device state is PIO 0 and the
+                 * controller state is undefined.  Reset also wakes up
+                 * drives from sleeping mode.
+                 */
+                dev->pio_mode = XFER_PIO_0;
+                dev->flags &= ~ATA_DFLAG_SLEEPING;
-                ata_link_for_each_dev(dev, link) {
+                if (ata_link_offline(link))
-                        /* After the reset, the device state is PIO 0
+                        continue;
-                         * and the controller state is undefined.
-                         * Reset also wakes up drives from sleeping
-                         * mode.
-                         */
-                        dev->pio_mode = XFER_PIO_0;
-                        dev->flags &= ~ATA_DFLAG_SLEEPING;
-                        if (ata_link_offline(link))
+                /* apply class override and convert UNKNOWN to NONE */
-                                continue;
+                if (lflags & ATA_LFLAG_ASSUME_ATA)
+                        classes[dev->devno] = ATA_DEV_ATA;
+                else if (lflags & ATA_LFLAG_ASSUME_SEMB)
+                        classes[dev->devno] = ATA_DEV_SEMB_UNSUP; /* not yet */
+                else if (classes[dev->devno] == ATA_DEV_UNKNOWN)
+                        classes[dev->devno] = ATA_DEV_NONE;
+        }
-                        /* apply class override and convert UNKNOWN to NONE */
+        /* record current link speed */
-                        if (link->flags & ATA_LFLAG_ASSUME_ATA)
+        if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
-                                classes[dev->devno] = ATA_DEV_ATA;
+                link->sata_spd = (sstatus >> 4) & 0xf;
-                        else if (link->flags & ATA_LFLAG_ASSUME_SEMB)
-                                classes[dev->devno] = ATA_DEV_SEMB_UNSUP; /* not yet */
-                        else if (classes[dev->devno] == ATA_DEV_UNKNOWN)
-                                classes[dev->devno] = ATA_DEV_NONE;
-                }
-                /* record current link speed */
+        if (postreset)
-                if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
+                postreset(link, classes);
-                        link->sata_spd = (sstatus >> 4) & 0xf;
-                if (postreset)
+        /* reset successful, schedule revalidation */
-                        postreset(link, classes);
+        ata_eh_done(link, NULL, ehc->i.action & ATA_EH_RESET_MASK);
+        ehc->i.action |= ATA_EH_REVALIDATE;
-                /* reset successful, schedule revalidation */
+        rc = 0;
-                ata_eh_done(link, NULL, ehc->i.action & ATA_EH_RESET_MASK);
-                ehc->i.action |= ATA_EH_REVALIDATE;
-        }
 out:
        /* clear hotplug flag */
        ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
@@ -2266,6 +2258,28 @@ int ata_eh_reset(struct ata_link *link, int classify,
        spin_unlock_irqrestore(ap->lock, flags);
        return rc;
+ fail:
+        if (rc == -ERESTART || try >= max_tries)
+                goto out;
+        now = jiffies;
+        if (time_before(now, deadline)) {
+                unsigned long delta = deadline - now;
+                ata_link_printk(link, KERN_WARNING, "reset failed "
+                                "(errno=%d), retrying in %u secs\n",
+                                rc, (jiffies_to_msecs(delta) + 999) / 1000);
+                while (delta)
+                        delta = schedule_timeout_uninterruptible(delta);
+        }
+        if (rc == -EPIPE || try == max_tries - 1)
+                sata_down_spd_limit(link);
+        if (hardreset)
+                reset = hardreset;
+        goto retry;
 }
 static int ata_eh_revalidate_and_attach(struct ata_link *link,
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index fc89590d37..94144ed50a 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -120,7 +120,7 @@ static const struct {
        { MEDIUM_POWER, "medium_power" },
 };
-const char *ata_scsi_lpm_get(enum link_pm policy)
+static const char *ata_scsi_lpm_get(enum link_pm policy)
 {
        int i;
@@ -841,6 +841,9 @@ static void ata_scsi_dev_config(struct scsi_device *sdev,
                blk_queue_max_hw_segments(q, q->max_hw_segments - 1);
        }
+        if (dev->flags & ATA_DFLAG_AN)
+                set_bit(SDEV_EVT_MEDIA_CHANGE, sdev->supported_events);
        if (dev->flags & ATA_DFLAG_NCQ) {
                int depth;
@@ -3296,10 +3299,9 @@ static void ata_scsi_handle_link_detach(struct ata_link *link)
 */
 void ata_scsi_media_change_notify(struct ata_device *dev)
 {
-#ifdef OTHER_AN_PATCHES_HAVE_BEEN_APPLIED
        if (dev->sdev)
-                scsi_device_event_notify(dev->sdev, SDEV_MEDIA_CHANGE);
+                sdev_evt_send_simple(dev->sdev, SDEV_EVT_MEDIA_CHANGE,
-#endif
+                                     GFP_ATOMIC);
 }
 /**
diff --git a/drivers/ata/sata_fsl.c b/drivers/ata/sata_fsl.c
index b4c37b9e41..d015b4adcf 100644
--- a/drivers/ata/sata_fsl.c
+++ b/drivers/ata/sata_fsl.c
@@ -34,7 +34,8 @@ enum {
        SATA_FSL_HOST_FLAGS     = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
-                                ATA_FLAG_NCQ  | ATA_FLAG_SKIP_D2H_BSY),
+                                ATA_FLAG_NCQ),
+        SATA_FSL_HOST_LFLAGS    = ATA_LFLAG_SKIP_D2H_BSY,
        SATA_FSL_MAX_CMDS       = SATA_FSL_QUEUE_DEPTH,
        SATA_FSL_CMD_HDR_SIZE   = 16,   /* 4 DWORDS */
@@ -264,10 +265,11 @@ struct sata_fsl_host_priv {
        void __iomem *hcr_base;
        void __iomem *ssr_base;
        void __iomem *csr_base;
+        int irq;
 };
 static inline unsigned int sata_fsl_tag(unsigned int tag,
-                                        void __iomem * hcr_base)
+                                        void __iomem *hcr_base)
 {
        /* We let libATA core do actual (queue) tag allocation */
@@ -306,7 +308,7 @@ static void sata_fsl_setup_cmd_hdr_entry(struct sata_fsl_port_priv *pp,
        pp->cmdslot[tag].prde_fis_len =
            cpu_to_le32((num_prde << 16) | (fis_len << 2));
        pp->cmdslot[tag].ttl = cpu_to_le32(data_xfer_len & ~0x03);
-        pp->cmdslot[tag].desc_info = cpu_to_le32((desc_info | (tag & 0x1F)));
+        pp->cmdslot[tag].desc_info = cpu_to_le32(desc_info | (tag & 0x1F));
        VPRINTK("cda=0x%x, prde_fis_len=0x%x, ttl=0x%x, di=0x%x\n",
                pp->cmdslot[tag].cda,
@@ -316,7 +318,7 @@ static void sata_fsl_setup_cmd_hdr_entry(struct sata_fsl_port_priv *pp,
 }
 static unsigned int sata_fsl_fill_sg(struct ata_queued_cmd *qc, void *cmd_desc,
-                                     u32 * ttl, dma_addr_t cmd_desc_paddr)
+                                     u32 *ttl, dma_addr_t cmd_desc_paddr)
 {
        struct scatterlist *sg;
        unsigned int num_prde = 0;
@@ -353,7 +355,7 @@ static unsigned int sata_fsl_fill_sg(struct ata_queued_cmd *qc, void *cmd_desc,
                                        "s/g len unaligned : 0x%x\n", sg_len);
                if ((num_prde == (SATA_FSL_MAX_PRD_DIRECT - 1)) &&
-                    !ata_sg_is_last(sg, qc)) {
+                    (qc->n_iter + 1 != qc->n_elem)) {
                        VPRINTK("setting indirect prde\n");
                        prd_ptr_to_indirect_ext = prd;
                        prd->dba = cpu_to_le32(indirect_ext_segment_paddr);
@@ -404,7 +406,7 @@ static void sata_fsl_qc_prep(struct ata_queued_cmd *qc)
        cd = (struct command_desc *)pp->cmdentry + tag;
        cd_paddr = pp->cmdentry_paddr + tag * SATA_FSL_CMD_DESC_SIZE;
-        ata_tf_to_fis(&qc->tf, 0, 1, (u8 *) & cd->cfis);
+        ata_tf_to_fis(&qc->tf, 0, 1, (u8 *) &cd->cfis);
        VPRINTK("Dumping cfis : 0x%x, 0x%x, 0x%x\n",
                cd->cfis[0], cd->cfis[1], cd->cfis[2]);
@@ -470,16 +472,10 @@ static int sata_fsl_scr_write(struct ata_port *ap, unsigned int sc_reg_in,
        switch (sc_reg_in) {
        case SCR_STATUS:
-                sc_reg = 0;
-                break;
        case SCR_ERROR:
-                sc_reg = 1;
-                break;
        case SCR_CONTROL:
-                sc_reg = 2;
-                break;
        case SCR_ACTIVE:
-                sc_reg = 3;
+                sc_reg = sc_reg_in;
                break;
        default:
                return -EINVAL;
@@ -487,7 +483,7 @@ static int sata_fsl_scr_write(struct ata_port *ap, unsigned int sc_reg_in,
        VPRINTK("xx_scr_write, reg_in = %d\n", sc_reg);
-        iowrite32(val, (void __iomem *)ssr_base + (sc_reg * 4));
+        iowrite32(val, ssr_base + (sc_reg * 4));
        return 0;
 }
@@ -500,16 +496,10 @@ static int sata_fsl_scr_read(struct ata_port *ap, unsigned int sc_reg_in,
        switch (sc_reg_in) {
        case SCR_STATUS:
-                sc_reg = 0;
-                break;
        case SCR_ERROR:
-                sc_reg = 1;
-                break;
        case SCR_CONTROL:
-                sc_reg = 2;
-                break;
        case SCR_ACTIVE:
-                sc_reg = 3;
+                sc_reg = sc_reg_in;
                break;
        default:
                return -EINVAL;
@@ -517,7 +507,7 @@ static int sata_fsl_scr_read(struct ata_port *ap, unsigned int sc_reg_in,
        VPRINTK("xx_scr_read, reg_in = %d\n", sc_reg);
-        *val = ioread32((void __iomem *)ssr_base + (sc_reg * 4));
+        *val = ioread32(ssr_base + (sc_reg * 4));
        return 0;
 }
@@ -571,7 +561,6 @@ static inline void sata_fsl_cache_taskfile_from_d2h_fis(struct ata_queued_cmd
                                                        struct ata_port *ap)
 {
        struct sata_fsl_port_priv *pp = ap->private_data;
-        u8 fis[6 * 4];
        struct sata_fsl_host_priv *host_priv = ap->host->private_data;
        void __iomem *hcr_base = host_priv->hcr_base;
        unsigned int tag = sata_fsl_tag(qc->tag, hcr_base);
@@ -579,8 +568,7 @@ static inline void sata_fsl_cache_taskfile_from_d2h_fis(struct ata_queued_cmd
        cd = pp->cmdentry + tag;
-        memcpy(fis, &cd->sfis, 6 * 4);  /* should we use memcpy_from_io() */
+        ata_tf_from_fis(cd->sfis, &pp->tf);
-        ata_tf_from_fis(fis, &pp->tf);
 }
 static u8 sata_fsl_check_status(struct ata_port *ap)
@@ -664,6 +652,7 @@ static int sata_fsl_port_start(struct ata_port *ap)
        VPRINTK("HControl = 0x%x\n", ioread32(hcr_base + HCONTROL));
        VPRINTK("CHBA  = 0x%x\n", ioread32(hcr_base + CHBA));
+#ifdef CONFIG_MPC8315_DS
        /*
         * Workaround for 8315DS board 3gbps link-up issue,
         * currently limit SATA port to GEN1 speed
@@ -676,6 +665,7 @@ static int sata_fsl_port_start(struct ata_port *ap)
        sata_fsl_scr_read(ap, SCR_CONTROL, &temp);
        dev_printk(KERN_WARNING, dev, "scr_control, speed limited to %x\n",
                        temp);
+#endif
        return 0;
 }
@@ -728,9 +718,10 @@ static unsigned int sata_fsl_dev_classify(struct ata_port *ap)
        return ata_dev_classify(&tf);
 }
-static int sata_fsl_softreset(struct ata_port *ap, unsigned int *class,
+static int sata_fsl_softreset(struct ata_link *link, unsigned int *class,
                              unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
        struct sata_fsl_port_priv *pp = ap->private_data;
        struct sata_fsl_host_priv *host_priv = ap->host->private_data;
        void __iomem *hcr_base = host_priv->hcr_base;
@@ -739,10 +730,6 @@ static int sata_fsl_softreset(struct ata_port *ap, unsigned int *class,
        u8 *cfis;
        u32 Serror;
        int i = 0;
-        struct ata_queued_cmd qc;
-        u8 *buf;
-        dma_addr_t dma_address;
-        struct scatterlist *sg;
        unsigned long start_jiffies;
        DPRINTK("in xx_softreset\n");
@@ -811,7 +798,7 @@ try_offline_again:
         */
        temp = ata_wait_register(hcr_base + HSTATUS, 0xFF, 0, 1, 500);
-        if ((!(temp & 0x10)) || ata_port_offline(ap)) {
+        if ((!(temp & 0x10)) || ata_link_offline(link)) {
                ata_port_printk(ap, KERN_WARNING,
                                "No Device OR PHYRDY change,Hstatus = 0x%x\n",
                                ioread32(hcr_base + HSTATUS));
@@ -842,13 +829,10 @@ try_offline_again:
         * reached here, we can send a command to the target device
         */
-        if (ap->sactive)
-                goto skip_srst_do_ncq_error_handling;
        DPRINTK("Sending SRST/device reset\n");
-        ata_tf_init(ap->device, &tf);
+        ata_tf_init(link->device, &tf);
-        cfis = (u8 *) & pp->cmdentry->cfis;
+        cfis = (u8 *) &pp->cmdentry->cfis;
        /* device reset/SRST is a control register update FIS, uses tag0 */
        sata_fsl_setup_cmd_hdr_entry(pp, 0,
@@ -912,76 +896,13 @@ try_offline_again:
         * command bit of the CCreg
         */
        iowrite32(0x01, CC + hcr_base); /* We know it will be cmd#0 always */
-        goto check_device_signature;
-skip_srst_do_ncq_error_handling:
-        VPRINTK("Sending read log ext(10h) command\n");
-        memset(&qc, 0, sizeof(struct ata_queued_cmd));
-        ata_tf_init(ap->device, &tf);
-        tf.command = ATA_CMD_READ_LOG_EXT;
-        tf.lbal = ATA_LOG_SATA_NCQ;
-        tf.nsect = 1;
-        tf.hob_nsect = 0;
-        tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
-        tf.protocol = ATA_PROT_PIO;
-        qc.tag = ATA_TAG_INTERNAL;
-        qc.scsicmd = NULL;
-        qc.ap = ap;
-        qc.dev = ap->device;
-        qc.tf = tf;
-        qc.flags |= ATA_QCFLAG_RESULT_TF;
-        qc.dma_dir = DMA_FROM_DEVICE;
-        buf = ap->sector_buf;
-        ata_sg_init_one(&qc, buf, 1 * ATA_SECT_SIZE);
-        /*
-         * Need to DMA-map the memory buffer associated with the command
-         */
-        sg = qc.__sg;
-        dma_address = dma_map_single(ap->dev, qc.buf_virt,
-                                     sg->length, DMA_FROM_DEVICE);
-        sg_dma_address(sg) = dma_address;
-        sg_dma_len(sg) = sg->length;
-        VPRINTK("EH, addr = 0x%x, len = 0x%x\n", dma_address, sg->length);
-        sata_fsl_qc_prep(&qc);
-        sata_fsl_qc_issue(&qc);
-        temp = ata_wait_register(CQ + hcr_base, 0x1, 0x1, 1, 5000);
-        if (temp & 0x1) {
-                VPRINTK("READ_LOG_EXT_10H issue failed\n");
-                VPRINTK("READ_LOG@5000,CQ=0x%x,CA=0x%x,CC=0x%x\n",
-                        ioread32(CQ + hcr_base),
-                        ioread32(CA + hcr_base), ioread32(CC + hcr_base));
-                sata_fsl_scr_read(ap, SCR_ERROR, &Serror);
-                VPRINTK("HStatus = 0x%x\n", ioread32(hcr_base + HSTATUS));
-                VPRINTK("HControl = 0x%x\n", ioread32(hcr_base + HCONTROL));
-                VPRINTK("Serror = 0x%x\n", Serror);
-                goto err;
-        }
-        iowrite32(0x01, CC + hcr_base); /* We know it will be cmd#0 always */
-      check_device_signature:
        DPRINTK("SATA FSL : Now checking device signature\n");
        *class = ATA_DEV_NONE;
        /* Verify if SStatus indicates device presence */
-        if (ata_port_online(ap)) {
+        if (ata_link_online(link)) {
                /*
                 * if we are here, device presence has been detected,
                 * 1st D2H FIS would have been received, but sfis in
@@ -1002,25 +923,13 @@ err:
        return -EIO;
 }
-static int sata_fsl_hardreset(struct ata_port *ap, unsigned int *class,
-                              unsigned long deadline)
-{
-        int retval;
-        retval = sata_std_hardreset(ap, class, deadline);
-        DPRINTK("SATA FSL : in xx_hardreset, retval = 0x%d\n", retval);
-        return retval;
-}
 static void sata_fsl_error_handler(struct ata_port *ap)
 {
        DPRINTK("in xx_error_handler\n");
        /* perform recovery */
-        ata_do_eh(ap, ata_std_prereset, sata_fsl_softreset, sata_fsl_hardreset,
+        ata_do_eh(ap, ata_std_prereset, sata_fsl_softreset, sata_std_hardreset,
                  ata_std_postreset);
 }
@@ -1042,7 +951,8 @@ static void sata_fsl_irq_clear(struct ata_port *ap)
 static void sata_fsl_error_intr(struct ata_port *ap)
 {
-        struct ata_eh_info *ehi = &ap->eh_info;
+        struct ata_link *link = &ap->link;
+        struct ata_eh_info *ehi = &link->eh_info;
        struct sata_fsl_host_priv *host_priv = ap->host->private_data;
        void __iomem *hcr_base = host_priv->hcr_base;
        u32 hstatus, dereg, cereg = 0, SError = 0;
@@ -1111,7 +1021,7 @@ static void sata_fsl_error_intr(struct ata_port *ap)
        }
        /* record error info */
-        qc = ata_qc_from_tag(ap, ap->active_tag);
+        qc = ata_qc_from_tag(ap, link->active_tag);
        if (qc) {
                sata_fsl_cache_taskfile_from_d2h_fis(qc, qc->ap);
@@ -1139,6 +1049,7 @@ static void sata_fsl_qc_complete(struct ata_queued_cmd *qc)
 static void sata_fsl_host_intr(struct ata_port *ap)
 {
+        struct ata_link *link = &ap->link;
        struct sata_fsl_host_priv *host_priv = ap->host->private_data;
        void __iomem *hcr_base = host_priv->hcr_base;
        u32 hstatus, qc_active = 0;
@@ -1161,7 +1072,7 @@ static void sata_fsl_host_intr(struct ata_port *ap)
                return;
        }
-        if (ap->sactive) {      /* only true for NCQ commands */
+        if (link->sactive) {    /* only true for NCQ commands */
                int i;
                /* Read command completed register */
                qc_active = ioread32(hcr_base + CC);
@@ -1190,10 +1101,10 @@ static void sata_fsl_host_intr(struct ata_port *ap)
        } else if (ap->qc_active) {
                iowrite32(1, hcr_base + CC);
-                qc = ata_qc_from_tag(ap, ap->active_tag);
+                qc = ata_qc_from_tag(ap, link->active_tag);
                DPRINTK("completing non-ncq cmd, tag=%d,CC=0x%x\n",
-                        ap->active_tag, ioread32(hcr_base + CC));
+                        link->active_tag, ioread32(hcr_base + CC));
                if (qc) {
                        sata_fsl_qc_complete(qc);
@@ -1312,15 +1223,9 @@ static struct scsi_host_template sata_fsl_sht = {
        .slave_configure = ata_scsi_slave_config,
        .slave_destroy = ata_scsi_slave_destroy,
        .bios_param = ata_std_bios_param,
-#ifdef CONFIG_PM
-        .suspend = ata_scsi_device_suspend,
-        .resume = ata_scsi_device_resume,
-#endif
 };
 static const struct ata_port_operations sata_fsl_ops = {
-        .port_disable = ata_port_disable,
        .check_status = sata_fsl_check_status,
        .check_altstatus = sata_fsl_check_status,
        .dev_select = ata_noop_dev_select,
@@ -1330,8 +1235,6 @@ static const struct ata_port_operations sata_fsl_ops = {
        .qc_prep = sata_fsl_qc_prep,
        .qc_issue = sata_fsl_qc_issue,
        .irq_clear = sata_fsl_irq_clear,
-        .irq_on = ata_dummy_irq_on,
-        .irq_ack = ata_dummy_irq_ack,
        .scr_read = sata_fsl_scr_read,
        .scr_write = sata_fsl_scr_write,
@@ -1348,6 +1251,7 @@ static const struct ata_port_operations sata_fsl_ops = {
 static const struct ata_port_info sata_fsl_port_info[] = {
        {
         .flags = SATA_FSL_HOST_FLAGS,
+         .link_flags = SATA_FSL_HOST_LFLAGS,
         .pio_mask = 0x1f,      /* pio 0-4 */
         .udma_mask = 0x7f,     /* udma 0-6 */
         .port_ops = &sata_fsl_ops,
@@ -1398,6 +1302,7 @@ static int sata_fsl_probe(struct of_device *ofdev,
                dev_printk(KERN_ERR, &ofdev->dev, "invalid irq from platform\n");
                goto error_exit_with_cleanup;
        }
+        host_priv->irq = irq;
        /* allocate host structure */
        host = ata_host_alloc_pinfo(&ofdev->dev, ppi, SATA_FSL_MAX_PORTS);
@@ -1444,7 +1349,7 @@ static int sata_fsl_remove(struct of_device *ofdev)
        dev_set_drvdata(&ofdev->dev, NULL);
-        irq_dispose_mapping(host->irq);
+        irq_dispose_mapping(host_priv->irq);
        iounmap(host_priv->hcr_base);
        kfree(host_priv);
diff --git a/drivers/ata/sata_promise.c b/drivers/ata/sata_promise.c
index 825e717bce..7914def54f 100644
--- a/drivers/ata/sata_promise.c
+++ b/drivers/ata/sata_promise.c
@@ -587,7 +587,7 @@ static void pdc_fill_sg(struct ata_queued_cmd *qc)
                        VPRINTK("Splitting last PRD.\n");
                        addr = le32_to_cpu(ap->prd[idx - 1].addr);
-                        ap->prd[idx - 1].flags_len -= cpu_to_le32(SG_COUNT_ASIC_BUG);
+                        ap->prd[idx - 1].flags_len = cpu_to_le32(len - SG_COUNT_ASIC_BUG);
                        VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx - 1, addr, SG_COUNT_ASIC_BUG);
                        addr = addr + len - SG_COUNT_ASIC_BUG;
diff --git a/drivers/base/dmapool.c b/drivers/base/dmapool.c
index 5beddc322e..b5034dc72a 100644
--- a/drivers/base/dmapool.c
+++ b/drivers/base/dmapool.c
@@ -2,7 +2,6 @@
 #include <linux/device.h>
 #include <linux/mm.h>
 #include <asm/io.h>             /* Needed for i386 to build */
-#include <asm/scatterlist.h>    /* Needed for i386 to build */
 #include <linux/dma-mapping.h>
 #include <linux/dmapool.h>
 #include <linux/slab.h>
diff --git a/drivers/char/drm/radeon_cp.c b/drivers/char/drm/radeon_cp.c
index 335423c5c1..24fca8ec13 100644
--- a/drivers/char/drm/radeon_cp.c
+++ b/drivers/char/drm/radeon_cp.c
@@ -1679,7 +1679,7 @@ static int radeon_do_init_cp(struct drm_device * dev, drm_radeon_init_t * init)
                        dev_priv->gart_info.bus_addr =
                            dev_priv->pcigart_offset + dev_priv->fb_location;
                        dev_priv->gart_info.mapping.offset =
-                            dev_priv->gart_info.bus_addr;
+                            dev_priv->pcigart_offset + dev_priv->fb_aper_offset;
                        dev_priv->gart_info.mapping.size =
                            dev_priv->gart_info.table_size;
@@ -2275,7 +2275,8 @@ int radeon_driver_firstopen(struct drm_device *dev)
        if (ret != 0)
                return ret;
-        ret = drm_addmap(dev, drm_get_resource_start(dev, 0),
+        dev_priv->fb_aper_offset = drm_get_resource_start(dev, 0);
+        ret = drm_addmap(dev, dev_priv->fb_aper_offset,
                         drm_get_resource_len(dev, 0), _DRM_FRAME_BUFFER,
                         _DRM_WRITE_COMBINING, &map);
        if (ret != 0)
diff --git a/drivers/char/drm/radeon_drv.h b/drivers/char/drm/radeon_drv.h
index e4077bc212..bfbb60a929 100644
--- a/drivers/char/drm/radeon_drv.h
+++ b/drivers/char/drm/radeon_drv.h
@@ -293,6 +293,7 @@ typedef struct drm_radeon_private {
        /* starting from here on, data is preserved accross an open */
        uint32_t flags;         /* see radeon_chip_flags */
+        unsigned long fb_aper_offset;
 } drm_radeon_private_t;
 typedef struct drm_radeon_buf_priv {
diff --git a/drivers/char/drm/sis_mm.c b/drivers/char/drm/sis_mm.c
index 6be1c57575..a6b7ccdaf7 100644
--- a/drivers/char/drm/sis_mm.c
+++ b/drivers/char/drm/sis_mm.c
@@ -134,6 +134,7 @@ static int sis_drm_alloc(struct drm_device *dev, struct drm_file *file_priv,
                      dev_priv->agp_initialized)) {
                DRM_ERROR
                    ("Attempt to allocate from uninitialized memory manager.\n");
+                mutex_unlock(&dev->struct_mutex);
                return -EINVAL;
        }
diff --git a/drivers/ieee1394/dma.c b/drivers/ieee1394/dma.c
index f5f4983dfb..7c4eb39b70 100644
--- a/drivers/ieee1394/dma.c
+++ b/drivers/ieee1394/dma.c
@@ -103,8 +103,7 @@ int dma_region_alloc(struct dma_region *dma, unsigned long n_bytes,
                goto err;
        }
-        /* just to be safe - this will become unnecessary once sglist->address goes away */
+        sg_init_table(dma->sglist, dma->n_pages);
-        memset(dma->sglist, 0, dma->n_pages * sizeof(*dma->sglist));
        /* fill scatter/gather list with pages */
        for (i = 0; i < dma->n_pages; i++) {
diff --git a/drivers/ieee1394/sbp2.c b/drivers/ieee1394/sbp2.c
index d5dfe11aa5..b83d254bc8 100644
--- a/drivers/ieee1394/sbp2.c
+++ b/drivers/ieee1394/sbp2.c
@@ -71,11 +71,11 @@
 #include <linux/types.h>
 #include <linux/wait.h>
 #include <linux/workqueue.h>
+#include <linux/scatterlist.h>
 #include <asm/byteorder.h>
 #include <asm/errno.h>
 #include <asm/param.h>
-#include <asm/scatterlist.h>
 #include <asm/system.h>
 #include <asm/types.h>
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 8939e61050..5a7eb65018 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -102,6 +102,8 @@ static void combine_restrictions_low(struct io_restrictions *lhs,
        lhs->seg_boundary_mask =
                min_not_zero(lhs->seg_boundary_mask, rhs->seg_boundary_mask);
+        lhs->bounce_pfn = min_not_zero(lhs->bounce_pfn, rhs->bounce_pfn);
        lhs->no_cluster |= rhs->no_cluster;
 }
@@ -566,6 +568,8 @@ void dm_set_device_limits(struct dm_target *ti, struct block_device *bdev)
                min_not_zero(rs->seg_boundary_mask,
                             q->seg_boundary_mask);
+        rs->bounce_pfn = min_not_zero(rs->bounce_pfn, q->bounce_pfn);
        rs->no_cluster |= !test_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags);
 }
 EXPORT_SYMBOL_GPL(dm_set_device_limits);
@@ -707,6 +711,8 @@ static void check_for_valid_limits(struct io_restrictions *rs)
                rs->max_segment_size = MAX_SEGMENT_SIZE;
        if (!rs->seg_boundary_mask)
                rs->seg_boundary_mask = -1;
+        if (!rs->bounce_pfn)
+                rs->bounce_pfn = -1;
 }
 int dm_table_add_target(struct dm_table *t, const char *type,
@@ -891,6 +897,7 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q)
        q->hardsect_size = t->limits.hardsect_size;
        q->max_segment_size = t->limits.max_segment_size;
        q->seg_boundary_mask = t->limits.seg_boundary_mask;
+        q->bounce_pfn = t->limits.bounce_pfn;
        if (t->limits.no_cluster)
                q->queue_flags &= ~(1 << QUEUE_FLAG_CLUSTER);
        else
diff --git a/drivers/media/video/bt8xx/bttvp.h b/drivers/media/video/bt8xx/bttvp.h
index 0b92c35a84..d4ac4c4b49 100644
--- a/drivers/media/video/bt8xx/bttvp.h
+++ b/drivers/media/video/bt8xx/bttvp.h
@@ -36,7 +36,7 @@
 #include <linux/pci.h>
 #include <linux/input.h>
 #include <linux/mutex.h>
-#include <asm/scatterlist.h>
+#include <linux/scatterlist.h>
 #include <asm/io.h>
 #include <media/v4l2-common.h>
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 09435e0ec6..b96667448e 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -19,7 +19,6 @@
 #include <linux/pagemap.h>
 #include <linux/err.h>
 #include <linux/leds.h>
-#include <asm/scatterlist.h>
 #include <linux/scatterlist.h>
 #include <linux/mmc/card.h>
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index 7471d49909..64b05c6270 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -10,7 +10,6 @@
 */
 #include <linux/types.h>
-#include <asm/scatterlist.h>
 #include <linux/scatterlist.h>
 #include <linux/mmc/host.h>
diff --git a/drivers/mmc/core/sd_ops.c b/drivers/mmc/core/sd_ops.c
index a6dafe62b9..0d96080d44 100644
--- a/drivers/mmc/core/sd_ops.c
+++ b/drivers/mmc/core/sd_ops.c
@@ -10,7 +10,6 @@
 */
 #include <linux/types.h>
-#include <asm/scatterlist.h>
 #include <linux/scatterlist.h>
 #include <linux/mmc/host.h>
diff --git a/drivers/mmc/core/sdio_ops.c b/drivers/mmc/core/sdio_ops.c
index 4d289b2750..e1fca588e3 100644
--- a/drivers/mmc/core/sdio_ops.c
+++ b/drivers/mmc/core/sdio_ops.c
@@ -9,7 +9,6 @@
 * your option) any later version.
 */
-#include <asm/scatterlist.h>
 #include <linux/scatterlist.h>
 #include <linux/mmc/host.h>
diff --git a/drivers/net/meth.c b/drivers/net/meth.c
index e25dbab673..0c89b028a8 100644
--- a/drivers/net/meth.c
+++ b/drivers/net/meth.c
@@ -33,7 +33,6 @@
 #include <asm/ip32/ip32_ints.h>
 #include <asm/io.h>
-#include <asm/scatterlist.h>
 #include "meth.h"
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index e3fe83a23c..29cf1457ca 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -120,7 +120,8 @@ static int cmos_read_alarm(struct device *dev, struct rtc_wkalrm *t)
        t->time.tm_hour = CMOS_READ(RTC_HOURS_ALARM);
        if (cmos->day_alrm) {
-                t->time.tm_mday = CMOS_READ(cmos->day_alrm);
+                /* ignore upper bits on readback per ACPI spec */
+                t->time.tm_mday = CMOS_READ(cmos->day_alrm) & 0x3f;
                if (!t->time.tm_mday)
                        t->time.tm_mday = -1;
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c
index 22d91ee173..5f2396c039 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.c
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.c
@@ -556,7 +556,7 @@ static int ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct,
                                   unsigned long timeout)
 {
        u64 *crq_as_u64 = (u64 *) &evt_struct->crq;
-        int request_status;
+        int request_status = 0;
        int rc;
        /* If we have exhausted our request limit, just fail this request,
@@ -574,6 +574,13 @@ static int ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct,
                if (request_status < -1)
                        goto send_error;
                /* Otherwise, we may have run out of requests. */
+                /* If request limit was 0 when we started the adapter is in the
+                 * process of performing a login with the server adapter, or
+                 * we may have run out of requests.
+                 */
+                else if (request_status == -1 &&
+                         evt_struct->iu.srp.login_req.opcode != SRP_LOGIN_REQ)
+                        goto send_busy;
                /* Abort and reset calls should make it through.
                 * Nothing except abort and reset should use the last two
                 * slots unless we had two or less to begin with.
@@ -633,7 +640,8 @@ static int ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct,
        unmap_cmd_data(&evt_struct->iu.srp.cmd, evt_struct, hostdata->dev);
        free_event_struct(&hostdata->pool, evt_struct);
-        atomic_inc(&hostdata->request_limit);
+        if (request_status != -1)
+                atomic_inc(&hostdata->request_limit);
        return SCSI_MLQUEUE_HOST_BUSY;
 send_error:
@@ -927,10 +935,11 @@ static int send_srp_login(struct ibmvscsi_host_data *hostdata)
        login->req_buf_fmt = SRP_BUF_FORMAT_DIRECT | SRP_BUF_FORMAT_INDIRECT;
        
        spin_lock_irqsave(hostdata->host->host_lock, flags);
-        /* Start out with a request limit of 1, since this is negotiated in
+        /* Start out with a request limit of 0, since this is negotiated in
-         * the login request we are just sending
+         * the login request we are just sending and login requests always
+         * get sent by the driver regardless of request_limit.
         */
-        atomic_set(&hostdata->request_limit, 1);
+        atomic_set(&hostdata->request_limit, 0);
        rc = ibmvscsi_send_srp_event(evt_struct, hostdata, init_timeout * 2);
        spin_unlock_irqrestore(hostdata->host->host_lock, flags);
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index c0755565fa..4e46045dea 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -682,6 +682,7 @@ lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
        IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
        struct lpfc_iocbq *piocbq = &(lpfc_cmd->cur_iocbq);
        int datadir = scsi_cmnd->sc_data_direction;
+        char tag[2];
        lpfc_cmd->fcp_rsp->rspSnsLen = 0;
        /* clear task management bits */
@@ -692,8 +693,8 @@ lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
        memcpy(&fcp_cmnd->fcpCdb[0], scsi_cmnd->cmnd, 16);
-        if (scsi_cmnd->device->tagged_supported) {
+        if (scsi_populate_tag_msg(scsi_cmnd, tag)) {
-                switch (scsi_cmnd->tag) {
+                switch (tag[0]) {
                case HEAD_OF_QUEUE_TAG:
                        fcp_cmnd->fcpCntl1 = HEAD_OF_Q;
                        break;
diff --git a/drivers/scsi/osst.c b/drivers/scsi/osst.c
index 4652ad2251..abef7048f2 100644
--- a/drivers/scsi/osst.c
+++ b/drivers/scsi/osst.c
@@ -593,10 +593,11 @@ static int osst_verify_frame(struct osst_tape * STp, int frame_seq_number, int q
        if (aux->frame_type != OS_FRAME_TYPE_DATA &&
            aux->frame_type != OS_FRAME_TYPE_EOD &&
            aux->frame_type != OS_FRAME_TYPE_MARKER) {
-                if (!quiet)
+                if (!quiet) {
 #if DEBUG
                        printk(OSST_DEB_MSG "%s:D: Skipping frame, frame type %x\n", name, aux->frame_type);
 #endif
+                }
                goto err_out;
        }
        if (aux->frame_type == OS_FRAME_TYPE_EOD &&
@@ -606,11 +607,12 @@ static int osst_verify_frame(struct osst_tape * STp, int frame_seq_number, int q
                goto err_out;
        }
        if (frame_seq_number != -1 && ntohl(aux->frame_seq_num) != frame_seq_number) {
-                if (!quiet)
+                if (!quiet) {
 #if DEBUG
                        printk(OSST_DEB_MSG "%s:D: Skipping frame, sequence number %u (expected %d)\n", 
                                            name, ntohl(aux->frame_seq_num), frame_seq_number);
 #endif
+                }
                goto err_out;
        }
        if (aux->frame_type == OS_FRAME_TYPE_MARKER) {
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 61fdaf02f2..0e81e4cf88 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -785,7 +785,7 @@ struct scatterlist *scsi_alloc_sgtable(struct scsi_cmnd *cmd, gfp_t gfp_mask)
                 * end-of-list
                 */
                if (!left)
-                        sg_mark_end(sgl, this);
+                        sg_mark_end(&sgl[this - 1]);
                /*
                 * don't allow subsequent mempool allocs to sleep, it would
@@ -2115,6 +2115,142 @@ scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state)
 EXPORT_SYMBOL(scsi_device_set_state);
 /**
+ *      sdev_evt_emit - emit a single SCSI device uevent
+ *      @sdev: associated SCSI device
+ *      @evt: event to emit
+ *
+ *      Send a single uevent (scsi_event) to the associated scsi_device.
+ */
+static void scsi_evt_emit(struct scsi_device *sdev, struct scsi_event *evt)
+{
+        int idx = 0;
+        char *envp[3];
+        switch (evt->evt_type) {
+        case SDEV_EVT_MEDIA_CHANGE:
+                envp[idx++] = "SDEV_MEDIA_CHANGE=1";
+                break;
+        default:
+                /* do nothing */
+                break;
+        }
+        envp[idx++] = NULL;
+        kobject_uevent_env(&sdev->sdev_gendev.kobj, KOBJ_CHANGE, envp);
+}
+/**
+ *      sdev_evt_thread - send a uevent for each scsi event
+ *      @work: work struct for scsi_device
+ *
+ *      Dispatch queued events to their associated scsi_device kobjects
+ *      as uevents.
+ */
+void scsi_evt_thread(struct work_struct *work)
+{
+        struct scsi_device *sdev;
+        LIST_HEAD(event_list);
+        sdev = container_of(work, struct scsi_device, event_work);
+        while (1) {
+                struct scsi_event *evt;
+                struct list_head *this, *tmp;
+                unsigned long flags;
+                spin_lock_irqsave(&sdev->list_lock, flags);
+                list_splice_init(&sdev->event_list, &event_list);
+                spin_unlock_irqrestore(&sdev->list_lock, flags);
+                if (list_empty(&event_list))
+                        break;
+                list_for_each_safe(this, tmp, &event_list) {
+                        evt = list_entry(this, struct scsi_event, node);
+                        list_del(&evt->node);
+                        scsi_evt_emit(sdev, evt);
+                        kfree(evt);
+                }
+        }
+}
+/**
+ *      sdev_evt_send - send asserted event to uevent thread
+ *      @sdev: scsi_device event occurred on
+ *      @evt: event to send
+ *
+ *      Assert scsi device event asynchronously.
+ */
+void sdev_evt_send(struct scsi_device *sdev, struct scsi_event *evt)
+{
+        unsigned long flags;
+        if (!test_bit(evt->evt_type, sdev->supported_events)) {
+                kfree(evt);
+                return;
+        }
+        spin_lock_irqsave(&sdev->list_lock, flags);
+        list_add_tail(&evt->node, &sdev->event_list);
+        schedule_work(&sdev->event_work);
+        spin_unlock_irqrestore(&sdev->list_lock, flags);
+}
+EXPORT_SYMBOL_GPL(sdev_evt_send);
+/**
+ *      sdev_evt_alloc - allocate a new scsi event
+ *      @evt_type: type of event to allocate
+ *      @gfpflags: GFP flags for allocation
+ *
+ *      Allocates and returns a new scsi_event.
+ */
+struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,
+                                  gfp_t gfpflags)
+{
+        struct scsi_event *evt = kzalloc(sizeof(struct scsi_event), gfpflags);
+        if (!evt)
+                return NULL;
+        evt->evt_type = evt_type;
+        INIT_LIST_HEAD(&evt->node);
+        /* evt_type-specific initialization, if any */
+        switch (evt_type) {
+        case SDEV_EVT_MEDIA_CHANGE:
+        default:
+                /* do nothing */
+                break;
+        }
+        return evt;
+}
+EXPORT_SYMBOL_GPL(sdev_evt_alloc);
+/**
+ *      sdev_evt_send_simple - send asserted event to uevent thread
+ *      @sdev: scsi_device event occurred on
+ *      @evt_type: type of event to send
+ *      @gfpflags: GFP flags for allocation
+ *
+ *      Assert scsi device event asynchronously, given an event type.
+ */
+void sdev_evt_send_simple(struct scsi_device *sdev,
+                          enum scsi_device_event evt_type, gfp_t gfpflags)
+{
+        struct scsi_event *evt = sdev_evt_alloc(evt_type, gfpflags);
+        if (!evt) {
+                sdev_printk(KERN_ERR, sdev, "event %d eaten due to OOM\n",
+                            evt_type);
+                return;
+        }
+        sdev_evt_send(sdev, evt);
+}
+EXPORT_SYMBOL_GPL(sdev_evt_send_simple);
+/**
 *      scsi_device_quiesce - Block user issued commands.
 *      @sdev:  scsi device to quiesce.
 *
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index b53c5f67e3..40ea71cd2c 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -236,6 +236,7 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
        struct scsi_device *sdev;
        int display_failure_msg = 1, ret;
        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
+        extern void scsi_evt_thread(struct work_struct *work);
        sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,
                       GFP_ATOMIC);
@@ -254,7 +255,9 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
        INIT_LIST_HEAD(&sdev->same_target_siblings);
        INIT_LIST_HEAD(&sdev->cmd_list);
        INIT_LIST_HEAD(&sdev->starved_entry);
+        INIT_LIST_HEAD(&sdev->event_list);
        spin_lock_init(&sdev->list_lock);
+        INIT_WORK(&sdev->event_work, scsi_evt_thread);
        sdev->sdev_gendev.parent = get_device(&starget->dev);
        sdev->sdev_target = starget;
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index d531ceeb0d..f374fdcb68 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -268,6 +268,7 @@ static void scsi_device_dev_release_usercontext(struct work_struct *work)
        struct scsi_device *sdev;
        struct device *parent;
        struct scsi_target *starget;
+        struct list_head *this, *tmp;
        unsigned long flags;
        sdev = container_of(work, struct scsi_device, ew.work);
@@ -282,6 +283,16 @@ static void scsi_device_dev_release_usercontext(struct work_struct *work)
        list_del(&sdev->starved_entry);
        spin_unlock_irqrestore(sdev->host->host_lock, flags);
+        cancel_work_sync(&sdev->event_work);
+        list_for_each_safe(this, tmp, &sdev->event_list) {
+                struct scsi_event *evt;
+                evt = list_entry(this, struct scsi_event, node);
+                list_del(&evt->node);
+                kfree(evt);
+        }
        if (sdev->request_queue) {
                sdev->request_queue->queuedata = NULL;
                /* user context needed to free queue */
@@ -614,6 +625,41 @@ sdev_show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
 }
 static DEVICE_ATTR(modalias, S_IRUGO, sdev_show_modalias, NULL);
+#define DECLARE_EVT_SHOW(name, Cap_name)                                \
+static ssize_t                                                          \
+sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \
+                                char *buf)                              \
+{                                                                       \
+        struct scsi_device *sdev = to_scsi_device(dev);                 \
+        int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\
+        return snprintf(buf, 20, "%d\n", val);                          \
+}
+#define DECLARE_EVT_STORE(name, Cap_name)                               \
+static ssize_t                                                          \
+sdev_store_evt_##name(struct device *dev, struct device_attribute *attr, \
+                      const char *buf, size_t count)                    \
+{                                                                       \
+        struct scsi_device *sdev = to_scsi_device(dev);                 \
+        int val = simple_strtoul(buf, NULL, 0);                         \
+        if (val == 0)                                                   \
+                clear_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \
+        else if (val == 1)                                              \
+                set_bit(SDEV_EVT_##Cap_name, sdev->supported_events);   \
+        else                                                            \
+                return -EINVAL;                                         \
+        return count;                                                   \
+}
+#define DECLARE_EVT(name, Cap_name)                                     \
+        DECLARE_EVT_SHOW(name, Cap_name)                                \
+        DECLARE_EVT_STORE(name, Cap_name)                               \
+        static DEVICE_ATTR(evt_##name, S_IRUGO, sdev_show_evt_##name,   \
+                           sdev_store_evt_##name);
+#define REF_EVT(name) &dev_attr_evt_##name.attr
+DECLARE_EVT(media_change, MEDIA_CHANGE)
 /* Default template for device attributes.  May NOT be modified */
 static struct attribute *scsi_sdev_attrs[] = {
        &dev_attr_device_blocked.attr,
@@ -631,6 +677,7 @@ static struct attribute *scsi_sdev_attrs[] = {
        &dev_attr_iodone_cnt.attr,
        &dev_attr_ioerr_cnt.attr,
        &dev_attr_modalias.attr,
+        REF_EVT(media_change),
        NULL
 };
diff --git a/drivers/sh/maple/maple.c b/drivers/sh/maple/maple.c
index 161d1021b7..e52a6296ca 100644
--- a/drivers/sh/maple/maple.c
+++ b/drivers/sh/maple/maple.c
@@ -601,8 +601,7 @@ static int match_maple_bus_driver(struct device *devptr,
       return 0;
 }
-static int maple_bus_uevent(struct device *dev, char **envp,
+static int maple_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
-                           int num_envp, char *buffer, int buffer_size)
 {
       return 0;
 }
diff --git a/drivers/usb/core/buffer.c b/drivers/usb/core/buffer.c
index ead2475406..28d4972f7a 100644
--- a/drivers/usb/core/buffer.c
+++ b/drivers/usb/core/buffer.c
@@ -11,7 +11,6 @@
 #include <linux/device.h>
 #include <linux/mm.h>
 #include <asm/io.h>
-#include <asm/scatterlist.h>
 #include <linux/dma-mapping.h>
 #include <linux/dmapool.h>
 #include <linux/usb.h>
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 3dd997df85..fea8256a18 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -30,7 +30,6 @@
 #include <linux/utsname.h>
 #include <linux/mm.h>
 #include <asm/io.h>
-#include <asm/scatterlist.h>
 #include <linux/device.h>
 #include <linux/dma-mapping.h>
 #include <linux/mutex.h>
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 69aa68287d..c4a6f1095b 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -36,7 +36,7 @@
 #include <linux/workqueue.h>
 #include <asm/io.h>
-#include <asm/scatterlist.h>
+#include <linux/scatterlist.h>
 #include <linux/mm.h>
 #include <linux/dma-mapping.h>