kernel/drivers/memstick/host/rtsx_usb_ms.c

   1 /* Realtek USB Memstick Card Interface driver
   2  *
   3  * Copyright(c) 2009-2013 Realtek Semiconductor Corp. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2
   7  * as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, see <http://www.gnu.org/licenses/>.
  16  *
  17  * Author:
  18  *   Roger Tseng <rogerable@realtek.com>
  19  */
  20
  21 #include <linux/module.h>
  22 #include <linux/highmem.h>
  23 #include <linux/delay.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/workqueue.h>
  26 #include <linux/memstick.h>
  27 #include <linux/kthread.h>
  28 #include <linux/mfd/rtsx_usb.h>
  29 #include <linux/pm_runtime.h>
  30 #include <linux/mutex.h>
  31 #include <linux/sched.h>
  32 #include <linux/completion.h>
  33 #include <asm/unaligned.h>
  34
  35 struct rtsx_usb_ms {
  36         struct platform_device  *pdev;
  37         struct rtsx_ucr *ucr;
  38         struct memstick_host    *msh;
  39         struct memstick_request *req;
  40
  41         struct mutex            host_mutex;
  42         struct work_struct      handle_req;
  43
  44         struct task_struct      *detect_ms;
  45         struct completion       detect_ms_exit;
  46
  47         u8                      ssc_depth;
  48         unsigned int            clock;
  49         int                     power_mode;
  50         unsigned char           ifmode;
  51         bool                    eject;
  52 };
  53
  54 static inline struct device *ms_dev(struct rtsx_usb_ms *host)
  55 {
  56         return &(host->pdev->dev);
  57 }
  58
  59 static inline void ms_clear_error(struct rtsx_usb_ms *host)
  60 {
  61         struct rtsx_ucr *ucr = host->ucr;
  62         rtsx_usb_ep0_write_register(ucr, CARD_STOP,
  63                                   MS_STOP | MS_CLR_ERR,
  64                                   MS_STOP | MS_CLR_ERR);
  65
  66         rtsx_usb_clear_dma_err(ucr);
  67         rtsx_usb_clear_fsm_err(ucr);
  68 }
  69
  70 #ifdef DEBUG
  71
  72 static void ms_print_debug_regs(struct rtsx_usb_ms *host)
  73 {
  74         struct rtsx_ucr *ucr = host->ucr;
  75         u16 i;
  76         u8 *ptr;
  77
  78         /* Print MS host internal registers */
  79         rtsx_usb_init_cmd(ucr);
  80
  81         /* MS_CFG to MS_INT_REG */
  82         for (i = 0xFD40; i <= 0xFD44; i++)
  83                 rtsx_usb_add_cmd(ucr, READ_REG_CMD, i, 0, 0);
  84
  85         /* CARD_SHARE_MODE to CARD_GPIO */
  86         for (i = 0xFD51; i <= 0xFD56; i++)
  87                 rtsx_usb_add_cmd(ucr, READ_REG_CMD, i, 0, 0);
  88
  89         /* CARD_PULL_CTLx */
  90         for (i = 0xFD60; i <= 0xFD65; i++)
  91                 rtsx_usb_add_cmd(ucr, READ_REG_CMD, i, 0, 0);
  92
  93         /* CARD_DATA_SOURCE, CARD_SELECT, CARD_CLK_EN, CARD_PWR_CTL */
  94         rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_DATA_SOURCE, 0, 0);
  95         rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_SELECT, 0, 0);
  96         rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_CLK_EN, 0, 0);
  97         rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_PWR_CTL, 0, 0);
  98
  99         rtsx_usb_send_cmd(ucr, MODE_CR, 100);
 100         rtsx_usb_get_rsp(ucr, 21, 100);
 101
 102         ptr = ucr->rsp_buf;
 103         for (i = 0xFD40; i <= 0xFD44; i++)
 104                 dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", i, *(ptr++));
 105         for (i = 0xFD51; i <= 0xFD56; i++)
 106                 dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", i, *(ptr++));
 107         for (i = 0xFD60; i <= 0xFD65; i++)
 108                 dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", i, *(ptr++));
 109
 110         dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_DATA_SOURCE, *(ptr++));
 111         dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_SELECT, *(ptr++));
 112         dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_CLK_EN, *(ptr++));
 113         dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_PWR_CTL, *(ptr++));
 114 }
 115
 116 #else
 117
 118 static void ms_print_debug_regs(struct rtsx_usb_ms *host)
 119 {
 120 }
 121
 122 #endif
 123
 124 static int ms_pull_ctl_disable_lqfp48(struct rtsx_ucr *ucr)
 125 {
 126         rtsx_usb_init_cmd(ucr);
 127
 128         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0x55);
 129         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x55);
 130         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0x95);
 131         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x55);
 132         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x55);
 133         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0xA5);
 134
 135         return rtsx_usb_send_cmd(ucr, MODE_C, 100);
 136 }
 137
 138 static int ms_pull_ctl_disable_qfn24(struct rtsx_ucr *ucr)
 139 {
 140         rtsx_usb_init_cmd(ucr);
 141
 142         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0x65);
 143         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x55);
 144         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0x95);
 145         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x55);
 146         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x56);
 147         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0x59);
 148
 149         return rtsx_usb_send_cmd(ucr, MODE_C, 100);
 150 }
 151
 152 static int ms_pull_ctl_enable_lqfp48(struct rtsx_ucr *ucr)
 153 {
 154         rtsx_usb_init_cmd(ucr);
 155
 156         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0x55);
 157         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x55);
 158         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0x95);
 159         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x55);
 160         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x55);
 161         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0xA5);
 162
 163         return rtsx_usb_send_cmd(ucr, MODE_C, 100);
 164 }
 165
 166 static int ms_pull_ctl_enable_qfn24(struct rtsx_ucr *ucr)
 167 {
 168         rtsx_usb_init_cmd(ucr);
 169
 170         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0x65);
 171         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x55);
 172         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0x95);
 173         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x55);
 174         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x55);
 175         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0x59);
 176
 177         return rtsx_usb_send_cmd(ucr, MODE_C, 100);
 178 }
 179
 180 static int ms_power_on(struct rtsx_usb_ms *host)
 181 {
 182         struct rtsx_ucr *ucr = host->ucr;
 183         int err;
 184
 185         dev_dbg(ms_dev(host), "%s\n", __func__);
 186
 187         rtsx_usb_init_cmd(ucr);
 188         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_SELECT, 0x07, MS_MOD_SEL);
 189         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_SHARE_MODE,
 190                         CARD_SHARE_MASK, CARD_SHARE_MS);
 191         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_CLK_EN,
 192                         MS_CLK_EN, MS_CLK_EN);
 193         err = rtsx_usb_send_cmd(ucr, MODE_C, 100);
 194         if (err < 0)
 195                 return err;
 196
 197         if (CHECK_PKG(ucr, LQFP48))
 198                 err = ms_pull_ctl_enable_lqfp48(ucr);
 199         else
 200                 err = ms_pull_ctl_enable_qfn24(ucr);
 201         if (err < 0)
 202                 return err;
 203
 204         err = rtsx_usb_write_register(ucr, CARD_PWR_CTL,
 205                         POWER_MASK, PARTIAL_POWER_ON);
 206         if (err)
 207                 return err;
 208
 209         usleep_range(800, 1000);
 210
 211         rtsx_usb_init_cmd(ucr);
 212         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PWR_CTL,
 213                         POWER_MASK, POWER_ON);
 214         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_OE,
 215                         MS_OUTPUT_EN, MS_OUTPUT_EN);
 216
 217         return rtsx_usb_send_cmd(ucr, MODE_C, 100);
 218 }
 219
 220 static int ms_power_off(struct rtsx_usb_ms *host)
 221 {
 222         struct rtsx_ucr *ucr = host->ucr;
 223         int err;
 224
 225         dev_dbg(ms_dev(host), "%s\n", __func__);
 226
 227         rtsx_usb_init_cmd(ucr);
 228
 229         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_CLK_EN, MS_CLK_EN, 0);
 230         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_OE, MS_OUTPUT_EN, 0);
 231
 232         err = rtsx_usb_send_cmd(ucr, MODE_C, 100);
 233         if (err < 0)
 234                 return err;
 235
 236         if (CHECK_PKG(ucr, LQFP48))
 237                 return ms_pull_ctl_disable_lqfp48(ucr);
 238
 239         return ms_pull_ctl_disable_qfn24(ucr);
 240 }
 241
 242 static int ms_transfer_data(struct rtsx_usb_ms *host, unsigned char data_dir,
 243                 u8 tpc, u8 cfg, struct scatterlist *sg)
 244 {
 245         struct rtsx_ucr *ucr = host->ucr;
 246         int err;
 247         unsigned int length = sg->length;
 248         u16 sec_cnt = (u16)(length / 512);
 249         u8 trans_mode, dma_dir, flag;
 250         unsigned int pipe;
 251         struct memstick_dev *card = host->msh->card;
 252
 253         dev_dbg(ms_dev(host), "%s: tpc = 0x%02x, data_dir = %s, length = %d\n",
 254                         __func__, tpc, (data_dir == READ) ? "READ" : "WRITE",
 255                         length);
 256
 257         if (data_dir == READ) {
 258                 flag = MODE_CDIR;
 259                 dma_dir = DMA_DIR_FROM_CARD;
 260                 if (card->id.type != MEMSTICK_TYPE_PRO)
 261                         trans_mode = MS_TM_NORMAL_READ;
 262                 else
 263                         trans_mode = MS_TM_AUTO_READ;
 264                 pipe = usb_rcvbulkpipe(ucr->pusb_dev, EP_BULK_IN);
 265         } else {
 266                 flag = MODE_CDOR;
 267                 dma_dir = DMA_DIR_TO_CARD;
 268                 if (card->id.type != MEMSTICK_TYPE_PRO)
 269                         trans_mode = MS_TM_NORMAL_WRITE;
 270                 else
 271                         trans_mode = MS_TM_AUTO_WRITE;
 272                 pipe = usb_sndbulkpipe(ucr->pusb_dev, EP_BULK_OUT);
 273         }
 274
 275         rtsx_usb_init_cmd(ucr);
 276
 277         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
 278         if (card->id.type == MEMSTICK_TYPE_PRO) {
 279                 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_SECTOR_CNT_H,
 280                                 0xFF, (u8)(sec_cnt >> 8));
 281                 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_SECTOR_CNT_L,
 282                                 0xFF, (u8)sec_cnt);
 283         }
 284         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
 285
 286         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC3,
 287                         0xFF, (u8)(length >> 24));
 288         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC2,
 289                         0xFF, (u8)(length >> 16));
 290         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC1,
 291                         0xFF, (u8)(length >> 8));
 292         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC0, 0xFF,
 293                         (u8)length);
 294         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_CTL,
 295                         0x03 | DMA_PACK_SIZE_MASK, dma_dir | DMA_EN | DMA_512);
 296         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
 297                         0x01, RING_BUFFER);
 298
 299         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANSFER,
 300                         0xFF, MS_TRANSFER_START | trans_mode);
 301         rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, MS_TRANSFER,
 302                         MS_TRANSFER_END, MS_TRANSFER_END);
 303
 304         err = rtsx_usb_send_cmd(ucr, flag | STAGE_MS_STATUS, 100);
 305         if (err)
 306                 return err;
 307
 308         err = rtsx_usb_transfer_data(ucr, pipe, sg, length,
 309                         1, NULL, 10000);
 310         if (err)
 311                 goto err_out;
 312
 313         err = rtsx_usb_get_rsp(ucr, 3, 15000);
 314         if (err)
 315                 goto err_out;
 316
 317         if (ucr->rsp_buf[0] & MS_TRANSFER_ERR ||
 318             ucr->rsp_buf[1] & (MS_CRC16_ERR | MS_RDY_TIMEOUT)) {
 319                 err = -EIO;
 320                 goto err_out;
 321         }
 322         return 0;
 323 err_out:
 324         ms_clear_error(host);
 325         return err;
 326 }
 327
 328 static int ms_write_bytes(struct rtsx_usb_ms *host, u8 tpc,
 329                 u8 cfg, u8 cnt, u8 *data, u8 *int_reg)
 330 {
 331         struct rtsx_ucr *ucr = host->ucr;
 332         int err, i;
 333
 334         dev_dbg(ms_dev(host), "%s: tpc = 0x%02x\n", __func__, tpc);
 335
 336         rtsx_usb_init_cmd(ucr);
 337
 338         for (i = 0; i < cnt; i++)
 339                 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
 340                                 PPBUF_BASE2 + i, 0xFF, data[i]);
 341
 342         if (cnt % 2)
 343                 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
 344                                 PPBUF_BASE2 + i, 0xFF, 0xFF);
 345
 346         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
 347         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt);
 348         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
 349         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
 350                         0x01, PINGPONG_BUFFER);
 351
 352         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANSFER,
 353                         0xFF, MS_TRANSFER_START | MS_TM_WRITE_BYTES);
 354         rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, MS_TRANSFER,
 355                         MS_TRANSFER_END, MS_TRANSFER_END);
 356         rtsx_usb_add_cmd(ucr, READ_REG_CMD, MS_TRANS_CFG, 0, 0);
 357
 358         err = rtsx_usb_send_cmd(ucr, MODE_CR, 100);
 359         if (err)
 360                 return err;
 361
 362         err = rtsx_usb_get_rsp(ucr, 2, 5000);
 363         if (err || (ucr->rsp_buf[0] & MS_TRANSFER_ERR)) {
 364                 u8 val;
 365
 366                 rtsx_usb_ep0_read_register(ucr, MS_TRANS_CFG, &val);
 367                 dev_dbg(ms_dev(host), "MS_TRANS_CFG: 0x%02x\n", val);
 368
 369                 if (int_reg)
 370                         *int_reg = val & 0x0F;
 371
 372                 ms_print_debug_regs(host);
 373
 374                 ms_clear_error(host);
 375
 376                 if (!(tpc & 0x08)) {
 377                         if (val & MS_CRC16_ERR)
 378                                 return -EIO;
 379                 } else {
 380                         if (!(val & 0x80)) {
 381                                 if (val & (MS_INT_ERR | MS_INT_CMDNK))
 382                                         return -EIO;
 383                         }
 384                 }
 385
 386                 return -ETIMEDOUT;
 387         }
 388
 389         if (int_reg)
 390                 *int_reg = ucr->rsp_buf[1] & 0x0F;
 391
 392         return 0;
 393 }
 394
 395 static int ms_read_bytes(struct rtsx_usb_ms *host, u8 tpc,
 396                 u8 cfg, u8 cnt, u8 *data, u8 *int_reg)
 397 {
 398         struct rtsx_ucr *ucr = host->ucr;
 399         int err, i;
 400         u8 *ptr;
 401
 402         dev_dbg(ms_dev(host), "%s: tpc = 0x%02x\n", __func__, tpc);
 403
 404         rtsx_usb_init_cmd(ucr);
 405
 406         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
 407         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt);
 408         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
 409         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
 410                         0x01, PINGPONG_BUFFER);
 411
 412         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANSFER,
 413                         0xFF, MS_TRANSFER_START | MS_TM_READ_BYTES);
 414         rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, MS_TRANSFER,
 415                         MS_TRANSFER_END, MS_TRANSFER_END);
 416         for (i = 0; i < cnt - 1; i++)
 417                 rtsx_usb_add_cmd(ucr, READ_REG_CMD, PPBUF_BASE2 + i, 0, 0);
 418         if (cnt % 2)
 419                 rtsx_usb_add_cmd(ucr, READ_REG_CMD, PPBUF_BASE2 + cnt, 0, 0);
 420         else
 421                 rtsx_usb_add_cmd(ucr, READ_REG_CMD,
 422                                 PPBUF_BASE2 + cnt - 1, 0, 0);
 423
 424         rtsx_usb_add_cmd(ucr, READ_REG_CMD, MS_TRANS_CFG, 0, 0);
 425
 426         err = rtsx_usb_send_cmd(ucr, MODE_CR, 100);
 427         if (err)
 428                 return err;
 429
 430         err = rtsx_usb_get_rsp(ucr, cnt + 2, 5000);
 431         if (err || (ucr->rsp_buf[0] & MS_TRANSFER_ERR)) {
 432                 u8 val;
 433
 434                 rtsx_usb_ep0_read_register(ucr, MS_TRANS_CFG, &val);
 435                 dev_dbg(ms_dev(host), "MS_TRANS_CFG: 0x%02x\n", val);
 436
 437                 if (int_reg && (host->ifmode != MEMSTICK_SERIAL))
 438                         *int_reg = val & 0x0F;
 439
 440                 ms_print_debug_regs(host);
 441
 442                 ms_clear_error(host);
 443
 444                 if (!(tpc & 0x08)) {
 445                         if (val & MS_CRC16_ERR)
 446                                 return -EIO;
 447                 } else {
 448                         if (!(val & 0x80)) {
 449                                 if (val & (MS_INT_ERR | MS_INT_CMDNK))
 450                                         return -EIO;
 451                         }
 452                 }
 453
 454                 return -ETIMEDOUT;
 455         }
 456
 457         ptr = ucr->rsp_buf + 1;
 458         for (i = 0; i < cnt; i++)
 459                 data[i] = *ptr++;
 460
 461
 462         if (int_reg && (host->ifmode != MEMSTICK_SERIAL))
 463                 *int_reg = *ptr & 0x0F;
 464
 465         return 0;
 466 }
 467
 468 static int rtsx_usb_ms_issue_cmd(struct rtsx_usb_ms *host)
 469 {
 470         struct memstick_request *req = host->req;
 471         int err = 0;
 472         u8 cfg = 0, int_reg;
 473
 474         dev_dbg(ms_dev(host), "%s\n", __func__);
 475
 476         if (req->need_card_int) {
 477                 if (host->ifmode != MEMSTICK_SERIAL)
 478                         cfg = WAIT_INT;
 479         }
 480
 481         if (req->long_data) {
 482                 err = ms_transfer_data(host, req->data_dir,
 483                                 req->tpc, cfg, &(req->sg));
 484         } else {
 485                 if (req->data_dir == READ)
 486                         err = ms_read_bytes(host, req->tpc, cfg,
 487                                         req->data_len, req->data, &int_reg);
 488                 else
 489                         err = ms_write_bytes(host, req->tpc, cfg,
 490                                         req->data_len, req->data, &int_reg);
 491         }
 492         if (err < 0)
 493                 return err;
 494
 495         if (req->need_card_int) {
 496                 if (host->ifmode == MEMSTICK_SERIAL) {
 497                         err = ms_read_bytes(host, MS_TPC_GET_INT,
 498                                         NO_WAIT_INT, 1, &req->int_reg, NULL);
 499                         if (err < 0)
 500                                 return err;
 501                 } else {
 502
 503                         if (int_reg & MS_INT_CMDNK)
 504                                 req->int_reg |= MEMSTICK_INT_CMDNAK;
 505                         if (int_reg & MS_INT_BREQ)
 506                                 req->int_reg |= MEMSTICK_INT_BREQ;
 507                         if (int_reg & MS_INT_ERR)
 508                                 req->int_reg |= MEMSTICK_INT_ERR;
 509                         if (int_reg & MS_INT_CED)
 510                                 req->int_reg |= MEMSTICK_INT_CED;
 511                 }
 512                 dev_dbg(ms_dev(host), "int_reg: 0x%02x\n", req->int_reg);
 513         }
 514
 515         return 0;
 516 }
 517
 518 static void rtsx_usb_ms_handle_req(struct work_struct *work)
 519 {
 520         struct rtsx_usb_ms *host = container_of(work,
 521                         struct rtsx_usb_ms, handle_req);
 522         struct rtsx_ucr *ucr = host->ucr;
 523         struct memstick_host *msh = host->msh;
 524         int rc;
 525
 526         if (!host->req) {
 527                 do {
 528                         rc = memstick_next_req(msh, &host->req);
 529                         dev_dbg(ms_dev(host), "next req %d\n", rc);
 530
 531                         if (!rc) {
 532                                 mutex_lock(&ucr->dev_mutex);
 533
 534                                 if (rtsx_usb_card_exclusive_check(ucr,
 535                                                         RTSX_USB_MS_CARD))
 536                                         host->req->error = -EIO;
 537                                 else
 538                                         host->req->error =
 539                                                 rtsx_usb_ms_issue_cmd(host);
 540
 541                                 mutex_unlock(&ucr->dev_mutex);
 542
 543                                 dev_dbg(ms_dev(host), "req result %d\n",
 544                                                 host->req->error);
 545                         }
 546                 } while (!rc);
 547         }
 548
 549 }
 550
 551 static void rtsx_usb_ms_request(struct memstick_host *msh)
 552 {
 553         struct rtsx_usb_ms *host = memstick_priv(msh);
 554
 555         dev_dbg(ms_dev(host), "--> %s\n", __func__);
 556
 557         if (!host->eject)
 558                 schedule_work(&host->handle_req);
 559 }
 560
 561 static int rtsx_usb_ms_set_param(struct memstick_host *msh,
 562                 enum memstick_param param, int value)
 563 {
 564         struct rtsx_usb_ms *host = memstick_priv(msh);
 565         struct rtsx_ucr *ucr = host->ucr;
 566         unsigned int clock = 0;
 567         u8 ssc_depth = 0;
 568         int err;
 569
 570         dev_dbg(ms_dev(host), "%s: param = %d, value = %d\n",
 571                         __func__, param, value);
 572
 573         mutex_lock(&ucr->dev_mutex);
 574
 575         err = rtsx_usb_card_exclusive_check(ucr, RTSX_USB_MS_CARD);
 576         if (err)
 577                 goto out;
 578
 579         switch (param) {
 580         case MEMSTICK_POWER:
 581                 if (value == host->power_mode)
 582                         break;
 583
 584                 if (value == MEMSTICK_POWER_ON) {
 585                         pm_runtime_get_sync(ms_dev(host));
 586                         err = ms_power_on(host);
 587                 } else if (value == MEMSTICK_POWER_OFF) {
 588                         err = ms_power_off(host);
 589                         if (host->msh->card)
 590                                 pm_runtime_put_noidle(ms_dev(host));
 591                         else
 592                                 pm_runtime_put(ms_dev(host));
 593                 } else
 594                         err = -EINVAL;
 595                 if (!err)
 596                         host->power_mode = value;
 597                 break;
 598
 599         case MEMSTICK_INTERFACE:
 600                 if (value == MEMSTICK_SERIAL) {
 601                         clock = 19000000;
 602                         ssc_depth = SSC_DEPTH_512K;
 603                         err = rtsx_usb_write_register(ucr, MS_CFG, 0x5A,
 604                                        MS_BUS_WIDTH_1 | PUSH_TIME_DEFAULT);
 605                         if (err < 0)
 606                                 break;
 607                 } else if (value == MEMSTICK_PAR4) {
 608                         clock = 39000000;
 609                         ssc_depth = SSC_DEPTH_1M;
 610
 611                         err = rtsx_usb_write_register(ucr, MS_CFG, 0x5A,
 612                                         MS_BUS_WIDTH_4 | PUSH_TIME_ODD |
 613                                         MS_NO_CHECK_INT);
 614                         if (err < 0)
 615                                 break;
 616                 } else {
 617                         err = -EINVAL;
 618                         break;
 619                 }
 620
 621                 err = rtsx_usb_switch_clock(ucr, clock,
 622                                 ssc_depth, false, true, false);
 623                 if (err < 0) {
 624                         dev_dbg(ms_dev(host), "switch clock failed\n");
 625                         break;
 626                 }
 627
 628                 host->ssc_depth = ssc_depth;
 629                 host->clock = clock;
 630                 host->ifmode = value;
 631                 break;
 632         default:
 633                 err = -EINVAL;
 634                 break;
 635         }
 636 out:
 637         mutex_unlock(&ucr->dev_mutex);
 638
 639         /* power-on delay */
 640         if (param == MEMSTICK_POWER && value == MEMSTICK_POWER_ON)
 641                 usleep_range(10000, 12000);
 642
 643         dev_dbg(ms_dev(host), "%s: return = %d\n", __func__, err);
 644         return err;
 645 }
 646
 647 #ifdef CONFIG_PM_SLEEP
 648 static int rtsx_usb_ms_suspend(struct device *dev)
 649 {
 650         struct rtsx_usb_ms *host = dev_get_drvdata(dev);
 651         struct memstick_host *msh = host->msh;
 652
 653         dev_dbg(ms_dev(host), "--> %s\n", __func__);
 654
 655         memstick_suspend_host(msh);
 656         return 0;
 657 }
 658
 659 static int rtsx_usb_ms_resume(struct device *dev)
 660 {
 661         struct rtsx_usb_ms *host = dev_get_drvdata(dev);
 662         struct memstick_host *msh = host->msh;
 663
 664         dev_dbg(ms_dev(host), "--> %s\n", __func__);
 665
 666         memstick_resume_host(msh);
 667         return 0;
 668 }
 669 #endif /* CONFIG_PM_SLEEP */
 670
 671 /*
 672  * Thread function of ms card slot detection. The thread starts right after
 673  * successful host addition. It stops while the driver removal function sets
 674  * host->eject true.
 675  */
 676 static int rtsx_usb_detect_ms_card(void *__host)
 677 {
 678         struct rtsx_usb_ms *host = (struct rtsx_usb_ms *)__host;
 679         struct rtsx_ucr *ucr = host->ucr;
 680         u8 val = 0;
 681         int err;
 682
 683         for (;;) {
 684                 mutex_lock(&ucr->dev_mutex);
 685
 686                 /* Check pending MS card changes */
 687                 err = rtsx_usb_read_register(ucr, CARD_INT_PEND, &val);
 688                 if (err) {
 689                         mutex_unlock(&ucr->dev_mutex);
 690                         goto poll_again;
 691                 }
 692
 693                 /* Clear the pending */
 694                 rtsx_usb_write_register(ucr, CARD_INT_PEND,
 695                                 XD_INT | MS_INT | SD_INT,
 696                                 XD_INT | MS_INT | SD_INT);
 697
 698                 mutex_unlock(&ucr->dev_mutex);
 699
 700                 if (val & MS_INT) {
 701                         dev_dbg(ms_dev(host), "MS slot change detected\n");
 702                         memstick_detect_change(host->msh);
 703                 }
 704
 705 poll_again:
 706                 if (host->eject)
 707                         break;
 708
 709                 msleep(1000);
 710         }
 711
 712         complete(&host->detect_ms_exit);
 713         return 0;
 714 }
 715
 716 static int rtsx_usb_ms_drv_probe(struct platform_device *pdev)
 717 {
 718         struct memstick_host *msh;
 719         struct rtsx_usb_ms *host;
 720         struct rtsx_ucr *ucr;
 721         int err;
 722
 723         ucr = usb_get_intfdata(to_usb_interface(pdev->dev.parent));
 724         if (!ucr)
 725                 return -ENXIO;
 726
 727         dev_dbg(&(pdev->dev),
 728                         "Realtek USB Memstick controller found\n");
 729
 730         msh = memstick_alloc_host(sizeof(*host), &pdev->dev);
 731         if (!msh)
 732                 return -ENOMEM;
 733
 734         host = memstick_priv(msh);
 735         host->ucr = ucr;
 736         host->msh = msh;
 737         host->pdev = pdev;
 738         host->power_mode = MEMSTICK_POWER_OFF;
 739         platform_set_drvdata(pdev, host);
 740
 741         mutex_init(&host->host_mutex);
 742         INIT_WORK(&host->handle_req, rtsx_usb_ms_handle_req);
 743
 744         init_completion(&host->detect_ms_exit);
 745         host->detect_ms = kthread_create(rtsx_usb_detect_ms_card, host,
 746                         "rtsx_usb_ms_%d", pdev->id);
 747         if (IS_ERR(host->detect_ms)) {
 748                 dev_dbg(&(pdev->dev),
 749                                 "Unable to create polling thread.\n");
 750                 err = PTR_ERR(host->detect_ms);
 751                 goto err_out;
 752         }
 753
 754         msh->request = rtsx_usb_ms_request;
 755         msh->set_param = rtsx_usb_ms_set_param;
 756         msh->caps = MEMSTICK_CAP_PAR4;
 757
 758         pm_runtime_enable(&pdev->dev);
 759         err = memstick_add_host(msh);
 760         if (err)
 761                 goto err_out;
 762
 763         wake_up_process(host->detect_ms);
 764         return 0;
 765 err_out:
 766         memstick_free_host(msh);
 767         return err;
 768 }
 769
 770 static int rtsx_usb_ms_drv_remove(struct platform_device *pdev)
 771 {
 772         struct rtsx_usb_ms *host = platform_get_drvdata(pdev);
 773         struct memstick_host *msh;
 774         int err;
 775
 776         msh = host->msh;
 777         host->eject = true;
 778         cancel_work_sync(&host->handle_req);
 779
 780         mutex_lock(&host->host_mutex);
 781         if (host->req) {
 782                 dev_dbg(&(pdev->dev),
 783                         "%s: Controller removed during transfer\n",
 784                         dev_name(&msh->dev));
 785                 host->req->error = -ENOMEDIUM;
 786                 do {
 787                         err = memstick_next_req(msh, &host->req);
 788                         if (!err)
 789                                 host->req->error = -ENOMEDIUM;
 790                 } while (!err);
 791         }
 792         mutex_unlock(&host->host_mutex);
 793
 794         wait_for_completion(&host->detect_ms_exit);
 795         memstick_remove_host(msh);
 796         memstick_free_host(msh);
 797
 798         /* Balance possible unbalanced usage count
 799          * e.g. unconditional module removal
 800          */
 801         if (pm_runtime_active(ms_dev(host)))
 802                 pm_runtime_put(ms_dev(host));
 803
 804         pm_runtime_disable(&pdev->dev);
 805         platform_set_drvdata(pdev, NULL);
 806
 807         dev_dbg(&(pdev->dev),
 808                 ": Realtek USB Memstick controller has been removed\n");
 809
 810         return 0;
 811 }
 812
 813 static SIMPLE_DEV_PM_OPS(rtsx_usb_ms_pm_ops,
 814                 rtsx_usb_ms_suspend, rtsx_usb_ms_resume);
 815
 816 static struct platform_device_id rtsx_usb_ms_ids[] = {
 817         {
 818                 .name = "rtsx_usb_ms",
 819         }, {
 820                 /* sentinel */
 821         }
 822 };
 823 MODULE_DEVICE_TABLE(platform, rtsx_usb_ms_ids);
 824
 825 static struct platform_driver rtsx_usb_ms_driver = {
 826         .probe          = rtsx_usb_ms_drv_probe,
 827         .remove         = rtsx_usb_ms_drv_remove,
 828         .id_table       = rtsx_usb_ms_ids,
 829         .driver         = {
 830                 .name   = "rtsx_usb_ms",
 831                 .pm     = &rtsx_usb_ms_pm_ops,
 832         },
 833 };
 834 module_platform_driver(rtsx_usb_ms_driver);
 835
 836 MODULE_LICENSE("GPL v2");
 837 MODULE_AUTHOR("Roger Tseng <rogerable@realtek.com>");
 838 MODULE_DESCRIPTION("Realtek USB Memstick Card Host Driver");