4 files changed, 140 insertions, 29 deletions

diff --git a/drivers/usb/storage/Kconfig b/drivers/usb/storage/Kconfig
index bedc4b9f2ac4..fe2d803a6347 100644
--- a/drivers/usb/storage/Kconfig
+++ b/drivers/usb/storage/Kconfig
@@ -42,7 +42,7 @@ config USB_STORAGE_REALTEK
 
 config REALTEK_AUTOPM
         bool "Realtek Card Reader autosuspend support"
-        depends on USB_STORAGE_REALTEK && CONFIG_PM_RUNTIME
+        depends on USB_STORAGE_REALTEK && PM_RUNTIME
         default y
 
 config USB_STORAGE_DATAFAB
diff --git a/drivers/usb/storage/realtek_cr.c b/drivers/usb/storage/realtek_cr.c
index 34adc4b42ceb..0ce5f79197e7 100644
--- a/drivers/usb/storage/realtek_cr.c
+++ b/drivers/usb/storage/realtek_cr.c
@@ -25,7 +25,6 @@
 #include <linux/kthread.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
-#include <linux/version.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -293,6 +292,52 @@ static int rts51x_bulk_transport(struct us_data *us, u8 lun,
         return USB_STOR_TRANSPORT_ERROR;
 }
 
+static int rts51x_bulk_transport_special(struct us_data *us, u8 lun,
+                                 u8 *cmd, int cmd_len, u8 *buf, int buf_len,
+                                 enum dma_data_direction dir, int *act_len)
+{
+        struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
+        struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
+        int result;
+        unsigned int cswlen;
+        unsigned int cbwlen = US_BULK_CB_WRAP_LEN;
+
+        /* set up the command wrapper */
+        bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
+        bcb->DataTransferLength = cpu_to_le32(buf_len);
+        bcb->Flags = (dir == DMA_FROM_DEVICE) ? 1 << 7 : 0;
+        bcb->Tag = ++us->tag;
+        bcb->Lun = lun;
+        bcb->Length = cmd_len;
+
+        /* copy the command payload */
+        memset(bcb->CDB, 0, sizeof(bcb->CDB));
+        memcpy(bcb->CDB, cmd, bcb->Length);
+
+        /* send it to out endpoint */
+        result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
+                                bcb, cbwlen, NULL);
+        if (result != USB_STOR_XFER_GOOD)
+                return USB_STOR_TRANSPORT_ERROR;
+
+        /* DATA STAGE */
+        /* send/receive data payload, if there is any */
+
+        if (buf && buf_len) {
+                unsigned int pipe = (dir == DMA_FROM_DEVICE) ?
+                                us->recv_bulk_pipe : us->send_bulk_pipe;
+                result = usb_stor_bulk_transfer_buf(us, pipe,
+                                buf, buf_len, NULL);
+                if (result == USB_STOR_XFER_ERROR)
+                        return USB_STOR_TRANSPORT_ERROR;
+        }
+
+        /* get CSW for device status */
+        result = usb_bulk_msg(us->pusb_dev, us->recv_bulk_pipe, bcs,
+                        US_BULK_CS_WRAP_LEN, &cswlen, 250);
+        return result;
+}
+
 /* Determine what the maximum LUN supported is */
 static int rts51x_get_max_lun(struct us_data *us)
 {
@@ -320,6 +365,11 @@ static int rts51x_read_mem(struct us_data *us, u16 addr, u8 *data, u16 len)
 {
         int retval;
         u8 cmnd[12] = { 0 };
+        u8 *buf;
+
+        buf = kmalloc(len, GFP_NOIO);
+        if (buf == NULL)
+                return USB_STOR_TRANSPORT_ERROR;
 
         US_DEBUGP("%s, addr = 0x%x, len = %d\n", __func__, addr, len);
 
@@ -331,10 +381,14 @@ static int rts51x_read_mem(struct us_data *us, u16 addr, u8 *data, u16 len)
         cmnd[5] = (u8) len;
 
         retval = rts51x_bulk_transport(us, 0, cmnd, 12,
-                                       data, len, DMA_FROM_DEVICE, NULL);
-        if (retval != USB_STOR_TRANSPORT_GOOD)
+                                       buf, len, DMA_FROM_DEVICE, NULL);
+        if (retval != USB_STOR_TRANSPORT_GOOD) {
+                kfree(buf);
                 return -EIO;
+        }
 
+        memcpy(data, buf, len);
+        kfree(buf);
         return 0;
 }
 
