drivers/staging/rts_pstor/rtsx.c

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