Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /* Driver for Realtek USB card reader
0003  *
0004  * Copyright(c) 2009-2013 Realtek Semiconductor Corp. All rights reserved.
0005  *
0006  * Author:
0007  *   Roger Tseng <rogerable@realtek.com>
0008  */
0009 #include <linux/module.h>
0010 #include <linux/slab.h>
0011 #include <linux/mutex.h>
0012 #include <linux/usb.h>
0013 #include <linux/platform_device.h>
0014 #include <linux/mfd/core.h>
0015 #include <linux/rtsx_usb.h>
0016 
0017 static int polling_pipe = 1;
0018 module_param(polling_pipe, int, S_IRUGO | S_IWUSR);
0019 MODULE_PARM_DESC(polling_pipe, "polling pipe (0: ctl, 1: bulk)");
0020 
0021 static const struct mfd_cell rtsx_usb_cells[] = {
0022     [RTSX_USB_SD_CARD] = {
0023         .name = "rtsx_usb_sdmmc",
0024         .pdata_size = 0,
0025     },
0026     [RTSX_USB_MS_CARD] = {
0027         .name = "rtsx_usb_ms",
0028         .pdata_size = 0,
0029     },
0030 };
0031 
0032 static void rtsx_usb_sg_timed_out(struct timer_list *t)
0033 {
0034     struct rtsx_ucr *ucr = from_timer(ucr, t, sg_timer);
0035 
0036     dev_dbg(&ucr->pusb_intf->dev, "%s: sg transfer timed out", __func__);
0037     usb_sg_cancel(&ucr->current_sg);
0038 }
0039 
0040 static int rtsx_usb_bulk_transfer_sglist(struct rtsx_ucr *ucr,
0041         unsigned int pipe, struct scatterlist *sg, int num_sg,
0042         unsigned int length, unsigned int *act_len, int timeout)
0043 {
0044     int ret;
0045 
0046     dev_dbg(&ucr->pusb_intf->dev, "%s: xfer %u bytes, %d entries\n",
0047             __func__, length, num_sg);
0048     ret = usb_sg_init(&ucr->current_sg, ucr->pusb_dev, pipe, 0,
0049             sg, num_sg, length, GFP_NOIO);
0050     if (ret)
0051         return ret;
0052 
0053     ucr->sg_timer.expires = jiffies + msecs_to_jiffies(timeout);
0054     add_timer(&ucr->sg_timer);
0055     usb_sg_wait(&ucr->current_sg);
0056     if (!del_timer_sync(&ucr->sg_timer))
0057         ret = -ETIMEDOUT;
0058     else
0059         ret = ucr->current_sg.status;
0060 
0061     if (act_len)
0062         *act_len = ucr->current_sg.bytes;
0063 
0064     return ret;
0065 }
0066 
0067 int rtsx_usb_transfer_data(struct rtsx_ucr *ucr, unsigned int pipe,
0068                   void *buf, unsigned int len, int num_sg,
0069                   unsigned int *act_len, int timeout)
0070 {
0071     if (timeout < 600)
0072         timeout = 600;
0073 
0074     if (num_sg)
0075         return rtsx_usb_bulk_transfer_sglist(ucr, pipe,
0076                 (struct scatterlist *)buf, num_sg, len, act_len,
0077                 timeout);
0078     else
0079         return usb_bulk_msg(ucr->pusb_dev, pipe, buf, len, act_len,
0080                 timeout);
0081 }
0082 EXPORT_SYMBOL_GPL(rtsx_usb_transfer_data);
0083 
0084 static inline void rtsx_usb_seq_cmd_hdr(struct rtsx_ucr *ucr,
0085         u16 addr, u16 len, u8 seq_type)
0086 {
0087     rtsx_usb_cmd_hdr_tag(ucr);
0088 
0089     ucr->cmd_buf[PACKET_TYPE] = seq_type;
0090     ucr->cmd_buf[5] = (u8)(len >> 8);
0091     ucr->cmd_buf[6] = (u8)len;
0092     ucr->cmd_buf[8] = (u8)(addr >> 8);
0093     ucr->cmd_buf[9] = (u8)addr;
0094 
0095     if (seq_type == SEQ_WRITE)
0096         ucr->cmd_buf[STAGE_FLAG] = 0;
0097     else
0098         ucr->cmd_buf[STAGE_FLAG] = STAGE_R;
0099 }
0100 
0101 static int rtsx_usb_seq_write_register(struct rtsx_ucr *ucr,
0102         u16 addr, u16 len, u8 *data)
0103 {
0104     u16 cmd_len = ALIGN(SEQ_WRITE_DATA_OFFSET + len, 4);
0105 
0106     if (!data)
0107         return -EINVAL;
0108 
0109     if (cmd_len > IOBUF_SIZE)
0110         return -EINVAL;
0111 
0112     rtsx_usb_seq_cmd_hdr(ucr, addr, len, SEQ_WRITE);
0113     memcpy(ucr->cmd_buf + SEQ_WRITE_DATA_OFFSET, data, len);
0114 
0115     return rtsx_usb_transfer_data(ucr,
0116             usb_sndbulkpipe(ucr->pusb_dev, EP_BULK_OUT),
0117             ucr->cmd_buf, cmd_len, 0, NULL, 100);
0118 }
0119 
0120 static int rtsx_usb_seq_read_register(struct rtsx_ucr *ucr,
0121         u16 addr, u16 len, u8 *data)
0122 {
0123     int i, ret;
0124     u16 rsp_len = round_down(len, 4);
0125     u16 res_len = len - rsp_len;
0126 
0127     if (!data)
0128         return -EINVAL;
0129 
0130     /* 4-byte aligned part */
0131     if (rsp_len) {
0132         rtsx_usb_seq_cmd_hdr(ucr, addr, len, SEQ_READ);
0133         ret = rtsx_usb_transfer_data(ucr,
0134                 usb_sndbulkpipe(ucr->pusb_dev, EP_BULK_OUT),
0135                 ucr->cmd_buf, 12, 0, NULL, 100);
0136         if (ret)
0137             return ret;
0138 
0139         ret = rtsx_usb_transfer_data(ucr,
0140                 usb_rcvbulkpipe(ucr->pusb_dev, EP_BULK_IN),
0141                 data, rsp_len, 0, NULL, 100);
0142         if (ret)
0143             return ret;
0144     }
0145 
0146     /* unaligned part */
0147     for (i = 0; i < res_len; i++) {
0148         ret = rtsx_usb_read_register(ucr, addr + rsp_len + i,
0149                 data + rsp_len + i);
0150         if (ret)
0151             return ret;
0152     }
0153 
0154     return 0;
0155 }
0156 
0157 int rtsx_usb_read_ppbuf(struct rtsx_ucr *ucr, u8 *buf, int buf_len)
0158 {
0159     return rtsx_usb_seq_read_register(ucr, PPBUF_BASE2, (u16)buf_len, buf);
0160 }
0161 EXPORT_SYMBOL_GPL(rtsx_usb_read_ppbuf);
0162 
0163 int rtsx_usb_write_ppbuf(struct rtsx_ucr *ucr, u8 *buf, int buf_len)
0164 {
0165     return rtsx_usb_seq_write_register(ucr, PPBUF_BASE2, (u16)buf_len, buf);
0166 }
0167 EXPORT_SYMBOL_GPL(rtsx_usb_write_ppbuf);
0168 
0169 int rtsx_usb_ep0_write_register(struct rtsx_ucr *ucr, u16 addr,
0170         u8 mask, u8 data)
0171 {
0172     u16 value, index;
0173 
0174     addr |= EP0_WRITE_REG_CMD << EP0_OP_SHIFT;
0175     value = swab16(addr);
0176     index = mask | data << 8;
0177 
0178     return usb_control_msg(ucr->pusb_dev,
0179             usb_sndctrlpipe(ucr->pusb_dev, 0), RTSX_USB_REQ_REG_OP,
0180             USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0181             value, index, NULL, 0, 100);
0182 }
0183 EXPORT_SYMBOL_GPL(rtsx_usb_ep0_write_register);
0184 
0185 int rtsx_usb_ep0_read_register(struct rtsx_ucr *ucr, u16 addr, u8 *data)
0186 {
0187     u16 value;
0188     u8 *buf;
0189     int ret;
0190 
0191     if (!data)
0192         return -EINVAL;
0193 
0194     buf = kzalloc(sizeof(u8), GFP_KERNEL);
0195     if (!buf)
0196         return -ENOMEM;
0197 
0198     addr |= EP0_READ_REG_CMD << EP0_OP_SHIFT;
0199     value = swab16(addr);
0200 
0201     ret = usb_control_msg(ucr->pusb_dev,
0202             usb_rcvctrlpipe(ucr->pusb_dev, 0), RTSX_USB_REQ_REG_OP,
0203             USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0204             value, 0, buf, 1, 100);
0205     *data = *buf;
0206 
0207     kfree(buf);
0208     return ret;
0209 }
0210 EXPORT_SYMBOL_GPL(rtsx_usb_ep0_read_register);
0211 
0212 void rtsx_usb_add_cmd(struct rtsx_ucr *ucr, u8 cmd_type, u16 reg_addr,
0213         u8 mask, u8 data)
0214 {
0215     int i;
0216 
0217     if (ucr->cmd_idx < (IOBUF_SIZE - CMD_OFFSET) / 4) {
0218         i = CMD_OFFSET + ucr->cmd_idx * 4;
0219 
0220         ucr->cmd_buf[i++] = ((cmd_type & 0x03) << 6) |
0221             (u8)((reg_addr >> 8) & 0x3F);
0222         ucr->cmd_buf[i++] = (u8)reg_addr;
0223         ucr->cmd_buf[i++] = mask;
0224         ucr->cmd_buf[i++] = data;
0225 
0226         ucr->cmd_idx++;
0227     }
0228 }
0229 EXPORT_SYMBOL_GPL(rtsx_usb_add_cmd);
0230 
0231 int rtsx_usb_send_cmd(struct rtsx_ucr *ucr, u8 flag, int timeout)
0232 {
0233     int ret;
0234 
0235     ucr->cmd_buf[CNT_H] = (u8)(ucr->cmd_idx >> 8);
0236     ucr->cmd_buf[CNT_L] = (u8)(ucr->cmd_idx);
0237     ucr->cmd_buf[STAGE_FLAG] = flag;
0238 
0239     ret = rtsx_usb_transfer_data(ucr,
0240             usb_sndbulkpipe(ucr->pusb_dev, EP_BULK_OUT),
0241             ucr->cmd_buf, ucr->cmd_idx * 4 + CMD_OFFSET,
0242             0, NULL, timeout);
0243     if (ret) {
0244         rtsx_usb_clear_fsm_err(ucr);
0245         return ret;
0246     }
0247 
0248     return 0;
0249 }
0250 EXPORT_SYMBOL_GPL(rtsx_usb_send_cmd);
0251 
0252 int rtsx_usb_get_rsp(struct rtsx_ucr *ucr, int rsp_len, int timeout)
0253 {
0254     if (rsp_len <= 0)
0255         return -EINVAL;
0256 
0257     rsp_len = ALIGN(rsp_len, 4);
0258 
0259     return rtsx_usb_transfer_data(ucr,
0260             usb_rcvbulkpipe(ucr->pusb_dev, EP_BULK_IN),
0261             ucr->rsp_buf, rsp_len, 0, NULL, timeout);
0262 }
0263 EXPORT_SYMBOL_GPL(rtsx_usb_get_rsp);
0264 
0265 static int rtsx_usb_get_status_with_bulk(struct rtsx_ucr *ucr, u16 *status)
0266 {
0267     int ret;
0268 
0269     rtsx_usb_init_cmd(ucr);
0270     rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_EXIST, 0x00, 0x00);
0271     rtsx_usb_add_cmd(ucr, READ_REG_CMD, OCPSTAT, 0x00, 0x00);
0272     ret = rtsx_usb_send_cmd(ucr, MODE_CR, 100);
0273     if (ret)
0274         return ret;
0275 
0276     ret = rtsx_usb_get_rsp(ucr, 2, 100);
0277     if (ret)
0278         return ret;
0279 
0280     *status = ((ucr->rsp_buf[0] >> 2) & 0x0f) |
0281           ((ucr->rsp_buf[1] & 0x03) << 4);
0282 
0283     return 0;
0284 }
0285 
0286 int rtsx_usb_get_card_status(struct rtsx_ucr *ucr, u16 *status)
0287 {
0288     int ret;
0289     u16 *buf;
0290 
0291     if (!status)
0292         return -EINVAL;
0293 
0294     if (polling_pipe == 0) {
0295         buf = kzalloc(sizeof(u16), GFP_KERNEL);
0296         if (!buf)
0297             return -ENOMEM;
0298 
0299         ret = usb_control_msg(ucr->pusb_dev,
0300                 usb_rcvctrlpipe(ucr->pusb_dev, 0),
0301                 RTSX_USB_REQ_POLL,
0302                 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0303                 0, 0, buf, 2, 100);
0304         *status = *buf;
0305 
0306         kfree(buf);
0307     } else {
0308         ret = rtsx_usb_get_status_with_bulk(ucr, status);
0309     }
0310 
0311     /* usb_control_msg may return positive when success */
0312     if (ret < 0)
0313         return ret;
0314 
0315     return 0;
0316 }
0317 EXPORT_SYMBOL_GPL(rtsx_usb_get_card_status);
0318 
0319 static int rtsx_usb_write_phy_register(struct rtsx_ucr *ucr, u8 addr, u8 val)
0320 {
0321     dev_dbg(&ucr->pusb_intf->dev, "Write 0x%x to phy register 0x%x\n",
0322             val, addr);
0323 
0324     rtsx_usb_init_cmd(ucr);
0325 
0326     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VSTAIN, 0xFF, val);
0327     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VCONTROL, 0xFF, addr & 0x0F);
0328     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x00);
0329     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x00);
0330     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x01);
0331     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VCONTROL,
0332             0xFF, (addr >> 4) & 0x0F);
0333     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x00);
0334     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x00);
0335     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x01);
0336 
0337     return rtsx_usb_send_cmd(ucr, MODE_C, 100);
0338 }
0339 
0340 int rtsx_usb_write_register(struct rtsx_ucr *ucr, u16 addr, u8 mask, u8 data)
0341 {
0342     rtsx_usb_init_cmd(ucr);
0343     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, addr, mask, data);
0344     return rtsx_usb_send_cmd(ucr, MODE_C, 100);
0345 }
0346 EXPORT_SYMBOL_GPL(rtsx_usb_write_register);
0347 
0348 int rtsx_usb_read_register(struct rtsx_ucr *ucr, u16 addr, u8 *data)
0349 {
0350     int ret;
0351 
0352     if (data != NULL)
0353         *data = 0;
0354 
0355     rtsx_usb_init_cmd(ucr);
0356     rtsx_usb_add_cmd(ucr, READ_REG_CMD, addr, 0, 0);
0357     ret = rtsx_usb_send_cmd(ucr, MODE_CR, 100);
0358     if (ret)
0359         return ret;
0360 
0361     ret = rtsx_usb_get_rsp(ucr, 1, 100);
0362     if (ret)
0363         return ret;
0364 
0365     if (data != NULL)
0366         *data = ucr->rsp_buf[0];
0367 
0368     return 0;
0369 }
0370 EXPORT_SYMBOL_GPL(rtsx_usb_read_register);
0371 
0372 static inline u8 double_ssc_depth(u8 depth)
0373 {
0374     return (depth > 1) ? (depth - 1) : depth;
0375 }
0376 
0377 static u8 revise_ssc_depth(u8 ssc_depth, u8 div)
0378 {
0379     if (div > CLK_DIV_1) {
0380         if (ssc_depth > div - 1)
0381             ssc_depth -= (div - 1);
0382         else
0383             ssc_depth = SSC_DEPTH_2M;
0384     }
0385 
0386     return ssc_depth;
0387 }
0388 
0389 int rtsx_usb_switch_clock(struct rtsx_ucr *ucr, unsigned int card_clock,
0390         u8 ssc_depth, bool initial_mode, bool double_clk, bool vpclk)
0391 {
0392     int ret;
0393     u8 n, clk_divider, mcu_cnt, div;
0394 
0395     if (!card_clock) {
0396         ucr->cur_clk = 0;
0397         return 0;
0398     }
0399 
0400     if (initial_mode) {
0401         /* We use 250k(around) here, in initial stage */
0402         clk_divider = SD_CLK_DIVIDE_128;
0403         card_clock = 30000000;
0404     } else {
0405         clk_divider = SD_CLK_DIVIDE_0;
0406     }
0407 
0408     ret = rtsx_usb_write_register(ucr, SD_CFG1,
0409             SD_CLK_DIVIDE_MASK, clk_divider);
0410     if (ret < 0)
0411         return ret;
0412 
0413     card_clock /= 1000000;
0414     dev_dbg(&ucr->pusb_intf->dev,
0415             "Switch card clock to %dMHz\n", card_clock);
0416 
0417     if (!initial_mode && double_clk)
0418         card_clock *= 2;
0419     dev_dbg(&ucr->pusb_intf->dev,
0420             "Internal SSC clock: %dMHz (cur_clk = %d)\n",
0421             card_clock, ucr->cur_clk);
0422 
0423     if (card_clock == ucr->cur_clk)
0424         return 0;
0425 
0426     /* Converting clock value into internal settings: n and div */
0427     n = card_clock - 2;
0428     if ((card_clock <= 2) || (n > MAX_DIV_N))
0429         return -EINVAL;
0430 
0431     mcu_cnt = 60/card_clock + 3;
0432     if (mcu_cnt > 15)
0433         mcu_cnt = 15;
0434 
0435     /* Make sure that the SSC clock div_n is not less than MIN_DIV_N */
0436 
0437     div = CLK_DIV_1;
0438     while (n < MIN_DIV_N && div < CLK_DIV_4) {
0439         n = (n + 2) * 2 - 2;
0440         div++;
0441     }
0442     dev_dbg(&ucr->pusb_intf->dev, "n = %d, div = %d\n", n, div);
0443 
0444     if (double_clk)
0445         ssc_depth = double_ssc_depth(ssc_depth);
0446 
0447     ssc_depth = revise_ssc_depth(ssc_depth, div);
0448     dev_dbg(&ucr->pusb_intf->dev, "ssc_depth = %d\n", ssc_depth);
0449 
0450     rtsx_usb_init_cmd(ucr);
0451     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CLK_DIV, CLK_CHANGE, CLK_CHANGE);
0452     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CLK_DIV,
0453             0x3F, (div << 4) | mcu_cnt);
0454     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SSC_CTL1, SSC_RSTB, 0);
0455     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SSC_CTL2,
0456             SSC_DEPTH_MASK, ssc_depth);
0457     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SSC_DIV_N_0, 0xFF, n);
0458     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SSC_CTL1, SSC_RSTB, SSC_RSTB);
0459     if (vpclk) {
0460         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_VPCLK0_CTL,
0461                 PHASE_NOT_RESET, 0);
0462         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_VPCLK0_CTL,
0463                 PHASE_NOT_RESET, PHASE_NOT_RESET);
0464     }
0465 
0466     ret = rtsx_usb_send_cmd(ucr, MODE_C, 2000);
0467     if (ret < 0)
0468         return ret;
0469 
0470     ret = rtsx_usb_write_register(ucr, SSC_CTL1, 0xff,
0471             SSC_RSTB | SSC_8X_EN | SSC_SEL_4M);
0472     if (ret < 0)
0473         return ret;
0474 
0475     /* Wait SSC clock stable */
0476     usleep_range(100, 1000);
0477 
0478     ret = rtsx_usb_write_register(ucr, CLK_DIV, CLK_CHANGE, 0);
0479     if (ret < 0)
0480         return ret;
0481 
0482     ucr->cur_clk = card_clock;
0483 
0484     return 0;
0485 }
0486 EXPORT_SYMBOL_GPL(rtsx_usb_switch_clock);
0487 
0488 int rtsx_usb_card_exclusive_check(struct rtsx_ucr *ucr, int card)
0489 {
0490     int ret;
0491     u16 val;
0492     u16 cd_mask[] = {
0493         [RTSX_USB_SD_CARD] = (CD_MASK & ~SD_CD),
0494         [RTSX_USB_MS_CARD] = (CD_MASK & ~MS_CD)
0495     };
0496 
0497     ret = rtsx_usb_get_card_status(ucr, &val);
0498     /*
0499      * If get status fails, return 0 (ok) for the exclusive check
0500      * and let the flow fail at somewhere else.
0501      */
0502     if (ret)
0503         return 0;
0504 
0505     if (val & cd_mask[card])
0506         return -EIO;
0507 
0508     return 0;
0509 }
0510 EXPORT_SYMBOL_GPL(rtsx_usb_card_exclusive_check);
0511 
0512 static int rtsx_usb_reset_chip(struct rtsx_ucr *ucr)
0513 {
0514     int ret;
0515     u8 val;
0516 
0517     rtsx_usb_init_cmd(ucr);
0518 
0519     if (CHECK_PKG(ucr, LQFP48)) {
0520         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PWR_CTL,
0521                 LDO3318_PWR_MASK, LDO_SUSPEND);
0522         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PWR_CTL,
0523                 FORCE_LDO_POWERB, FORCE_LDO_POWERB);
0524         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1,
0525                 0x30, 0x10);
0526         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5,
0527                 0x03, 0x01);
0528         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6,
0529                 0x0C, 0x04);
0530     }
0531 
0532     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SYS_DUMMY0, NYET_MSAK, NYET_EN);
0533     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CD_DEGLITCH_WIDTH, 0xFF, 0x08);
0534     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
0535             CD_DEGLITCH_EN, XD_CD_DEGLITCH_EN, 0x0);
0536     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD30_DRIVE_SEL,
0537             SD30_DRIVE_MASK, DRIVER_TYPE_D);
0538     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
0539             CARD_DRIVE_SEL, SD20_DRIVE_MASK, 0x0);
0540     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, LDO_POWER_CFG, 0xE0, 0x0);
0541 
0542     if (ucr->is_rts5179)
0543         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
0544                 CARD_PULL_CTL5, 0x03, 0x01);
0545 
0546     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DMA1_CTL,
0547                EXTEND_DMA1_ASYNC_SIGNAL, EXTEND_DMA1_ASYNC_SIGNAL);
0548     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_INT_PEND,
0549             XD_INT | MS_INT | SD_INT,
0550             XD_INT | MS_INT | SD_INT);
0551 
0552     ret = rtsx_usb_send_cmd(ucr, MODE_C, 100);
0553     if (ret)
0554         return ret;
0555 
0556     /* config non-crystal mode */
0557     rtsx_usb_read_register(ucr, CFG_MODE, &val);
0558     if ((val & XTAL_FREE) || ((val & CLK_MODE_MASK) == CLK_MODE_NON_XTAL)) {
0559         ret = rtsx_usb_write_phy_register(ucr, 0xC2, 0x7C);
0560         if (ret)
0561             return ret;
0562     }
0563 
0564     return 0;
0565 }
0566 
0567 static int rtsx_usb_init_chip(struct rtsx_ucr *ucr)
0568 {
0569     int ret;
0570     u8 val;
0571 
0572     rtsx_usb_clear_fsm_err(ucr);
0573 
0574     /* power on SSC */
0575     ret = rtsx_usb_write_register(ucr,
0576             FPDCTL, SSC_POWER_MASK, SSC_POWER_ON);
0577     if (ret)
0578         return ret;
0579 
0580     usleep_range(100, 1000);
0581     ret = rtsx_usb_write_register(ucr, CLK_DIV, CLK_CHANGE, 0x00);
0582     if (ret)
0583         return ret;
0584 
0585     /* determine IC version */
0586     ret = rtsx_usb_read_register(ucr, HW_VERSION, &val);
0587     if (ret)
0588         return ret;
0589 
0590     ucr->ic_version = val & HW_VER_MASK;
0591 
0592     /* determine package */
0593     ret = rtsx_usb_read_register(ucr, CARD_SHARE_MODE, &val);
0594     if (ret)
0595         return ret;
0596 
0597     if (val & CARD_SHARE_LQFP_SEL) {
0598         ucr->package = LQFP48;
0599         dev_dbg(&ucr->pusb_intf->dev, "Package: LQFP48\n");
0600     } else {
0601         ucr->package = QFN24;
0602         dev_dbg(&ucr->pusb_intf->dev, "Package: QFN24\n");
0603     }
0604 
0605     /* determine IC variations */
0606     rtsx_usb_read_register(ucr, CFG_MODE_1, &val);
0607     if (val & RTS5179) {
0608         ucr->is_rts5179 = true;
0609         dev_dbg(&ucr->pusb_intf->dev, "Device is rts5179\n");
0610     } else {
0611         ucr->is_rts5179 = false;
0612     }
0613 
0614     return rtsx_usb_reset_chip(ucr);
0615 }
0616 
0617 static int rtsx_usb_probe(struct usb_interface *intf,
0618              const struct usb_device_id *id)
0619 {
0620     struct usb_device *usb_dev = interface_to_usbdev(intf);
0621     struct rtsx_ucr *ucr;
0622     int ret;
0623 
0624     dev_dbg(&intf->dev,
0625         ": Realtek USB Card Reader found at bus %03d address %03d\n",
0626          usb_dev->bus->busnum, usb_dev->devnum);
0627 
0628     ucr = devm_kzalloc(&intf->dev, sizeof(*ucr), GFP_KERNEL);
0629     if (!ucr)
0630         return -ENOMEM;
0631 
0632     ucr->pusb_dev = usb_dev;
0633 
0634     ucr->cmd_buf = kmalloc(IOBUF_SIZE, GFP_KERNEL);
0635     if (!ucr->cmd_buf)
0636         return -ENOMEM;
0637 
0638     ucr->rsp_buf = kmalloc(IOBUF_SIZE, GFP_KERNEL);
0639     if (!ucr->rsp_buf) {
0640         ret = -ENOMEM;
0641         goto out_free_cmd_buf;
0642     }
0643 
0644     usb_set_intfdata(intf, ucr);
0645 
0646     ucr->vendor_id = id->idVendor;
0647     ucr->product_id = id->idProduct;
0648 
0649     mutex_init(&ucr->dev_mutex);
0650 
0651     ucr->pusb_intf = intf;
0652 
0653     /* initialize */
0654     ret = rtsx_usb_init_chip(ucr);
0655     if (ret)
0656         goto out_init_fail;
0657 
0658     /* initialize USB SG transfer timer */
0659     timer_setup(&ucr->sg_timer, rtsx_usb_sg_timed_out, 0);
0660 
0661     ret = mfd_add_hotplug_devices(&intf->dev, rtsx_usb_cells,
0662                       ARRAY_SIZE(rtsx_usb_cells));
0663     if (ret)
0664         goto out_init_fail;
0665 
0666 #ifdef CONFIG_PM
0667     intf->needs_remote_wakeup = 1;
0668     usb_enable_autosuspend(usb_dev);
0669 #endif
0670 
0671     return 0;
0672 
0673 out_init_fail:
0674     usb_set_intfdata(ucr->pusb_intf, NULL);
0675     kfree(ucr->rsp_buf);
0676     ucr->rsp_buf = NULL;
0677 out_free_cmd_buf:
0678     kfree(ucr->cmd_buf);
0679     ucr->cmd_buf = NULL;
0680     return ret;
0681 }
0682 
0683 static void rtsx_usb_disconnect(struct usb_interface *intf)
0684 {
0685     struct rtsx_ucr *ucr = (struct rtsx_ucr *)usb_get_intfdata(intf);
0686 
0687     dev_dbg(&intf->dev, "%s called\n", __func__);
0688 
0689     mfd_remove_devices(&intf->dev);
0690 
0691     usb_set_intfdata(ucr->pusb_intf, NULL);
0692 
0693     kfree(ucr->cmd_buf);
0694     ucr->cmd_buf = NULL;
0695 
0696     kfree(ucr->rsp_buf);
0697     ucr->rsp_buf = NULL;
0698 }
0699 
0700 #ifdef CONFIG_PM
0701 static int rtsx_usb_suspend(struct usb_interface *intf, pm_message_t message)
0702 {
0703     struct rtsx_ucr *ucr =
0704         (struct rtsx_ucr *)usb_get_intfdata(intf);
0705     u16 val = 0;
0706 
0707     dev_dbg(&intf->dev, "%s called with pm message 0x%04x\n",
0708             __func__, message.event);
0709 
0710     if (PMSG_IS_AUTO(message)) {
0711         if (mutex_trylock(&ucr->dev_mutex)) {
0712             rtsx_usb_get_card_status(ucr, &val);
0713             mutex_unlock(&ucr->dev_mutex);
0714 
0715             /* Defer the autosuspend if card exists */
0716             if (val & (SD_CD | MS_CD))
0717                 return -EAGAIN;
0718         } else {
0719             /* There is an ongoing operation*/
0720             return -EAGAIN;
0721         }
0722     }
0723 
0724     return 0;
0725 }
0726 
0727 static int rtsx_usb_resume_child(struct device *dev, void *data)
0728 {
0729     pm_request_resume(dev);
0730     return 0;
0731 }
0732 
0733 static int rtsx_usb_resume(struct usb_interface *intf)
0734 {
0735     device_for_each_child(&intf->dev, NULL, rtsx_usb_resume_child);
0736     return 0;
0737 }
0738 
0739 static int rtsx_usb_reset_resume(struct usb_interface *intf)
0740 {
0741     struct rtsx_ucr *ucr =
0742         (struct rtsx_ucr *)usb_get_intfdata(intf);
0743 
0744     rtsx_usb_reset_chip(ucr);
0745     device_for_each_child(&intf->dev, NULL, rtsx_usb_resume_child);
0746     return 0;
0747 }
0748 
0749 #else /* CONFIG_PM */
0750 
0751 #define rtsx_usb_suspend NULL
0752 #define rtsx_usb_resume NULL
0753 #define rtsx_usb_reset_resume NULL
0754 
0755 #endif /* CONFIG_PM */
0756 
0757 
0758 static int rtsx_usb_pre_reset(struct usb_interface *intf)
0759 {
0760     struct rtsx_ucr *ucr = (struct rtsx_ucr *)usb_get_intfdata(intf);
0761 
0762     mutex_lock(&ucr->dev_mutex);
0763     return 0;
0764 }
0765 
0766 static int rtsx_usb_post_reset(struct usb_interface *intf)
0767 {
0768     struct rtsx_ucr *ucr = (struct rtsx_ucr *)usb_get_intfdata(intf);
0769 
0770     mutex_unlock(&ucr->dev_mutex);
0771     return 0;
0772 }
0773 
0774 static const struct usb_device_id rtsx_usb_usb_ids[] = {
0775     { USB_DEVICE(0x0BDA, 0x0129) },
0776     { USB_DEVICE(0x0BDA, 0x0139) },
0777     { USB_DEVICE(0x0BDA, 0x0140) },
0778     { }
0779 };
0780 MODULE_DEVICE_TABLE(usb, rtsx_usb_usb_ids);
0781 
0782 static struct usb_driver rtsx_usb_driver = {
0783     .name           = "rtsx_usb",
0784     .probe          = rtsx_usb_probe,
0785     .disconnect     = rtsx_usb_disconnect,
0786     .suspend        = rtsx_usb_suspend,
0787     .resume         = rtsx_usb_resume,
0788     .reset_resume       = rtsx_usb_reset_resume,
0789     .pre_reset      = rtsx_usb_pre_reset,
0790     .post_reset     = rtsx_usb_post_reset,
0791     .id_table       = rtsx_usb_usb_ids,
0792     .supports_autosuspend   = 1,
0793     .soft_unbind        = 1,
0794 };
0795 
0796 module_usb_driver(rtsx_usb_driver);
0797 
0798 MODULE_LICENSE("GPL v2");
0799 MODULE_AUTHOR("Roger Tseng <rogerable@realtek.com>");
0800 MODULE_DESCRIPTION("Realtek USB Card Reader Driver");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!