Version 1.02 of the Realtek USB card reader driver fixes the lsusb hang.

drivers/usb/storage/realtek_cr.c

 /* Driver for Realtek RTS51xx USB card reader
  *
  * Copyright(c) 2009 Realtek Semiconductor Corp. All rights reserved.  
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
  * Free Software Foundation; either version 2, or (at your option) any
  * later version.
  *
  * This program is distributed in the hope that it will be useful, but
@@ skipping 26 matching lines @@
 #include <linux/usb_usual.h>
 
 #include "usb.h"
 #include "transport.h"
 #include "protocol.h"
 #include "debug.h"
 
 MODULE_DESCRIPTION("Driver for Realtek USB Card Reader");
 MODULE_AUTHOR("wwang <wei_wang@realsil.com.cn>");
 MODULE_LICENSE("GPL");
+MODULE_VERSION("1.02");
 
 static int ss_en = 1;
 module_param(ss_en, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(ss_en, "enable selective suspend");
 
-static int ss_delay = 20;
+static int ss_delay = 50;
 module_param(ss_delay, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(ss_delay, "seconds to delay before entering selective suspend");
 
 static int needs_remote_wakeup = 0;
 module_param(needs_remote_wakeup, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(needs_remote_wakeup, "ss state needs remote wakeup supported");
 
 static int auto_delink_en = 1;
 module_param(auto_delink_en, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(auto_delink_en, "enable auto delink");
 
-enum CHIP_STAT  {STAT_INIT, STAT_IDLE, STAT_RUN, STAT_SS_PRE, STAT_SS};
+enum CHIP_STAT  {STAT_INIT, STAT_IDLE, STAT_RUN, STAT_SS_PRE, STAT_SS, STAT_SUSPEND};
 
 struct rts51x_status {
         u16 vid;
         u16 pid;
         u8 cur_lun;
         u8 card_type;
         u8 total_lun;
         u16 fw_ver;
         u8 phy_exist;
         u8 multi_flag;
         u8 multi_card;
         u8 log_exist;
         union {
                 u8 detailed_type1;
                 u8 detailed_type2;
         } detailed_type;
         u8 function[2];
 };
 
 struct rts51x_chip {
         u16                     vendor_id;
         u16                     product_id;
         char                    max_lun;
         
         int                     ss_counter;
         int                     idle_counter;
         enum CHIP_STAT          chip_stat;
         
+        int                     resume_from_scsi;
+        
         struct rts51x_status    *status;
         int                     status_len;
         u8                      lun_ready;
         
         u32                     flag;
         
         struct task_struct      *polling_thread; /* the polling thread   */
 };
 
 // flag definition
