150a6cb93Swwang /* Driver for Realtek RTS51xx USB card reader 250a6cb93Swwang * 350a6cb93Swwang * Copyright(c) 2009 Realtek Semiconductor Corp. All rights reserved. 450a6cb93Swwang * 550a6cb93Swwang * This program is free software; you can redistribute it and/or modify it 650a6cb93Swwang * under the terms of the GNU General Public License as published by the 750a6cb93Swwang * Free Software Foundation; either version 2, or (at your option) any 850a6cb93Swwang * later version. 950a6cb93Swwang * 1050a6cb93Swwang * This program is distributed in the hope that it will be useful, but 1150a6cb93Swwang * WITHOUT ANY WARRANTY; without even the implied warranty of 1250a6cb93Swwang * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 1350a6cb93Swwang * General Public License for more details. 1450a6cb93Swwang * 1550a6cb93Swwang * You should have received a copy of the GNU General Public License along 1650a6cb93Swwang * with this program; if not, see <http://www.gnu.org/licenses/>. 1750a6cb93Swwang * 1850a6cb93Swwang * Author: 1950a6cb93Swwang * wwang (wei_wang@realsil.com.cn) 2050a6cb93Swwang * No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China 2150a6cb93Swwang */ 2250a6cb93Swwang 2350a6cb93Swwang #include <linux/module.h> 2450a6cb93Swwang #include <linux/blkdev.h> 2550a6cb93Swwang #include <linux/kthread.h> 2650a6cb93Swwang #include <linux/sched.h> 2750a6cb93Swwang #include <linux/kernel.h> 2850a6cb93Swwang 2950a6cb93Swwang #include <scsi/scsi.h> 3050a6cb93Swwang #include <scsi/scsi_cmnd.h> 3150a6cb93Swwang #include <scsi/scsi_device.h> 3250a6cb93Swwang #include <linux/cdrom.h> 3350a6cb93Swwang 3450a6cb93Swwang #include <linux/usb.h> 3550a6cb93Swwang #include <linux/slab.h> 3650a6cb93Swwang #include <linux/usb_usual.h> 3750a6cb93Swwang 3850a6cb93Swwang #include "usb.h" 3950a6cb93Swwang #include "transport.h" 4050a6cb93Swwang #include "protocol.h" 4150a6cb93Swwang #include "debug.h" 4250a6cb93Swwang 4350a6cb93Swwang MODULE_DESCRIPTION("Driver for Realtek USB Card Reader"); 4450a6cb93Swwang MODULE_AUTHOR("wwang <wei_wang@realsil.com.cn>"); 4550a6cb93Swwang MODULE_LICENSE("GPL"); 4650a6cb93Swwang MODULE_VERSION("1.03"); 4750a6cb93Swwang 4850a6cb93Swwang static int auto_delink_en = 1; 4950a6cb93Swwang module_param(auto_delink_en, int, S_IRUGO | S_IWUSR); 5050a6cb93Swwang MODULE_PARM_DESC(auto_delink_en, "enable auto delink"); 5150a6cb93Swwang 52e931830bSedwin_rong #ifdef CONFIG_REALTEK_AUTOPM 53e931830bSedwin_rong static int ss_en = 1; 54e931830bSedwin_rong module_param(ss_en, int, S_IRUGO | S_IWUSR); 55e931830bSedwin_rong MODULE_PARM_DESC(ss_en, "enable selective suspend"); 56e931830bSedwin_rong 57e931830bSedwin_rong static int ss_delay = 50; 58e931830bSedwin_rong module_param(ss_delay, int, S_IRUGO | S_IWUSR); 59e931830bSedwin_rong MODULE_PARM_DESC(ss_delay, 60e931830bSedwin_rong "seconds to delay before entering selective suspend"); 61e931830bSedwin_rong 62e931830bSedwin_rong enum RTS51X_STAT { 63e931830bSedwin_rong RTS51X_STAT_INIT, 64e931830bSedwin_rong RTS51X_STAT_IDLE, 65e931830bSedwin_rong RTS51X_STAT_RUN, 66e931830bSedwin_rong RTS51X_STAT_SS 67e931830bSedwin_rong }; 68e931830bSedwin_rong 69e931830bSedwin_rong #define POLLING_INTERVAL 50 70e931830bSedwin_rong 71e931830bSedwin_rong #define rts51x_set_stat(chip, stat) \ 72e931830bSedwin_rong ((chip)->state = (enum RTS51X_STAT)(stat)) 73e931830bSedwin_rong #define rts51x_get_stat(chip) ((chip)->state) 74e931830bSedwin_rong 75e931830bSedwin_rong #define SET_LUN_READY(chip, lun) ((chip)->lun_ready |= ((u8)1 << (lun))) 76e931830bSedwin_rong #define CLR_LUN_READY(chip, lun) ((chip)->lun_ready &= ~((u8)1 << (lun))) 77e931830bSedwin_rong #define TST_LUN_READY(chip, lun) ((chip)->lun_ready & ((u8)1 << (lun))) 78e931830bSedwin_rong 79e931830bSedwin_rong #endif 80e931830bSedwin_rong 8150a6cb93Swwang struct rts51x_status { 8250a6cb93Swwang u16 vid; 8350a6cb93Swwang u16 pid; 8450a6cb93Swwang u8 cur_lun; 8550a6cb93Swwang u8 card_type; 8650a6cb93Swwang u8 total_lun; 8750a6cb93Swwang u16 fw_ver; 8850a6cb93Swwang u8 phy_exist; 8950a6cb93Swwang u8 multi_flag; 9050a6cb93Swwang u8 multi_card; 9150a6cb93Swwang u8 log_exist; 9250a6cb93Swwang union { 9350a6cb93Swwang u8 detailed_type1; 9450a6cb93Swwang u8 detailed_type2; 9550a6cb93Swwang } detailed_type; 9650a6cb93Swwang u8 function[2]; 9750a6cb93Swwang }; 9850a6cb93Swwang 9950a6cb93Swwang struct rts51x_chip { 10050a6cb93Swwang u16 vendor_id; 10150a6cb93Swwang u16 product_id; 10250a6cb93Swwang char max_lun; 10350a6cb93Swwang 10450a6cb93Swwang struct rts51x_status *status; 10550a6cb93Swwang int status_len; 10650a6cb93Swwang 10750a6cb93Swwang u32 flag; 108e931830bSedwin_rong #ifdef CONFIG_REALTEK_AUTOPM 109e931830bSedwin_rong struct us_data *us; 110e931830bSedwin_rong struct timer_list rts51x_suspend_timer; 111e931830bSedwin_rong unsigned long timer_expires; 112e931830bSedwin_rong int pwr_state; 113e931830bSedwin_rong u8 lun_ready; 114e931830bSedwin_rong enum RTS51X_STAT state; 115e931830bSedwin_rong int support_auto_delink; 116e931830bSedwin_rong #endif 117e931830bSedwin_rong /* used to back up the protocal choosen in probe1 phase */ 118e931830bSedwin_rong proto_cmnd proto_handler_backup; 11950a6cb93Swwang }; 12050a6cb93Swwang 12150a6cb93Swwang /* flag definition */ 12250a6cb93Swwang #define FLIDX_AUTO_DELINK 0x01 12350a6cb93Swwang 12450a6cb93Swwang #define SCSI_LUN(srb) ((srb)->device->lun) 12550a6cb93Swwang 12650a6cb93Swwang /* Bit Operation */ 12750a6cb93Swwang #define SET_BIT(data, idx) ((data) |= 1 << (idx)) 12850a6cb93Swwang #define CLR_BIT(data, idx) ((data) &= ~(1 << (idx))) 12950a6cb93Swwang #define CHK_BIT(data, idx) ((data) & (1 << (idx))) 13050a6cb93Swwang 13150a6cb93Swwang #define SET_AUTO_DELINK(chip) ((chip)->flag |= FLIDX_AUTO_DELINK) 13250a6cb93Swwang #define CLR_AUTO_DELINK(chip) ((chip)->flag &= ~FLIDX_AUTO_DELINK) 13350a6cb93Swwang #define CHK_AUTO_DELINK(chip) ((chip)->flag & FLIDX_AUTO_DELINK) 13450a6cb93Swwang 13550a6cb93Swwang #define RTS51X_GET_VID(chip) ((chip)->vendor_id) 13650a6cb93Swwang #define RTS51X_GET_PID(chip) ((chip)->product_id) 13750a6cb93Swwang 138e931830bSedwin_rong #define VENDOR_ID(chip) ((chip)->status[0].vid) 139e931830bSedwin_rong #define PRODUCT_ID(chip) ((chip)->status[0].pid) 14050a6cb93Swwang #define FW_VERSION(chip) ((chip)->status[0].fw_ver) 14150a6cb93Swwang #define STATUS_LEN(chip) ((chip)->status_len) 14250a6cb93Swwang 143e931830bSedwin_rong #define STATUS_SUCCESS 0 144e931830bSedwin_rong #define STATUS_FAIL 1 145e931830bSedwin_rong 14650a6cb93Swwang /* Check card reader function */ 14750a6cb93Swwang #define SUPPORT_DETAILED_TYPE1(chip) \ 14850a6cb93Swwang CHK_BIT((chip)->status[0].function[0], 1) 14950a6cb93Swwang #define SUPPORT_OT(chip) \ 15050a6cb93Swwang CHK_BIT((chip)->status[0].function[0], 2) 15150a6cb93Swwang #define SUPPORT_OC(chip) \ 15250a6cb93Swwang CHK_BIT((chip)->status[0].function[0], 3) 15350a6cb93Swwang #define SUPPORT_AUTO_DELINK(chip) \ 15450a6cb93Swwang CHK_BIT((chip)->status[0].function[0], 4) 15550a6cb93Swwang #define SUPPORT_SDIO(chip) \ 15650a6cb93Swwang CHK_BIT((chip)->status[0].function[1], 0) 15750a6cb93Swwang #define SUPPORT_DETAILED_TYPE2(chip) \ 15850a6cb93Swwang CHK_BIT((chip)->status[0].function[1], 1) 15950a6cb93Swwang 16050a6cb93Swwang #define CHECK_PID(chip, pid) (RTS51X_GET_PID(chip) == (pid)) 16150a6cb93Swwang #define CHECK_FW_VER(chip, fw_ver) (FW_VERSION(chip) == (fw_ver)) 16250a6cb93Swwang #define CHECK_ID(chip, pid, fw_ver) \ 16350a6cb93Swwang (CHECK_PID((chip), (pid)) && CHECK_FW_VER((chip), (fw_ver))) 16450a6cb93Swwang 16550a6cb93Swwang static int init_realtek_cr(struct us_data *us); 16650a6cb93Swwang 16750a6cb93Swwang /* 16850a6cb93Swwang * The table of devices 16950a6cb93Swwang */ 17050a6cb93Swwang #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \ 17150a6cb93Swwang vendorName, productName, useProtocol, useTransport, \ 17250a6cb93Swwang initFunction, flags) \ 17350a6cb93Swwang {\ 17450a6cb93Swwang USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \ 175f61870eeSSebastian Andrzej Siewior .driver_info = (flags) \ 17650a6cb93Swwang } 17750a6cb93Swwang 1788a9e658aSwwang static const struct usb_device_id realtek_cr_ids[] = { 17950a6cb93Swwang # include "unusual_realtek.h" 18050a6cb93Swwang {} /* Terminating entry */ 18150a6cb93Swwang }; 182151d9fadSedwin_rong 18350a6cb93Swwang MODULE_DEVICE_TABLE(usb, realtek_cr_ids); 18450a6cb93Swwang 18550a6cb93Swwang #undef UNUSUAL_DEV 18650a6cb93Swwang 18750a6cb93Swwang /* 18850a6cb93Swwang * The flags table 18950a6cb93Swwang */ 19050a6cb93Swwang #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \ 19150a6cb93Swwang vendor_name, product_name, use_protocol, use_transport, \ 19250a6cb93Swwang init_function, Flags) \ 19350a6cb93Swwang { \ 19450a6cb93Swwang .vendorName = vendor_name, \ 19550a6cb93Swwang .productName = product_name, \ 19650a6cb93Swwang .useProtocol = use_protocol, \ 19750a6cb93Swwang .useTransport = use_transport, \ 19850a6cb93Swwang .initFunction = init_function, \ 19950a6cb93Swwang } 20050a6cb93Swwang 20150a6cb93Swwang static struct us_unusual_dev realtek_cr_unusual_dev_list[] = { 20250a6cb93Swwang # include "unusual_realtek.h" 20350a6cb93Swwang {} /* Terminating entry */ 20450a6cb93Swwang }; 20550a6cb93Swwang 20650a6cb93Swwang #undef UNUSUAL_DEV 20750a6cb93Swwang 20850a6cb93Swwang static int rts51x_bulk_transport(struct us_data *us, u8 lun, 20950a6cb93Swwang u8 *cmd, int cmd_len, u8 *buf, int buf_len, 21050a6cb93Swwang enum dma_data_direction dir, int *act_len) 21150a6cb93Swwang { 21250a6cb93Swwang struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *)us->iobuf; 21350a6cb93Swwang struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *)us->iobuf; 21450a6cb93Swwang int result; 21550a6cb93Swwang unsigned int residue; 21650a6cb93Swwang unsigned int cswlen; 21750a6cb93Swwang unsigned int cbwlen = US_BULK_CB_WRAP_LEN; 21850a6cb93Swwang 21950a6cb93Swwang /* set up the command wrapper */ 22050a6cb93Swwang bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 22150a6cb93Swwang bcb->DataTransferLength = cpu_to_le32(buf_len); 222b8db6d64SSebastian Andrzej Siewior bcb->Flags = (dir == DMA_FROM_DEVICE) ? US_BULK_FLAG_IN : 0; 22350a6cb93Swwang bcb->Tag = ++us->tag; 22450a6cb93Swwang bcb->Lun = lun; 22550a6cb93Swwang bcb->Length = cmd_len; 22650a6cb93Swwang 22750a6cb93Swwang /* copy the command payload */ 22850a6cb93Swwang memset(bcb->CDB, 0, sizeof(bcb->CDB)); 22950a6cb93Swwang memcpy(bcb->CDB, cmd, bcb->Length); 23050a6cb93Swwang 23150a6cb93Swwang /* send it to out endpoint */ 23250a6cb93Swwang result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, 23350a6cb93Swwang bcb, cbwlen, NULL); 23450a6cb93Swwang if (result != USB_STOR_XFER_GOOD) 23550a6cb93Swwang return USB_STOR_TRANSPORT_ERROR; 23650a6cb93Swwang 23750a6cb93Swwang /* DATA STAGE */ 23850a6cb93Swwang /* send/receive data payload, if there is any */ 23950a6cb93Swwang 24050a6cb93Swwang if (buf && buf_len) { 24150a6cb93Swwang unsigned int pipe = (dir == DMA_FROM_DEVICE) ? 24250a6cb93Swwang us->recv_bulk_pipe : us->send_bulk_pipe; 24350a6cb93Swwang result = usb_stor_bulk_transfer_buf(us, pipe, 24450a6cb93Swwang buf, buf_len, NULL); 24550a6cb93Swwang if (result == USB_STOR_XFER_ERROR) 24650a6cb93Swwang return USB_STOR_TRANSPORT_ERROR; 24750a6cb93Swwang } 24850a6cb93Swwang 24950a6cb93Swwang /* get CSW for device status */ 25050a6cb93Swwang result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, 25150a6cb93Swwang bcs, US_BULK_CS_WRAP_LEN, &cswlen); 25250a6cb93Swwang if (result != USB_STOR_XFER_GOOD) 25350a6cb93Swwang return USB_STOR_TRANSPORT_ERROR; 25450a6cb93Swwang 25550a6cb93Swwang /* check bulk status */ 25650a6cb93Swwang if (bcs->Signature != cpu_to_le32(US_BULK_CS_SIGN)) { 257191648d0SJoe Perches usb_stor_dbg(us, "Signature mismatch: got %08X, expecting %08X\n", 258151d9fadSedwin_rong le32_to_cpu(bcs->Signature), US_BULK_CS_SIGN); 25950a6cb93Swwang return USB_STOR_TRANSPORT_ERROR; 26050a6cb93Swwang } 26150a6cb93Swwang 26250a6cb93Swwang residue = bcs->Residue; 26350a6cb93Swwang if (bcs->Tag != us->tag) 26450a6cb93Swwang return USB_STOR_TRANSPORT_ERROR; 26550a6cb93Swwang 26650a6cb93Swwang /* try to compute the actual residue, based on how much data 26750a6cb93Swwang * was really transferred and what the device tells us */ 26850a6cb93Swwang if (residue) 26950a6cb93Swwang residue = residue < buf_len ? residue : buf_len; 27050a6cb93Swwang 27150a6cb93Swwang if (act_len) 27250a6cb93Swwang *act_len = buf_len - residue; 27350a6cb93Swwang 27450a6cb93Swwang /* based on the status code, we report good or bad */ 27550a6cb93Swwang switch (bcs->Status) { 27650a6cb93Swwang case US_BULK_STAT_OK: 27750a6cb93Swwang /* command good -- note that data could be short */ 27850a6cb93Swwang return USB_STOR_TRANSPORT_GOOD; 27950a6cb93Swwang 28050a6cb93Swwang case US_BULK_STAT_FAIL: 28150a6cb93Swwang /* command failed */ 28250a6cb93Swwang return USB_STOR_TRANSPORT_FAILED; 28350a6cb93Swwang 28450a6cb93Swwang case US_BULK_STAT_PHASE: 28550a6cb93Swwang /* phase error -- note that a transport reset will be 28650a6cb93Swwang * invoked by the invoke_transport() function 28750a6cb93Swwang */ 28850a6cb93Swwang return USB_STOR_TRANSPORT_ERROR; 28950a6cb93Swwang } 29050a6cb93Swwang 29150a6cb93Swwang /* we should never get here, but if we do, we're in trouble */ 29250a6cb93Swwang return USB_STOR_TRANSPORT_ERROR; 29350a6cb93Swwang } 29450a6cb93Swwang 29545e1892eSedwin_rong static int rts51x_bulk_transport_special(struct us_data *us, u8 lun, 29645e1892eSedwin_rong u8 *cmd, int cmd_len, u8 *buf, int buf_len, 29745e1892eSedwin_rong enum dma_data_direction dir, int *act_len) 29845e1892eSedwin_rong { 29945e1892eSedwin_rong struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 30045e1892eSedwin_rong struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf; 30145e1892eSedwin_rong int result; 30245e1892eSedwin_rong unsigned int cswlen; 30345e1892eSedwin_rong unsigned int cbwlen = US_BULK_CB_WRAP_LEN; 30445e1892eSedwin_rong 30545e1892eSedwin_rong /* set up the command wrapper */ 30645e1892eSedwin_rong bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 30745e1892eSedwin_rong bcb->DataTransferLength = cpu_to_le32(buf_len); 308b8db6d64SSebastian Andrzej Siewior bcb->Flags = (dir == DMA_FROM_DEVICE) ? US_BULK_FLAG_IN : 0; 30945e1892eSedwin_rong bcb->Tag = ++us->tag; 31045e1892eSedwin_rong bcb->Lun = lun; 31145e1892eSedwin_rong bcb->Length = cmd_len; 31245e1892eSedwin_rong 31345e1892eSedwin_rong /* copy the command payload */ 31445e1892eSedwin_rong memset(bcb->CDB, 0, sizeof(bcb->CDB)); 31545e1892eSedwin_rong memcpy(bcb->CDB, cmd, bcb->Length); 31645e1892eSedwin_rong 31745e1892eSedwin_rong /* send it to out endpoint */ 31845e1892eSedwin_rong result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, 31945e1892eSedwin_rong bcb, cbwlen, NULL); 32045e1892eSedwin_rong if (result != USB_STOR_XFER_GOOD) 32145e1892eSedwin_rong return USB_STOR_TRANSPORT_ERROR; 32245e1892eSedwin_rong 32345e1892eSedwin_rong /* DATA STAGE */ 32445e1892eSedwin_rong /* send/receive data payload, if there is any */ 32545e1892eSedwin_rong 32645e1892eSedwin_rong if (buf && buf_len) { 32745e1892eSedwin_rong unsigned int pipe = (dir == DMA_FROM_DEVICE) ? 32845e1892eSedwin_rong us->recv_bulk_pipe : us->send_bulk_pipe; 32945e1892eSedwin_rong result = usb_stor_bulk_transfer_buf(us, pipe, 33045e1892eSedwin_rong buf, buf_len, NULL); 33145e1892eSedwin_rong if (result == USB_STOR_XFER_ERROR) 33245e1892eSedwin_rong return USB_STOR_TRANSPORT_ERROR; 33345e1892eSedwin_rong } 33445e1892eSedwin_rong 33545e1892eSedwin_rong /* get CSW for device status */ 33645e1892eSedwin_rong result = usb_bulk_msg(us->pusb_dev, us->recv_bulk_pipe, bcs, 33745e1892eSedwin_rong US_BULK_CS_WRAP_LEN, &cswlen, 250); 33845e1892eSedwin_rong return result; 33945e1892eSedwin_rong } 34045e1892eSedwin_rong 34150a6cb93Swwang /* Determine what the maximum LUN supported is */ 34250a6cb93Swwang static int rts51x_get_max_lun(struct us_data *us) 34350a6cb93Swwang { 34450a6cb93Swwang int result; 34550a6cb93Swwang 34650a6cb93Swwang /* issue the command */ 34750a6cb93Swwang us->iobuf[0] = 0; 34850a6cb93Swwang result = usb_stor_control_msg(us, us->recv_ctrl_pipe, 34950a6cb93Swwang US_BULK_GET_MAX_LUN, 35050a6cb93Swwang USB_DIR_IN | USB_TYPE_CLASS | 35150a6cb93Swwang USB_RECIP_INTERFACE, 35250a6cb93Swwang 0, us->ifnum, us->iobuf, 1, 10 * HZ); 35350a6cb93Swwang 354191648d0SJoe Perches usb_stor_dbg(us, "GetMaxLUN command result is %d, data is %d\n", 35550a6cb93Swwang result, us->iobuf[0]); 35650a6cb93Swwang 35750a6cb93Swwang /* if we have a successful request, return the result */ 35850a6cb93Swwang if (result > 0) 35950a6cb93Swwang return us->iobuf[0]; 36050a6cb93Swwang 36150a6cb93Swwang return 0; 36250a6cb93Swwang } 36350a6cb93Swwang 36450a6cb93Swwang static int rts51x_read_mem(struct us_data *us, u16 addr, u8 *data, u16 len) 36550a6cb93Swwang { 36650a6cb93Swwang int retval; 36750a6cb93Swwang u8 cmnd[12] = { 0 }; 368065e6096SAdam Cozzette u8 *buf; 369065e6096SAdam Cozzette 370065e6096SAdam Cozzette buf = kmalloc(len, GFP_NOIO); 371065e6096SAdam Cozzette if (buf == NULL) 372065e6096SAdam Cozzette return USB_STOR_TRANSPORT_ERROR; 37350a6cb93Swwang 374191648d0SJoe Perches usb_stor_dbg(us, "addr = 0x%x, len = %d\n", addr, len); 37550a6cb93Swwang 37650a6cb93Swwang cmnd[0] = 0xF0; 37750a6cb93Swwang cmnd[1] = 0x0D; 37850a6cb93Swwang cmnd[2] = (u8) (addr >> 8); 37950a6cb93Swwang cmnd[3] = (u8) addr; 38050a6cb93Swwang cmnd[4] = (u8) (len >> 8); 38150a6cb93Swwang cmnd[5] = (u8) len; 38250a6cb93Swwang 38350a6cb93Swwang retval = rts51x_bulk_transport(us, 0, cmnd, 12, 384065e6096SAdam Cozzette buf, len, DMA_FROM_DEVICE, NULL); 385065e6096SAdam Cozzette if (retval != USB_STOR_TRANSPORT_GOOD) { 386065e6096SAdam Cozzette kfree(buf); 38750a6cb93Swwang return -EIO; 388065e6096SAdam Cozzette } 38950a6cb93Swwang 390065e6096SAdam Cozzette memcpy(data, buf, len); 391065e6096SAdam Cozzette kfree(buf); 39250a6cb93Swwang return 0; 39350a6cb93Swwang } 39450a6cb93Swwang 39550a6cb93Swwang static int rts51x_write_mem(struct us_data *us, u16 addr, u8 *data, u16 len) 39650a6cb93Swwang { 39750a6cb93Swwang int retval; 39850a6cb93Swwang u8 cmnd[12] = { 0 }; 399065e6096SAdam Cozzette u8 *buf; 400065e6096SAdam Cozzette 401eb545522SThomas Meyer buf = kmemdup(data, len, GFP_NOIO); 402065e6096SAdam Cozzette if (buf == NULL) 403065e6096SAdam Cozzette return USB_STOR_TRANSPORT_ERROR; 40450a6cb93Swwang 405191648d0SJoe Perches usb_stor_dbg(us, "addr = 0x%x, len = %d\n", addr, len); 40650a6cb93Swwang 40750a6cb93Swwang cmnd[0] = 0xF0; 40850a6cb93Swwang cmnd[1] = 0x0E; 40950a6cb93Swwang cmnd[2] = (u8) (addr >> 8); 41050a6cb93Swwang cmnd[3] = (u8) addr; 41150a6cb93Swwang cmnd[4] = (u8) (len >> 8); 41250a6cb93Swwang cmnd[5] = (u8) len; 41350a6cb93Swwang 41450a6cb93Swwang retval = rts51x_bulk_transport(us, 0, cmnd, 12, 415065e6096SAdam Cozzette buf, len, DMA_TO_DEVICE, NULL); 416065e6096SAdam Cozzette kfree(buf); 41750a6cb93Swwang if (retval != USB_STOR_TRANSPORT_GOOD) 41850a6cb93Swwang return -EIO; 41950a6cb93Swwang 42050a6cb93Swwang return 0; 42150a6cb93Swwang } 42250a6cb93Swwang 42350a6cb93Swwang static int rts51x_read_status(struct us_data *us, 42450a6cb93Swwang u8 lun, u8 *status, int len, int *actlen) 42550a6cb93Swwang { 42650a6cb93Swwang int retval; 42750a6cb93Swwang u8 cmnd[12] = { 0 }; 428065e6096SAdam Cozzette u8 *buf; 429065e6096SAdam Cozzette 430065e6096SAdam Cozzette buf = kmalloc(len, GFP_NOIO); 431065e6096SAdam Cozzette if (buf == NULL) 432065e6096SAdam Cozzette return USB_STOR_TRANSPORT_ERROR; 43350a6cb93Swwang 434191648d0SJoe Perches usb_stor_dbg(us, "lun = %d\n", lun); 43550a6cb93Swwang 43650a6cb93Swwang cmnd[0] = 0xF0; 43750a6cb93Swwang cmnd[1] = 0x09; 43850a6cb93Swwang 43950a6cb93Swwang retval = rts51x_bulk_transport(us, lun, cmnd, 12, 440065e6096SAdam Cozzette buf, len, DMA_FROM_DEVICE, actlen); 441065e6096SAdam Cozzette if (retval != USB_STOR_TRANSPORT_GOOD) { 442065e6096SAdam Cozzette kfree(buf); 44350a6cb93Swwang return -EIO; 444065e6096SAdam Cozzette } 44550a6cb93Swwang 446065e6096SAdam Cozzette memcpy(status, buf, len); 447065e6096SAdam Cozzette kfree(buf); 44850a6cb93Swwang return 0; 44950a6cb93Swwang } 45050a6cb93Swwang 45150a6cb93Swwang static int rts51x_check_status(struct us_data *us, u8 lun) 45250a6cb93Swwang { 45350a6cb93Swwang struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra); 45450a6cb93Swwang int retval; 45550a6cb93Swwang u8 buf[16]; 45650a6cb93Swwang 45750a6cb93Swwang retval = rts51x_read_status(us, lun, buf, 16, &(chip->status_len)); 458806df3acSJingoo Han if (retval != STATUS_SUCCESS) 45950a6cb93Swwang return -EIO; 46050a6cb93Swwang 461191648d0SJoe Perches usb_stor_dbg(us, "chip->status_len = %d\n", chip->status_len); 46250a6cb93Swwang 46350a6cb93Swwang chip->status[lun].vid = ((u16) buf[0] << 8) | buf[1]; 46450a6cb93Swwang chip->status[lun].pid = ((u16) buf[2] << 8) | buf[3]; 46550a6cb93Swwang chip->status[lun].cur_lun = buf[4]; 46650a6cb93Swwang chip->status[lun].card_type = buf[5]; 46750a6cb93Swwang chip->status[lun].total_lun = buf[6]; 46850a6cb93Swwang chip->status[lun].fw_ver = ((u16) buf[7] << 8) | buf[8]; 46950a6cb93Swwang chip->status[lun].phy_exist = buf[9]; 47050a6cb93Swwang chip->status[lun].multi_flag = buf[10]; 47150a6cb93Swwang chip->status[lun].multi_card = buf[11]; 47250a6cb93Swwang chip->status[lun].log_exist = buf[12]; 47350a6cb93Swwang if (chip->status_len == 16) { 47450a6cb93Swwang chip->status[lun].detailed_type.detailed_type1 = buf[13]; 47550a6cb93Swwang chip->status[lun].function[0] = buf[14]; 47650a6cb93Swwang chip->status[lun].function[1] = buf[15]; 47750a6cb93Swwang } 47850a6cb93Swwang 47950a6cb93Swwang return 0; 48050a6cb93Swwang } 48150a6cb93Swwang 48250a6cb93Swwang static int enable_oscillator(struct us_data *us) 48350a6cb93Swwang { 48450a6cb93Swwang int retval; 48550a6cb93Swwang u8 value; 48650a6cb93Swwang 48750a6cb93Swwang retval = rts51x_read_mem(us, 0xFE77, &value, 1); 48850a6cb93Swwang if (retval < 0) 48950a6cb93Swwang return -EIO; 49050a6cb93Swwang 49150a6cb93Swwang value |= 0x04; 49250a6cb93Swwang retval = rts51x_write_mem(us, 0xFE77, &value, 1); 49350a6cb93Swwang if (retval < 0) 49450a6cb93Swwang return -EIO; 49550a6cb93Swwang 49650a6cb93Swwang retval = rts51x_read_mem(us, 0xFE77, &value, 1); 49750a6cb93Swwang if (retval < 0) 49850a6cb93Swwang return -EIO; 49950a6cb93Swwang 50050a6cb93Swwang if (!(value & 0x04)) 50150a6cb93Swwang return -EIO; 50250a6cb93Swwang 50350a6cb93Swwang return 0; 50450a6cb93Swwang } 50550a6cb93Swwang 50645e1892eSedwin_rong static int __do_config_autodelink(struct us_data *us, u8 *data, u16 len) 50745e1892eSedwin_rong { 50845e1892eSedwin_rong int retval; 50945e1892eSedwin_rong u8 cmnd[12] = {0}; 5104898e071Sjwboyer@redhat.com u8 *buf; 51145e1892eSedwin_rong 512191648d0SJoe Perches usb_stor_dbg(us, "addr = 0xfe47, len = %d\n", len); 51345e1892eSedwin_rong 5144898e071Sjwboyer@redhat.com buf = kmemdup(data, len, GFP_NOIO); 5154898e071Sjwboyer@redhat.com if (!buf) 5164898e071Sjwboyer@redhat.com return USB_STOR_TRANSPORT_ERROR; 5174898e071Sjwboyer@redhat.com 51845e1892eSedwin_rong cmnd[0] = 0xF0; 51945e1892eSedwin_rong cmnd[1] = 0x0E; 520d762ad47SFelipe Balbi cmnd[2] = 0xfe; 521d762ad47SFelipe Balbi cmnd[3] = 0x47; 52245e1892eSedwin_rong cmnd[4] = (u8)(len >> 8); 52345e1892eSedwin_rong cmnd[5] = (u8)len; 52445e1892eSedwin_rong 5254898e071Sjwboyer@redhat.com retval = rts51x_bulk_transport_special(us, 0, cmnd, 12, buf, len, DMA_TO_DEVICE, NULL); 5264898e071Sjwboyer@redhat.com kfree(buf); 52745e1892eSedwin_rong if (retval != USB_STOR_TRANSPORT_GOOD) { 52845e1892eSedwin_rong return -EIO; 52945e1892eSedwin_rong } 53045e1892eSedwin_rong 53145e1892eSedwin_rong return 0; 53245e1892eSedwin_rong } 53345e1892eSedwin_rong 53450a6cb93Swwang static int do_config_autodelink(struct us_data *us, int enable, int force) 53550a6cb93Swwang { 53650a6cb93Swwang int retval; 53750a6cb93Swwang u8 value; 53850a6cb93Swwang 53950a6cb93Swwang retval = rts51x_read_mem(us, 0xFE47, &value, 1); 54050a6cb93Swwang if (retval < 0) 54150a6cb93Swwang return -EIO; 54250a6cb93Swwang 54350a6cb93Swwang if (enable) { 54450a6cb93Swwang if (force) 54550a6cb93Swwang value |= 0x03; 54650a6cb93Swwang else 54750a6cb93Swwang value |= 0x01; 54850a6cb93Swwang } else { 54950a6cb93Swwang value &= ~0x03; 55050a6cb93Swwang } 55150a6cb93Swwang 552191648d0SJoe Perches usb_stor_dbg(us, "set 0xfe47 to 0x%x\n", value); 55350a6cb93Swwang 55445e1892eSedwin_rong /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */ 55545e1892eSedwin_rong retval = __do_config_autodelink(us, &value, 1); 55650a6cb93Swwang if (retval < 0) 55750a6cb93Swwang return -EIO; 55850a6cb93Swwang 55950a6cb93Swwang return 0; 56050a6cb93Swwang } 56150a6cb93Swwang 56250a6cb93Swwang static int config_autodelink_after_power_on(struct us_data *us) 56350a6cb93Swwang { 56450a6cb93Swwang struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra); 56550a6cb93Swwang int retval; 56650a6cb93Swwang u8 value; 56750a6cb93Swwang 56850a6cb93Swwang if (!CHK_AUTO_DELINK(chip)) 56950a6cb93Swwang return 0; 57050a6cb93Swwang 57150a6cb93Swwang retval = rts51x_read_mem(us, 0xFE47, &value, 1); 57250a6cb93Swwang if (retval < 0) 57350a6cb93Swwang return -EIO; 57450a6cb93Swwang 57550a6cb93Swwang if (auto_delink_en) { 57650a6cb93Swwang CLR_BIT(value, 0); 57750a6cb93Swwang CLR_BIT(value, 1); 57850a6cb93Swwang SET_BIT(value, 2); 57950a6cb93Swwang 58050a6cb93Swwang if (CHECK_ID(chip, 0x0138, 0x3882)) 58150a6cb93Swwang CLR_BIT(value, 2); 58250a6cb93Swwang 58350a6cb93Swwang SET_BIT(value, 7); 58450a6cb93Swwang 58545e1892eSedwin_rong /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */ 58645e1892eSedwin_rong retval = __do_config_autodelink(us, &value, 1); 58750a6cb93Swwang if (retval < 0) 58850a6cb93Swwang return -EIO; 58950a6cb93Swwang 59050a6cb93Swwang retval = enable_oscillator(us); 59150a6cb93Swwang if (retval == 0) 59250a6cb93Swwang (void)do_config_autodelink(us, 1, 0); 59350a6cb93Swwang } else { 59450a6cb93Swwang /* Autodelink controlled by firmware */ 59550a6cb93Swwang 59650a6cb93Swwang SET_BIT(value, 2); 59750a6cb93Swwang 59850a6cb93Swwang if (CHECK_ID(chip, 0x0138, 0x3882)) 59950a6cb93Swwang CLR_BIT(value, 2); 60050a6cb93Swwang 60150a6cb93Swwang if (CHECK_ID(chip, 0x0159, 0x5889) || 60250a6cb93Swwang CHECK_ID(chip, 0x0138, 0x3880)) { 60350a6cb93Swwang CLR_BIT(value, 0); 60450a6cb93Swwang CLR_BIT(value, 7); 60550a6cb93Swwang } 60650a6cb93Swwang 60745e1892eSedwin_rong /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */ 60845e1892eSedwin_rong retval = __do_config_autodelink(us, &value, 1); 60950a6cb93Swwang if (retval < 0) 61050a6cb93Swwang return -EIO; 61150a6cb93Swwang 61250a6cb93Swwang if (CHECK_ID(chip, 0x0159, 0x5888)) { 61350a6cb93Swwang value = 0xFF; 61450a6cb93Swwang retval = rts51x_write_mem(us, 0xFE79, &value, 1); 61550a6cb93Swwang if (retval < 0) 61650a6cb93Swwang return -EIO; 61750a6cb93Swwang 61850a6cb93Swwang value = 0x01; 61950a6cb93Swwang retval = rts51x_write_mem(us, 0x48, &value, 1); 62050a6cb93Swwang if (retval < 0) 62150a6cb93Swwang return -EIO; 62250a6cb93Swwang } 62350a6cb93Swwang } 62450a6cb93Swwang 62550a6cb93Swwang return 0; 62650a6cb93Swwang } 62750a6cb93Swwang 62850a6cb93Swwang static int config_autodelink_before_power_down(struct us_data *us) 62950a6cb93Swwang { 63050a6cb93Swwang struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra); 63150a6cb93Swwang int retval; 63250a6cb93Swwang u8 value; 63350a6cb93Swwang 63450a6cb93Swwang if (!CHK_AUTO_DELINK(chip)) 63550a6cb93Swwang return 0; 63650a6cb93Swwang 63750a6cb93Swwang if (auto_delink_en) { 63850a6cb93Swwang retval = rts51x_read_mem(us, 0xFE77, &value, 1); 63950a6cb93Swwang if (retval < 0) 64050a6cb93Swwang return -EIO; 64150a6cb93Swwang 64250a6cb93Swwang SET_BIT(value, 2); 64350a6cb93Swwang retval = rts51x_write_mem(us, 0xFE77, &value, 1); 64450a6cb93Swwang if (retval < 0) 64550a6cb93Swwang return -EIO; 64650a6cb93Swwang 64750a6cb93Swwang if (CHECK_ID(chip, 0x0159, 0x5888)) { 64850a6cb93Swwang value = 0x01; 64950a6cb93Swwang retval = rts51x_write_mem(us, 0x48, &value, 1); 65050a6cb93Swwang if (retval < 0) 65150a6cb93Swwang return -EIO; 65250a6cb93Swwang } 65350a6cb93Swwang 65450a6cb93Swwang retval = rts51x_read_mem(us, 0xFE47, &value, 1); 65550a6cb93Swwang if (retval < 0) 65650a6cb93Swwang return -EIO; 65750a6cb93Swwang 65850a6cb93Swwang SET_BIT(value, 0); 65950a6cb93Swwang if (CHECK_ID(chip, 0x0138, 0x3882)) 66050a6cb93Swwang SET_BIT(value, 2); 66150a6cb93Swwang retval = rts51x_write_mem(us, 0xFE77, &value, 1); 66250a6cb93Swwang if (retval < 0) 66350a6cb93Swwang return -EIO; 66450a6cb93Swwang } else { 66550a6cb93Swwang if (CHECK_ID(chip, 0x0159, 0x5889) || 66650a6cb93Swwang CHECK_ID(chip, 0x0138, 0x3880) || 66750a6cb93Swwang CHECK_ID(chip, 0x0138, 0x3882)) { 66850a6cb93Swwang retval = rts51x_read_mem(us, 0xFE47, &value, 1); 66950a6cb93Swwang if (retval < 0) 67050a6cb93Swwang return -EIO; 67150a6cb93Swwang 67250a6cb93Swwang if (CHECK_ID(chip, 0x0159, 0x5889) || 67350a6cb93Swwang CHECK_ID(chip, 0x0138, 0x3880)) { 67450a6cb93Swwang SET_BIT(value, 0); 67550a6cb93Swwang SET_BIT(value, 7); 67650a6cb93Swwang } 67750a6cb93Swwang 67850a6cb93Swwang if (CHECK_ID(chip, 0x0138, 0x3882)) 67950a6cb93Swwang SET_BIT(value, 2); 68050a6cb93Swwang 68145e1892eSedwin_rong /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */ 68245e1892eSedwin_rong retval = __do_config_autodelink(us, &value, 1); 68350a6cb93Swwang if (retval < 0) 68450a6cb93Swwang return -EIO; 68550a6cb93Swwang } 68650a6cb93Swwang 68750a6cb93Swwang if (CHECK_ID(chip, 0x0159, 0x5888)) { 68850a6cb93Swwang value = 0x01; 68950a6cb93Swwang retval = rts51x_write_mem(us, 0x48, &value, 1); 69050a6cb93Swwang if (retval < 0) 69150a6cb93Swwang return -EIO; 69250a6cb93Swwang } 69350a6cb93Swwang } 69450a6cb93Swwang 69550a6cb93Swwang return 0; 69650a6cb93Swwang } 69750a6cb93Swwang 698e931830bSedwin_rong static void fw5895_init(struct us_data *us) 699e931830bSedwin_rong { 700e931830bSedwin_rong struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra); 701e931830bSedwin_rong int retval; 702e931830bSedwin_rong u8 val; 703e931830bSedwin_rong 704e931830bSedwin_rong if ((PRODUCT_ID(chip) != 0x0158) || (FW_VERSION(chip) != 0x5895)) { 705191648d0SJoe Perches usb_stor_dbg(us, "Not the specified device, return immediately!\n"); 706e931830bSedwin_rong } else { 707e931830bSedwin_rong retval = rts51x_read_mem(us, 0xFD6F, &val, 1); 708e931830bSedwin_rong if (retval == STATUS_SUCCESS && (val & 0x1F) == 0) { 709e931830bSedwin_rong val = 0x1F; 710e931830bSedwin_rong retval = rts51x_write_mem(us, 0xFD70, &val, 1); 711e931830bSedwin_rong if (retval != STATUS_SUCCESS) 712191648d0SJoe Perches usb_stor_dbg(us, "Write memory fail\n"); 713e931830bSedwin_rong } else { 714191648d0SJoe Perches usb_stor_dbg(us, "Read memory fail, OR (val & 0x1F) != 0\n"); 715e931830bSedwin_rong } 716e931830bSedwin_rong } 717e931830bSedwin_rong } 718e931830bSedwin_rong 719e931830bSedwin_rong #ifdef CONFIG_REALTEK_AUTOPM 720e931830bSedwin_rong static void fw5895_set_mmc_wp(struct us_data *us) 721e931830bSedwin_rong { 722e931830bSedwin_rong struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra); 723e931830bSedwin_rong int retval; 724e931830bSedwin_rong u8 buf[13]; 725e931830bSedwin_rong 726e931830bSedwin_rong if ((PRODUCT_ID(chip) != 0x0158) || (FW_VERSION(chip) != 0x5895)) { 727191648d0SJoe Perches usb_stor_dbg(us, "Not the specified device, return immediately!\n"); 728e931830bSedwin_rong } else { 729e931830bSedwin_rong retval = rts51x_read_mem(us, 0xFD6F, buf, 1); 730e931830bSedwin_rong if (retval == STATUS_SUCCESS && (buf[0] & 0x24) == 0x24) { 731e931830bSedwin_rong /* SD Exist and SD WP */ 732e931830bSedwin_rong retval = rts51x_read_mem(us, 0xD04E, buf, 1); 733e931830bSedwin_rong if (retval == STATUS_SUCCESS) { 734e931830bSedwin_rong buf[0] |= 0x04; 735e931830bSedwin_rong retval = rts51x_write_mem(us, 0xFD70, buf, 1); 736e931830bSedwin_rong if (retval != STATUS_SUCCESS) 737191648d0SJoe Perches usb_stor_dbg(us, "Write memory fail\n"); 738e931830bSedwin_rong } else { 739191648d0SJoe Perches usb_stor_dbg(us, "Read memory fail\n"); 740e931830bSedwin_rong } 741e931830bSedwin_rong } else { 742191648d0SJoe Perches usb_stor_dbg(us, "Read memory fail, OR (buf[0]&0x24)!=0x24\n"); 743e931830bSedwin_rong } 744e931830bSedwin_rong } 745e931830bSedwin_rong } 746e931830bSedwin_rong 747e931830bSedwin_rong static void rts51x_modi_suspend_timer(struct rts51x_chip *chip) 748e931830bSedwin_rong { 749191648d0SJoe Perches struct us_data *us = chip->us; 750191648d0SJoe Perches 751191648d0SJoe Perches usb_stor_dbg(us, "state:%d\n", rts51x_get_stat(chip)); 752e931830bSedwin_rong 753e931830bSedwin_rong chip->timer_expires = jiffies + msecs_to_jiffies(1000*ss_delay); 754e931830bSedwin_rong mod_timer(&chip->rts51x_suspend_timer, chip->timer_expires); 755e931830bSedwin_rong } 756e931830bSedwin_rong 757e931830bSedwin_rong static void rts51x_suspend_timer_fn(unsigned long data) 758e931830bSedwin_rong { 759e931830bSedwin_rong struct rts51x_chip *chip = (struct rts51x_chip *)data; 760e931830bSedwin_rong struct us_data *us = chip->us; 761e931830bSedwin_rong 762e931830bSedwin_rong switch (rts51x_get_stat(chip)) { 763e931830bSedwin_rong case RTS51X_STAT_INIT: 764e931830bSedwin_rong case RTS51X_STAT_RUN: 765e931830bSedwin_rong rts51x_modi_suspend_timer(chip); 766e931830bSedwin_rong break; 767e931830bSedwin_rong case RTS51X_STAT_IDLE: 768e931830bSedwin_rong case RTS51X_STAT_SS: 769191648d0SJoe Perches usb_stor_dbg(us, "RTS51X_STAT_SS, intf->pm_usage_cnt:%d, power.usage:%d\n", 770e931830bSedwin_rong atomic_read(&us->pusb_intf->pm_usage_cnt), 771e931830bSedwin_rong atomic_read(&us->pusb_intf->dev.power.usage_count)); 772e931830bSedwin_rong 773e931830bSedwin_rong if (atomic_read(&us->pusb_intf->pm_usage_cnt) > 0) { 774191648d0SJoe Perches usb_stor_dbg(us, "Ready to enter SS state\n"); 775e931830bSedwin_rong rts51x_set_stat(chip, RTS51X_STAT_SS); 776e931830bSedwin_rong /* ignore mass storage interface's children */ 777e931830bSedwin_rong pm_suspend_ignore_children(&us->pusb_intf->dev, true); 778b3ef051dSStanislaw Gruszka usb_autopm_put_interface_async(us->pusb_intf); 779191648d0SJoe Perches usb_stor_dbg(us, "RTS51X_STAT_SS 01, intf->pm_usage_cnt:%d, power.usage:%d\n", 780e931830bSedwin_rong atomic_read(&us->pusb_intf->pm_usage_cnt), 781191648d0SJoe Perches atomic_read(&us->pusb_intf->dev.power.usage_count)); 782e931830bSedwin_rong } 783e931830bSedwin_rong break; 784e931830bSedwin_rong default: 785191648d0SJoe Perches usb_stor_dbg(us, "Unknown state !!!\n"); 786e931830bSedwin_rong break; 787e931830bSedwin_rong } 788e931830bSedwin_rong } 789e931830bSedwin_rong 790e931830bSedwin_rong static inline int working_scsi(struct scsi_cmnd *srb) 791e931830bSedwin_rong { 792e931830bSedwin_rong if ((srb->cmnd[0] == TEST_UNIT_READY) || 793e931830bSedwin_rong (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL)) { 794e931830bSedwin_rong return 0; 795e931830bSedwin_rong } 796e931830bSedwin_rong 797e931830bSedwin_rong return 1; 798e931830bSedwin_rong } 799e931830bSedwin_rong 800d762ad47SFelipe Balbi static void rts51x_invoke_transport(struct scsi_cmnd *srb, struct us_data *us) 801e931830bSedwin_rong { 802e931830bSedwin_rong struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra); 803e931830bSedwin_rong static int card_first_show = 1; 804e931830bSedwin_rong static u8 media_not_present[] = { 0x70, 0, 0x02, 0, 0, 0, 0, 805e931830bSedwin_rong 10, 0, 0, 0, 0, 0x3A, 0, 0, 0, 0, 0 806e931830bSedwin_rong }; 807e931830bSedwin_rong static u8 invalid_cmd_field[] = { 0x70, 0, 0x05, 0, 0, 0, 0, 808e931830bSedwin_rong 10, 0, 0, 0, 0, 0x24, 0, 0, 0, 0, 0 809e931830bSedwin_rong }; 810e931830bSedwin_rong int ret; 811e931830bSedwin_rong 812e931830bSedwin_rong if (working_scsi(srb)) { 813191648d0SJoe Perches usb_stor_dbg(us, "working scsi, intf->pm_usage_cnt:%d, power.usage:%d\n", 814e931830bSedwin_rong atomic_read(&us->pusb_intf->pm_usage_cnt), 815e931830bSedwin_rong atomic_read(&us->pusb_intf->dev.power.usage_count)); 816e931830bSedwin_rong 817e931830bSedwin_rong if (atomic_read(&us->pusb_intf->pm_usage_cnt) <= 0) { 818e931830bSedwin_rong ret = usb_autopm_get_interface(us->pusb_intf); 819191648d0SJoe Perches usb_stor_dbg(us, "working scsi, ret=%d\n", ret); 820e931830bSedwin_rong } 821e931830bSedwin_rong if (rts51x_get_stat(chip) != RTS51X_STAT_RUN) 822e931830bSedwin_rong rts51x_set_stat(chip, RTS51X_STAT_RUN); 823e931830bSedwin_rong chip->proto_handler_backup(srb, us); 824e931830bSedwin_rong } else { 825e931830bSedwin_rong if (rts51x_get_stat(chip) == RTS51X_STAT_SS) { 826191648d0SJoe Perches usb_stor_dbg(us, "NOT working scsi\n"); 827e931830bSedwin_rong if ((srb->cmnd[0] == TEST_UNIT_READY) && 828e931830bSedwin_rong (chip->pwr_state == US_SUSPEND)) { 829e931830bSedwin_rong if (TST_LUN_READY(chip, srb->device->lun)) { 830e931830bSedwin_rong srb->result = SAM_STAT_GOOD; 831e931830bSedwin_rong } else { 832e931830bSedwin_rong srb->result = SAM_STAT_CHECK_CONDITION; 833e931830bSedwin_rong memcpy(srb->sense_buffer, 834e931830bSedwin_rong media_not_present, 835e931830bSedwin_rong US_SENSE_SIZE); 836e931830bSedwin_rong } 837191648d0SJoe Perches usb_stor_dbg(us, "TEST_UNIT_READY\n"); 838e931830bSedwin_rong goto out; 839e931830bSedwin_rong } 840e931830bSedwin_rong if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) { 841e931830bSedwin_rong int prevent = srb->cmnd[4] & 0x1; 842e931830bSedwin_rong if (prevent) { 843e931830bSedwin_rong srb->result = SAM_STAT_CHECK_CONDITION; 844e931830bSedwin_rong memcpy(srb->sense_buffer, 845e931830bSedwin_rong invalid_cmd_field, 846e931830bSedwin_rong US_SENSE_SIZE); 847e931830bSedwin_rong } else { 848e931830bSedwin_rong srb->result = SAM_STAT_GOOD; 849e931830bSedwin_rong } 850191648d0SJoe Perches usb_stor_dbg(us, "ALLOW_MEDIUM_REMOVAL\n"); 851e931830bSedwin_rong goto out; 852e931830bSedwin_rong } 853e931830bSedwin_rong } else { 854191648d0SJoe Perches usb_stor_dbg(us, "NOT working scsi, not SS\n"); 855e931830bSedwin_rong chip->proto_handler_backup(srb, us); 85648fc7f7eSAdam Buchbinder /* Check whether card is plugged in */ 857e931830bSedwin_rong if (srb->cmnd[0] == TEST_UNIT_READY) { 858e931830bSedwin_rong if (srb->result == SAM_STAT_GOOD) { 859e931830bSedwin_rong SET_LUN_READY(chip, srb->device->lun); 860e931830bSedwin_rong if (card_first_show) { 861e931830bSedwin_rong card_first_show = 0; 862e931830bSedwin_rong fw5895_set_mmc_wp(us); 863e931830bSedwin_rong } 864e931830bSedwin_rong } else { 865e931830bSedwin_rong CLR_LUN_READY(chip, srb->device->lun); 866e931830bSedwin_rong card_first_show = 1; 867e931830bSedwin_rong } 868e931830bSedwin_rong } 869e931830bSedwin_rong if (rts51x_get_stat(chip) != RTS51X_STAT_IDLE) 870e931830bSedwin_rong rts51x_set_stat(chip, RTS51X_STAT_IDLE); 871e931830bSedwin_rong } 872e931830bSedwin_rong } 873e931830bSedwin_rong out: 874191648d0SJoe Perches usb_stor_dbg(us, "state:%d\n", rts51x_get_stat(chip)); 875e931830bSedwin_rong if (rts51x_get_stat(chip) == RTS51X_STAT_RUN) 876e931830bSedwin_rong rts51x_modi_suspend_timer(chip); 877e931830bSedwin_rong } 878e931830bSedwin_rong 879e931830bSedwin_rong static int realtek_cr_autosuspend_setup(struct us_data *us) 880e931830bSedwin_rong { 881e931830bSedwin_rong struct rts51x_chip *chip; 882e931830bSedwin_rong struct rts51x_status *status = NULL; 883e931830bSedwin_rong u8 buf[16]; 884e931830bSedwin_rong int retval; 885e931830bSedwin_rong 886e931830bSedwin_rong chip = (struct rts51x_chip *)us->extra; 887e931830bSedwin_rong chip->support_auto_delink = 0; 888e931830bSedwin_rong chip->pwr_state = US_RESUME; 889e931830bSedwin_rong chip->lun_ready = 0; 890e931830bSedwin_rong rts51x_set_stat(chip, RTS51X_STAT_INIT); 891e931830bSedwin_rong 892e931830bSedwin_rong retval = rts51x_read_status(us, 0, buf, 16, &(chip->status_len)); 893e931830bSedwin_rong if (retval != STATUS_SUCCESS) { 894191648d0SJoe Perches usb_stor_dbg(us, "Read status fail\n"); 895e931830bSedwin_rong return -EIO; 896e931830bSedwin_rong } 897e931830bSedwin_rong status = chip->status; 898e931830bSedwin_rong status->vid = ((u16) buf[0] << 8) | buf[1]; 899e931830bSedwin_rong status->pid = ((u16) buf[2] << 8) | buf[3]; 900e931830bSedwin_rong status->cur_lun = buf[4]; 901e931830bSedwin_rong status->card_type = buf[5]; 902e931830bSedwin_rong status->total_lun = buf[6]; 903e931830bSedwin_rong status->fw_ver = ((u16) buf[7] << 8) | buf[8]; 904e931830bSedwin_rong status->phy_exist = buf[9]; 905e931830bSedwin_rong status->multi_flag = buf[10]; 906e931830bSedwin_rong status->multi_card = buf[11]; 907e931830bSedwin_rong status->log_exist = buf[12]; 908e931830bSedwin_rong if (chip->status_len == 16) { 909e931830bSedwin_rong status->detailed_type.detailed_type1 = buf[13]; 910e931830bSedwin_rong status->function[0] = buf[14]; 911e931830bSedwin_rong status->function[1] = buf[15]; 912e931830bSedwin_rong } 913e931830bSedwin_rong 914e931830bSedwin_rong /* back up the proto_handler in us->extra */ 915e931830bSedwin_rong chip = (struct rts51x_chip *)(us->extra); 916e931830bSedwin_rong chip->proto_handler_backup = us->proto_handler; 917e931830bSedwin_rong /* Set the autosuspend_delay to 0 */ 918e931830bSedwin_rong pm_runtime_set_autosuspend_delay(&us->pusb_dev->dev, 0); 919e931830bSedwin_rong /* override us->proto_handler setted in get_protocol() */ 920e931830bSedwin_rong us->proto_handler = rts51x_invoke_transport; 921e931830bSedwin_rong 922e931830bSedwin_rong chip->timer_expires = 0; 923e931830bSedwin_rong setup_timer(&chip->rts51x_suspend_timer, rts51x_suspend_timer_fn, 924e931830bSedwin_rong (unsigned long)chip); 925e931830bSedwin_rong fw5895_init(us); 926e931830bSedwin_rong 927e931830bSedwin_rong /* enable autosuspend funciton of the usb device */ 928e931830bSedwin_rong usb_enable_autosuspend(us->pusb_dev); 929e931830bSedwin_rong 930e931830bSedwin_rong return 0; 931e931830bSedwin_rong } 932e931830bSedwin_rong #endif 933e931830bSedwin_rong 93450a6cb93Swwang static void realtek_cr_destructor(void *extra) 93550a6cb93Swwang { 936677a0b5aSAndrew Morton struct rts51x_chip *chip = extra; 937e931830bSedwin_rong 93850a6cb93Swwang if (!chip) 93950a6cb93Swwang return; 940191648d0SJoe Perches 941e931830bSedwin_rong #ifdef CONFIG_REALTEK_AUTOPM 942e931830bSedwin_rong if (ss_en) { 943e931830bSedwin_rong del_timer(&chip->rts51x_suspend_timer); 944e931830bSedwin_rong chip->timer_expires = 0; 945e931830bSedwin_rong } 946e931830bSedwin_rong #endif 94750a6cb93Swwang kfree(chip->status); 94850a6cb93Swwang } 94950a6cb93Swwang 95050a6cb93Swwang #ifdef CONFIG_PM 951d762ad47SFelipe Balbi static int realtek_cr_suspend(struct usb_interface *iface, pm_message_t message) 95250a6cb93Swwang { 953e931830bSedwin_rong struct us_data *us = usb_get_intfdata(iface); 954e931830bSedwin_rong 955e931830bSedwin_rong /* wait until no command is running */ 956e931830bSedwin_rong mutex_lock(&us->dev_mutex); 957e931830bSedwin_rong 958e931830bSedwin_rong config_autodelink_before_power_down(us); 959e931830bSedwin_rong 960e931830bSedwin_rong mutex_unlock(&us->dev_mutex); 961e931830bSedwin_rong 962e931830bSedwin_rong return 0; 96350a6cb93Swwang } 964e931830bSedwin_rong 965e931830bSedwin_rong static int realtek_cr_resume(struct usb_interface *iface) 966e931830bSedwin_rong { 967e931830bSedwin_rong struct us_data *us = usb_get_intfdata(iface); 968e931830bSedwin_rong 969e931830bSedwin_rong fw5895_init(us); 970e931830bSedwin_rong config_autodelink_after_power_on(us); 971e931830bSedwin_rong 972e931830bSedwin_rong return 0; 973e931830bSedwin_rong } 974e931830bSedwin_rong #else 975e931830bSedwin_rong #define realtek_cr_suspend NULL 976e931830bSedwin_rong #define realtek_cr_resume NULL 97750a6cb93Swwang #endif 97850a6cb93Swwang 97950a6cb93Swwang static int init_realtek_cr(struct us_data *us) 98050a6cb93Swwang { 98150a6cb93Swwang struct rts51x_chip *chip; 98250a6cb93Swwang int size, i, retval; 98350a6cb93Swwang 98450a6cb93Swwang chip = kzalloc(sizeof(struct rts51x_chip), GFP_KERNEL); 98550a6cb93Swwang if (!chip) 98650a6cb93Swwang return -ENOMEM; 98750a6cb93Swwang 98850a6cb93Swwang us->extra = chip; 98950a6cb93Swwang us->extra_destructor = realtek_cr_destructor; 99050a6cb93Swwang us->max_lun = chip->max_lun = rts51x_get_max_lun(us); 99150a6cb93Swwang 992191648d0SJoe Perches usb_stor_dbg(us, "chip->max_lun = %d\n", chip->max_lun); 99350a6cb93Swwang 99450a6cb93Swwang size = (chip->max_lun + 1) * sizeof(struct rts51x_status); 99550a6cb93Swwang chip->status = kzalloc(size, GFP_KERNEL); 99650a6cb93Swwang if (!chip->status) 99750a6cb93Swwang goto INIT_FAIL; 99850a6cb93Swwang 99950a6cb93Swwang for (i = 0; i <= (int)(chip->max_lun); i++) { 100050a6cb93Swwang retval = rts51x_check_status(us, (u8) i); 100150a6cb93Swwang if (retval < 0) 100250a6cb93Swwang goto INIT_FAIL; 100350a6cb93Swwang } 100450a6cb93Swwang 100550a6cb93Swwang if (CHECK_FW_VER(chip, 0x5888) || CHECK_FW_VER(chip, 0x5889) || 100650a6cb93Swwang CHECK_FW_VER(chip, 0x5901)) 100750a6cb93Swwang SET_AUTO_DELINK(chip); 100850a6cb93Swwang if (STATUS_LEN(chip) == 16) { 100950a6cb93Swwang if (SUPPORT_AUTO_DELINK(chip)) 101050a6cb93Swwang SET_AUTO_DELINK(chip); 101150a6cb93Swwang } 1012e931830bSedwin_rong #ifdef CONFIG_REALTEK_AUTOPM 1013e931830bSedwin_rong if (ss_en) { 1014e931830bSedwin_rong chip->us = us; 1015e931830bSedwin_rong realtek_cr_autosuspend_setup(us); 1016e931830bSedwin_rong } 1017e931830bSedwin_rong #endif 101850a6cb93Swwang 1019191648d0SJoe Perches usb_stor_dbg(us, "chip->flag = 0x%x\n", chip->flag); 102050a6cb93Swwang 102150a6cb93Swwang (void)config_autodelink_after_power_on(us); 102250a6cb93Swwang 102350a6cb93Swwang return 0; 102450a6cb93Swwang 102550a6cb93Swwang INIT_FAIL: 102650a6cb93Swwang if (us->extra) { 102750a6cb93Swwang kfree(chip->status); 102850a6cb93Swwang kfree(us->extra); 102950a6cb93Swwang us->extra = NULL; 103050a6cb93Swwang } 103150a6cb93Swwang 103250a6cb93Swwang return -EIO; 103350a6cb93Swwang } 103450a6cb93Swwang 103550a6cb93Swwang static int realtek_cr_probe(struct usb_interface *intf, 103650a6cb93Swwang const struct usb_device_id *id) 103750a6cb93Swwang { 103850a6cb93Swwang struct us_data *us; 103950a6cb93Swwang int result; 104050a6cb93Swwang 1041191648d0SJoe Perches dev_dbg(&intf->dev, "Probe Realtek Card Reader!\n"); 104250a6cb93Swwang 104350a6cb93Swwang result = usb_stor_probe1(&us, intf, id, 1044151d9fadSedwin_rong (id - realtek_cr_ids) + 1045151d9fadSedwin_rong realtek_cr_unusual_dev_list); 104650a6cb93Swwang if (result) 104750a6cb93Swwang return result; 104850a6cb93Swwang 104950a6cb93Swwang result = usb_stor_probe2(us); 1050151d9fadSedwin_rong 105150a6cb93Swwang return result; 105250a6cb93Swwang } 105350a6cb93Swwang 105450a6cb93Swwang static struct usb_driver realtek_cr_driver = { 105550a6cb93Swwang .name = "ums-realtek", 105650a6cb93Swwang .probe = realtek_cr_probe, 105750a6cb93Swwang .disconnect = usb_stor_disconnect, 1058e931830bSedwin_rong /* .suspend = usb_stor_suspend, */ 1059e931830bSedwin_rong /* .resume = usb_stor_resume, */ 106050a6cb93Swwang .reset_resume = usb_stor_reset_resume, 1061e931830bSedwin_rong .suspend = realtek_cr_suspend, 1062e931830bSedwin_rong .resume = realtek_cr_resume, 106350a6cb93Swwang .pre_reset = usb_stor_pre_reset, 106450a6cb93Swwang .post_reset = usb_stor_post_reset, 106550a6cb93Swwang .id_table = realtek_cr_ids, 106650a6cb93Swwang .soft_unbind = 1, 1067e931830bSedwin_rong .supports_autosuspend = 1, 1068e73b2db6SHuajun Li .no_dynamic_id = 1, 106950a6cb93Swwang }; 107050a6cb93Swwang 107165db4305SGreg Kroah-Hartman module_usb_driver(realtek_cr_driver); 1072