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