linux/drivers/memstick/host/rtsx_usb_ms.c
<<
>>
Prefs
   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
  35struct 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
  54static inline struct device *ms_dev(struct rtsx_usb_ms *host)
  55{
  56        return &(host->pdev->dev);
  57}
  58
  59static 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
  72static 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
 118static void ms_print_debug_regs(struct rtsx_usb_ms *host)
 119{
 120}
 121
 122#endif
 123
 124static 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
 138static 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
 152static 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
 166static 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
 180static 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
 220static 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
 242static 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;
 323err_out:
 324        ms_clear_error(host);
 325        return err;
 326}
 327
 328static 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
 395static 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
 468static 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
 518static 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
 551static 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
 561static 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        }
 636out:
 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
 648static 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
 659static 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 */
 676static 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
 705poll_again:
 706                if (host->eject)
 707                        break;
 708
 709                msleep(1000);
 710        }
 711
 712        complete(&host->detect_ms_exit);
 713        return 0;
 714}
 715
 716static 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;
 765err_out:
 766        memstick_free_host(msh);
 767        return err;
 768}
 769
 770static 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
 813static SIMPLE_DEV_PM_OPS(rtsx_usb_ms_pm_ops,
 814                rtsx_usb_ms_suspend, rtsx_usb_ms_resume);
 815
 816static struct platform_device_id rtsx_usb_ms_ids[] = {
 817        {
 818                .name = "rtsx_usb_ms",
 819        }, {
 820                /* sentinel */
 821        }
 822};
 823MODULE_DEVICE_TABLE(platform, rtsx_usb_ms_ids);
 824
 825static 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};
 834module_platform_driver(rtsx_usb_ms_driver);
 835
 836MODULE_LICENSE("GPL v2");
 837MODULE_AUTHOR("Roger Tseng <rogerable@realtek.com>");
 838MODULE_DESCRIPTION("Realtek USB Memstick Card Host Driver");
 839
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.