linux/drivers/memstick/host/rtsx_pci_ms.c
<<
>>
Prefs
   1/* Realtek PCI-Express 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 as published by the
   7 * Free Software Foundation; either version 2, or (at your option) any
   8 * later version.
   9 *
  10 * This program is distributed in the hope that it will be useful, but
  11 * WITHOUT ANY WARRANTY; without even the implied warranty of
  12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 * General Public License for more details.
  14 *
  15 * You should have received a copy of the GNU General Public License along
  16 * with this program; if not, see <http://www.gnu.org/licenses/>.
  17 *
  18 * Author:
  19 *   Wei WANG <wei_wang@realsil.com.cn>
  20 */
  21
  22#include <linux/module.h>
  23#include <linux/highmem.h>
  24#include <linux/delay.h>
  25#include <linux/platform_device.h>
  26#include <linux/memstick.h>
  27#include <linux/rtsx_pci.h>
  28#include <asm/unaligned.h>
  29
  30struct realtek_pci_ms {
  31        struct platform_device  *pdev;
  32        struct rtsx_pcr         *pcr;
  33        struct memstick_host    *msh;
  34        struct memstick_request *req;
  35
  36        struct mutex            host_mutex;
  37        struct work_struct      handle_req;
  38
  39        u8                      ssc_depth;
  40        unsigned int            clock;
  41        unsigned char           ifmode;
  42        bool                    eject;
  43};
  44
  45static inline struct device *ms_dev(struct realtek_pci_ms *host)
  46{
  47        return &(host->pdev->dev);
  48}
  49
  50static inline void ms_clear_error(struct realtek_pci_ms *host)
  51{
  52        rtsx_pci_write_register(host->pcr, CARD_STOP,
  53                        MS_STOP | MS_CLR_ERR, MS_STOP | MS_CLR_ERR);
  54}
  55
  56#ifdef DEBUG
  57
  58static void ms_print_debug_regs(struct realtek_pci_ms *host)
  59{
  60        struct rtsx_pcr *pcr = host->pcr;
  61        u16 i;
  62        u8 *ptr;
  63
  64        /* Print MS host internal registers */
  65        rtsx_pci_init_cmd(pcr);
  66        for (i = 0xFD40; i <= 0xFD44; i++)
  67                rtsx_pci_add_cmd(pcr, READ_REG_CMD, i, 0, 0);
  68        for (i = 0xFD52; i <= 0xFD69; i++)
  69                rtsx_pci_add_cmd(pcr, READ_REG_CMD, i, 0, 0);
  70        rtsx_pci_send_cmd(pcr, 100);
  71
  72        ptr = rtsx_pci_get_cmd_data(pcr);
  73        for (i = 0xFD40; i <= 0xFD44; i++)
  74                dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", i, *(ptr++));
  75        for (i = 0xFD52; i <= 0xFD69; i++)
  76                dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", i, *(ptr++));
  77}
  78
  79#else
  80
  81#define ms_print_debug_regs(host)
  82
  83#endif
  84
  85static int ms_power_on(struct realtek_pci_ms *host)
  86{
  87        struct rtsx_pcr *pcr = host->pcr;
  88        int err;
  89
  90        rtsx_pci_init_cmd(pcr);
  91        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, CARD_SELECT, 0x07, MS_MOD_SEL);
  92        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, CARD_SHARE_MODE,
  93                        CARD_SHARE_MASK, CARD_SHARE_48_MS);
  94        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, CARD_CLK_EN,
  95                        MS_CLK_EN, MS_CLK_EN);
  96        err = rtsx_pci_send_cmd(pcr, 100);
  97        if (err < 0)
  98                return err;
  99
 100        err = rtsx_pci_card_pull_ctl_enable(pcr, RTSX_MS_CARD);
 101        if (err < 0)
 102                return err;
 103
 104        err = rtsx_pci_card_power_on(pcr, RTSX_MS_CARD);
 105        if (err < 0)
 106                return err;
 107
 108        /* Wait ms power stable */
 109        msleep(150);
 110
 111        err = rtsx_pci_write_register(pcr, CARD_OE,
 112                        MS_OUTPUT_EN, MS_OUTPUT_EN);
 113        if (err < 0)
 114                return err;
 115
 116        return 0;
 117}
 118
 119static int ms_power_off(struct realtek_pci_ms *host)
 120{
 121        struct rtsx_pcr *pcr = host->pcr;
 122        int err;
 123
 124        rtsx_pci_init_cmd(pcr);
 125
 126        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, CARD_CLK_EN, MS_CLK_EN, 0);
 127        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, CARD_OE, MS_OUTPUT_EN, 0);
 128
 129        err = rtsx_pci_send_cmd(pcr, 100);
 130        if (err < 0)
 131                return err;
 132
 133        err = rtsx_pci_card_power_off(pcr, RTSX_MS_CARD);
 134        if (err < 0)
 135                return err;
 136
 137        return rtsx_pci_card_pull_ctl_disable(pcr, RTSX_MS_CARD);
 138}
 139
 140static int ms_transfer_data(struct realtek_pci_ms *host, unsigned char data_dir,
 141                u8 tpc, u8 cfg, struct scatterlist *sg)
 142{
 143        struct rtsx_pcr *pcr = host->pcr;
 144        int err;
 145        unsigned int length = sg->length;
 146        u16 sec_cnt = (u16)(length / 512);
 147        u8 val, trans_mode, dma_dir;
 148        struct memstick_dev *card = host->msh->card;
 149        bool pro_card = card->id.type == MEMSTICK_TYPE_PRO;
 150
 151        dev_dbg(ms_dev(host), "%s: tpc = 0x%02x, data_dir = %s, length = %d\n",
 152                        __func__, tpc, (data_dir == READ) ? "READ" : "WRITE",
 153                        length);
 154
 155        if (data_dir == READ) {
 156                dma_dir = DMA_DIR_FROM_CARD;
 157                trans_mode = pro_card ? MS_TM_AUTO_READ : MS_TM_NORMAL_READ;
 158        } else {
 159                dma_dir = DMA_DIR_TO_CARD;
 160                trans_mode = pro_card ? MS_TM_AUTO_WRITE : MS_TM_NORMAL_WRITE;
 161        }
 162
 163        rtsx_pci_init_cmd(pcr);
 164
 165        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
 166        if (pro_card) {
 167                rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, MS_SECTOR_CNT_H,
 168                                0xFF, (u8)(sec_cnt >> 8));
 169                rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, MS_SECTOR_CNT_L,
 170                                0xFF, (u8)sec_cnt);
 171        }
 172        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
 173
 174        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, IRQSTAT0,
 175                        DMA_DONE_INT, DMA_DONE_INT);
 176        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, DMATC3, 0xFF, (u8)(length >> 24));
 177        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, DMATC2, 0xFF, (u8)(length >> 16));
 178        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, DMATC1, 0xFF, (u8)(length >> 8));
 179        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, DMATC0, 0xFF, (u8)length);
 180        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, DMACTL,
 181                        0x03 | DMA_PACK_SIZE_MASK, dma_dir | DMA_EN | DMA_512);
 182        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, CARD_DATA_SOURCE,
 183                        0x01, RING_BUFFER);
 184
 185        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, MS_TRANSFER,
 186                        0xFF, MS_TRANSFER_START | trans_mode);
 187        rtsx_pci_add_cmd(pcr, CHECK_REG_CMD, MS_TRANSFER,
 188                        MS_TRANSFER_END, MS_TRANSFER_END);
 189
 190        rtsx_pci_send_cmd_no_wait(pcr);
 191
 192        err = rtsx_pci_transfer_data(pcr, sg, 1, data_dir == READ, 10000);
 193        if (err < 0) {
 194                ms_clear_error(host);
 195                return err;
 196        }
 197
 198        rtsx_pci_read_register(pcr, MS_TRANS_CFG, &val);
 199        if (pro_card) {
 200                if (val & (MS_INT_CMDNK | MS_INT_ERR |
 201                                MS_CRC16_ERR | MS_RDY_TIMEOUT))
 202                        return -EIO;
 203        } else {
 204                if (val & (MS_CRC16_ERR | MS_RDY_TIMEOUT))
 205                        return -EIO;
 206        }
 207
 208        return 0;
 209}
 210
 211static int ms_write_bytes(struct realtek_pci_ms *host, u8 tpc,
 212                u8 cfg, u8 cnt, u8 *data, u8 *int_reg)
 213{
 214        struct rtsx_pcr *pcr = host->pcr;
 215        int err, i;
 216
 217        dev_dbg(ms_dev(host), "%s: tpc = 0x%02x\n", __func__, tpc);
 218
 219        if (!data)
 220                return -EINVAL;
 221
 222        rtsx_pci_init_cmd(pcr);
 223
 224        for (i = 0; i < cnt; i++)
 225                rtsx_pci_add_cmd(pcr, WRITE_REG_CMD,
 226                                PPBUF_BASE2 + i, 0xFF, data[i]);
 227        if (cnt % 2)
 228                rtsx_pci_add_cmd(pcr, WRITE_REG_CMD,
 229                                PPBUF_BASE2 + i, 0xFF, 0xFF);
 230
 231        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
 232        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt);
 233        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
 234        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, CARD_DATA_SOURCE,
 235                        0x01, PINGPONG_BUFFER);
 236
 237        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, MS_TRANSFER,
 238                        0xFF, MS_TRANSFER_START | MS_TM_WRITE_BYTES);
 239        rtsx_pci_add_cmd(pcr, CHECK_REG_CMD, MS_TRANSFER,
 240                        MS_TRANSFER_END, MS_TRANSFER_END);
 241        if (int_reg)
 242                rtsx_pci_add_cmd(pcr, READ_REG_CMD, MS_TRANS_CFG, 0, 0);
 243
 244        err = rtsx_pci_send_cmd(pcr, 5000);
 245        if (err < 0) {
 246                u8 val;
 247
 248                rtsx_pci_read_register(pcr, MS_TRANS_CFG, &val);
 249                dev_dbg(ms_dev(host), "MS_TRANS_CFG: 0x%02x\n", val);
 250
 251                if (int_reg)
 252                        *int_reg = val & 0x0F;
 253
 254                ms_print_debug_regs(host);
 255
 256                ms_clear_error(host);
 257
 258                if (!(tpc & 0x08)) {
 259                        if (val & MS_CRC16_ERR)
 260                                return -EIO;
 261                } else {
 262                        if (!(val & 0x80)) {
 263                                if (val & (MS_INT_ERR | MS_INT_CMDNK))
 264                                        return -EIO;
 265                        }
 266                }
 267
 268                return -ETIMEDOUT;
 269        }
 270
 271        if (int_reg) {
 272                u8 *ptr = rtsx_pci_get_cmd_data(pcr) + 1;
 273                *int_reg = *ptr & 0x0F;
 274        }
 275
 276        return 0;
 277}
 278
 279static int ms_read_bytes(struct realtek_pci_ms *host, u8 tpc,
 280                u8 cfg, u8 cnt, u8 *data, u8 *int_reg)
 281{
 282        struct rtsx_pcr *pcr = host->pcr;
 283        int err, i;
 284        u8 *ptr;
 285
 286        dev_dbg(ms_dev(host), "%s: tpc = 0x%02x\n", __func__, tpc);
 287
 288        if (!data)
 289                return -EINVAL;
 290
 291        rtsx_pci_init_cmd(pcr);
 292
 293        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
 294        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt);
 295        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
 296        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, CARD_DATA_SOURCE,
 297                        0x01, PINGPONG_BUFFER);
 298
 299        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, MS_TRANSFER,
 300                        0xFF, MS_TRANSFER_START | MS_TM_READ_BYTES);
 301        rtsx_pci_add_cmd(pcr, CHECK_REG_CMD, MS_TRANSFER,
 302                        MS_TRANSFER_END, MS_TRANSFER_END);
 303        for (i = 0; i < cnt - 1; i++)
 304                rtsx_pci_add_cmd(pcr, READ_REG_CMD, PPBUF_BASE2 + i, 0, 0);
 305        if (cnt % 2)
 306                rtsx_pci_add_cmd(pcr, READ_REG_CMD, PPBUF_BASE2 + cnt, 0, 0);
 307        else
 308                rtsx_pci_add_cmd(pcr, READ_REG_CMD,
 309                                PPBUF_BASE2 + cnt - 1, 0, 0);
 310        if (int_reg)
 311                rtsx_pci_add_cmd(pcr, READ_REG_CMD, MS_TRANS_CFG, 0, 0);
 312
 313        err = rtsx_pci_send_cmd(pcr, 5000);
 314        if (err < 0) {
 315                u8 val;
 316
 317                rtsx_pci_read_register(pcr, MS_TRANS_CFG, &val);
 318                dev_dbg(ms_dev(host), "MS_TRANS_CFG: 0x%02x\n", val);
 319
 320                if (int_reg)
 321                        *int_reg = val & 0x0F;
 322
 323                ms_print_debug_regs(host);
 324
 325                ms_clear_error(host);
 326
 327                if (!(tpc & 0x08)) {
 328                        if (val & MS_CRC16_ERR)
 329                                return -EIO;
 330                } else {
 331                        if (!(val & 0x80)) {
 332                                if (val & (MS_INT_ERR | MS_INT_CMDNK))
 333                                        return -EIO;
 334                        }
 335                }
 336
 337                return -ETIMEDOUT;
 338        }
 339
 340        ptr = rtsx_pci_get_cmd_data(pcr) + 1;
 341        for (i = 0; i < cnt; i++)
 342                data[i] = *ptr++;
 343
 344        if (int_reg)
 345                *int_reg = *ptr & 0x0F;
 346
 347        return 0;
 348}
 349
 350static int rtsx_pci_ms_issue_cmd(struct realtek_pci_ms *host)
 351{
 352        struct memstick_request *req = host->req;
 353        int err = 0;
 354        u8 cfg = 0, int_reg;
 355
 356        dev_dbg(ms_dev(host), "%s\n", __func__);
 357
 358        if (req->need_card_int) {
 359                if (host->ifmode != MEMSTICK_SERIAL)
 360                        cfg = WAIT_INT;
 361        }
 362
 363        if (req->long_data) {
 364                err = ms_transfer_data(host, req->data_dir,
 365                                req->tpc, cfg, &(req->sg));
 366        } else {
 367                if (req->data_dir == READ) {
 368                        err = ms_read_bytes(host, req->tpc, cfg,
 369                                        req->data_len, req->data, &int_reg);
 370                } else {
 371                        err = ms_write_bytes(host, req->tpc, cfg,
 372                                        req->data_len, req->data, &int_reg);
 373                }
 374        }
 375        if (err < 0)
 376                return err;
 377
 378        if (req->need_card_int && (host->ifmode == MEMSTICK_SERIAL)) {
 379                err = ms_read_bytes(host, MS_TPC_GET_INT,
 380                                NO_WAIT_INT, 1, &int_reg, NULL);
 381                if (err < 0)
 382                        return err;
 383        }
 384
 385        if (req->need_card_int) {
 386                dev_dbg(ms_dev(host), "int_reg: 0x%02x\n", int_reg);
 387
 388                if (int_reg & MS_INT_CMDNK)
 389                        req->int_reg |= MEMSTICK_INT_CMDNAK;
 390                if (int_reg & MS_INT_BREQ)
 391                        req->int_reg |= MEMSTICK_INT_BREQ;
 392                if (int_reg & MS_INT_ERR)
 393                        req->int_reg |= MEMSTICK_INT_ERR;
 394                if (int_reg & MS_INT_CED)
 395                        req->int_reg |= MEMSTICK_INT_CED;
 396        }
 397
 398        return 0;
 399}
 400
 401static void rtsx_pci_ms_handle_req(struct work_struct *work)
 402{
 403        struct realtek_pci_ms *host = container_of(work,
 404                        struct realtek_pci_ms, handle_req);
 405        struct rtsx_pcr *pcr = host->pcr;
 406        struct memstick_host *msh = host->msh;
 407        int rc;
 408
 409        mutex_lock(&pcr->pcr_mutex);
 410
 411        rtsx_pci_start_run(pcr);
 412
 413        rtsx_pci_switch_clock(host->pcr, host->clock, host->ssc_depth,
 414                        false, true, false);
 415        rtsx_pci_write_register(pcr, CARD_SELECT, 0x07, MS_MOD_SEL);
 416        rtsx_pci_write_register(pcr, CARD_SHARE_MODE,
 417                        CARD_SHARE_MASK, CARD_SHARE_48_MS);
 418
 419        if (!host->req) {
 420                do {
 421                        rc = memstick_next_req(msh, &host->req);
 422                        dev_dbg(ms_dev(host), "next req %d\n", rc);
 423
 424                        if (!rc)
 425                                host->req->error = rtsx_pci_ms_issue_cmd(host);
 426                } while (!rc);
 427        }
 428
 429        mutex_unlock(&pcr->pcr_mutex);
 430}
 431
 432static void rtsx_pci_ms_request(struct memstick_host *msh)
 433{
 434        struct realtek_pci_ms *host = memstick_priv(msh);
 435
 436        dev_dbg(ms_dev(host), "--> %s\n", __func__);
 437
 438        if (rtsx_pci_card_exclusive_check(host->pcr, RTSX_MS_CARD))
 439                return;
 440
 441        schedule_work(&host->handle_req);
 442}
 443
 444static int rtsx_pci_ms_set_param(struct memstick_host *msh,
 445                enum memstick_param param, int value)
 446{
 447        struct realtek_pci_ms *host = memstick_priv(msh);
 448        struct rtsx_pcr *pcr = host->pcr;
 449        unsigned int clock = 0;
 450        u8 ssc_depth = 0;
 451        int err;
 452
 453        dev_dbg(ms_dev(host), "%s: param = %d, value = %d\n",
 454                        __func__, param, value);
 455
 456        err = rtsx_pci_card_exclusive_check(host->pcr, RTSX_MS_CARD);
 457        if (err)
 458                return err;
 459
 460        switch (param) {
 461        case MEMSTICK_POWER:
 462                if (value == MEMSTICK_POWER_ON)
 463                        err = ms_power_on(host);
 464                else if (value == MEMSTICK_POWER_OFF)
 465                        err = ms_power_off(host);
 466                else
 467                        return -EINVAL;
 468                break;
 469
 470        case MEMSTICK_INTERFACE:
 471                if (value == MEMSTICK_SERIAL) {
 472                        clock = 19000000;
 473                        ssc_depth = RTSX_SSC_DEPTH_500K;
 474
 475                        err = rtsx_pci_write_register(pcr, MS_CFG, 0x58,
 476                                        MS_BUS_WIDTH_1 | PUSH_TIME_DEFAULT);
 477                        if (err < 0)
 478                                return err;
 479                } else if (value == MEMSTICK_PAR4) {
 480                        clock = 39000000;
 481                        ssc_depth = RTSX_SSC_DEPTH_1M;
 482
 483                        err = rtsx_pci_write_register(pcr, MS_CFG,
 484                                        0x58, MS_BUS_WIDTH_4 | PUSH_TIME_ODD);
 485                        if (err < 0)
 486                                return err;
 487                } else {
 488                        return -EINVAL;
 489                }
 490
 491                err = rtsx_pci_switch_clock(pcr, clock,
 492                                ssc_depth, false, true, false);
 493                if (err < 0)
 494                        return err;
 495
 496                host->ssc_depth = ssc_depth;
 497                host->clock = clock;
 498                host->ifmode = value;
 499                break;
 500        }
 501
 502        return 0;
 503}
 504
 505#ifdef CONFIG_PM
 506
 507static int rtsx_pci_ms_suspend(struct platform_device *pdev, pm_message_t state)
 508{
 509        struct realtek_pci_ms *host = platform_get_drvdata(pdev);
 510        struct memstick_host *msh = host->msh;
 511
 512        dev_dbg(ms_dev(host), "--> %s\n", __func__);
 513
 514        memstick_suspend_host(msh);
 515        return 0;
 516}
 517
 518static int rtsx_pci_ms_resume(struct platform_device *pdev)
 519{
 520        struct realtek_pci_ms *host = platform_get_drvdata(pdev);
 521        struct memstick_host *msh = host->msh;
 522
 523        dev_dbg(ms_dev(host), "--> %s\n", __func__);
 524
 525        memstick_resume_host(msh);
 526        return 0;
 527}
 528
 529#else /* CONFIG_PM */
 530
 531#define rtsx_pci_ms_suspend NULL
 532#define rtsx_pci_ms_resume NULL
 533
 534#endif /* CONFIG_PM */
 535
 536static void rtsx_pci_ms_card_event(struct platform_device *pdev)
 537{
 538        struct realtek_pci_ms *host = platform_get_drvdata(pdev);
 539
 540        memstick_detect_change(host->msh);
 541}
 542
 543static int rtsx_pci_ms_drv_probe(struct platform_device *pdev)
 544{
 545        struct memstick_host *msh;
 546        struct realtek_pci_ms *host;
 547        struct rtsx_pcr *pcr;
 548        struct pcr_handle *handle = pdev->dev.platform_data;
 549        int rc;
 550
 551        if (!handle)
 552                return -ENXIO;
 553
 554        pcr = handle->pcr;
 555        if (!pcr)
 556                return -ENXIO;
 557
 558        dev_dbg(&(pdev->dev),
 559                        ": Realtek PCI-E Memstick controller found\n");
 560
 561        msh = memstick_alloc_host(sizeof(*host), &pdev->dev);
 562        if (!msh)
 563                return -ENOMEM;
 564
 565        host = memstick_priv(msh);
 566        host->pcr = pcr;
 567        host->msh = msh;
 568        host->pdev = pdev;
 569        platform_set_drvdata(pdev, host);
 570        pcr->slots[RTSX_MS_CARD].p_dev = pdev;
 571        pcr->slots[RTSX_MS_CARD].card_event = rtsx_pci_ms_card_event;
 572
 573        mutex_init(&host->host_mutex);
 574
 575        INIT_WORK(&host->handle_req, rtsx_pci_ms_handle_req);
 576        msh->request = rtsx_pci_ms_request;
 577        msh->set_param = rtsx_pci_ms_set_param;
 578        msh->caps = MEMSTICK_CAP_PAR4;
 579
 580        rc = memstick_add_host(msh);
 581        if (rc) {
 582                memstick_free_host(msh);
 583                return rc;
 584        }
 585
 586        return 0;
 587}
 588
 589static int rtsx_pci_ms_drv_remove(struct platform_device *pdev)
 590{
 591        struct realtek_pci_ms *host = platform_get_drvdata(pdev);
 592        struct rtsx_pcr *pcr;
 593        struct memstick_host *msh;
 594        int rc;
 595
 596        if (!host)
 597                return 0;
 598
 599        pcr = host->pcr;
 600        pcr->slots[RTSX_MS_CARD].p_dev = NULL;
 601        pcr->slots[RTSX_MS_CARD].card_event = NULL;
 602        msh = host->msh;
 603        host->eject = true;
 604        cancel_work_sync(&host->handle_req);
 605
 606        mutex_lock(&host->host_mutex);
 607        if (host->req) {
 608                dev_dbg(&(pdev->dev),
 609                        "%s: Controller removed during transfer\n",
 610                        dev_name(&msh->dev));
 611
 612                rtsx_pci_complete_unfinished_transfer(pcr);
 613
 614                host->req->error = -ENOMEDIUM;
 615                do {
 616                        rc = memstick_next_req(msh, &host->req);
 617                        if (!rc)
 618                                host->req->error = -ENOMEDIUM;
 619                } while (!rc);
 620        }
 621        mutex_unlock(&host->host_mutex);
 622
 623        memstick_remove_host(msh);
 624        memstick_free_host(msh);
 625
 626        dev_dbg(&(pdev->dev),
 627                ": Realtek PCI-E Memstick controller has been removed\n");
 628
 629        return 0;
 630}
 631
 632static struct platform_device_id rtsx_pci_ms_ids[] = {
 633        {
 634                .name = DRV_NAME_RTSX_PCI_MS,
 635        }, {
 636                /* sentinel */
 637        }
 638};
 639MODULE_DEVICE_TABLE(platform, rtsx_pci_ms_ids);
 640
 641static struct platform_driver rtsx_pci_ms_driver = {
 642        .probe          = rtsx_pci_ms_drv_probe,
 643        .remove         = rtsx_pci_ms_drv_remove,
 644        .id_table       = rtsx_pci_ms_ids,
 645        .suspend        = rtsx_pci_ms_suspend,
 646        .resume         = rtsx_pci_ms_resume,
 647        .driver         = {
 648                .name   = DRV_NAME_RTSX_PCI_MS,
 649        },
 650};
 651module_platform_driver(rtsx_pci_ms_driver);
 652
 653MODULE_LICENSE("GPL");
 654MODULE_AUTHOR("Wei WANG <wei_wang@realsil.com.cn>");
 655MODULE_DESCRIPTION("Realtek PCI-E Memstick Card Host Driver");
 656