drivers/staging/rts5208/rtsx.c

   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);