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), \ 17550a6cb93Swwang .driver_info = (flags)|(USB_US_TYPE_STOR<<24)\ 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); 22250a6cb93Swwang bcb->Flags = (dir == DMA_FROM_DEVICE) ? 1 << 7 : 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)) { 25750a6cb93Swwang US_DEBUGP("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); 30845e1892eSedwin_rong bcb->Flags = (dir == DMA_FROM_DEVICE) ? 1 << 7 : 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 35450a6cb93Swwang US_DEBUGP("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 37450a6cb93Swwang US_DEBUGP("%s, addr = 0x%x, len = %d\n", __func__, 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 401065e6096SAdam Cozzette buf = kmalloc(len, GFP_NOIO); 402065e6096SAdam Cozzette if (buf == NULL) 403065e6096SAdam Cozzette return USB_STOR_TRANSPORT_ERROR; 404065e6096SAdam Cozzette memcpy(buf, data, len); 40550a6cb93Swwang 40650a6cb93Swwang US_DEBUGP("%s, addr = 0x%x, len = %d\n", __func__, addr, len); 40750a6cb93Swwang 40850a6cb93Swwang cmnd[0] = 0xF0; 40950a6cb93Swwang cmnd[1] = 0x0E; 41050a6cb93Swwang cmnd[2] = (u8) (addr >> 8); 41150a6cb93Swwang cmnd[3] = (u8) addr; 41250a6cb93Swwang cmnd[4] = (u8) (len >> 8); 41350a6cb93Swwang cmnd[5] = (u8) len; 41450a6cb93Swwang 41550a6cb93Swwang retval = rts51x_bulk_transport(us, 0, cmnd, 12, 416065e6096SAdam Cozzette buf, len, DMA_TO_DEVICE, NULL); 417065e6096SAdam Cozzette kfree(buf); 41850a6cb93Swwang if (retval != USB_STOR_TRANSPORT_GOOD) 41950a6cb93Swwang return -EIO; 42050a6cb93Swwang 42150a6cb93Swwang return 0; 42250a6cb93Swwang } 42350a6cb93Swwang 42450a6cb93Swwang static int rts51x_read_status(struct us_data *us, 42550a6cb93Swwang u8 lun, u8 *status, int len, int *actlen) 42650a6cb93Swwang { 42750a6cb93Swwang int retval; 42850a6cb93Swwang u8 cmnd[12] = { 0 }; 429065e6096SAdam Cozzette u8 *buf; 430065e6096SAdam Cozzette 431065e6096SAdam Cozzette buf = kmalloc(len, GFP_NOIO); 432065e6096SAdam Cozzette if (buf == NULL) 433065e6096SAdam Cozzette return USB_STOR_TRANSPORT_ERROR; 43450a6cb93Swwang 43550a6cb93Swwang US_DEBUGP("%s, lun = %d\n", __func__, lun); 43650a6cb93Swwang 43750a6cb93Swwang cmnd[0] = 0xF0; 43850a6cb93Swwang cmnd[1] = 0x09; 43950a6cb93Swwang 44050a6cb93Swwang retval = rts51x_bulk_transport(us, lun, cmnd, 12, 441065e6096SAdam Cozzette buf, len, DMA_FROM_DEVICE, actlen); 442065e6096SAdam Cozzette if (retval != USB_STOR_TRANSPORT_GOOD) { 443065e6096SAdam Cozzette kfree(buf); 44450a6cb93Swwang return -EIO; 445065e6096SAdam Cozzette } 44650a6cb93Swwang 447065e6096SAdam Cozzette memcpy(status, buf, len); 448065e6096SAdam Cozzette kfree(buf); 44950a6cb93Swwang return 0; 45050a6cb93Swwang } 45150a6cb93Swwang 45250a6cb93Swwang static int rts51x_check_status(struct us_data *us, u8 lun) 45350a6cb93Swwang { 45450a6cb93Swwang struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra); 45550a6cb93Swwang int retval; 45650a6cb93Swwang u8 buf[16]; 45750a6cb93Swwang 45850a6cb93Swwang retval = rts51x_read_status(us, lun, buf, 16, &(chip->status_len)); 45950a6cb93Swwang if (retval < 0) 46050a6cb93Swwang return -EIO; 46150a6cb93Swwang 46250a6cb93Swwang US_DEBUGP("chip->status_len = %d\n", chip->status_len); 46350a6cb93Swwang 46450a6cb93Swwang chip->status[lun].vid = ((u16) buf[0] << 8) | buf[1]; 46550a6cb93Swwang chip->status[lun].pid = ((u16) buf[2] << 8) | buf[3]; 46650a6cb93Swwang chip->status[lun].cur_lun = buf[4]; 46750a6cb93Swwang chip->status[lun].card_type = buf[5]; 46850a6cb93Swwang chip->status[lun].total_lun = buf[6]; 46950a6cb93Swwang chip->status[lun].fw_ver = ((u16) buf[7] << 8) | buf[8]; 47050a6cb93Swwang chip->status[lun].phy_exist = buf[9]; 47150a6cb93Swwang chip->status[lun].multi_flag = buf[10]; 47250a6cb93Swwang chip->status[lun].multi_card = buf[11]; 47350a6cb93Swwang chip->status[lun].log_exist = buf[12]; 47450a6cb93Swwang if (chip->status_len == 16) { 47550a6cb93Swwang chip->status[lun].detailed_type.detailed_type1 = buf[13]; 47650a6cb93Swwang chip->status[lun].function[0] = buf[14]; 47750a6cb93Swwang chip->status[lun].function[1] = buf[15]; 47850a6cb93Swwang } 47950a6cb93Swwang 48050a6cb93Swwang return 0; 48150a6cb93Swwang } 48250a6cb93Swwang 48350a6cb93Swwang static int enable_oscillator(struct us_data *us) 48450a6cb93Swwang { 48550a6cb93Swwang int retval; 48650a6cb93Swwang u8 value; 48750a6cb93Swwang 48850a6cb93Swwang retval = rts51x_read_mem(us, 0xFE77, &value, 1); 48950a6cb93Swwang if (retval < 0) 49050a6cb93Swwang return -EIO; 49150a6cb93Swwang 49250a6cb93Swwang value |= 0x04; 49350a6cb93Swwang retval = rts51x_write_mem(us, 0xFE77, &value, 1); 49450a6cb93Swwang if (retval < 0) 49550a6cb93Swwang return -EIO; 49650a6cb93Swwang 49750a6cb93Swwang retval = rts51x_read_mem(us, 0xFE77, &value, 1); 49850a6cb93Swwang if (retval < 0) 49950a6cb93Swwang return -EIO; 50050a6cb93Swwang 50150a6cb93Swwang if (!(value & 0x04)) 50250a6cb93Swwang return -EIO; 50350a6cb93Swwang 50450a6cb93Swwang return 0; 50550a6cb93Swwang } 50650a6cb93Swwang 50745e1892eSedwin_rong static int __do_config_autodelink(struct us_data *us, u8 *data, u16 len) 50845e1892eSedwin_rong { 50945e1892eSedwin_rong int retval; 51045e1892eSedwin_rong u16 addr = 0xFE47; 51145e1892eSedwin_rong u8 cmnd[12] = {0}; 51245e1892eSedwin_rong 51345e1892eSedwin_rong US_DEBUGP("%s, addr = 0x%x, len = %d\n", __FUNCTION__, addr, len); 51445e1892eSedwin_rong 51545e1892eSedwin_rong cmnd[0] = 0xF0; 51645e1892eSedwin_rong cmnd[1] = 0x0E; 51745e1892eSedwin_rong cmnd[2] = (u8)(addr >> 8); 51845e1892eSedwin_rong cmnd[3] = (u8)addr; 51945e1892eSedwin_rong cmnd[4] = (u8)(len >> 8); 52045e1892eSedwin_rong cmnd[5] = (u8)len; 52145e1892eSedwin_rong 52245e1892eSedwin_rong retval = rts51x_bulk_transport_special(us, 0, cmnd, 12, data, len, DMA_TO_DEVICE, NULL); 52345e1892eSedwin_rong if (retval != USB_STOR_TRANSPORT_GOOD) { 52445e1892eSedwin_rong return -EIO; 52545e1892eSedwin_rong } 52645e1892eSedwin_rong 52745e1892eSedwin_rong return 0; 52845e1892eSedwin_rong } 52945e1892eSedwin_rong 53050a6cb93Swwang static int do_config_autodelink(struct us_data *us, int enable, int force) 53150a6cb93Swwang { 53250a6cb93Swwang int retval; 53350a6cb93Swwang u8 value; 53450a6cb93Swwang 53550a6cb93Swwang retval = rts51x_read_mem(us, 0xFE47, &value, 1); 53650a6cb93Swwang if (retval < 0) 53750a6cb93Swwang return -EIO; 53850a6cb93Swwang 53950a6cb93Swwang if (enable) { 54050a6cb93Swwang if (force) 54150a6cb93Swwang value |= 0x03; 54250a6cb93Swwang else 54350a6cb93Swwang value |= 0x01; 54450a6cb93Swwang } else { 54550a6cb93Swwang value &= ~0x03; 54650a6cb93Swwang } 54750a6cb93Swwang 54850a6cb93Swwang US_DEBUGP("In %s,set 0xfe47 to 0x%x\n", __func__, value); 54950a6cb93Swwang 55045e1892eSedwin_rong /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */ 55145e1892eSedwin_rong retval = __do_config_autodelink(us, &value, 1); 55250a6cb93Swwang if (retval < 0) 55350a6cb93Swwang return -EIO; 55450a6cb93Swwang 55550a6cb93Swwang return 0; 55650a6cb93Swwang } 55750a6cb93Swwang 55850a6cb93Swwang static int config_autodelink_after_power_on(struct us_data *us) 55950a6cb93Swwang { 56050a6cb93Swwang struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra); 56150a6cb93Swwang int retval; 56250a6cb93Swwang u8 value; 56350a6cb93Swwang 564e931830bSedwin_rong US_DEBUGP("%s: <---\n", __func__); 565e931830bSedwin_rong 56650a6cb93Swwang if (!CHK_AUTO_DELINK(chip)) 56750a6cb93Swwang return 0; 56850a6cb93Swwang 56950a6cb93Swwang retval = rts51x_read_mem(us, 0xFE47, &value, 1); 57050a6cb93Swwang if (retval < 0) 57150a6cb93Swwang return -EIO; 57250a6cb93Swwang 57350a6cb93Swwang if (auto_delink_en) { 57450a6cb93Swwang CLR_BIT(value, 0); 57550a6cb93Swwang CLR_BIT(value, 1); 57650a6cb93Swwang SET_BIT(value, 2); 57750a6cb93Swwang 57850a6cb93Swwang if (CHECK_ID(chip, 0x0138, 0x3882)) 57950a6cb93Swwang CLR_BIT(value, 2); 58050a6cb93Swwang 58150a6cb93Swwang SET_BIT(value, 7); 58250a6cb93Swwang 58345e1892eSedwin_rong /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */ 58445e1892eSedwin_rong retval = __do_config_autodelink(us, &value, 1); 58550a6cb93Swwang if (retval < 0) 58650a6cb93Swwang return -EIO; 58750a6cb93Swwang 58850a6cb93Swwang retval = enable_oscillator(us); 58950a6cb93Swwang if (retval == 0) 59050a6cb93Swwang (void)do_config_autodelink(us, 1, 0); 59150a6cb93Swwang } else { 59250a6cb93Swwang /* Autodelink controlled by firmware */ 59350a6cb93Swwang 59450a6cb93Swwang SET_BIT(value, 2); 59550a6cb93Swwang 59650a6cb93Swwang if (CHECK_ID(chip, 0x0138, 0x3882)) 59750a6cb93Swwang CLR_BIT(value, 2); 59850a6cb93Swwang 59950a6cb93Swwang if (CHECK_ID(chip, 0x0159, 0x5889) || 60050a6cb93Swwang CHECK_ID(chip, 0x0138, 0x3880)) { 60150a6cb93Swwang CLR_BIT(value, 0); 60250a6cb93Swwang CLR_BIT(value, 7); 60350a6cb93Swwang } 60450a6cb93Swwang 60545e1892eSedwin_rong /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */ 60645e1892eSedwin_rong retval = __do_config_autodelink(us, &value, 1); 60750a6cb93Swwang if (retval < 0) 60850a6cb93Swwang return -EIO; 60950a6cb93Swwang 61050a6cb93Swwang if (CHECK_ID(chip, 0x0159, 0x5888)) { 61150a6cb93Swwang value = 0xFF; 61250a6cb93Swwang retval = rts51x_write_mem(us, 0xFE79, &value, 1); 61350a6cb93Swwang if (retval < 0) 61450a6cb93Swwang return -EIO; 61550a6cb93Swwang 61650a6cb93Swwang value = 0x01; 61750a6cb93Swwang retval = rts51x_write_mem(us, 0x48, &value, 1); 61850a6cb93Swwang if (retval < 0) 61950a6cb93Swwang return -EIO; 62050a6cb93Swwang } 62150a6cb93Swwang } 62250a6cb93Swwang 623e931830bSedwin_rong US_DEBUGP("%s: --->\n", __func__); 624e931830bSedwin_rong 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 634e931830bSedwin_rong US_DEBUGP("%s: <---\n", __func__); 635e931830bSedwin_rong 63650a6cb93Swwang if (!CHK_AUTO_DELINK(chip)) 63750a6cb93Swwang return 0; 63850a6cb93Swwang 63950a6cb93Swwang if (auto_delink_en) { 64050a6cb93Swwang retval = rts51x_read_mem(us, 0xFE77, &value, 1); 64150a6cb93Swwang if (retval < 0) 64250a6cb93Swwang return -EIO; 64350a6cb93Swwang 64450a6cb93Swwang SET_BIT(value, 2); 64550a6cb93Swwang retval = rts51x_write_mem(us, 0xFE77, &value, 1); 64650a6cb93Swwang if (retval < 0) 64750a6cb93Swwang return -EIO; 64850a6cb93Swwang 64950a6cb93Swwang if (CHECK_ID(chip, 0x0159, 0x5888)) { 65050a6cb93Swwang value = 0x01; 65150a6cb93Swwang retval = rts51x_write_mem(us, 0x48, &value, 1); 65250a6cb93Swwang if (retval < 0) 65350a6cb93Swwang return -EIO; 65450a6cb93Swwang } 65550a6cb93Swwang 65650a6cb93Swwang retval = rts51x_read_mem(us, 0xFE47, &value, 1); 65750a6cb93Swwang if (retval < 0) 65850a6cb93Swwang return -EIO; 65950a6cb93Swwang 66050a6cb93Swwang SET_BIT(value, 0); 66150a6cb93Swwang if (CHECK_ID(chip, 0x0138, 0x3882)) 66250a6cb93Swwang SET_BIT(value, 2); 66350a6cb93Swwang retval = rts51x_write_mem(us, 0xFE77, &value, 1); 66450a6cb93Swwang if (retval < 0) 66550a6cb93Swwang return -EIO; 66650a6cb93Swwang } else { 66750a6cb93Swwang if (CHECK_ID(chip, 0x0159, 0x5889) || 66850a6cb93Swwang CHECK_ID(chip, 0x0138, 0x3880) || 66950a6cb93Swwang CHECK_ID(chip, 0x0138, 0x3882)) { 67050a6cb93Swwang retval = rts51x_read_mem(us, 0xFE47, &value, 1); 67150a6cb93Swwang if (retval < 0) 67250a6cb93Swwang return -EIO; 67350a6cb93Swwang 67450a6cb93Swwang if (CHECK_ID(chip, 0x0159, 0x5889) || 67550a6cb93Swwang CHECK_ID(chip, 0x0138, 0x3880)) { 67650a6cb93Swwang SET_BIT(value, 0); 67750a6cb93Swwang SET_BIT(value, 7); 67850a6cb93Swwang } 67950a6cb93Swwang 68050a6cb93Swwang if (CHECK_ID(chip, 0x0138, 0x3882)) 68150a6cb93Swwang SET_BIT(value, 2); 68250a6cb93Swwang 68345e1892eSedwin_rong /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */ 68445e1892eSedwin_rong retval = __do_config_autodelink(us, &value, 1); 68550a6cb93Swwang if (retval < 0) 68650a6cb93Swwang return -EIO; 68750a6cb93Swwang } 68850a6cb93Swwang 68950a6cb93Swwang if (CHECK_ID(chip, 0x0159, 0x5888)) { 69050a6cb93Swwang value = 0x01; 69150a6cb93Swwang retval = rts51x_write_mem(us, 0x48, &value, 1); 69250a6cb93Swwang if (retval < 0) 69350a6cb93Swwang return -EIO; 69450a6cb93Swwang } 69550a6cb93Swwang } 69650a6cb93Swwang 697e931830bSedwin_rong US_DEBUGP("%s: --->\n", __func__); 698e931830bSedwin_rong 69950a6cb93Swwang return 0; 70050a6cb93Swwang } 70150a6cb93Swwang 702e931830bSedwin_rong static void fw5895_init(struct us_data *us) 703e931830bSedwin_rong { 704e931830bSedwin_rong struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra); 705e931830bSedwin_rong int retval; 706e931830bSedwin_rong u8 val; 707e931830bSedwin_rong 708e931830bSedwin_rong US_DEBUGP("%s: <---\n", __func__); 709e931830bSedwin_rong 710e931830bSedwin_rong if ((PRODUCT_ID(chip) != 0x0158) || (FW_VERSION(chip) != 0x5895)) { 711e931830bSedwin_rong US_DEBUGP("Not the specified device, return immediately!\n"); 712e931830bSedwin_rong } else { 713e931830bSedwin_rong retval = rts51x_read_mem(us, 0xFD6F, &val, 1); 714e931830bSedwin_rong if (retval == STATUS_SUCCESS && (val & 0x1F) == 0) { 715e931830bSedwin_rong val = 0x1F; 716e931830bSedwin_rong retval = rts51x_write_mem(us, 0xFD70, &val, 1); 717e931830bSedwin_rong if (retval != STATUS_SUCCESS) 718e931830bSedwin_rong US_DEBUGP("Write memory fail\n"); 719e931830bSedwin_rong } else { 720e931830bSedwin_rong US_DEBUGP("Read memory fail, OR (val & 0x1F) != 0\n"); 721e931830bSedwin_rong } 722e931830bSedwin_rong } 723e931830bSedwin_rong 724e931830bSedwin_rong US_DEBUGP("%s: --->\n", __func__); 725e931830bSedwin_rong } 726e931830bSedwin_rong 727e931830bSedwin_rong #ifdef CONFIG_REALTEK_AUTOPM 728e931830bSedwin_rong static void fw5895_set_mmc_wp(struct us_data *us) 729e931830bSedwin_rong { 730e931830bSedwin_rong struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra); 731e931830bSedwin_rong int retval; 732e931830bSedwin_rong u8 buf[13]; 733e931830bSedwin_rong 734e931830bSedwin_rong US_DEBUGP("%s: <---\n", __func__); 735e931830bSedwin_rong 736e931830bSedwin_rong if ((PRODUCT_ID(chip) != 0x0158) || (FW_VERSION(chip) != 0x5895)) { 737e931830bSedwin_rong US_DEBUGP("Not the specified device, return immediately!\n"); 738e931830bSedwin_rong } else { 739e931830bSedwin_rong retval = rts51x_read_mem(us, 0xFD6F, buf, 1); 740e931830bSedwin_rong if (retval == STATUS_SUCCESS && (buf[0] & 0x24) == 0x24) { 741e931830bSedwin_rong /* SD Exist and SD WP */ 742e931830bSedwin_rong retval = rts51x_read_mem(us, 0xD04E, buf, 1); 743e931830bSedwin_rong if (retval == STATUS_SUCCESS) { 744e931830bSedwin_rong buf[0] |= 0x04; 745e931830bSedwin_rong retval = rts51x_write_mem(us, 0xFD70, buf, 1); 746e931830bSedwin_rong if (retval != STATUS_SUCCESS) 747e931830bSedwin_rong US_DEBUGP("Write memory fail\n"); 748e931830bSedwin_rong } else { 749e931830bSedwin_rong US_DEBUGP("Read memory fail\n"); 750e931830bSedwin_rong } 751e931830bSedwin_rong } else { 752e931830bSedwin_rong US_DEBUGP("Read memory fail, OR (buf[0]&0x24)!=0x24\n"); 753e931830bSedwin_rong } 754e931830bSedwin_rong } 755e931830bSedwin_rong 756e931830bSedwin_rong US_DEBUGP("%s: --->\n", __func__); 757e931830bSedwin_rong } 758e931830bSedwin_rong 759e931830bSedwin_rong static void rts51x_modi_suspend_timer(struct rts51x_chip *chip) 760e931830bSedwin_rong { 761e931830bSedwin_rong US_DEBUGP("%s: <---, state:%d\n", __func__, rts51x_get_stat(chip)); 762e931830bSedwin_rong 763e931830bSedwin_rong chip->timer_expires = jiffies + msecs_to_jiffies(1000*ss_delay); 764e931830bSedwin_rong mod_timer(&chip->rts51x_suspend_timer, chip->timer_expires); 765e931830bSedwin_rong 766e931830bSedwin_rong US_DEBUGP("%s: --->\n", __func__); 767e931830bSedwin_rong } 768e931830bSedwin_rong 769e931830bSedwin_rong static void rts51x_suspend_timer_fn(unsigned long data) 770e931830bSedwin_rong { 771e931830bSedwin_rong struct rts51x_chip *chip = (struct rts51x_chip *)data; 772e931830bSedwin_rong struct us_data *us = chip->us; 773e931830bSedwin_rong 774e931830bSedwin_rong US_DEBUGP("%s: <---\n", __func__); 775e931830bSedwin_rong 776e931830bSedwin_rong switch (rts51x_get_stat(chip)) { 777e931830bSedwin_rong case RTS51X_STAT_INIT: 778e931830bSedwin_rong case RTS51X_STAT_RUN: 779e931830bSedwin_rong rts51x_modi_suspend_timer(chip); 780e931830bSedwin_rong break; 781e931830bSedwin_rong case RTS51X_STAT_IDLE: 782e931830bSedwin_rong case RTS51X_STAT_SS: 783e931830bSedwin_rong US_DEBUGP("%s: RTS51X_STAT_SS, intf->pm_usage_cnt:%d," 784e931830bSedwin_rong "power.usage:%d\n", __func__, 785e931830bSedwin_rong atomic_read(&us->pusb_intf->pm_usage_cnt), 786e931830bSedwin_rong atomic_read(&us->pusb_intf->dev.power.usage_count)); 787e931830bSedwin_rong 788e931830bSedwin_rong if (atomic_read(&us->pusb_intf->pm_usage_cnt) > 0) { 789e931830bSedwin_rong US_DEBUGP("%s: Ready to enter SS state.\n", 790e931830bSedwin_rong __func__); 791e931830bSedwin_rong rts51x_set_stat(chip, RTS51X_STAT_SS); 792e931830bSedwin_rong /* ignore mass storage interface's children */ 793e931830bSedwin_rong pm_suspend_ignore_children(&us->pusb_intf->dev, true); 794e931830bSedwin_rong usb_autopm_put_interface(us->pusb_intf); 795e931830bSedwin_rong US_DEBUGP("%s: RTS51X_STAT_SS 01," 796e931830bSedwin_rong "intf->pm_usage_cnt:%d, power.usage:%d\n", 797e931830bSedwin_rong __func__, 798e931830bSedwin_rong atomic_read(&us->pusb_intf->pm_usage_cnt), 799e931830bSedwin_rong atomic_read( 800e931830bSedwin_rong &us->pusb_intf->dev.power.usage_count)); 801e931830bSedwin_rong } 802e931830bSedwin_rong break; 803e931830bSedwin_rong default: 804e931830bSedwin_rong US_DEBUGP("%s: Unknonwn state !!!\n", __func__); 805e931830bSedwin_rong break; 806e931830bSedwin_rong } 807e931830bSedwin_rong 808e931830bSedwin_rong US_DEBUGP("%s: --->\n", __func__); 809e931830bSedwin_rong } 810e931830bSedwin_rong 811e931830bSedwin_rong static inline int working_scsi(struct scsi_cmnd *srb) 812e931830bSedwin_rong { 813e931830bSedwin_rong if ((srb->cmnd[0] == TEST_UNIT_READY) || 814e931830bSedwin_rong (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL)) { 815e931830bSedwin_rong return 0; 816e931830bSedwin_rong } 817e931830bSedwin_rong 818e931830bSedwin_rong return 1; 819e931830bSedwin_rong } 820e931830bSedwin_rong 821e931830bSedwin_rong void rts51x_invoke_transport(struct scsi_cmnd *srb, struct us_data *us) 822e931830bSedwin_rong { 823e931830bSedwin_rong struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra); 824e931830bSedwin_rong static int card_first_show = 1; 825e931830bSedwin_rong static u8 media_not_present[] = { 0x70, 0, 0x02, 0, 0, 0, 0, 826e931830bSedwin_rong 10, 0, 0, 0, 0, 0x3A, 0, 0, 0, 0, 0 827e931830bSedwin_rong }; 828e931830bSedwin_rong static u8 invalid_cmd_field[] = { 0x70, 0, 0x05, 0, 0, 0, 0, 829e931830bSedwin_rong 10, 0, 0, 0, 0, 0x24, 0, 0, 0, 0, 0 830e931830bSedwin_rong }; 831e931830bSedwin_rong int ret; 832e931830bSedwin_rong 833e931830bSedwin_rong US_DEBUGP("%s: <---\n", __func__); 834e931830bSedwin_rong 835e931830bSedwin_rong if (working_scsi(srb)) { 836e931830bSedwin_rong US_DEBUGP("%s: working scsi, intf->pm_usage_cnt:%d," 837e931830bSedwin_rong "power.usage:%d\n", __func__, 838e931830bSedwin_rong atomic_read(&us->pusb_intf->pm_usage_cnt), 839e931830bSedwin_rong atomic_read(&us->pusb_intf->dev.power.usage_count)); 840e931830bSedwin_rong 841e931830bSedwin_rong if (atomic_read(&us->pusb_intf->pm_usage_cnt) <= 0) { 842e931830bSedwin_rong ret = usb_autopm_get_interface(us->pusb_intf); 843e931830bSedwin_rong US_DEBUGP("%s: working scsi, ret=%d\n", __func__, ret); 844e931830bSedwin_rong } 845e931830bSedwin_rong if (rts51x_get_stat(chip) != RTS51X_STAT_RUN) 846e931830bSedwin_rong rts51x_set_stat(chip, RTS51X_STAT_RUN); 847e931830bSedwin_rong chip->proto_handler_backup(srb, us); 848e931830bSedwin_rong } else { 849e931830bSedwin_rong if (rts51x_get_stat(chip) == RTS51X_STAT_SS) { 850e931830bSedwin_rong US_DEBUGP("%s: NOT working scsi\n", __func__); 851e931830bSedwin_rong if ((srb->cmnd[0] == TEST_UNIT_READY) && 852e931830bSedwin_rong (chip->pwr_state == US_SUSPEND)) { 853e931830bSedwin_rong if (TST_LUN_READY(chip, srb->device->lun)) { 854e931830bSedwin_rong srb->result = SAM_STAT_GOOD; 855e931830bSedwin_rong } else { 856e931830bSedwin_rong srb->result = SAM_STAT_CHECK_CONDITION; 857e931830bSedwin_rong memcpy(srb->sense_buffer, 858e931830bSedwin_rong media_not_present, 859e931830bSedwin_rong US_SENSE_SIZE); 860e931830bSedwin_rong } 861e931830bSedwin_rong US_DEBUGP("%s: TEST_UNIT_READY--->\n", 862e931830bSedwin_rong __func__); 863e931830bSedwin_rong goto out; 864e931830bSedwin_rong } 865e931830bSedwin_rong if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) { 866e931830bSedwin_rong int prevent = srb->cmnd[4] & 0x1; 867e931830bSedwin_rong if (prevent) { 868e931830bSedwin_rong srb->result = SAM_STAT_CHECK_CONDITION; 869e931830bSedwin_rong memcpy(srb->sense_buffer, 870e931830bSedwin_rong invalid_cmd_field, 871e931830bSedwin_rong US_SENSE_SIZE); 872e931830bSedwin_rong } else { 873e931830bSedwin_rong srb->result = SAM_STAT_GOOD; 874e931830bSedwin_rong } 875e931830bSedwin_rong US_DEBUGP("%s: ALLOW_MEDIUM_REMOVAL--->\n", 876e931830bSedwin_rong __func__); 877e931830bSedwin_rong goto out; 878e931830bSedwin_rong } 879e931830bSedwin_rong } else { 880e931830bSedwin_rong US_DEBUGP("%s: NOT working scsi, not SS\n", __func__); 881e931830bSedwin_rong chip->proto_handler_backup(srb, us); 882e931830bSedwin_rong /* Check wether card is plugged in */ 883e931830bSedwin_rong if (srb->cmnd[0] == TEST_UNIT_READY) { 884e931830bSedwin_rong if (srb->result == SAM_STAT_GOOD) { 885e931830bSedwin_rong SET_LUN_READY(chip, srb->device->lun); 886e931830bSedwin_rong if (card_first_show) { 887e931830bSedwin_rong card_first_show = 0; 888e931830bSedwin_rong fw5895_set_mmc_wp(us); 889e931830bSedwin_rong } 890e931830bSedwin_rong } else { 891e931830bSedwin_rong CLR_LUN_READY(chip, srb->device->lun); 892e931830bSedwin_rong card_first_show = 1; 893e931830bSedwin_rong } 894e931830bSedwin_rong } 895e931830bSedwin_rong if (rts51x_get_stat(chip) != RTS51X_STAT_IDLE) 896e931830bSedwin_rong rts51x_set_stat(chip, RTS51X_STAT_IDLE); 897e931830bSedwin_rong } 898e931830bSedwin_rong } 899e931830bSedwin_rong out: 900e931830bSedwin_rong US_DEBUGP("%s: state:%d\n", __func__, rts51x_get_stat(chip)); 901e931830bSedwin_rong if (rts51x_get_stat(chip) == RTS51X_STAT_RUN) 902e931830bSedwin_rong rts51x_modi_suspend_timer(chip); 903e931830bSedwin_rong 904e931830bSedwin_rong US_DEBUGP("%s: --->\n", __func__); 905e931830bSedwin_rong } 906e931830bSedwin_rong 907e931830bSedwin_rong static int realtek_cr_autosuspend_setup(struct us_data *us) 908e931830bSedwin_rong { 909e931830bSedwin_rong struct rts51x_chip *chip; 910e931830bSedwin_rong struct rts51x_status *status = NULL; 911e931830bSedwin_rong u8 buf[16]; 912e931830bSedwin_rong int retval; 913e931830bSedwin_rong 914e931830bSedwin_rong chip = (struct rts51x_chip *)us->extra; 915e931830bSedwin_rong chip->support_auto_delink = 0; 916e931830bSedwin_rong chip->pwr_state = US_RESUME; 917e931830bSedwin_rong chip->lun_ready = 0; 918e931830bSedwin_rong rts51x_set_stat(chip, RTS51X_STAT_INIT); 919e931830bSedwin_rong 920e931830bSedwin_rong retval = rts51x_read_status(us, 0, buf, 16, &(chip->status_len)); 921e931830bSedwin_rong if (retval != STATUS_SUCCESS) { 922e931830bSedwin_rong US_DEBUGP("Read status fail\n"); 923e931830bSedwin_rong return -EIO; 924e931830bSedwin_rong } 925e931830bSedwin_rong status = chip->status; 926e931830bSedwin_rong status->vid = ((u16) buf[0] << 8) | buf[1]; 927e931830bSedwin_rong status->pid = ((u16) buf[2] << 8) | buf[3]; 928e931830bSedwin_rong status->cur_lun = buf[4]; 929e931830bSedwin_rong status->card_type = buf[5]; 930e931830bSedwin_rong status->total_lun = buf[6]; 931e931830bSedwin_rong status->fw_ver = ((u16) buf[7] << 8) | buf[8]; 932e931830bSedwin_rong status->phy_exist = buf[9]; 933e931830bSedwin_rong status->multi_flag = buf[10]; 934e931830bSedwin_rong status->multi_card = buf[11]; 935e931830bSedwin_rong status->log_exist = buf[12]; 936e931830bSedwin_rong if (chip->status_len == 16) { 937e931830bSedwin_rong status->detailed_type.detailed_type1 = buf[13]; 938e931830bSedwin_rong status->function[0] = buf[14]; 939e931830bSedwin_rong status->function[1] = buf[15]; 940e931830bSedwin_rong } 941e931830bSedwin_rong 942e931830bSedwin_rong /* back up the proto_handler in us->extra */ 943e931830bSedwin_rong chip = (struct rts51x_chip *)(us->extra); 944e931830bSedwin_rong chip->proto_handler_backup = us->proto_handler; 945e931830bSedwin_rong /* Set the autosuspend_delay to 0 */ 946e931830bSedwin_rong pm_runtime_set_autosuspend_delay(&us->pusb_dev->dev, 0); 947e931830bSedwin_rong /* override us->proto_handler setted in get_protocol() */ 948e931830bSedwin_rong us->proto_handler = rts51x_invoke_transport; 949e931830bSedwin_rong 950e931830bSedwin_rong chip->timer_expires = 0; 951e931830bSedwin_rong setup_timer(&chip->rts51x_suspend_timer, rts51x_suspend_timer_fn, 952e931830bSedwin_rong (unsigned long)chip); 953e931830bSedwin_rong fw5895_init(us); 954e931830bSedwin_rong 955e931830bSedwin_rong /* enable autosuspend funciton of the usb device */ 956e931830bSedwin_rong usb_enable_autosuspend(us->pusb_dev); 957e931830bSedwin_rong 958e931830bSedwin_rong return 0; 959e931830bSedwin_rong } 960e931830bSedwin_rong #endif 961e931830bSedwin_rong 96250a6cb93Swwang static void realtek_cr_destructor(void *extra) 96350a6cb93Swwang { 96450a6cb93Swwang struct rts51x_chip *chip = (struct rts51x_chip *)extra; 96550a6cb93Swwang 966e931830bSedwin_rong US_DEBUGP("%s: <---\n", __func__); 967e931830bSedwin_rong 96850a6cb93Swwang if (!chip) 96950a6cb93Swwang return; 970e931830bSedwin_rong #ifdef CONFIG_REALTEK_AUTOPM 971e931830bSedwin_rong if (ss_en) { 972e931830bSedwin_rong del_timer(&chip->rts51x_suspend_timer); 973e931830bSedwin_rong chip->timer_expires = 0; 974e931830bSedwin_rong } 975e931830bSedwin_rong #endif 97650a6cb93Swwang kfree(chip->status); 97750a6cb93Swwang } 97850a6cb93Swwang 97950a6cb93Swwang #ifdef CONFIG_PM 980e931830bSedwin_rong int realtek_cr_suspend(struct usb_interface *iface, pm_message_t message) 98150a6cb93Swwang { 982e931830bSedwin_rong struct us_data *us = usb_get_intfdata(iface); 983e931830bSedwin_rong 984e931830bSedwin_rong US_DEBUGP("%s: <---\n", __func__); 985e931830bSedwin_rong 986e931830bSedwin_rong /* wait until no command is running */ 987e931830bSedwin_rong mutex_lock(&us->dev_mutex); 988e931830bSedwin_rong 989e931830bSedwin_rong config_autodelink_before_power_down(us); 990e931830bSedwin_rong 991e931830bSedwin_rong mutex_unlock(&us->dev_mutex); 992e931830bSedwin_rong 993e931830bSedwin_rong US_DEBUGP("%s: --->\n", __func__); 994e931830bSedwin_rong 995e931830bSedwin_rong return 0; 99650a6cb93Swwang } 997e931830bSedwin_rong 998e931830bSedwin_rong static int realtek_cr_resume(struct usb_interface *iface) 999e931830bSedwin_rong { 1000e931830bSedwin_rong struct us_data *us = usb_get_intfdata(iface); 1001e931830bSedwin_rong 1002e931830bSedwin_rong US_DEBUGP("%s: <---\n", __func__); 1003e931830bSedwin_rong 1004e931830bSedwin_rong fw5895_init(us); 1005e931830bSedwin_rong config_autodelink_after_power_on(us); 1006e931830bSedwin_rong 1007e931830bSedwin_rong US_DEBUGP("%s: --->\n", __func__); 1008e931830bSedwin_rong 1009e931830bSedwin_rong return 0; 1010e931830bSedwin_rong } 1011e931830bSedwin_rong #else 1012e931830bSedwin_rong #define realtek_cr_suspend NULL 1013e931830bSedwin_rong #define realtek_cr_resume NULL 101450a6cb93Swwang #endif 101550a6cb93Swwang 101650a6cb93Swwang static int init_realtek_cr(struct us_data *us) 101750a6cb93Swwang { 101850a6cb93Swwang struct rts51x_chip *chip; 101950a6cb93Swwang int size, i, retval; 102050a6cb93Swwang 102150a6cb93Swwang chip = kzalloc(sizeof(struct rts51x_chip), GFP_KERNEL); 102250a6cb93Swwang if (!chip) 102350a6cb93Swwang return -ENOMEM; 102450a6cb93Swwang 102550a6cb93Swwang us->extra = chip; 102650a6cb93Swwang us->extra_destructor = realtek_cr_destructor; 102750a6cb93Swwang us->max_lun = chip->max_lun = rts51x_get_max_lun(us); 102850a6cb93Swwang 102950a6cb93Swwang US_DEBUGP("chip->max_lun = %d\n", chip->max_lun); 103050a6cb93Swwang 103150a6cb93Swwang size = (chip->max_lun + 1) * sizeof(struct rts51x_status); 103250a6cb93Swwang chip->status = kzalloc(size, GFP_KERNEL); 103350a6cb93Swwang if (!chip->status) 103450a6cb93Swwang goto INIT_FAIL; 103550a6cb93Swwang 103650a6cb93Swwang for (i = 0; i <= (int)(chip->max_lun); i++) { 103750a6cb93Swwang retval = rts51x_check_status(us, (u8) i); 103850a6cb93Swwang if (retval < 0) 103950a6cb93Swwang goto INIT_FAIL; 104050a6cb93Swwang } 104150a6cb93Swwang 104250a6cb93Swwang if (CHECK_FW_VER(chip, 0x5888) || CHECK_FW_VER(chip, 0x5889) || 104350a6cb93Swwang CHECK_FW_VER(chip, 0x5901)) 104450a6cb93Swwang SET_AUTO_DELINK(chip); 104550a6cb93Swwang if (STATUS_LEN(chip) == 16) { 104650a6cb93Swwang if (SUPPORT_AUTO_DELINK(chip)) 104750a6cb93Swwang SET_AUTO_DELINK(chip); 104850a6cb93Swwang } 1049e931830bSedwin_rong #ifdef CONFIG_REALTEK_AUTOPM 1050e931830bSedwin_rong if (ss_en) { 1051e931830bSedwin_rong chip->us = us; 1052e931830bSedwin_rong realtek_cr_autosuspend_setup(us); 1053e931830bSedwin_rong } 1054e931830bSedwin_rong #endif 105550a6cb93Swwang 105650a6cb93Swwang US_DEBUGP("chip->flag = 0x%x\n", chip->flag); 105750a6cb93Swwang 105850a6cb93Swwang (void)config_autodelink_after_power_on(us); 105950a6cb93Swwang 106050a6cb93Swwang return 0; 106150a6cb93Swwang 106250a6cb93Swwang INIT_FAIL: 106350a6cb93Swwang if (us->extra) { 106450a6cb93Swwang kfree(chip->status); 106550a6cb93Swwang kfree(us->extra); 106650a6cb93Swwang us->extra = NULL; 106750a6cb93Swwang } 106850a6cb93Swwang 106950a6cb93Swwang return -EIO; 107050a6cb93Swwang } 107150a6cb93Swwang 107250a6cb93Swwang static int realtek_cr_probe(struct usb_interface *intf, 107350a6cb93Swwang const struct usb_device_id *id) 107450a6cb93Swwang { 107550a6cb93Swwang struct us_data *us; 107650a6cb93Swwang int result; 107750a6cb93Swwang 107850a6cb93Swwang US_DEBUGP("Probe Realtek Card Reader!\n"); 107950a6cb93Swwang 108050a6cb93Swwang result = usb_stor_probe1(&us, intf, id, 1081151d9fadSedwin_rong (id - realtek_cr_ids) + 1082151d9fadSedwin_rong realtek_cr_unusual_dev_list); 108350a6cb93Swwang if (result) 108450a6cb93Swwang return result; 108550a6cb93Swwang 108650a6cb93Swwang result = usb_stor_probe2(us); 1087151d9fadSedwin_rong 108850a6cb93Swwang return result; 108950a6cb93Swwang } 109050a6cb93Swwang 109150a6cb93Swwang static struct usb_driver realtek_cr_driver = { 109250a6cb93Swwang .name = "ums-realtek", 109350a6cb93Swwang .probe = realtek_cr_probe, 109450a6cb93Swwang .disconnect = usb_stor_disconnect, 1095e931830bSedwin_rong /* .suspend = usb_stor_suspend, */ 1096e931830bSedwin_rong /* .resume = usb_stor_resume, */ 109750a6cb93Swwang .reset_resume = usb_stor_reset_resume, 1098e931830bSedwin_rong .suspend = realtek_cr_suspend, 1099e931830bSedwin_rong .resume = realtek_cr_resume, 110050a6cb93Swwang .pre_reset = usb_stor_pre_reset, 110150a6cb93Swwang .post_reset = usb_stor_post_reset, 110250a6cb93Swwang .id_table = realtek_cr_ids, 110350a6cb93Swwang .soft_unbind = 1, 1104e931830bSedwin_rong .supports_autosuspend = 1, 110550a6cb93Swwang }; 110650a6cb93Swwang 110765db4305SGreg Kroah-Hartman module_usb_driver(realtek_cr_driver); 1108