1 /* Driver for Realtek PCI-Express card reader
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 * Micky Ching (micky_ching@realsil.com.cn)
21 */
22
23 #include <linux/blkdev.h>
24 #include <linux/kthread.h>
25 #include <linux/sched.h>
26 #include <linux/workqueue.h>
27
28 #include "rtsx.h"
29 #include "ms.h"
30 #include "sd.h"
31 #include "xd.h"
32
33 MODULE_DESCRIPTION("Realtek PCI-Express card reader rts5208/rts5288 driver");
34 MODULE_LICENSE("GPL");
35
36 static unsigned int delay_use = 1;
37 module_param(delay_use, uint, S_IRUGO | S_IWUSR);
38 MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device");
39
40 static int ss_en;
41 module_param(ss_en, int, S_IRUGO | S_IWUSR);
42 MODULE_PARM_DESC(ss_en, "enable selective suspend");
43
44 static int ss_interval = 50;
45 module_param(ss_interval, int, S_IRUGO | S_IWUSR);
46 MODULE_PARM_DESC(ss_interval, "Interval to enter ss state in seconds");
47
48 static int auto_delink_en;
49 module_param(auto_delink_en, int, S_IRUGO | S_IWUSR);
50 MODULE_PARM_DESC(auto_delink_en, "enable auto delink");
51
52 static unsigned char aspm_l0s_l1_en;
53 module_param(aspm_l0s_l1_en, byte, S_IRUGO | S_IWUSR);
54 MODULE_PARM_DESC(aspm_l0s_l1_en, "enable device aspm");
55
56 static int msi_en;
57 module_param(msi_en, int, S_IRUGO | S_IWUSR);
58 MODULE_PARM_DESC(msi_en, "enable msi");
59
60 static irqreturn_t rtsx_interrupt(int irq, void *dev_id);
61
62 /***********************************************************************
63 * Host functions
64 ***********************************************************************/
65
host_info(struct Scsi_Host * host)66 static const char *host_info(struct Scsi_Host *host)
67 {
68 return "SCSI emulation for PCI-Express Mass Storage devices";
69 }
70
slave_alloc(struct scsi_device * sdev)71 static int slave_alloc(struct scsi_device *sdev)
72 {
73 /*
74 * Set the INQUIRY transfer length to 36. We don't use any of
75 * the extra data and many devices choke if asked for more or
76 * less than 36 bytes.
77 */
78 sdev->inquiry_len = 36;
79 return 0;
80 }
81
slave_configure(struct scsi_device * sdev)82 static int slave_configure(struct scsi_device *sdev)
83 {
84 /* Scatter-gather buffers (all but the last) must have a length
85 * divisible by the bulk maxpacket size. Otherwise a data packet
86 * would end up being short, causing a premature end to the data
87 * transfer. Since high-speed bulk pipes have a maxpacket size
88 * of 512, we'll use that as the scsi device queue's DMA alignment
89 * mask. Guaranteeing proper alignment of the first buffer will
90 * have the desired effect because, except at the beginning and
91 * the end, scatter-gather buffers follow page boundaries. */
92 blk_queue_dma_alignment(sdev->request_queue, (512 - 1));
93
94 /* Set the SCSI level to at least 2. We'll leave it at 3 if that's
95 * what is originally reported. We need this to avoid confusing
96 * the SCSI layer with devices that report 0 or 1, but need 10-byte
97 * commands (ala ATAPI devices behind certain bridges, or devices
98 * which simply have broken INQUIRY data).
99 *
100 * NOTE: This means /dev/sg programs (ala cdrecord) will get the
101 * actual information. This seems to be the preference for
102 * programs like that.
103 *
104 * NOTE: This also means that /proc/scsi/scsi and sysfs may report
105 * the actual value or the modified one, depending on where the
106 * data comes from.
107 */
108 if (sdev->scsi_level < SCSI_2)
109 sdev->scsi_level = sdev->sdev_target->scsi_level = SCSI_2;
110
111 return 0;
112 }
113
114
115 /***********************************************************************
116 * /proc/scsi/ functions
117 ***********************************************************************/
118
119 /* we use this macro to help us write into the buffer */
120 #undef SPRINTF
121 #define SPRINTF(args...) \
122 do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0)
123
124 /* queue a command */
125 /* This is always called with scsi_lock(host) held */
queuecommand_lck(struct scsi_cmnd * srb,void (* done)(struct scsi_cmnd *))126 static int queuecommand_lck(struct scsi_cmnd *srb,
127 void (*done)(struct scsi_cmnd *))
128 {
129 struct rtsx_dev *dev = host_to_rtsx(srb->device->host);
130 struct rtsx_chip *chip = dev->chip;
131
132 /* check for state-transition errors */
133 if (chip->srb != NULL) {
134 dev_err(&dev->pci->dev, "Error: chip->srb = %p\n",
135 chip->srb);
136 return SCSI_MLQUEUE_HOST_BUSY;
137 }
138
139 /* fail the command if we are disconnecting */
140 if (rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT)) {
141 dev_info(&dev->pci->dev, "Fail command during disconnect\n");
142 srb->result = DID_NO_CONNECT << 16;
143 done(srb);
144 return 0;
145 }
146
147 /* enqueue the command and wake up the control thread */
148 srb->scsi_done = done;
149 chip->srb = srb;
150 complete(&dev->cmnd_ready);
151
152 return 0;
153 }
154
DEF_SCSI_QCMD(queuecommand)155 static DEF_SCSI_QCMD(queuecommand)
156
157 /***********************************************************************
158 * Error handling functions
159 ***********************************************************************/
160
161 /* Command timeout and abort */
162 static int command_abort(struct scsi_cmnd *srb)
163 {
164 struct Scsi_Host *host = srb->device->host;
165 struct rtsx_dev *dev = host_to_rtsx(host);
166 struct rtsx_chip *chip = dev->chip;
167
168 dev_info(&dev->pci->dev, "%s called\n", __func__);
169
170 scsi_lock(host);
171
172 /* Is this command still active? */
173 if (chip->srb != srb) {
174 scsi_unlock(host);
175 dev_info(&dev->pci->dev, "-- nothing to abort\n");
176 return FAILED;
177 }
178
179 rtsx_set_stat(chip, RTSX_STAT_ABORT);
180
181 scsi_unlock(host);
182
183 /* Wait for the aborted command to finish */
184 wait_for_completion(&dev->notify);
185
186 return SUCCESS;
187 }
188
189 /* This invokes the transport reset mechanism to reset the state of the
190 * device */
device_reset(struct scsi_cmnd * srb)191 static int device_reset(struct scsi_cmnd *srb)
192 {
193 int result = 0;
194 struct rtsx_dev *dev = host_to_rtsx(srb->device->host);
195
196 dev_info(&dev->pci->dev, "%s called\n", __func__);
197
198 return result < 0 ? FAILED : SUCCESS;
199 }
200
201 /* Simulate a SCSI bus reset by resetting the device's USB port. */
bus_reset(struct scsi_cmnd * srb)202 static int bus_reset(struct scsi_cmnd *srb)
203 {
204 int result = 0;
205 struct rtsx_dev *dev = host_to_rtsx(srb->device->host);
206
207 dev_info(&dev->pci->dev, "%s called\n", __func__);
208
209 return result < 0 ? FAILED : SUCCESS;
210 }
211
212
213 /*
214 * this defines our host template, with which we'll allocate hosts
215 */
216
217 static struct scsi_host_template rtsx_host_template = {
218 /* basic userland interface stuff */
219 .name = CR_DRIVER_NAME,
220 .proc_name = CR_DRIVER_NAME,
221 .info = host_info,
222
223 /* command interface -- queued only */
224 .queuecommand = queuecommand,
225
226 /* error and abort handlers */
227 .eh_abort_handler = command_abort,
228 .eh_device_reset_handler = device_reset,
229 .eh_bus_reset_handler = bus_reset,
230
231 /* queue commands only, only one command per LUN */
232 .can_queue = 1,
233 .cmd_per_lun = 1,
234
235 /* unknown initiator id */
236 .this_id = -1,
237
238 .slave_alloc = slave_alloc,
239 .slave_configure = slave_configure,
240
241 /* lots of sg segments can be handled */
242 .sg_tablesize = SG_ALL,
243
244 /* limit the total size of a transfer to 120 KB */
245 .max_sectors = 240,
246
247 /* merge commands... this seems to help performance, but
248 * periodically someone should test to see which setting is more
249 * optimal.
250 */
251 .use_clustering = 1,
252
253 /* emulated HBA */
254 .emulated = 1,
255
256 /* we do our own delay after a device or bus reset */
257 .skip_settle_delay = 1,
258
259 /* module management */
260 .module = THIS_MODULE
261 };
262
263
rtsx_acquire_irq(struct rtsx_dev * dev)264 static int rtsx_acquire_irq(struct rtsx_dev *dev)
265 {
266 struct rtsx_chip *chip = dev->chip;
267
268 dev_info(&dev->pci->dev, "%s: chip->msi_en = %d, pci->irq = %d\n",
269 __func__, chip->msi_en, dev->pci->irq);
270
271 if (request_irq(dev->pci->irq, rtsx_interrupt,
272 chip->msi_en ? 0 : IRQF_SHARED,
273 CR_DRIVER_NAME, dev)) {
274 dev_err(&dev->pci->dev,
275 "rtsx: unable to grab IRQ %d, disabling device\n",
276 dev->pci->irq);
277 return -1;
278 }
279
280 dev->irq = dev->pci->irq;
281 pci_intx(dev->pci, !chip->msi_en);
282
283 return 0;
284 }
285
286
rtsx_read_pci_cfg_byte(u8 bus,u8 dev,u8 func,u8 offset,u8 * val)287 int rtsx_read_pci_cfg_byte(u8 bus, u8 dev, u8 func, u8 offset, u8 *val)
288 {
289 struct pci_dev *pdev;
290 u8 data;
291 u8 devfn = (dev << 3) | func;
292
293 pdev = pci_get_bus_and_slot(bus, devfn);
294 if (!pdev)
295 return -1;
296
297 pci_read_config_byte(pdev, offset, &data);
298 if (val)
299 *val = data;
300
301 return 0;
302 }
303
304 #ifdef CONFIG_PM
305 /*
306 * power management
307 */
rtsx_suspend(struct pci_dev * pci,pm_message_t state)308 static int rtsx_suspend(struct pci_dev *pci, pm_message_t state)
309 {
310 struct rtsx_dev *dev = pci_get_drvdata(pci);
311 struct rtsx_chip *chip;
312
313 if (!dev)
314 return 0;
315
316 /* lock the device pointers */
317 mutex_lock(&(dev->dev_mutex));
318
319 chip = dev->chip;
320
321 rtsx_do_before_power_down(chip, PM_S3);
322
323 if (dev->irq >= 0) {
324 synchronize_irq(dev->irq);
325 free_irq(dev->irq, (void *)dev);
326 dev->irq = -1;
327 }
328
329 if (chip->msi_en)
330 pci_disable_msi(pci);
331
332 pci_save_state(pci);
333 pci_enable_wake(pci, pci_choose_state(pci, state), 1);
334 pci_disable_device(pci);
335 pci_set_power_state(pci, pci_choose_state(pci, state));
336
337 /* unlock the device pointers */
338 mutex_unlock(&dev->dev_mutex);
339
340 return 0;
341 }
342
rtsx_resume(struct pci_dev * pci)343 static int rtsx_resume(struct pci_dev *pci)
344 {
345 struct rtsx_dev *dev = pci_get_drvdata(pci);
346 struct rtsx_chip *chip;
347
348 if (!dev)
349 return 0;
350
351 chip = dev->chip;
352
353 /* lock the device pointers */
354 mutex_lock(&(dev->dev_mutex));
355
356 pci_set_power_state(pci, PCI_D0);
357 pci_restore_state(pci);
358 if (pci_enable_device(pci) < 0) {
359 dev_err(&dev->pci->dev,
360 "%s: pci_enable_device failed, disabling device\n",
361 CR_DRIVER_NAME);
362 /* unlock the device pointers */
363 mutex_unlock(&dev->dev_mutex);
364 return -EIO;
365 }
366 pci_set_master(pci);
367
368 if (chip->msi_en) {
369 if (pci_enable_msi(pci) < 0)
370 chip->msi_en = 0;
371 }
372
373 if (rtsx_acquire_irq(dev) < 0) {
374 /* unlock the device pointers */
375 mutex_unlock(&dev->dev_mutex);
376 return -EIO;
377 }
378
379 rtsx_write_register(chip, HOST_SLEEP_STATE, 0x03, 0x00);
380 rtsx_init_chip(chip);
381
382 /* unlock the device pointers */
383 mutex_unlock(&dev->dev_mutex);
384
385 return 0;
386 }
387 #endif /* CONFIG_PM */
388
rtsx_shutdown(struct pci_dev * pci)389 static void rtsx_shutdown(struct pci_dev *pci)
390 {
391 struct rtsx_dev *dev = pci_get_drvdata(pci);
392 struct rtsx_chip *chip;
393
394 if (!dev)
395 return;
396
397 chip = dev->chip;
398
399 rtsx_do_before_power_down(chip, PM_S1);
400
401 if (dev->irq >= 0) {
402 synchronize_irq(dev->irq);
403 free_irq(dev->irq, (void *)dev);
404 dev->irq = -1;
405 }
406
407 if (chip->msi_en)
408 pci_disable_msi(pci);
409
410 pci_disable_device(pci);
411 }
412
rtsx_control_thread(void * __dev)413 static int rtsx_control_thread(void *__dev)
414 {
415 struct rtsx_dev *dev = __dev;
416 struct rtsx_chip *chip = dev->chip;
417 struct Scsi_Host *host = rtsx_to_host(dev);
418
419 for (;;) {
420 if (wait_for_completion_interruptible(&dev->cmnd_ready))
421 break;
422
423 /* lock the device pointers */
424 mutex_lock(&(dev->dev_mutex));
425
426 /* if the device has disconnected, we are free to exit */
427 if (rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT)) {
428 dev_info(&dev->pci->dev, "-- rtsx-control exiting\n");
429 mutex_unlock(&dev->dev_mutex);
430 break;
431 }
432
433 /* lock access to the state */
434 scsi_lock(host);
435
436 /* has the command aborted ? */
437 if (rtsx_chk_stat(chip, RTSX_STAT_ABORT)) {
438 chip->srb->result = DID_ABORT << 16;
439 goto SkipForAbort;
440 }
441
442 scsi_unlock(host);
443
444 /* reject the command if the direction indicator
445 * is UNKNOWN
446 */
447 if (chip->srb->sc_data_direction == DMA_BIDIRECTIONAL) {
448 dev_err(&dev->pci->dev, "UNKNOWN data direction\n");
449 chip->srb->result = DID_ERROR << 16;
450 }
451
452 /* reject if target != 0 or if LUN is higher than
453 * the maximum known LUN
454 */
455 else if (chip->srb->device->id) {
456 dev_err(&dev->pci->dev, "Bad target number (%d:%d)\n",
457 chip->srb->device->id,
458 (u8)chip->srb->device->lun);
459 chip->srb->result = DID_BAD_TARGET << 16;
460 }
461
462 else if (chip->srb->device->lun > chip->max_lun) {
463 dev_err(&dev->pci->dev, "Bad LUN (%d:%d)\n",
464 chip->srb->device->id,
465 (u8)chip->srb->device->lun);
466 chip->srb->result = DID_BAD_TARGET << 16;
467 }
468
469 /* we've got a command, let's do it! */
470 else {
471 scsi_show_command(chip);
472 rtsx_invoke_transport(chip->srb, chip);
473 }
474
475 /* lock access to the state */
476 scsi_lock(host);
477
478 /* did the command already complete because of a disconnect? */
479 if (!chip->srb)
480 ; /* nothing to do */
481
482 /* indicate that the command is done */
483 else if (chip->srb->result != DID_ABORT << 16) {
484 chip->srb->scsi_done(chip->srb);
485 } else {
486 SkipForAbort:
487 dev_err(&dev->pci->dev, "scsi command aborted\n");
488 }
489
490 if (rtsx_chk_stat(chip, RTSX_STAT_ABORT)) {
491 complete(&(dev->notify));
492
493 rtsx_set_stat(chip, RTSX_STAT_IDLE);
494 }
495
496 /* finished working on this command */
497 chip->srb = NULL;
498 scsi_unlock(host);
499
500 /* unlock the device pointers */
501 mutex_unlock(&dev->dev_mutex);
502 } /* for (;;) */
503
504 /* notify the exit routine that we're actually exiting now
505 *
506 * complete()/wait_for_completion() is similar to up()/down(),
507 * except that complete() is safe in the case where the structure
508 * is getting deleted in a parallel mode of execution (i.e. just
509 * after the down() -- that's necessary for the thread-shutdown
510 * case.
511 *
512 * complete_and_exit() goes even further than this -- it is safe in
513 * the case that the thread of the caller is going away (not just
514 * the structure) -- this is necessary for the module-remove case.
515 * This is important in preemption kernels, which transfer the flow
516 * of execution immediately upon a complete().
517 */
518 complete_and_exit(&dev->control_exit, 0);
519 }
520
521
rtsx_polling_thread(void * __dev)522 static int rtsx_polling_thread(void *__dev)
523 {
524 struct rtsx_dev *dev = __dev;
525 struct rtsx_chip *chip = dev->chip;
526 struct sd_info *sd_card = &(chip->sd_card);
527 struct xd_info *xd_card = &(chip->xd_card);
528 struct ms_info *ms_card = &(chip->ms_card);
529
530 sd_card->cleanup_counter = 0;
531 xd_card->cleanup_counter = 0;
532 ms_card->cleanup_counter = 0;
533
534 /* Wait until SCSI scan finished */
535 wait_timeout((delay_use + 5) * 1000);
536
537 for (;;) {
538
539 set_current_state(TASK_INTERRUPTIBLE);
540 schedule_timeout(POLLING_INTERVAL);
541
542 /* lock the device pointers */
543 mutex_lock(&(dev->dev_mutex));
544
545 /* if the device has disconnected, we are free to exit */
546 if (rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT)) {
547 dev_info(&dev->pci->dev, "-- rtsx-polling exiting\n");
548 mutex_unlock(&dev->dev_mutex);
549 break;
550 }
551
552 mutex_unlock(&dev->dev_mutex);
553
554 mspro_polling_format_status(chip);
555
556 /* lock the device pointers */
557 mutex_lock(&(dev->dev_mutex));
558
559 rtsx_polling_func(chip);
560
561 /* unlock the device pointers */
562 mutex_unlock(&dev->dev_mutex);
563 }
564
565 complete_and_exit(&dev->polling_exit, 0);
566 }
567
568 /*
569 * interrupt handler
570 */
rtsx_interrupt(int irq,void * dev_id)571 static irqreturn_t rtsx_interrupt(int irq, void *dev_id)
572 {
573 struct rtsx_dev *dev = dev_id;
574 struct rtsx_chip *chip;
575 int retval;
576 u32 status;
577
578 if (dev)
579 chip = dev->chip;
580 else
581 return IRQ_NONE;
582
583 if (!chip)
584 return IRQ_NONE;
585
586 spin_lock(&dev->reg_lock);
587
588 retval = rtsx_pre_handle_interrupt(chip);
589 if (retval == STATUS_FAIL) {
590 spin_unlock(&dev->reg_lock);
591 if (chip->int_reg == 0xFFFFFFFF)
592 return IRQ_HANDLED;
593 return IRQ_NONE;
594 }
595
596 status = chip->int_reg;
597
598 if (dev->check_card_cd) {
599 if (!(dev->check_card_cd & status)) {
600 /* card not exist, return TRANS_RESULT_FAIL */
601 dev->trans_result = TRANS_RESULT_FAIL;
602 if (dev->done)
603 complete(dev->done);
604 goto Exit;
605 }
606 }
607
608 if (status & (NEED_COMPLETE_INT | DELINK_INT)) {
609 if (status & (TRANS_FAIL_INT | DELINK_INT)) {
610 if (status & DELINK_INT)
611 RTSX_SET_DELINK(chip);
612 dev->trans_result = TRANS_RESULT_FAIL;
613 if (dev->done)
614 complete(dev->done);
615 } else if (status & TRANS_OK_INT) {
616 dev->trans_result = TRANS_RESULT_OK;
617 if (dev->done)
618 complete(dev->done);
619 } else if (status & DATA_DONE_INT) {
620 dev->trans_result = TRANS_NOT_READY;
621 if (dev->done && (dev->trans_state == STATE_TRANS_SG))
622 complete(dev->done);
623 }
624 }
625
626 Exit:
627 spin_unlock(&dev->reg_lock);
628 return IRQ_HANDLED;
629 }
630
631
632 /* Release all our dynamic resources */
rtsx_release_resources(struct rtsx_dev * dev)633 static void rtsx_release_resources(struct rtsx_dev *dev)
634 {
635 dev_info(&dev->pci->dev, "-- %s\n", __func__);
636
637 /* Tell the control thread to exit. The SCSI host must
638 * already have been removed so it won't try to queue
639 * any more commands.
640 */
641 dev_info(&dev->pci->dev, "-- sending exit command to thread\n");
642 complete(&dev->cmnd_ready);
643 if (dev->ctl_thread)
644 wait_for_completion(&dev->control_exit);
645 if (dev->polling_thread)
646 wait_for_completion(&dev->polling_exit);
647
648 wait_timeout(200);
649
650 if (dev->rtsx_resv_buf) {
651 dma_free_coherent(&(dev->pci->dev), RTSX_RESV_BUF_LEN,
652 dev->rtsx_resv_buf, dev->rtsx_resv_buf_addr);
653 dev->chip->host_cmds_ptr = NULL;
654 dev->chip->host_sg_tbl_ptr = NULL;
655 }
656
657 if (dev->irq > 0)
658 free_irq(dev->irq, (void *)dev);
659 if (dev->chip->msi_en)
660 pci_disable_msi(dev->pci);
661 if (dev->remap_addr)
662 iounmap(dev->remap_addr);
663
664 pci_disable_device(dev->pci);
665 pci_release_regions(dev->pci);
666
667 rtsx_release_chip(dev->chip);
668 kfree(dev->chip);
669 }
670
671 /* First stage of disconnect processing: stop all commands and remove
672 * the host */
quiesce_and_remove_host(struct rtsx_dev * dev)673 static void quiesce_and_remove_host(struct rtsx_dev *dev)
674 {
675 struct Scsi_Host *host = rtsx_to_host(dev);
676 struct rtsx_chip *chip = dev->chip;
677
678 /* Prevent new transfers, stop the current command, and
679 * interrupt a SCSI-scan or device-reset delay */
680 mutex_lock(&dev->dev_mutex);
681 scsi_lock(host);
682 rtsx_set_stat(chip, RTSX_STAT_DISCONNECT);
683 scsi_unlock(host);
684 mutex_unlock(&dev->dev_mutex);
685 wake_up(&dev->delay_wait);
686 wait_for_completion(&dev->scanning_done);
687
688 /* Wait some time to let other threads exist */
689 wait_timeout(100);
690
691 /* queuecommand won't accept any new commands and the control
692 * thread won't execute a previously-queued command. If there
693 * is such a command pending, complete it with an error. */
694 mutex_lock(&dev->dev_mutex);
695 if (chip->srb) {
696 chip->srb->result = DID_NO_CONNECT << 16;
697 scsi_lock(host);
698 chip->srb->scsi_done(dev->chip->srb);
699 chip->srb = NULL;
700 scsi_unlock(host);
701 }
702 mutex_unlock(&dev->dev_mutex);
703
704 /* Now we own no commands so it's safe to remove the SCSI host */
705 scsi_remove_host(host);
706 }
707
708 /* Second stage of disconnect processing: deallocate all resources */
release_everything(struct rtsx_dev * dev)709 static void release_everything(struct rtsx_dev *dev)
710 {
711 rtsx_release_resources(dev);
712
713 /* Drop our reference to the host; the SCSI core will free it
714 * when the refcount becomes 0. */
715 scsi_host_put(rtsx_to_host(dev));
716 }
717
718 /* Thread to carry out delayed SCSI-device scanning */
rtsx_scan_thread(void * __dev)719 static int rtsx_scan_thread(void *__dev)
720 {
721 struct rtsx_dev *dev = (struct rtsx_dev *)__dev;
722 struct rtsx_chip *chip = dev->chip;
723
724 /* Wait for the timeout to expire or for a disconnect */
725 if (delay_use > 0) {
726 dev_info(&dev->pci->dev,
727 "%s: waiting for device to settle before scanning\n",
728 CR_DRIVER_NAME);
729 wait_event_interruptible_timeout(dev->delay_wait,
730 rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT),
731 delay_use * HZ);
732 }
733
734 /* If the device is still connected, perform the scanning */
735 if (!rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT)) {
736 scsi_scan_host(rtsx_to_host(dev));
737 dev_info(&dev->pci->dev, "%s: device scan complete\n",
738 CR_DRIVER_NAME);
739
740 /* Should we unbind if no devices were detected? */
741 }
742
743 complete_and_exit(&dev->scanning_done, 0);
744 }
745
rtsx_init_options(struct rtsx_chip * chip)746 static void rtsx_init_options(struct rtsx_chip *chip)
747 {
748 chip->vendor_id = chip->rtsx->pci->vendor;
749 chip->product_id = chip->rtsx->pci->device;
750 chip->adma_mode = 1;
751 chip->lun_mc = 0;
752 chip->driver_first_load = 1;
753 #ifdef HW_AUTO_SWITCH_SD_BUS
754 chip->sdio_in_charge = 0;
755 #endif
756
757 chip->mspro_formatter_enable = 1;
758 chip->ignore_sd = 0;
759 chip->use_hw_setting = 0;
760 chip->lun_mode = DEFAULT_SINGLE;
761 chip->auto_delink_en = auto_delink_en;
762 chip->ss_en = ss_en;
763 chip->ss_idle_period = ss_interval * 1000;
764 chip->remote_wakeup_en = 0;
765 chip->aspm_l0s_l1_en = aspm_l0s_l1_en;
766 chip->dynamic_aspm = 1;
767 chip->fpga_sd_sdr104_clk = CLK_200;
768 chip->fpga_sd_ddr50_clk = CLK_100;
769 chip->fpga_sd_sdr50_clk = CLK_100;
770 chip->fpga_sd_hs_clk = CLK_100;
771 chip->fpga_mmc_52m_clk = CLK_80;
772 chip->fpga_ms_hg_clk = CLK_80;
773 chip->fpga_ms_4bit_clk = CLK_80;
774 chip->fpga_ms_1bit_clk = CLK_40;
775 chip->asic_sd_sdr104_clk = 203;
776 chip->asic_sd_sdr50_clk = 98;
777 chip->asic_sd_ddr50_clk = 98;
778 chip->asic_sd_hs_clk = 98;
779 chip->asic_mmc_52m_clk = 98;
780 chip->asic_ms_hg_clk = 117;
781 chip->asic_ms_4bit_clk = 78;
782 chip->asic_ms_1bit_clk = 39;
783 chip->ssc_depth_sd_sdr104 = SSC_DEPTH_2M;
784 chip->ssc_depth_sd_sdr50 = SSC_DEPTH_2M;
785 chip->ssc_depth_sd_ddr50 = SSC_DEPTH_1M;
786 chip->ssc_depth_sd_hs = SSC_DEPTH_1M;
787 chip->ssc_depth_mmc_52m = SSC_DEPTH_1M;
788 chip->ssc_depth_ms_hg = SSC_DEPTH_1M;
789 chip->ssc_depth_ms_4bit = SSC_DEPTH_512K;
790 chip->ssc_depth_low_speed = SSC_DEPTH_512K;
791 chip->ssc_en = 1;
792 chip->sd_speed_prior = 0x01040203;
793 chip->sd_current_prior = 0x00010203;
794 chip->sd_ctl = SD_PUSH_POINT_AUTO |
795 SD_SAMPLE_POINT_AUTO |
796 SUPPORT_MMC_DDR_MODE;
797 chip->sd_ddr_tx_phase = 0;
798 chip->mmc_ddr_tx_phase = 1;
799 chip->sd_default_tx_phase = 15;
800 chip->sd_default_rx_phase = 15;
801 chip->pmos_pwr_on_interval = 200;
802 chip->sd_voltage_switch_delay = 1000;
803 chip->ms_power_class_en = 3;
804
805 chip->sd_400mA_ocp_thd = 1;
806 chip->sd_800mA_ocp_thd = 5;
807 chip->ms_ocp_thd = 2;
808
809 chip->card_drive_sel = 0x55;
810 chip->sd30_drive_sel_1v8 = 0x03;
811 chip->sd30_drive_sel_3v3 = 0x01;
812
813 chip->do_delink_before_power_down = 1;
814 chip->auto_power_down = 1;
815 chip->polling_config = 0;
816
817 chip->force_clkreq_0 = 1;
818 chip->ft2_fast_mode = 0;
819
820 chip->sdio_retry_cnt = 1;
821
822 chip->xd_timeout = 2000;
823 chip->sd_timeout = 10000;
824 chip->ms_timeout = 2000;
825 chip->mspro_timeout = 15000;
826
827 chip->power_down_in_ss = 1;
828
829 chip->sdr104_en = 1;
830 chip->sdr50_en = 1;
831 chip->ddr50_en = 1;
832
833 chip->delink_stage1_step = 100;
834 chip->delink_stage2_step = 40;
835 chip->delink_stage3_step = 20;
836
837 chip->auto_delink_in_L1 = 1;
838 chip->blink_led = 1;
839 chip->msi_en = msi_en;
840 chip->hp_watch_bios_hotplug = 0;
841 chip->max_payload = 0;
842 chip->phy_voltage = 0;
843
844 chip->support_ms_8bit = 1;
845 chip->s3_pwr_off_delay = 1000;
846 }
847
rtsx_probe(struct pci_dev * pci,const struct pci_device_id * pci_id)848 static int rtsx_probe(struct pci_dev *pci,
849 const struct pci_device_id *pci_id)
850 {
851 struct Scsi_Host *host;
852 struct rtsx_dev *dev;
853 int err = 0;
854 struct task_struct *th;
855
856 dev_dbg(&pci->dev, "Realtek PCI-E card reader detected\n");
857
858 err = pci_enable_device(pci);
859 if (err < 0) {
860 dev_err(&pci->dev, "PCI enable device failed!\n");
861 return err;
862 }
863
864 err = pci_request_regions(pci, CR_DRIVER_NAME);
865 if (err < 0) {
866 dev_err(&pci->dev, "PCI request regions for %s failed!\n",
867 CR_DRIVER_NAME);
868 pci_disable_device(pci);
869 return err;
870 }
871
872 /*
873 * Ask the SCSI layer to allocate a host structure, with extra
874 * space at the end for our private rtsx_dev structure.
875 */
876 host = scsi_host_alloc(&rtsx_host_template, sizeof(*dev));
877 if (!host) {
878 dev_err(&pci->dev, "Unable to allocate the scsi host\n");
879 pci_release_regions(pci);
880 pci_disable_device(pci);
881 return -ENOMEM;
882 }
883
884 dev = host_to_rtsx(host);
885 memset(dev, 0, sizeof(struct rtsx_dev));
886
887 dev->chip = kzalloc(sizeof(struct rtsx_chip), GFP_KERNEL);
888 if (dev->chip == NULL) {
889 err = -ENOMEM;
890 goto errout;
891 }
892
893 spin_lock_init(&dev->reg_lock);
894 mutex_init(&(dev->dev_mutex));
895 init_completion(&dev->cmnd_ready);
896 init_completion(&dev->control_exit);
897 init_completion(&dev->polling_exit);
898 init_completion(&(dev->notify));
899 init_completion(&dev->scanning_done);
900 init_waitqueue_head(&dev->delay_wait);
901
902 dev->pci = pci;
903 dev->irq = -1;
904
905 dev_info(&pci->dev, "Resource length: 0x%x\n",
906 (unsigned int)pci_resource_len(pci, 0));
907 dev->addr = pci_resource_start(pci, 0);
908 dev->remap_addr = ioremap_nocache(dev->addr, pci_resource_len(pci, 0));
909 if (dev->remap_addr == NULL) {
910 dev_err(&pci->dev, "ioremap error\n");
911 err = -ENXIO;
912 goto errout;
913 }
914
915 /*
916 * Using "unsigned long" cast here to eliminate gcc warning in
917 * 64-bit system
918 */
919 dev_info(&pci->dev, "Original address: 0x%lx, remapped address: 0x%lx\n",
920 (unsigned long)(dev->addr), (unsigned long)(dev->remap_addr));
921
922 dev->rtsx_resv_buf = dma_alloc_coherent(&(pci->dev), RTSX_RESV_BUF_LEN,
923 &(dev->rtsx_resv_buf_addr), GFP_KERNEL);
924 if (dev->rtsx_resv_buf == NULL) {
925 dev_err(&pci->dev, "alloc dma buffer fail\n");
926 err = -ENXIO;
927 goto errout;
928 }
929 dev->chip->host_cmds_ptr = dev->rtsx_resv_buf;
930 dev->chip->host_cmds_addr = dev->rtsx_resv_buf_addr;
931 dev->chip->host_sg_tbl_ptr = dev->rtsx_resv_buf + HOST_CMDS_BUF_LEN;
932 dev->chip->host_sg_tbl_addr = dev->rtsx_resv_buf_addr +
933 HOST_CMDS_BUF_LEN;
934
935 dev->chip->rtsx = dev;
936
937 rtsx_init_options(dev->chip);
938
939 dev_info(&pci->dev, "pci->irq = %d\n", pci->irq);
940
941 if (dev->chip->msi_en) {
942 if (pci_enable_msi(pci) < 0)
943 dev->chip->msi_en = 0;
944 }
945
946 if (rtsx_acquire_irq(dev) < 0) {
947 err = -EBUSY;
948 goto errout;
949 }
950
951 pci_set_master(pci);
952 synchronize_irq(dev->irq);
953
954 rtsx_init_chip(dev->chip);
955
956 /* set the supported max_lun and max_id for the scsi host
957 * NOTE: the minimal value of max_id is 1 */
958 host->max_id = 1;
959 host->max_lun = dev->chip->max_lun;
960
961 /* Start up our control thread */
962 th = kthread_run(rtsx_control_thread, dev, CR_DRIVER_NAME);
963 if (IS_ERR(th)) {
964 dev_err(&pci->dev, "Unable to start control thread\n");
965 err = PTR_ERR(th);
966 goto errout;
967 }
968 dev->ctl_thread = th;
969
970 err = scsi_add_host(host, &pci->dev);
971 if (err) {
972 dev_err(&pci->dev, "Unable to add the scsi host\n");
973 goto errout;
974 }
975
976 /* Start up the thread for delayed SCSI-device scanning */
977 th = kthread_run(rtsx_scan_thread, dev, "rtsx-scan");
978 if (IS_ERR(th)) {
979 dev_err(&pci->dev, "Unable to start the device-scanning thread\n");
980 complete(&dev->scanning_done);
981 quiesce_and_remove_host(dev);
982 err = PTR_ERR(th);
983 goto errout;
984 }
985
986 /* Start up the thread for polling thread */
987 th = kthread_run(rtsx_polling_thread, dev, "rtsx-polling");
988 if (IS_ERR(th)) {
989 dev_err(&pci->dev, "Unable to start the device-polling thread\n");
990 quiesce_and_remove_host(dev);
991 err = PTR_ERR(th);
992 goto errout;
993 }
994 dev->polling_thread = th;
995
996 pci_set_drvdata(pci, dev);
997
998 return 0;
999
1000 /* We come here if there are any problems */
1001 errout:
1002 dev_err(&pci->dev, "rtsx_probe() failed\n");
1003 release_everything(dev);
1004
1005 return err;
1006 }
1007
1008
rtsx_remove(struct pci_dev * pci)1009 static void rtsx_remove(struct pci_dev *pci)
1010 {
1011 struct rtsx_dev *dev = pci_get_drvdata(pci);
1012
1013 dev_info(&pci->dev, "rtsx_remove() called\n");
1014
1015 quiesce_and_remove_host(dev);
1016 release_everything(dev);
1017
1018 pci_set_drvdata(pci, NULL);
1019 }
1020
1021 /* PCI IDs */
1022 static const struct pci_device_id rtsx_ids[] = {
1023 { PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x5208),
1024 PCI_CLASS_OTHERS << 16, 0xFF0000 },
1025 { PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x5288),
1026 PCI_CLASS_OTHERS << 16, 0xFF0000 },
1027 { 0, },
1028 };
1029
1030 MODULE_DEVICE_TABLE(pci, rtsx_ids);
1031
1032 /* pci_driver definition */
1033 static struct pci_driver rtsx_driver = {
1034 .name = CR_DRIVER_NAME,
1035 .id_table = rtsx_ids,
1036 .probe = rtsx_probe,
1037 .remove = rtsx_remove,
1038 #ifdef CONFIG_PM
1039 .suspend = rtsx_suspend,
1040 .resume = rtsx_resume,
1041 #endif
1042 .shutdown = rtsx_shutdown,
1043 };
1044
1045 module_pci_driver(rtsx_driver);
1046