?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mpls: make RTA_OIF optional
[linux/fpc-iii.git] / drivers / memstick / host / rtsx_pci_ms.c
blob818fa94354ae221f76205797bcb9ff791152f56d
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/mfd/rtsx_pci.h>
28 #include <asm/unaligned.h>
29
30 struct 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
45 static inline struct device *ms_dev(struct realtek_pci_ms *host)
46 {
47 return &(host->pdev->dev);
48 }
49
50 static 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
58 static 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
85 static 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
119 static 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
140 static 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
211 static 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
279 static 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
350 static 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
401 static 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
432 static 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
444 static 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
507 static 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
518 static 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
536 static 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
543 static 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
589 static 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
632 static struct platform_device_id rtsx_pci_ms_ids[] = {
633 {
634 .name = DRV_NAME_RTSX_PCI_MS,
635 }, {
636 /* sentinel */
637 }
638 };
639 MODULE_DEVICE_TABLE(platform, rtsx_pci_ms_ids);
640
641 static 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 };
651 module_platform_driver(rtsx_pci_ms_driver);
652
653 MODULE_LICENSE("GPL");
654 MODULE_AUTHOR("Wei WANG <wei_wang@realsil.com.cn>");
655 MODULE_DESCRIPTION("Realtek PCI-E Memstick Card Host Driver");
Linux with added FPC-III support