@@ skipping 312 matching lines @@
 {
         struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
         int retval;
         u8 buf[16];
         
         retval = rts51x_read_status(us, lun, buf, 16, &(chip->status_len));
         if (retval < 0) {
                 return -EIO;
         }
         
+        US_DEBUGP("chip->status_len = %d\n", chip->status_len);
+        
         chip->status[lun].vid = ((u16)buf[0] << 8) | buf[1];
         chip->status[lun].pid = ((u16)buf[2] << 8) | buf[3];
         chip->status[lun].cur_lun = buf[4];
         chip->status[lun].card_type = buf[5];
         chip->status[lun].total_lun = buf[6];
         chip->status[lun].fw_ver = ((u16)buf[7] << 8) | buf[8];
         chip->status[lun].phy_exist = buf[9];
         chip->status[lun].multi_flag = buf[10];
         chip->status[lun].multi_card = buf[11];
         chip->status[lun].log_exist = buf[12];
@@ skipping 213 matching lines @@
                         }
                 }
         }
         
         return 0;
 }
 
 static void rts51x_polling_func(struct us_data *us)
 {
         struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
+                        
+        /* lock the device pointers */
+        mutex_lock(&(us->dev_mutex));
         
         if (RTS51X_CHK_STAT(chip, STAT_SS) || RTS51X_CHK_STAT(chip, STAT_SS_PRE)) {
+                /* unlock the device pointers */
+                mutex_unlock(&(us->dev_mutex));
                 return;
         }
 
 #ifdef CONFIG_PM
         if (ss_en) {
                 if (RTS51X_CHK_STAT(chip, STAT_IDLE)) {
                         if (chip->ss_counter < (ss_delay * 1000 / POLLING_INTERVAL)) {
                                 chip->ss_counter ++;
                         } else {
                                 US_DEBUGP("Ready to enter SS state\n");
                                 RTS51X_SET_STAT(chip, STAT_SS_PRE);   // Prepare SS state
+                                
+                                /* unlock the device pointers */
+                                mutex_unlock(&(us->dev_mutex));
                                 usb_autopm_enable(us->pusb_intf);
                                 return;
                         }
                 } else {
                         chip->ss_counter = 0;
                 }
         }
 #endif
         
         if (chip->idle_counter < IDLE_MAX_COUNT) {
                 chip->idle_counter ++;
         } else {
                 if (!RTS51X_CHK_STAT(chip, STAT_IDLE)) {
                         US_DEBUGP("Idle state\n");
                         RTS51X_SET_STAT(chip, STAT_IDLE);
                 }
         }
         
-        switch (RTS51X_GET_STAT(chip)) {
-        case STAT_RUN:
-                break;
-
-        case STAT_IDLE:
-                break;
-
-        default:
-                break;
-        }
+        /* unlock the device pointers */
+        mutex_unlock(&(us->dev_mutex));
 }
 
 static int rts51x_polling_thread(void * __us)
 {
         struct us_data *us = (struct us_data *)__us;
         
         // Wait until SCSI scan finished
         wait_timeout(10 * HZ);
 
         for(;;) {
                 wait_timeout(POLLING_INTERVAL);
                 
                 /* if the device has disconnected, we are free to exit */
                 if (kthread_should_stop()) {
                         printk(KERN_INFO "Stop polling thread!\n");
                         break;
                 }
                 
-                /* lock the device pointers */
-                mutex_lock(&(us->dev_mutex));
-                
                 rts51x_polling_func(us);
-                
-                /* unlock the device pointers */
-                mutex_unlock(&(us->dev_mutex));
+
         } /* for (;;) */
 
         __set_current_state(TASK_RUNNING);
         return 0;
 }
 
 #ifdef CONFIG_PM
