1 // SPDX-License-Identifier: GPL-2.0+
3 * Driver for Realtek PCI-Express card reader
5 * Copyright(c) 2009-2013 Realtek Semiconductor Corp. All rights reserved.
8 * Wei WANG (wei_wang@realsil.com.cn)
9 * Micky Ching (micky_ching@realsil.com.cn)
12 #include <linux/blkdev.h>
13 #include <linux/kthread.h>
14 #include <linux/sched.h>
15 #include <linux/workqueue.h>
22 MODULE_DESCRIPTION("Realtek PCI-Express card reader rts5208/rts5288 driver");
23 MODULE_LICENSE("GPL");
25 static unsigned int delay_use = 1;
26 module_param(delay_use, uint, 0644);
27 MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device");
30 module_param(ss_en, int, 0644);
31 MODULE_PARM_DESC(ss_en, "enable selective suspend");
33 static int ss_interval = 50;
34 module_param(ss_interval, int, 0644);
35 MODULE_PARM_DESC(ss_interval, "Interval to enter ss state in seconds");
37 static int auto_delink_en;
38 module_param(auto_delink_en, int, 0644);
39 MODULE_PARM_DESC(auto_delink_en, "enable auto delink");
41 static unsigned char aspm_l0s_l1_en;
42 module_param(aspm_l0s_l1_en, byte, 0644);
43 MODULE_PARM_DESC(aspm_l0s_l1_en, "enable device aspm");
46 module_param(msi_en, int, 0644);
47 MODULE_PARM_DESC(msi_en, "enable msi");
49 static irqreturn_t rtsx_interrupt(int irq, void *dev_id);
51 /***********************************************************************
53 ***********************************************************************/
55 static const char *host_info(struct Scsi_Host *host)
57 return "SCSI emulation for PCI-Express Mass Storage devices";
60 static int slave_alloc(struct scsi_device *sdev)
63 * Set the INQUIRY transfer length to 36. We don't use any of
64 * the extra data and many devices choke if asked for more or
67 sdev->inquiry_len = 36;
71 static int slave_configure(struct scsi_device *sdev)
74 * Scatter-gather buffers (all but the last) must have a length
75 * divisible by the bulk maxpacket size. Otherwise a data packet
76 * would end up being short, causing a premature end to the data
77 * transfer. Since high-speed bulk pipes have a maxpacket size
78 * of 512, we'll use that as the scsi device queue's DMA alignment
79 * mask. Guaranteeing proper alignment of the first buffer will
80 * have the desired effect because, except at the beginning and
81 * the end, scatter-gather buffers follow page boundaries.
83 blk_queue_dma_alignment(sdev->request_queue, (512 - 1));
85 /* Set the SCSI level to at least 2. We'll leave it at 3 if that's
86 * what is originally reported. We need this to avoid confusing
87 * the SCSI layer with devices that report 0 or 1, but need 10-byte
88 * commands (ala ATAPI devices behind certain bridges, or devices
89 * which simply have broken INQUIRY data).
91 * NOTE: This means /dev/sg programs (ala cdrecord) will get the
92 * actual information. This seems to be the preference for
95 * NOTE: This also means that /proc/scsi/scsi and sysfs may report
96 * the actual value or the modified one, depending on where the
99 if (sdev->scsi_level < SCSI_2) {
100 sdev->scsi_level = SCSI_2;
101 sdev->sdev_target->scsi_level = SCSI_2;
107 /***********************************************************************
108 * /proc/scsi/ functions
109 ***********************************************************************/
111 /* we use this macro to help us write into the buffer */
113 #define SPRINTF(args...) \
115 if (pos < buffer + length) \
116 pos += sprintf(pos, ## args); \
119 /* queue a command */
120 /* This is always called with scsi_lock(host) held */
121 static int queuecommand_lck(struct scsi_cmnd *srb)
123 void (*done)(struct scsi_cmnd *) = scsi_done;
124 struct rtsx_dev *dev = host_to_rtsx(srb->device->host);
125 struct rtsx_chip *chip = dev->chip;
127 /* check for state-transition errors */
129 dev_err(&dev->pci->dev, "Error: chip->srb = %p\n",
131 return SCSI_MLQUEUE_HOST_BUSY;
134 /* fail the command if we are disconnecting */
135 if (rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT)) {
136 dev_info(&dev->pci->dev, "Fail command during disconnect\n");
137 srb->result = DID_NO_CONNECT << 16;
142 /* enqueue the command and wake up the control thread */
144 complete(&dev->cmnd_ready);
149 static DEF_SCSI_QCMD(queuecommand)
151 /***********************************************************************
152 * Error handling functions
153 ***********************************************************************/
155 /* Command timeout and abort */
156 static int command_abort(struct scsi_cmnd *srb)
158 struct Scsi_Host *host = srb->device->host;
159 struct rtsx_dev *dev = host_to_rtsx(host);
160 struct rtsx_chip *chip = dev->chip;
162 dev_info(&dev->pci->dev, "%s called\n", __func__);
166 /* Is this command still active? */
167 if (chip->srb != srb) {
169 dev_info(&dev->pci->dev, "-- nothing to abort\n");
173 rtsx_set_stat(chip, RTSX_STAT_ABORT);
177 /* Wait for the aborted command to finish */
178 wait_for_completion(&dev->notify);
184 * This invokes the transport reset mechanism to reset the state of the
187 static int device_reset(struct scsi_cmnd *srb)
189 struct rtsx_dev *dev = host_to_rtsx(srb->device->host);
191 dev_info(&dev->pci->dev, "%s called\n", __func__);
197 * this defines our host template, with which we'll allocate hosts
200 static struct scsi_host_template rtsx_host_template = {
201 /* basic userland interface stuff */
202 .name = CR_DRIVER_NAME,
203 .proc_name = CR_DRIVER_NAME,
206 /* command interface -- queued only */
207 .queuecommand = queuecommand,
209 /* error and abort handlers */
210 .eh_abort_handler = command_abort,
211 .eh_device_reset_handler = device_reset,
213 /* queue commands only, only one command per LUN */
216 /* unknown initiator id */
219 .slave_alloc = slave_alloc,
220 .slave_configure = slave_configure,
222 /* lots of sg segments can be handled */
223 .sg_tablesize = SG_ALL,
225 /* limit the total size of a transfer to 120 KB */
231 /* we do our own delay after a device or bus reset */
232 .skip_settle_delay = 1,
234 /* module management */
235 .module = THIS_MODULE
238 static int rtsx_acquire_irq(struct rtsx_dev *dev)
240 struct rtsx_chip *chip = dev->chip;
242 dev_info(&dev->pci->dev, "%s: chip->msi_en = %d, pci->irq = %d\n",
243 __func__, chip->msi_en, dev->pci->irq);
245 if (request_irq(dev->pci->irq, rtsx_interrupt,
246 chip->msi_en ? 0 : IRQF_SHARED,
247 CR_DRIVER_NAME, dev)) {
248 dev_err(&dev->pci->dev,
249 "rtsx: unable to grab IRQ %d, disabling device\n",
254 dev->irq = dev->pci->irq;
255 pci_intx(dev->pci, !chip->msi_en);
263 static int __maybe_unused rtsx_suspend(struct device *dev_d)
265 struct pci_dev *pci = to_pci_dev(dev_d);
266 struct rtsx_dev *dev = pci_get_drvdata(pci);
267 struct rtsx_chip *chip;
272 /* lock the device pointers */
273 mutex_lock(&dev->dev_mutex);
277 rtsx_do_before_power_down(chip, PM_S3);
280 free_irq(dev->irq, (void *)dev);
285 pci_free_irq_vectors(pci);
287 device_wakeup_enable(dev_d);
289 /* unlock the device pointers */
290 mutex_unlock(&dev->dev_mutex);
295 static int __maybe_unused rtsx_resume(struct device *dev_d)
297 struct pci_dev *pci = to_pci_dev(dev_d);
298 struct rtsx_dev *dev = pci_get_drvdata(pci);
299 struct rtsx_chip *chip;
306 /* lock the device pointers */
307 mutex_lock(&dev->dev_mutex);
312 if (pci_alloc_irq_vectors(pci, 1, 1, PCI_IRQ_MSI) < 0)
316 if (rtsx_acquire_irq(dev) < 0) {
317 /* unlock the device pointers */
318 mutex_unlock(&dev->dev_mutex);
322 rtsx_write_register(chip, HOST_SLEEP_STATE, 0x03, 0x00);
323 rtsx_init_chip(chip);
325 /* unlock the device pointers */
326 mutex_unlock(&dev->dev_mutex);
331 static void rtsx_shutdown(struct pci_dev *pci)
333 struct rtsx_dev *dev = pci_get_drvdata(pci);
334 struct rtsx_chip *chip;
341 rtsx_do_before_power_down(chip, PM_S1);
344 free_irq(dev->irq, (void *)dev);
349 pci_free_irq_vectors(pci);
351 pci_disable_device(pci);
354 static int rtsx_control_thread(void *__dev)
356 struct rtsx_dev *dev = __dev;
357 struct rtsx_chip *chip = dev->chip;
358 struct Scsi_Host *host = rtsx_to_host(dev);
361 if (wait_for_completion_interruptible(&dev->cmnd_ready))
364 /* lock the device pointers */
365 mutex_lock(&dev->dev_mutex);
367 /* if the device has disconnected, we are free to exit */
368 if (rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT)) {
369 dev_info(&dev->pci->dev, "-- rtsx-control exiting\n");
370 mutex_unlock(&dev->dev_mutex);
374 /* lock access to the state */
377 /* has the command aborted ? */
378 if (rtsx_chk_stat(chip, RTSX_STAT_ABORT)) {
379 chip->srb->result = DID_ABORT << 16;
385 /* reject the command if the direction indicator
388 if (chip->srb->sc_data_direction == DMA_BIDIRECTIONAL) {
389 dev_err(&dev->pci->dev, "UNKNOWN data direction\n");
390 chip->srb->result = DID_ERROR << 16;
393 /* reject if target != 0 or if LUN is higher than
394 * the maximum known LUN
396 else if (chip->srb->device->id) {
397 dev_err(&dev->pci->dev, "Bad target number (%d:%d)\n",
398 chip->srb->device->id,
399 (u8)chip->srb->device->lun);
400 chip->srb->result = DID_BAD_TARGET << 16;
403 else if (chip->srb->device->lun > chip->max_lun) {
404 dev_err(&dev->pci->dev, "Bad LUN (%d:%d)\n",
405 chip->srb->device->id,
406 (u8)chip->srb->device->lun);
407 chip->srb->result = DID_BAD_TARGET << 16;
410 /* we've got a command, let's do it! */
412 scsi_show_command(chip);
413 rtsx_invoke_transport(chip->srb, chip);
416 /* lock access to the state */
419 /* did the command already complete because of a disconnect? */
421 ; /* nothing to do */
423 /* indicate that the command is done */
424 else if (chip->srb->result != DID_ABORT << 16) {
425 scsi_done(chip->srb);
428 dev_err(&dev->pci->dev, "scsi command aborted\n");
431 if (rtsx_chk_stat(chip, RTSX_STAT_ABORT)) {
432 complete(&dev->notify);
434 rtsx_set_stat(chip, RTSX_STAT_IDLE);
437 /* finished working on this command */
441 /* unlock the device pointers */
442 mutex_unlock(&dev->dev_mutex);
445 /* notify the exit routine that we're actually exiting now
447 * complete()/wait_for_completion() is similar to up()/down(),
448 * except that complete() is safe in the case where the structure
449 * is getting deleted in a parallel mode of execution (i.e. just
450 * after the down() -- that's necessary for the thread-shutdown
453 * complete_and_exit() goes even further than this -- it is safe in
454 * the case that the thread of the caller is going away (not just
455 * the structure) -- this is necessary for the module-remove case.
456 * This is important in preemption kernels, which transfer the flow
457 * of execution immediately upon a complete().
459 complete_and_exit(&dev->control_exit, 0);
462 static int rtsx_polling_thread(void *__dev)
464 struct rtsx_dev *dev = __dev;
465 struct rtsx_chip *chip = dev->chip;
466 struct sd_info *sd_card = &chip->sd_card;
467 struct xd_info *xd_card = &chip->xd_card;
468 struct ms_info *ms_card = &chip->ms_card;
470 sd_card->cleanup_counter = 0;
471 xd_card->cleanup_counter = 0;
472 ms_card->cleanup_counter = 0;
474 /* Wait until SCSI scan finished */
475 wait_timeout((delay_use + 5) * 1000);
478 set_current_state(TASK_INTERRUPTIBLE);
479 schedule_timeout(msecs_to_jiffies(POLLING_INTERVAL));
481 /* lock the device pointers */
482 mutex_lock(&dev->dev_mutex);
484 /* if the device has disconnected, we are free to exit */
485 if (rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT)) {
486 dev_info(&dev->pci->dev, "-- rtsx-polling exiting\n");
487 mutex_unlock(&dev->dev_mutex);
491 mutex_unlock(&dev->dev_mutex);
493 mspro_polling_format_status(chip);
495 /* lock the device pointers */
496 mutex_lock(&dev->dev_mutex);
498 rtsx_polling_func(chip);
500 /* unlock the device pointers */
501 mutex_unlock(&dev->dev_mutex);
504 complete_and_exit(&dev->polling_exit, 0);
510 static irqreturn_t rtsx_interrupt(int irq, void *dev_id)
512 struct rtsx_dev *dev = dev_id;
513 struct rtsx_chip *chip;
525 spin_lock(&dev->reg_lock);
527 retval = rtsx_pre_handle_interrupt(chip);
528 if (retval == STATUS_FAIL) {
529 spin_unlock(&dev->reg_lock);
530 if (chip->int_reg == 0xFFFFFFFF)
535 status = chip->int_reg;
537 if (dev->check_card_cd) {
538 if (!(dev->check_card_cd & status)) {
539 /* card not exist, return TRANS_RESULT_FAIL */
540 dev->trans_result = TRANS_RESULT_FAIL;
547 if (status & (NEED_COMPLETE_INT | DELINK_INT)) {
548 if (status & (TRANS_FAIL_INT | DELINK_INT)) {
549 if (status & DELINK_INT)
550 RTSX_SET_DELINK(chip);
551 dev->trans_result = TRANS_RESULT_FAIL;
554 } else if (status & TRANS_OK_INT) {
555 dev->trans_result = TRANS_RESULT_OK;
558 } else if (status & DATA_DONE_INT) {
559 dev->trans_result = TRANS_NOT_READY;
560 if (dev->done && (dev->trans_state == STATE_TRANS_SG))
566 spin_unlock(&dev->reg_lock);
570 /* Release all our dynamic resources */
571 static void rtsx_release_resources(struct rtsx_dev *dev)
573 dev_info(&dev->pci->dev, "-- %s\n", __func__);
575 /* Tell the control thread to exit. The SCSI host must
576 * already have been removed so it won't try to queue
579 dev_info(&dev->pci->dev, "-- sending exit command to thread\n");
580 complete(&dev->cmnd_ready);
582 wait_for_completion(&dev->control_exit);
583 if (dev->polling_thread)
584 wait_for_completion(&dev->polling_exit);
588 if (dev->rtsx_resv_buf) {
589 dev->chip->host_cmds_ptr = NULL;
590 dev->chip->host_sg_tbl_ptr = NULL;
594 free_irq(dev->irq, (void *)dev);
595 if (dev->chip->msi_en)
596 pci_free_irq_vectors(dev->pci);
598 iounmap(dev->remap_addr);
600 rtsx_release_chip(dev->chip);
605 * First stage of disconnect processing: stop all commands and remove
608 static void quiesce_and_remove_host(struct rtsx_dev *dev)
610 struct Scsi_Host *host = rtsx_to_host(dev);
611 struct rtsx_chip *chip = dev->chip;
614 * Prevent new transfers, stop the current command, and
615 * interrupt a SCSI-scan or device-reset delay
617 mutex_lock(&dev->dev_mutex);
619 rtsx_set_stat(chip, RTSX_STAT_DISCONNECT);
621 mutex_unlock(&dev->dev_mutex);
622 wake_up(&dev->delay_wait);
623 wait_for_completion(&dev->scanning_done);
625 /* Wait some time to let other threads exist */
629 * queuecommand won't accept any new commands and the control
630 * thread won't execute a previously-queued command. If there
631 * is such a command pending, complete it with an error.
633 mutex_lock(&dev->dev_mutex);
635 chip->srb->result = DID_NO_CONNECT << 16;
637 scsi_done(dev->chip->srb);
641 mutex_unlock(&dev->dev_mutex);
643 /* Now we own no commands so it's safe to remove the SCSI host */
644 scsi_remove_host(host);
647 /* Second stage of disconnect processing: deallocate all resources */
648 static void release_everything(struct rtsx_dev *dev)
650 rtsx_release_resources(dev);
653 * Drop our reference to the host; the SCSI core will free it
654 * when the refcount becomes 0.
656 scsi_host_put(rtsx_to_host(dev));
659 /* Thread to carry out delayed SCSI-device scanning */
660 static int rtsx_scan_thread(void *__dev)
662 struct rtsx_dev *dev = __dev;
663 struct rtsx_chip *chip = dev->chip;
665 /* Wait for the timeout to expire or for a disconnect */
667 dev_info(&dev->pci->dev,
668 "%s: waiting for device to settle before scanning\n",
670 wait_event_interruptible_timeout
672 rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT),
676 /* If the device is still connected, perform the scanning */
677 if (!rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT)) {
678 scsi_scan_host(rtsx_to_host(dev));
679 dev_info(&dev->pci->dev, "%s: device scan complete\n",
682 /* Should we unbind if no devices were detected? */
685 complete_and_exit(&dev->scanning_done, 0);
688 static void rtsx_init_options(struct rtsx_chip *chip)
690 chip->vendor_id = chip->rtsx->pci->vendor;
691 chip->product_id = chip->rtsx->pci->device;
694 chip->driver_first_load = 1;
695 #ifdef HW_AUTO_SWITCH_SD_BUS
696 chip->sdio_in_charge = 0;
699 chip->mspro_formatter_enable = 1;
701 chip->use_hw_setting = 0;
702 chip->lun_mode = DEFAULT_SINGLE;
703 chip->auto_delink_en = auto_delink_en;
705 chip->ss_idle_period = ss_interval * 1000;
706 chip->remote_wakeup_en = 0;
707 chip->aspm_l0s_l1_en = aspm_l0s_l1_en;
708 chip->dynamic_aspm = 1;
709 chip->fpga_sd_sdr104_clk = CLK_200;
710 chip->fpga_sd_ddr50_clk = CLK_100;
711 chip->fpga_sd_sdr50_clk = CLK_100;
712 chip->fpga_sd_hs_clk = CLK_100;
713 chip->fpga_mmc_52m_clk = CLK_80;
714 chip->fpga_ms_hg_clk = CLK_80;
715 chip->fpga_ms_4bit_clk = CLK_80;
716 chip->fpga_ms_1bit_clk = CLK_40;
717 chip->asic_sd_sdr104_clk = 203;
718 chip->asic_sd_sdr50_clk = 98;
719 chip->asic_sd_ddr50_clk = 98;
720 chip->asic_sd_hs_clk = 98;
721 chip->asic_mmc_52m_clk = 98;
722 chip->asic_ms_hg_clk = 117;
723 chip->asic_ms_4bit_clk = 78;
724 chip->asic_ms_1bit_clk = 39;
725 chip->ssc_depth_sd_sdr104 = SSC_DEPTH_2M;
726 chip->ssc_depth_sd_sdr50 = SSC_DEPTH_2M;
727 chip->ssc_depth_sd_ddr50 = SSC_DEPTH_1M;
728 chip->ssc_depth_sd_hs = SSC_DEPTH_1M;
729 chip->ssc_depth_mmc_52m = SSC_DEPTH_1M;
730 chip->ssc_depth_ms_hg = SSC_DEPTH_1M;
731 chip->ssc_depth_ms_4bit = SSC_DEPTH_512K;
732 chip->ssc_depth_low_speed = SSC_DEPTH_512K;
734 chip->sd_speed_prior = 0x01040203;
735 chip->sd_current_prior = 0x00010203;
736 chip->sd_ctl = SD_PUSH_POINT_AUTO |
737 SD_SAMPLE_POINT_AUTO |
738 SUPPORT_MMC_DDR_MODE;
739 chip->sd_ddr_tx_phase = 0;
740 chip->mmc_ddr_tx_phase = 1;
741 chip->sd_default_tx_phase = 15;
742 chip->sd_default_rx_phase = 15;
743 chip->pmos_pwr_on_interval = 200;
744 chip->sd_voltage_switch_delay = 1000;
745 chip->ms_power_class_en = 3;
747 chip->sd_400mA_ocp_thd = 1;
748 chip->sd_800mA_ocp_thd = 5;
749 chip->ms_ocp_thd = 2;
751 chip->card_drive_sel = 0x55;
752 chip->sd30_drive_sel_1v8 = 0x03;
753 chip->sd30_drive_sel_3v3 = 0x01;
755 chip->do_delink_before_power_down = 1;
756 chip->auto_power_down = 1;
757 chip->polling_config = 0;
759 chip->force_clkreq_0 = 1;
760 chip->ft2_fast_mode = 0;
762 chip->sdio_retry_cnt = 1;
764 chip->xd_timeout = 2000;
765 chip->sd_timeout = 10000;
766 chip->ms_timeout = 2000;
767 chip->mspro_timeout = 15000;
769 chip->power_down_in_ss = 1;
775 chip->delink_stage1_step = 100;
776 chip->delink_stage2_step = 40;
777 chip->delink_stage3_step = 20;
779 chip->auto_delink_in_L1 = 1;
781 chip->msi_en = msi_en;
782 chip->hp_watch_bios_hotplug = 0;
783 chip->max_payload = 0;
784 chip->phy_voltage = 0;
786 chip->support_ms_8bit = 1;
787 chip->s3_pwr_off_delay = 1000;
790 static int rtsx_probe(struct pci_dev *pci,
791 const struct pci_device_id *pci_id)
793 struct Scsi_Host *host;
794 struct rtsx_dev *dev;
796 struct task_struct *th;
798 dev_dbg(&pci->dev, "Realtek PCI-E card reader detected\n");
800 err = pcim_enable_device(pci);
802 dev_err(&pci->dev, "PCI enable device failed!\n");
806 err = pci_request_regions(pci, CR_DRIVER_NAME);
808 dev_err(&pci->dev, "PCI request regions for %s failed!\n",
814 * Ask the SCSI layer to allocate a host structure, with extra
815 * space at the end for our private rtsx_dev structure.
817 host = scsi_host_alloc(&rtsx_host_template, sizeof(*dev));
819 dev_err(&pci->dev, "Unable to allocate the scsi host\n");
821 goto scsi_host_alloc_fail;
824 dev = host_to_rtsx(host);
825 memset(dev, 0, sizeof(struct rtsx_dev));
827 dev->chip = kzalloc(sizeof(*dev->chip), GFP_KERNEL);
830 goto chip_alloc_fail;
833 spin_lock_init(&dev->reg_lock);
834 mutex_init(&dev->dev_mutex);
835 init_completion(&dev->cmnd_ready);
836 init_completion(&dev->control_exit);
837 init_completion(&dev->polling_exit);
838 init_completion(&dev->notify);
839 init_completion(&dev->scanning_done);
840 init_waitqueue_head(&dev->delay_wait);
845 dev_info(&pci->dev, "Resource length: 0x%x\n",
846 (unsigned int)pci_resource_len(pci, 0));
847 dev->addr = pci_resource_start(pci, 0);
848 dev->remap_addr = ioremap(dev->addr, pci_resource_len(pci, 0));
849 if (!dev->remap_addr) {
850 dev_err(&pci->dev, "ioremap error\n");
856 * Using "unsigned long" cast here to eliminate gcc warning in
859 dev_info(&pci->dev, "Original address: 0x%lx, remapped address: 0x%lx\n",
860 (unsigned long)(dev->addr), (unsigned long)(dev->remap_addr));
862 dev->rtsx_resv_buf = dmam_alloc_coherent(&pci->dev, RTSX_RESV_BUF_LEN,
863 &dev->rtsx_resv_buf_addr,
865 if (!dev->rtsx_resv_buf) {
866 dev_err(&pci->dev, "alloc dma buffer fail\n");
870 dev->chip->host_cmds_ptr = dev->rtsx_resv_buf;
871 dev->chip->host_cmds_addr = dev->rtsx_resv_buf_addr;
872 dev->chip->host_sg_tbl_ptr = dev->rtsx_resv_buf + HOST_CMDS_BUF_LEN;
873 dev->chip->host_sg_tbl_addr = dev->rtsx_resv_buf_addr +
876 dev->chip->rtsx = dev;
878 rtsx_init_options(dev->chip);
880 dev_info(&pci->dev, "pci->irq = %d\n", pci->irq);
882 if (dev->chip->msi_en) {
883 if (pci_alloc_irq_vectors(pci, 1, 1, PCI_IRQ_MSI) < 0)
884 dev->chip->msi_en = 0;
887 if (rtsx_acquire_irq(dev) < 0) {
889 goto irq_acquire_fail;
893 synchronize_irq(dev->irq);
895 rtsx_init_chip(dev->chip);
898 * set the supported max_lun and max_id for the scsi host
899 * NOTE: the minimal value of max_id is 1
902 host->max_lun = dev->chip->max_lun;
904 /* Start up our control thread */
905 th = kthread_run(rtsx_control_thread, dev, CR_DRIVER_NAME);
907 dev_err(&pci->dev, "Unable to start control thread\n");
909 goto control_thread_fail;
911 dev->ctl_thread = th;
913 err = scsi_add_host(host, &pci->dev);
915 dev_err(&pci->dev, "Unable to add the scsi host\n");
916 goto scsi_add_host_fail;
919 /* Start up the thread for delayed SCSI-device scanning */
920 th = kthread_run(rtsx_scan_thread, dev, "rtsx-scan");
922 dev_err(&pci->dev, "Unable to start the device-scanning thread\n");
923 complete(&dev->scanning_done);
925 goto scan_thread_fail;
928 /* Start up the thread for polling thread */
929 th = kthread_run(rtsx_polling_thread, dev, "rtsx-polling");
931 dev_err(&pci->dev, "Unable to start the device-polling thread\n");
933 goto scan_thread_fail;
935 dev->polling_thread = th;
937 pci_set_drvdata(pci, dev);
941 /* We come here if there are any problems */
943 quiesce_and_remove_host(dev);
945 complete(&dev->cmnd_ready);
946 wait_for_completion(&dev->control_exit);
948 free_irq(dev->irq, (void *)dev);
949 rtsx_release_chip(dev->chip);
951 dev->chip->host_cmds_ptr = NULL;
952 dev->chip->host_sg_tbl_ptr = NULL;
953 if (dev->chip->msi_en)
954 pci_free_irq_vectors(dev->pci);
956 iounmap(dev->remap_addr);
960 dev_err(&pci->dev, "%s failed\n", __func__);
962 scsi_host_alloc_fail:
963 pci_release_regions(pci);
967 static void rtsx_remove(struct pci_dev *pci)
969 struct rtsx_dev *dev = pci_get_drvdata(pci);
971 dev_info(&pci->dev, "%s called\n", __func__);
973 quiesce_and_remove_host(dev);
974 release_everything(dev);
975 pci_release_regions(pci);
979 static const struct pci_device_id rtsx_ids[] = {
980 { PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x5208),
981 PCI_CLASS_OTHERS << 16, 0xFF0000 },
982 { PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x5288),
983 PCI_CLASS_OTHERS << 16, 0xFF0000 },
987 MODULE_DEVICE_TABLE(pci, rtsx_ids);
989 static SIMPLE_DEV_PM_OPS(rtsx_pm_ops, rtsx_suspend, rtsx_resume);
991 /* pci_driver definition */
992 static struct pci_driver rtsx_driver = {
993 .name = CR_DRIVER_NAME,
994 .id_table = rtsx_ids,
996 .remove = rtsx_remove,
997 .driver.pm = &rtsx_pm_ops,
998 .shutdown = rtsx_shutdown,
1001 module_pci_driver(rtsx_driver);