@@ -342,6 +396,12 @@ static int rts51x_write_mem(struct us_data *us, u16 addr, u8 *data, u16 len)
 {
         int retval;
         u8 cmnd[12] = { 0 };
+        u8 *buf;
+
+        buf = kmalloc(len, GFP_NOIO);
+        if (buf == NULL)
+                return USB_STOR_TRANSPORT_ERROR;
+        memcpy(buf, data, len);
 
         US_DEBUGP("%s, addr = 0x%x, len = %d\n", __func__, addr, len);
 
@@ -353,7 +413,8 @@ static int rts51x_write_mem(struct us_data *us, u16 addr, u8 *data, u16 len)
         cmnd[5] = (u8) len;
 
         retval = rts51x_bulk_transport(us, 0, cmnd, 12,
-                                       data, len, DMA_TO_DEVICE, NULL);
+                                       buf, len, DMA_TO_DEVICE, NULL);
+        kfree(buf);
         if (retval != USB_STOR_TRANSPORT_GOOD)
                 return -EIO;
 
@@ -365,6 +426,11 @@ static int rts51x_read_status(struct us_data *us,
 {
         int retval;
         u8 cmnd[12] = { 0 };
+        u8 *buf;
+
+        buf = kmalloc(len, GFP_NOIO);
+        if (buf == NULL)
+                return USB_STOR_TRANSPORT_ERROR;
 
         US_DEBUGP("%s, lun = %d\n", __func__, lun);
 
@@ -372,10 +438,14 @@ static int rts51x_read_status(struct us_data *us,
         cmnd[1] = 0x09;
 
         retval = rts51x_bulk_transport(us, lun, cmnd, 12,
-                                       status, len, DMA_FROM_DEVICE, actlen);
-        if (retval != USB_STOR_TRANSPORT_GOOD)
+                                       buf, len, DMA_FROM_DEVICE, actlen);
+        if (retval != USB_STOR_TRANSPORT_GOOD) {
+                kfree(buf);
                 return -EIO;
+        }
 
+        memcpy(status, buf, len);
+        kfree(buf);
         return 0;
 }
 
@@ -434,6 +504,29 @@ static int enable_oscillator(struct us_data *us)
         return 0;
 }
 
+static int __do_config_autodelink(struct us_data *us, u8 *data, u16 len)
+{
+        int retval;
+        u16 addr = 0xFE47;
+        u8 cmnd[12] = {0};
+
+        US_DEBUGP("%s, addr = 0x%x, len = %d\n", __FUNCTION__, addr, len);
+
+        cmnd[0] = 0xF0;
+        cmnd[1] = 0x0E;
+        cmnd[2] = (u8)(addr >> 8);
+        cmnd[3] = (u8)addr;
+        cmnd[4] = (u8)(len >> 8);
+        cmnd[5] = (u8)len;
+
+        retval = rts51x_bulk_transport_special(us, 0, cmnd, 12, data, len, DMA_TO_DEVICE, NULL);
+        if (retval != USB_STOR_TRANSPORT_GOOD) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
 static int do_config_autodelink(struct us_data *us, int enable, int force)
 {
         int retval;
@@ -454,7 +547,8 @@ static int do_config_autodelink(struct us_data *us, int enable, int force)
 
         US_DEBUGP("In %s,set 0xfe47 to 0x%x\n", __func__, value);
 
-        retval = rts51x_write_mem(us, 0xFE47, &value, 1);
+        /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */
+        retval = __do_config_autodelink(us, &value, 1);
         if (retval < 0)
                 return -EIO;
 
@@ -486,7 +580,8 @@ static int config_autodelink_after_power_on(struct us_data *us)
 
                 SET_BIT(value, 7);
 
-                retval = rts51x_write_mem(us, 0xFE47, &value, 1);
+                /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */
+                retval = __do_config_autodelink(us, &value, 1);
                 if (retval < 0)
                         return -EIO;
 
@@ -507,7 +602,8 @@ static int config_autodelink_after_power_on(struct us_data *us)
                         CLR_BIT(value, 7);
                 }
 
-                retval = rts51x_write_mem(us, 0xFE47, &value, 1);
+                /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */
+                retval = __do_config_autodelink(us, &value, 1);
                 if (retval < 0)
                         return -EIO;
 
@@ -584,7 +680,8 @@ static int config_autodelink_before_power_down(struct us_data *us)
                         if (CHECK_ID(chip, 0x0138, 0x3882))
                                 SET_BIT(value, 2);
 
-                        retval = rts51x_write_mem(us, 0xFE47, &value, 1);
+                        /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */
+                        retval = __do_config_autodelink(us, &value, 1);
                         if (retval < 0)
                                 return -EIO;
                 }
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index e8ae21b2d387..ff32390d61e5 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -691,6 +691,9 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
                 int temp_result;
                 struct scsi_eh_save ses;
                 int sense_size = US_SENSE_SIZE;