-static void rts51x_handle_pm(struct us_data *us, int pwr_state)
+int realtek_cr_suspend(struct usb_interface *iface, pm_message_t message)
 {
+        struct us_data *us = usb_get_intfdata(iface);
         struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
+
+        US_DEBUGP("%s, message.event = 0x%x\n", __func__, message.event);
         
-        US_DEBUGP("Handle pm state: %s\n", pwr_state ? "resume" : "suspend");
+        /* Wait until no command is running */
+        mutex_lock(&us->dev_mutex);
+        
+        if (message.event == PM_EVENT_AUTO_SUSPEND) {
+                US_DEBUGP("Enter SS state");
+                chip->resume_from_scsi = 0;
+                RTS51X_SET_STAT(chip, STAT_SS);
+        } else {
+                US_DEBUGP("Enter SUSPEND state");
+                RTS51X_SET_STAT(chip, STAT_SUSPEND);
+        }
+        (void)config_autodelink_before_power_down(us);
 
-        if (pwr_state == US_RESUME) {
+        /* When runtime PM is working, we'll set a flag to indicate
+        * whether we should autoresume when a SCSI request arrives. */
+
+        mutex_unlock(&us->dev_mutex);
+
+        return 0;
+}
+
+int realtek_cr_resume(struct usb_interface *iface)
+{
+        struct us_data *us = usb_get_intfdata(iface);
+        struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
+
+        US_DEBUGP("%s\n", __func__);
+        
+        if (!RTS51X_CHK_STAT(chip, STAT_SS) || !chip->resume_from_scsi) {
+                mutex_lock(&us->dev_mutex);
+
                 if (GET_PM_USAGE_CNT(us) <= 0) {
                         // Remote wake up, increase pm_usage_cnt
                         US_DEBUGP("Incr pm_usage_cnt\n");
                         SET_PM_USAGE_CNT(us, 1);
-                        RTS51X_SET_STAT(chip, STAT_RUN);
                 }
-                
+
                 (void)config_autodelink_after_power_on(us);
-        } else {
-                if (RTS51X_CHK_STAT(chip, STAT_SS_PRE)) {
-                        US_DEBUGP("Enter SS state");
-                        RTS51X_SET_STAT(chip, STAT_SS);
-                }
-                
-                (void)config_autodelink_before_power_down(us);
+
+                RTS51X_SET_STAT(chip, STAT_RUN);
+        
+                mutex_unlock(&us->dev_mutex);
         }
 
-        US_DEBUGP("pm_usage_cnt = %d\n", GET_PM_USAGE_CNT(us));
+        return 0;
 }
 #endif
 
 static void realtek_cr_destructor(void *extra) 
 {
         struct rts51x_chip *chip = (struct rts51x_chip *)extra;
 
         if (!chip)
                 return;
         
@@ skipping 13 matching lines @@
         int size, i, retval;
         struct task_struct *th;
         
         chip = kzalloc(sizeof(struct rts51x_chip), GFP_KERNEL);
         if (!chip)
                 return -ENOMEM;
         
         us->extra = chip;
         us->extra_destructor = realtek_cr_destructor;
         
-#ifdef CONFIG_PM
-        us->suspend_resume_hook = rts51x_handle_pm;
-#endif
-        
         us->max_lun = chip->max_lun = rts51x_get_max_lun(us);
         
         US_DEBUGP("chip->max_lun = %d\n", chip->max_lun);
         
         size = (chip->max_lun + 1) * sizeof(struct rts51x_status);
         chip->status = (struct rts51x_status *)kzalloc(size, GFP_KERNEL);
         if (!chip->status) {
                 goto INIT_FAIL;
         }
         
         for (i = 0; i <= (int)(chip->max_lun); i++) {
                 retval = rts51x_check_status(us, (u8)i);
                 if (retval < 0) {
                         goto INIT_FAIL;
                 }
         }
         
         if (CHECK_FW_VER(chip, 0x5888) || CHECK_FW_VER(chip, 0x5889) || 
                         CHECK_FW_VER(chip, 0x5901)) {
                 SET_AUTO_DELINK(chip);
         }
         if (STATUS_LEN(chip) == 16) {
                 if (SUPPORT_AUTO_DELINK(chip)) {
                         SET_AUTO_DELINK(chip);
                 }
         }
         
+        US_DEBUGP("chip->flag = 0x%x\n", chip->flag);
+        
         (void)config_autodelink_after_power_on(us);
         
 #ifdef CONFIG_PM
         if (ss_en) {
                 us->pusb_intf->needs_remote_wakeup = needs_remote_wakeup;
                 SET_PM_USAGE_CNT(us, 1);
                 US_DEBUGP("pm_usage_cnt = %d\n", GET_PM_USAGE_CNT(us));
         
                 // Enable autosuspend
                 us->pusb_dev->autosuspend_disabled = 0;
@@ skipping 58 matching lines @@
                                 } else {
                                         result = USB_STOR_TRANSPORT_GOOD;
                                 }
                                 
                                 goto FINISH;
                         }
                 } else {
                         if (RTS51X_CHK_STAT(chip, STAT_SS)) {
                                 // Wake up device
                                 US_DEBUGP("Try to wake up device\n");
-                                mutex_unlock(&(us->dev_mutex));
+                                chip->resume_from_scsi = 1;
                                 usb_autopm_disable(us->pusb_intf);
                                 wait_timeout(3000);
-                                mutex_lock(&(us->dev_mutex));
+                                
+                                (void)config_autodelink_after_power_on(us);
                                 rts51x_reset_card(us, lun);
                         }
                         RTS51X_SET_STAT(chip, STAT_RUN);
                 }
         } 
         else 
 #endif
         {
                 RTS51X_SET_STAT(chip, STAT_RUN);
         }
@@ skipping 31 matching lines @@
         us->max_lun = 0;
 
         result = usb_stor_probe2(us);
         return result;
 }
 
 static struct usb_driver realtek_cr_driver = {
         .name =         "ums-realtek",
         .probe =        realtek_cr_probe,
         .disconnect =   usb_stor_disconnect,
-        .suspend =      usb_stor_suspend,
-        .resume =       usb_stor_resume,
+        .suspend =      realtek_cr_suspend,
+        .resume =       realtek_cr_resume,
         .reset_resume = usb_stor_reset_resume,
         .pre_reset =    usb_stor_pre_reset,
         .post_reset =   usb_stor_post_reset,
         .id_table =     realtek_cr_ids,
         .soft_unbind =  1,
 };
 
 static int __init realtek_cr_init(void)
 {
         return usb_register(&realtek_cr_driver);
 }
 
 static void __exit realtek_cr_exit(void)
 {
         usb_deregister(&realtek_cr_driver);
 }
 
 module_init(realtek_cr_init);
 module_exit(realtek_cr_exit);