Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /* Realtek USB Memstick Card Interface driver
0003  *
0004  * Copyright(c) 2009-2013 Realtek Semiconductor Corp. All rights reserved.
0005  *
0006  * Author:
0007  *   Roger Tseng <rogerable@realtek.com>
0008  */
0009 
0010 #include <linux/module.h>
0011 #include <linux/highmem.h>
0012 #include <linux/delay.h>
0013 #include <linux/platform_device.h>
0014 #include <linux/workqueue.h>
0015 #include <linux/memstick.h>
0016 #include <linux/kthread.h>
0017 #include <linux/rtsx_usb.h>
0018 #include <linux/pm_runtime.h>
0019 #include <linux/mutex.h>
0020 #include <linux/sched.h>
0021 #include <linux/completion.h>
0022 #include <asm/unaligned.h>
0023 
0024 struct rtsx_usb_ms {
0025     struct platform_device  *pdev;
0026     struct rtsx_ucr *ucr;
0027     struct memstick_host    *msh;
0028     struct memstick_request *req;
0029 
0030     struct mutex        host_mutex;
0031     struct work_struct  handle_req;
0032     struct delayed_work poll_card;
0033 
0034     u8          ssc_depth;
0035     unsigned int        clock;
0036     int         power_mode;
0037     unsigned char           ifmode;
0038     bool            eject;
0039     bool            system_suspending;
0040 };
0041 
0042 static inline struct device *ms_dev(struct rtsx_usb_ms *host)
0043 {
0044     return &(host->pdev->dev);
0045 }
0046 
0047 static inline void ms_clear_error(struct rtsx_usb_ms *host)
0048 {
0049     struct rtsx_ucr *ucr = host->ucr;
0050     rtsx_usb_ep0_write_register(ucr, CARD_STOP,
0051                   MS_STOP | MS_CLR_ERR,
0052                   MS_STOP | MS_CLR_ERR);
0053 
0054     rtsx_usb_clear_dma_err(ucr);
0055     rtsx_usb_clear_fsm_err(ucr);
0056 }
0057 
0058 #ifdef DEBUG
0059 
0060 static void ms_print_debug_regs(struct rtsx_usb_ms *host)
0061 {
0062     struct rtsx_ucr *ucr = host->ucr;
0063     u16 i;
0064     u8 *ptr;
0065 
0066     /* Print MS host internal registers */
0067     rtsx_usb_init_cmd(ucr);
0068 
0069     /* MS_CFG to MS_INT_REG */
0070     for (i = 0xFD40; i <= 0xFD44; i++)
0071         rtsx_usb_add_cmd(ucr, READ_REG_CMD, i, 0, 0);
0072 
0073     /* CARD_SHARE_MODE to CARD_GPIO */
0074     for (i = 0xFD51; i <= 0xFD56; i++)
0075         rtsx_usb_add_cmd(ucr, READ_REG_CMD, i, 0, 0);
0076 
0077     /* CARD_PULL_CTLx */
0078     for (i = 0xFD60; i <= 0xFD65; i++)
0079         rtsx_usb_add_cmd(ucr, READ_REG_CMD, i, 0, 0);
0080 
0081     /* CARD_DATA_SOURCE, CARD_SELECT, CARD_CLK_EN, CARD_PWR_CTL */
0082     rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_DATA_SOURCE, 0, 0);
0083     rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_SELECT, 0, 0);
0084     rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_CLK_EN, 0, 0);
0085     rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_PWR_CTL, 0, 0);
0086 
0087     rtsx_usb_send_cmd(ucr, MODE_CR, 100);
0088     rtsx_usb_get_rsp(ucr, 21, 100);
0089 
0090     ptr = ucr->rsp_buf;
0091     for (i = 0xFD40; i <= 0xFD44; i++)
0092         dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", i, *(ptr++));
0093     for (i = 0xFD51; i <= 0xFD56; i++)
0094         dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", i, *(ptr++));
0095     for (i = 0xFD60; i <= 0xFD65; i++)
0096         dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", i, *(ptr++));
0097 
0098     dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_DATA_SOURCE, *(ptr++));
0099     dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_SELECT, *(ptr++));
0100     dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_CLK_EN, *(ptr++));
0101     dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_PWR_CTL, *(ptr++));
0102 }
0103 
0104 #else
0105 
0106 static void ms_print_debug_regs(struct rtsx_usb_ms *host)
0107 {
0108 }
0109 
0110 #endif
0111 
0112 static int ms_pull_ctl_disable_lqfp48(struct rtsx_ucr *ucr)
0113 {
0114     rtsx_usb_init_cmd(ucr);
0115 
0116     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0x55);
0117     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x55);
0118     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0x95);
0119     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x55);
0120     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x55);
0121     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0xA5);
0122 
0123     return rtsx_usb_send_cmd(ucr, MODE_C, 100);
0124 }
0125 
0126 static int ms_pull_ctl_disable_qfn24(struct rtsx_ucr *ucr)
0127 {
0128     rtsx_usb_init_cmd(ucr);
0129 
0130     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0x65);
0131     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x55);
0132     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0x95);
0133     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x55);
0134     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x56);
0135     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0x59);
0136 
0137     return rtsx_usb_send_cmd(ucr, MODE_C, 100);
0138 }
0139 
0140 static int ms_pull_ctl_enable_lqfp48(struct rtsx_ucr *ucr)
0141 {
0142     rtsx_usb_init_cmd(ucr);
0143 
0144     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0x55);
0145     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x55);
0146     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0x95);
0147     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x55);
0148     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x55);
0149     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0xA5);
0150 
0151     return rtsx_usb_send_cmd(ucr, MODE_C, 100);
0152 }
0153 
0154 static int ms_pull_ctl_enable_qfn24(struct rtsx_ucr *ucr)
0155 {
0156     rtsx_usb_init_cmd(ucr);
0157 
0158     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0x65);
0159     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x55);
0160     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0x95);
0161     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x55);
0162     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x55);
0163     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0x59);
0164 
0165     return rtsx_usb_send_cmd(ucr, MODE_C, 100);
0166 }
0167 
0168 static int ms_power_on(struct rtsx_usb_ms *host)
0169 {
0170     struct rtsx_ucr *ucr = host->ucr;
0171     int err;
0172 
0173     dev_dbg(ms_dev(host), "%s\n", __func__);
0174 
0175     rtsx_usb_init_cmd(ucr);
0176     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_SELECT, 0x07, MS_MOD_SEL);
0177     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_SHARE_MODE,
0178             CARD_SHARE_MASK, CARD_SHARE_MS);
0179     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_CLK_EN,
0180             MS_CLK_EN, MS_CLK_EN);
0181     err = rtsx_usb_send_cmd(ucr, MODE_C, 100);
0182     if (err < 0)
0183         return err;
0184 
0185     if (CHECK_PKG(ucr, LQFP48))
0186         err = ms_pull_ctl_enable_lqfp48(ucr);
0187     else
0188         err = ms_pull_ctl_enable_qfn24(ucr);
0189     if (err < 0)
0190         return err;
0191 
0192     err = rtsx_usb_write_register(ucr, CARD_PWR_CTL,
0193             POWER_MASK, PARTIAL_POWER_ON);
0194     if (err)
0195         return err;
0196 
0197     usleep_range(800, 1000);
0198 
0199     rtsx_usb_init_cmd(ucr);
0200     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PWR_CTL,
0201             POWER_MASK, POWER_ON);
0202     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_OE,
0203             MS_OUTPUT_EN, MS_OUTPUT_EN);
0204 
0205     return rtsx_usb_send_cmd(ucr, MODE_C, 100);
0206 }
0207 
0208 static int ms_power_off(struct rtsx_usb_ms *host)
0209 {
0210     struct rtsx_ucr *ucr = host->ucr;
0211     int err;
0212 
0213     dev_dbg(ms_dev(host), "%s\n", __func__);
0214 
0215     rtsx_usb_init_cmd(ucr);
0216 
0217     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_CLK_EN, MS_CLK_EN, 0);
0218     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_OE, MS_OUTPUT_EN, 0);
0219 
0220     err = rtsx_usb_send_cmd(ucr, MODE_C, 100);
0221     if (err < 0)
0222         return err;
0223 
0224     if (CHECK_PKG(ucr, LQFP48))
0225         return ms_pull_ctl_disable_lqfp48(ucr);
0226 
0227     return ms_pull_ctl_disable_qfn24(ucr);
0228 }
0229 
0230 static int ms_transfer_data(struct rtsx_usb_ms *host, unsigned char data_dir,
0231         u8 tpc, u8 cfg, struct scatterlist *sg)
0232 {
0233     struct rtsx_ucr *ucr = host->ucr;
0234     int err;
0235     unsigned int length = sg->length;
0236     u16 sec_cnt = (u16)(length / 512);
0237     u8 trans_mode, dma_dir, flag;
0238     unsigned int pipe;
0239     struct memstick_dev *card = host->msh->card;
0240 
0241     dev_dbg(ms_dev(host), "%s: tpc = 0x%02x, data_dir = %s, length = %d\n",
0242             __func__, tpc, (data_dir == READ) ? "READ" : "WRITE",
0243             length);
0244 
0245     if (data_dir == READ) {
0246         flag = MODE_CDIR;
0247         dma_dir = DMA_DIR_FROM_CARD;
0248         if (card->id.type != MEMSTICK_TYPE_PRO)
0249             trans_mode = MS_TM_NORMAL_READ;
0250         else
0251             trans_mode = MS_TM_AUTO_READ;
0252         pipe = usb_rcvbulkpipe(ucr->pusb_dev, EP_BULK_IN);
0253     } else {
0254         flag = MODE_CDOR;
0255         dma_dir = DMA_DIR_TO_CARD;
0256         if (card->id.type != MEMSTICK_TYPE_PRO)
0257             trans_mode = MS_TM_NORMAL_WRITE;
0258         else
0259             trans_mode = MS_TM_AUTO_WRITE;
0260         pipe = usb_sndbulkpipe(ucr->pusb_dev, EP_BULK_OUT);
0261     }
0262 
0263     rtsx_usb_init_cmd(ucr);
0264 
0265     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
0266     if (card->id.type == MEMSTICK_TYPE_PRO) {
0267         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_SECTOR_CNT_H,
0268                 0xFF, (u8)(sec_cnt >> 8));
0269         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_SECTOR_CNT_L,
0270                 0xFF, (u8)sec_cnt);
0271     }
0272     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
0273 
0274     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC3,
0275             0xFF, (u8)(length >> 24));
0276     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC2,
0277             0xFF, (u8)(length >> 16));
0278     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC1,
0279             0xFF, (u8)(length >> 8));
0280     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC0, 0xFF,
0281             (u8)length);
0282     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_CTL,
0283             0x03 | DMA_PACK_SIZE_MASK, dma_dir | DMA_EN | DMA_512);
0284     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
0285             0x01, RING_BUFFER);
0286 
0287     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANSFER,
0288             0xFF, MS_TRANSFER_START | trans_mode);
0289     rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, MS_TRANSFER,
0290             MS_TRANSFER_END, MS_TRANSFER_END);
0291 
0292     err = rtsx_usb_send_cmd(ucr, flag | STAGE_MS_STATUS, 100);
0293     if (err)
0294         return err;
0295 
0296     err = rtsx_usb_transfer_data(ucr, pipe, sg, length,
0297             1, NULL, 10000);
0298     if (err)
0299         goto err_out;
0300 
0301     err = rtsx_usb_get_rsp(ucr, 3, 15000);
0302     if (err)
0303         goto err_out;
0304 
0305     if (ucr->rsp_buf[0] & MS_TRANSFER_ERR ||
0306         ucr->rsp_buf[1] & (MS_CRC16_ERR | MS_RDY_TIMEOUT)) {
0307         err = -EIO;
0308         goto err_out;
0309     }
0310     return 0;
0311 err_out:
0312     ms_clear_error(host);
0313     return err;
0314 }
0315 
0316 static int ms_write_bytes(struct rtsx_usb_ms *host, u8 tpc,
0317         u8 cfg, u8 cnt, u8 *data, u8 *int_reg)
0318 {
0319     struct rtsx_ucr *ucr = host->ucr;
0320     int err, i;
0321 
0322     dev_dbg(ms_dev(host), "%s: tpc = 0x%02x\n", __func__, tpc);
0323 
0324     rtsx_usb_init_cmd(ucr);
0325 
0326     for (i = 0; i < cnt; i++)
0327         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
0328                 PPBUF_BASE2 + i, 0xFF, data[i]);
0329 
0330     if (cnt % 2)
0331         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
0332                 PPBUF_BASE2 + i, 0xFF, 0xFF);
0333 
0334     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
0335     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt);
0336     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
0337     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
0338             0x01, PINGPONG_BUFFER);
0339 
0340     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANSFER,
0341             0xFF, MS_TRANSFER_START | MS_TM_WRITE_BYTES);
0342     rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, MS_TRANSFER,
0343             MS_TRANSFER_END, MS_TRANSFER_END);
0344     rtsx_usb_add_cmd(ucr, READ_REG_CMD, MS_TRANS_CFG, 0, 0);
0345 
0346     err = rtsx_usb_send_cmd(ucr, MODE_CR, 100);
0347     if (err)
0348         return err;
0349 
0350     err = rtsx_usb_get_rsp(ucr, 2, 5000);
0351     if (err || (ucr->rsp_buf[0] & MS_TRANSFER_ERR)) {
0352         u8 val;
0353 
0354         rtsx_usb_ep0_read_register(ucr, MS_TRANS_CFG, &val);
0355         dev_dbg(ms_dev(host), "MS_TRANS_CFG: 0x%02x\n", val);
0356 
0357         if (int_reg)
0358             *int_reg = val & 0x0F;
0359 
0360         ms_print_debug_regs(host);
0361 
0362         ms_clear_error(host);
0363 
0364         if (!(tpc & 0x08)) {
0365             if (val & MS_CRC16_ERR)
0366                 return -EIO;
0367         } else {
0368             if (!(val & 0x80)) {
0369                 if (val & (MS_INT_ERR | MS_INT_CMDNK))
0370                     return -EIO;
0371             }
0372         }
0373 
0374         return -ETIMEDOUT;
0375     }
0376 
0377     if (int_reg)
0378         *int_reg = ucr->rsp_buf[1] & 0x0F;
0379 
0380     return 0;
0381 }
0382 
0383 static int ms_read_bytes(struct rtsx_usb_ms *host, u8 tpc,
0384         u8 cfg, u8 cnt, u8 *data, u8 *int_reg)
0385 {
0386     struct rtsx_ucr *ucr = host->ucr;
0387     int err, i;
0388     u8 *ptr;
0389 
0390     dev_dbg(ms_dev(host), "%s: tpc = 0x%02x\n", __func__, tpc);
0391 
0392     rtsx_usb_init_cmd(ucr);
0393 
0394     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
0395     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt);
0396     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
0397     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
0398             0x01, PINGPONG_BUFFER);
0399 
0400     rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANSFER,
0401             0xFF, MS_TRANSFER_START | MS_TM_READ_BYTES);
0402     rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, MS_TRANSFER,
0403             MS_TRANSFER_END, MS_TRANSFER_END);
0404     for (i = 0; i < cnt - 1; i++)
0405         rtsx_usb_add_cmd(ucr, READ_REG_CMD, PPBUF_BASE2 + i, 0, 0);
0406     if (cnt % 2)
0407         rtsx_usb_add_cmd(ucr, READ_REG_CMD, PPBUF_BASE2 + cnt, 0, 0);
0408     else
0409         rtsx_usb_add_cmd(ucr, READ_REG_CMD,
0410                 PPBUF_BASE2 + cnt - 1, 0, 0);
0411 
0412     rtsx_usb_add_cmd(ucr, READ_REG_CMD, MS_TRANS_CFG, 0, 0);
0413 
0414     err = rtsx_usb_send_cmd(ucr, MODE_CR, 100);
0415     if (err)
0416         return err;
0417 
0418     err = rtsx_usb_get_rsp(ucr, cnt + 2, 5000);
0419     if (err || (ucr->rsp_buf[0] & MS_TRANSFER_ERR)) {
0420         u8 val;
0421 
0422         rtsx_usb_ep0_read_register(ucr, MS_TRANS_CFG, &val);
0423         dev_dbg(ms_dev(host), "MS_TRANS_CFG: 0x%02x\n", val);
0424 
0425         if (int_reg && (host->ifmode != MEMSTICK_SERIAL))
0426             *int_reg = val & 0x0F;
0427 
0428         ms_print_debug_regs(host);
0429 
0430         ms_clear_error(host);
0431 
0432         if (!(tpc & 0x08)) {
0433             if (val & MS_CRC16_ERR)
0434                 return -EIO;
0435         } else {
0436             if (!(val & 0x80)) {
0437                 if (val & (MS_INT_ERR | MS_INT_CMDNK))
0438                     return -EIO;
0439             }
0440         }
0441 
0442         return -ETIMEDOUT;
0443     }
0444 
0445     ptr = ucr->rsp_buf + 1;
0446     for (i = 0; i < cnt; i++)
0447         data[i] = *ptr++;
0448 
0449 
0450     if (int_reg && (host->ifmode != MEMSTICK_SERIAL))
0451         *int_reg = *ptr & 0x0F;
0452 
0453     return 0;
0454 }
0455 
0456 static int rtsx_usb_ms_issue_cmd(struct rtsx_usb_ms *host)
0457 {
0458     struct memstick_request *req = host->req;
0459     int err = 0;
0460     u8 cfg = 0, int_reg;
0461 
0462     dev_dbg(ms_dev(host), "%s\n", __func__);
0463 
0464     if (req->need_card_int) {
0465         if (host->ifmode != MEMSTICK_SERIAL)
0466             cfg = WAIT_INT;
0467     }
0468 
0469     if (req->long_data) {
0470         err = ms_transfer_data(host, req->data_dir,
0471                 req->tpc, cfg, &(req->sg));
0472     } else {
0473         if (req->data_dir == READ)
0474             err = ms_read_bytes(host, req->tpc, cfg,
0475                     req->data_len, req->data, &int_reg);
0476         else
0477             err = ms_write_bytes(host, req->tpc, cfg,
0478                     req->data_len, req->data, &int_reg);
0479     }
0480     if (err < 0)
0481         return err;
0482 
0483     if (req->need_card_int) {
0484         if (host->ifmode == MEMSTICK_SERIAL) {
0485             err = ms_read_bytes(host, MS_TPC_GET_INT,
0486                     NO_WAIT_INT, 1, &req->int_reg, NULL);
0487             if (err < 0)
0488                 return err;
0489         } else {
0490 
0491             if (int_reg & MS_INT_CMDNK)
0492                 req->int_reg |= MEMSTICK_INT_CMDNAK;
0493             if (int_reg & MS_INT_BREQ)
0494                 req->int_reg |= MEMSTICK_INT_BREQ;
0495             if (int_reg & MS_INT_ERR)
0496                 req->int_reg |= MEMSTICK_INT_ERR;
0497             if (int_reg & MS_INT_CED)
0498                 req->int_reg |= MEMSTICK_INT_CED;
0499         }
0500         dev_dbg(ms_dev(host), "int_reg: 0x%02x\n", req->int_reg);
0501     }
0502 
0503     return 0;
0504 }
0505 
0506 static void rtsx_usb_ms_handle_req(struct work_struct *work)
0507 {
0508     struct rtsx_usb_ms *host = container_of(work,
0509             struct rtsx_usb_ms, handle_req);
0510     struct rtsx_ucr *ucr = host->ucr;
0511     struct memstick_host *msh = host->msh;
0512     int rc;
0513 
0514     if (!host->req) {
0515         pm_runtime_get_sync(ms_dev(host));
0516         do {
0517             rc = memstick_next_req(msh, &host->req);
0518             dev_dbg(ms_dev(host), "next req %d\n", rc);
0519 
0520             if (!rc) {
0521                 mutex_lock(&ucr->dev_mutex);
0522 
0523                 if (rtsx_usb_card_exclusive_check(ucr,
0524                             RTSX_USB_MS_CARD))
0525                     host->req->error = -EIO;
0526                 else
0527                     host->req->error =
0528                         rtsx_usb_ms_issue_cmd(host);
0529 
0530                 mutex_unlock(&ucr->dev_mutex);
0531 
0532                 dev_dbg(ms_dev(host), "req result %d\n",
0533                         host->req->error);
0534             }
0535         } while (!rc);
0536         pm_runtime_put_sync(ms_dev(host));
0537     }
0538 
0539 }
0540 
0541 static void rtsx_usb_ms_request(struct memstick_host *msh)
0542 {
0543     struct rtsx_usb_ms *host = memstick_priv(msh);
0544 
0545     dev_dbg(ms_dev(host), "--> %s\n", __func__);
0546 
0547     if (!host->eject)
0548         schedule_work(&host->handle_req);
0549 }
0550 
0551 static int rtsx_usb_ms_set_param(struct memstick_host *msh,
0552         enum memstick_param param, int value)
0553 {
0554     struct rtsx_usb_ms *host = memstick_priv(msh);
0555     struct rtsx_ucr *ucr = host->ucr;
0556     unsigned int clock = 0;
0557     u8 ssc_depth = 0;
0558     int err;
0559 
0560     dev_dbg(ms_dev(host), "%s: param = %d, value = %d\n",
0561             __func__, param, value);
0562 
0563     pm_runtime_get_sync(ms_dev(host));
0564     mutex_lock(&ucr->dev_mutex);
0565 
0566     err = rtsx_usb_card_exclusive_check(ucr, RTSX_USB_MS_CARD);
0567     if (err)
0568         goto out;
0569 
0570     switch (param) {
0571     case MEMSTICK_POWER:
0572         if (value == host->power_mode)
0573             break;
0574 
0575         if (value == MEMSTICK_POWER_ON) {
0576             pm_runtime_get_noresume(ms_dev(host));
0577             err = ms_power_on(host);
0578             if (err)
0579                 pm_runtime_put_noidle(ms_dev(host));
0580         } else if (value == MEMSTICK_POWER_OFF) {
0581             err = ms_power_off(host);
0582             if (!err)
0583                 pm_runtime_put_noidle(ms_dev(host));
0584         } else
0585             err = -EINVAL;
0586         if (!err)
0587             host->power_mode = value;
0588         break;
0589 
0590     case MEMSTICK_INTERFACE:
0591         if (value == MEMSTICK_SERIAL) {
0592             clock = 19000000;
0593             ssc_depth = SSC_DEPTH_512K;
0594             err = rtsx_usb_write_register(ucr, MS_CFG, 0x5A,
0595                        MS_BUS_WIDTH_1 | PUSH_TIME_DEFAULT);
0596             if (err < 0)
0597                 break;
0598         } else if (value == MEMSTICK_PAR4) {
0599             clock = 39000000;
0600             ssc_depth = SSC_DEPTH_1M;
0601 
0602             err = rtsx_usb_write_register(ucr, MS_CFG, 0x5A,
0603                     MS_BUS_WIDTH_4 | PUSH_TIME_ODD |
0604                     MS_NO_CHECK_INT);
0605             if (err < 0)
0606                 break;
0607         } else {
0608             err = -EINVAL;
0609             break;
0610         }
0611 
0612         err = rtsx_usb_switch_clock(ucr, clock,
0613                 ssc_depth, false, true, false);
0614         if (err < 0) {
0615             dev_dbg(ms_dev(host), "switch clock failed\n");
0616             break;
0617         }
0618 
0619         host->ssc_depth = ssc_depth;
0620         host->clock = clock;
0621         host->ifmode = value;
0622         break;
0623     default:
0624         err = -EINVAL;
0625         break;
0626     }
0627 out:
0628     mutex_unlock(&ucr->dev_mutex);
0629     pm_runtime_put_sync(ms_dev(host));
0630 
0631     /* power-on delay */
0632     if (param == MEMSTICK_POWER && value == MEMSTICK_POWER_ON) {
0633         usleep_range(10000, 12000);
0634 
0635         if (!host->eject)
0636             schedule_delayed_work(&host->poll_card, 100);
0637     }
0638 
0639     dev_dbg(ms_dev(host), "%s: return = %d\n", __func__, err);
0640     return err;
0641 }
0642 
0643 #ifdef CONFIG_PM_SLEEP
0644 static int rtsx_usb_ms_suspend(struct device *dev)
0645 {
0646     struct rtsx_usb_ms *host = dev_get_drvdata(dev);
0647     struct memstick_host *msh = host->msh;
0648 
0649     /* Since we use rtsx_usb's resume callback to runtime resume its
0650      * children to implement remote wakeup signaling, this causes
0651      * rtsx_usb_ms' runtime resume callback runs after its suspend
0652      * callback:
0653      * rtsx_usb_ms_suspend()
0654      * rtsx_usb_resume()
0655      *   -> rtsx_usb_ms_runtime_resume()
0656      *     -> memstick_detect_change()
0657      *
0658      * rtsx_usb_suspend()
0659      *
0660      * To avoid this, skip runtime resume/suspend if system suspend is
0661      * underway.
0662      */
0663 
0664     host->system_suspending = true;
0665     memstick_suspend_host(msh);
0666 
0667     return 0;
0668 }
0669 
0670 static int rtsx_usb_ms_resume(struct device *dev)
0671 {
0672     struct rtsx_usb_ms *host = dev_get_drvdata(dev);
0673     struct memstick_host *msh = host->msh;
0674 
0675     memstick_resume_host(msh);
0676     host->system_suspending = false;
0677 
0678     return 0;
0679 }
0680 #endif /* CONFIG_PM_SLEEP */
0681 
0682 #ifdef CONFIG_PM
0683 static int rtsx_usb_ms_runtime_suspend(struct device *dev)
0684 {
0685     struct rtsx_usb_ms *host = dev_get_drvdata(dev);
0686 
0687     if (host->system_suspending)
0688         return 0;
0689 
0690     if (host->msh->card || host->power_mode != MEMSTICK_POWER_OFF)
0691         return -EAGAIN;
0692 
0693     return 0;
0694 }
0695 
0696 static int rtsx_usb_ms_runtime_resume(struct device *dev)
0697 {
0698     struct rtsx_usb_ms *host = dev_get_drvdata(dev);
0699 
0700 
0701     if (host->system_suspending)
0702         return 0;
0703 
0704     memstick_detect_change(host->msh);
0705 
0706     return 0;
0707 }
0708 #endif /* CONFIG_PM */
0709 
0710 static const struct dev_pm_ops rtsx_usb_ms_pm_ops = {
0711     SET_SYSTEM_SLEEP_PM_OPS(rtsx_usb_ms_suspend, rtsx_usb_ms_resume)
0712     SET_RUNTIME_PM_OPS(rtsx_usb_ms_runtime_suspend, rtsx_usb_ms_runtime_resume, NULL)
0713 };
0714 
0715 
0716 static void rtsx_usb_ms_poll_card(struct work_struct *work)
0717 {
0718     struct rtsx_usb_ms *host = container_of(work, struct rtsx_usb_ms,
0719             poll_card.work);
0720     struct rtsx_ucr *ucr = host->ucr;
0721     int err;
0722     u8 val;
0723 
0724     if (host->eject || host->power_mode != MEMSTICK_POWER_ON)
0725         return;
0726 
0727     pm_runtime_get_sync(ms_dev(host));
0728     mutex_lock(&ucr->dev_mutex);
0729 
0730     /* Check pending MS card changes */
0731     err = rtsx_usb_read_register(ucr, CARD_INT_PEND, &val);
0732     if (err) {
0733         mutex_unlock(&ucr->dev_mutex);
0734         goto poll_again;
0735     }
0736 
0737     /* Clear the pending */
0738     rtsx_usb_write_register(ucr, CARD_INT_PEND,
0739             XD_INT | MS_INT | SD_INT,
0740             XD_INT | MS_INT | SD_INT);
0741 
0742     mutex_unlock(&ucr->dev_mutex);
0743 
0744     if (val & MS_INT) {
0745         dev_dbg(ms_dev(host), "MS slot change detected\n");
0746         memstick_detect_change(host->msh);
0747     }
0748 
0749 poll_again:
0750     pm_runtime_put_sync(ms_dev(host));
0751 
0752     if (!host->eject && host->power_mode == MEMSTICK_POWER_ON)
0753         schedule_delayed_work(&host->poll_card, 100);
0754 }
0755 
0756 static int rtsx_usb_ms_drv_probe(struct platform_device *pdev)
0757 {
0758     struct memstick_host *msh;
0759     struct rtsx_usb_ms *host;
0760     struct rtsx_ucr *ucr;
0761     int err;
0762 
0763     ucr = usb_get_intfdata(to_usb_interface(pdev->dev.parent));
0764     if (!ucr)
0765         return -ENXIO;
0766 
0767     dev_dbg(&(pdev->dev),
0768             "Realtek USB Memstick controller found\n");
0769 
0770     msh = memstick_alloc_host(sizeof(*host), &pdev->dev);
0771     if (!msh)
0772         return -ENOMEM;
0773 
0774     host = memstick_priv(msh);
0775     host->ucr = ucr;
0776     host->msh = msh;
0777     host->pdev = pdev;
0778     host->power_mode = MEMSTICK_POWER_OFF;
0779     platform_set_drvdata(pdev, host);
0780 
0781     mutex_init(&host->host_mutex);
0782     INIT_WORK(&host->handle_req, rtsx_usb_ms_handle_req);
0783 
0784     INIT_DELAYED_WORK(&host->poll_card, rtsx_usb_ms_poll_card);
0785 
0786     msh->request = rtsx_usb_ms_request;
0787     msh->set_param = rtsx_usb_ms_set_param;
0788     msh->caps = MEMSTICK_CAP_PAR4;
0789 
0790     pm_runtime_get_noresume(ms_dev(host));
0791     pm_runtime_set_active(ms_dev(host));
0792     pm_runtime_enable(ms_dev(host));
0793 
0794     err = memstick_add_host(msh);
0795     if (err)
0796         goto err_out;
0797 
0798     pm_runtime_put(ms_dev(host));
0799 
0800     return 0;
0801 err_out:
0802     pm_runtime_disable(ms_dev(host));
0803     pm_runtime_put_noidle(ms_dev(host));
0804     memstick_free_host(msh);
0805     return err;
0806 }
0807 
0808 static int rtsx_usb_ms_drv_remove(struct platform_device *pdev)
0809 {
0810     struct rtsx_usb_ms *host = platform_get_drvdata(pdev);
0811     struct memstick_host *msh = host->msh;
0812     int err;
0813 
0814     host->eject = true;
0815     cancel_work_sync(&host->handle_req);
0816 
0817     mutex_lock(&host->host_mutex);
0818     if (host->req) {
0819         dev_dbg(ms_dev(host),
0820             "%s: Controller removed during transfer\n",
0821             dev_name(&msh->dev));
0822         host->req->error = -ENOMEDIUM;
0823         do {
0824             err = memstick_next_req(msh, &host->req);
0825             if (!err)
0826                 host->req->error = -ENOMEDIUM;
0827         } while (!err);
0828     }
0829     mutex_unlock(&host->host_mutex);
0830 
0831     /* Balance possible unbalanced usage count
0832      * e.g. unconditional module removal
0833      */
0834     if (pm_runtime_active(ms_dev(host)))
0835         pm_runtime_put(ms_dev(host));
0836 
0837     pm_runtime_disable(ms_dev(host));
0838     memstick_remove_host(msh);
0839     dev_dbg(ms_dev(host),
0840         ": Realtek USB Memstick controller has been removed\n");
0841     memstick_free_host(msh);
0842     platform_set_drvdata(pdev, NULL);
0843 
0844     return 0;
0845 }
0846 
0847 static struct platform_device_id rtsx_usb_ms_ids[] = {
0848     {
0849         .name = "rtsx_usb_ms",
0850     }, {
0851         /* sentinel */
0852     }
0853 };
0854 MODULE_DEVICE_TABLE(platform, rtsx_usb_ms_ids);
0855 
0856 static struct platform_driver rtsx_usb_ms_driver = {
0857     .probe      = rtsx_usb_ms_drv_probe,
0858     .remove     = rtsx_usb_ms_drv_remove,
0859     .id_table       = rtsx_usb_ms_ids,
0860     .driver     = {
0861         .name   = "rtsx_usb_ms",
0862         .pm = &rtsx_usb_ms_pm_ops,
0863     },
0864 };
0865 module_platform_driver(rtsx_usb_ms_driver);
0866 
0867 MODULE_LICENSE("GPL v2");
0868 MODULE_AUTHOR("Roger Tseng <rogerable@realtek.com>");
0869 MODULE_DESCRIPTION("Realtek USB Memstick Card Host 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!