+                struct scsi_sense_hdr sshdr;
+                const u8 *scdd;
+                u8 fm_ili;
 
                 /* device supports and needs bigger sense buffer */
                 if (us->fflags & US_FL_SANE_SENSE)
@@ -774,32 +777,30 @@ Retry_Sense:
                         srb->sense_buffer[7] = (US_SENSE_SIZE - 8);
                 }
 
+                scsi_normalize_sense(srb->sense_buffer, SCSI_SENSE_BUFFERSIZE,
+                                     &sshdr);
+
                 US_DEBUGP("-- Result from auto-sense is %d\n", temp_result);
                 US_DEBUGP("-- code: 0x%x, key: 0x%x, ASC: 0x%x, ASCQ: 0x%x\n",
-                          srb->sense_buffer[0],
-                          srb->sense_buffer[2] & 0xf,
-                          srb->sense_buffer[12], 
-                          srb->sense_buffer[13]);
+                          sshdr.response_code, sshdr.sense_key,
+                          sshdr.asc, sshdr.ascq);
 #ifdef CONFIG_USB_STORAGE_DEBUG
-                usb_stor_show_sense(
-                          srb->sense_buffer[2] & 0xf,
-                          srb->sense_buffer[12], 
-                          srb->sense_buffer[13]);
+                usb_stor_show_sense(sshdr.sense_key, sshdr.asc, sshdr.ascq);
 #endif
 
                 /* set the result so the higher layers expect this data */
                 srb->result = SAM_STAT_CHECK_CONDITION;
 
+                scdd = scsi_sense_desc_find(srb->sense_buffer,
+                                            SCSI_SENSE_BUFFERSIZE, 4);
+                fm_ili = (scdd ? scdd[3] : srb->sense_buffer[2]) & 0xA0;
+
                 /* We often get empty sense data.  This could indicate that
                  * everything worked or that there was an unspecified
                  * problem.  We have to decide which.
                  */
-                if (    /* Filemark 0, ignore EOM, ILI 0, no sense */
-                                (srb->sense_buffer[2] & 0xaf) == 0 &&
-                        /* No ASC or ASCQ */
-                                srb->sense_buffer[12] == 0 &&
-                                srb->sense_buffer[13] == 0) {
-
+                if (sshdr.sense_key == 0 && sshdr.asc == 0 && sshdr.ascq == 0 &&
+                    fm_ili == 0) {
                         /* If things are really okay, then let's show that.
                          * Zero out the sense buffer so the higher layers
                          * won't realize we did an unsolicited auto-sense.
@@ -814,7 +815,10 @@ Retry_Sense:
                          */
                         } else {
                                 srb->result = DID_ERROR << 16;
-                                srb->sense_buffer[2] = HARDWARE_ERROR;
+                                if ((sshdr.response_code & 0x72) == 0x72)
+                                        srb->sense_buffer[1] = HARDWARE_ERROR;
+                                else
+                                        srb->sense_buffer[2] = HARDWARE_ERROR;
                         }
                 }
         }
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index 0ca095820f3e..c325e69415a1 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -831,12 +831,22 @@ static int usb_stor_scan_thread(void * __us)
 
         dev_dbg(dev, "device found\n");
 
-        set_freezable();
-        /* Wait for the timeout to expire or for a disconnect */
+        set_freezable_with_signal();
+        /*
+         * Wait for the timeout to expire or for a disconnect
+         *
+         * We can't freeze in this thread or we risk causing khubd to
+         * fail to freeze, but we can't be non-freezable either. Nor can
+         * khubd freeze while waiting for scanning to complete as it may
+         * hold the device lock, causing a hang when suspending devices.
+         * So we request a fake signal when freezing and use
+         * interruptible sleep to kick us out of our wait early when
+         * freezing happens.
+         */
         if (delay_use > 0) {
                 dev_dbg(dev, "waiting for device to settle "
                                 "before scanning\n");
-                wait_event_freezable_timeout(us->delay_wait,
+                wait_event_interruptible_timeout(us->delay_wait,
                                 test_bit(US_FLIDX_DONT_SCAN, &us->dflags),
                                 delay_use * HZ);
         }