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