Merge branch 'master' into pm-sleep
[linux-3.10.git] / 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         for (;;) {
470                 if (wait_for_completion_interruptible(&dev->cmnd_ready))
471                         break;
472
473                 /* lock the device pointers */
474                 mutex_lock(&(dev->dev_mutex));
475
476                 /* if the device has disconnected, we are free to exit */
477                 if (rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT)) {
478                         printk(KERN_INFO "-- rtsx-control exiting\n");
479                         mutex_unlock(&dev->dev_mutex);
480                         break;
481                 }
482
483                 /* lock access to the state */
484                 scsi_lock(host);
485
486                 /* has the command aborted ? */
487                 if (rtsx_chk_stat(chip, RTSX_STAT_ABORT)) {
488                         chip->srb->result = DID_ABORT << 16;
489                         goto SkipForAbort;
490                 }
491
492                 scsi_unlock(host);
493
494                 /* reject the command if the direction indicator
495                  * is UNKNOWN
496                  */
497                 if (chip->srb->sc_data_direction == DMA_BIDIRECTIONAL) {
498                         printk(KERN_ERR "UNKNOWN data direction\n");
499                         chip->srb->result = DID_ERROR << 16;
500                 }
501
502                 /* reject if target != 0 or if LUN is higher than
503                  * the maximum known LUN
504                  */
505                 else if (chip->srb->device->id) {
506                         printk(KERN_ERR "Bad target number (%d:%d)\n",
507                                 chip->srb->device->id,
508                                 chip->srb->device->lun);
509                         chip->srb->result = DID_BAD_TARGET << 16;
510                 }
511
512                 else if (chip->srb->device->lun > chip->max_lun) {
513                         printk(KERN_ERR "Bad LUN (%d:%d)\n",
514                                 chip->srb->device->id,
515                                 chip->srb->device->lun);
516                         chip->srb->result = DID_BAD_TARGET << 16;
517                 }
518
519                 /* we've got a command, let's do it! */
520                 else {
521                         RTSX_DEBUG(scsi_show_command(chip->srb));
522                         rtsx_invoke_transport(chip->srb, chip);
523                 }
524
525                 /* lock access to the state */
526                 scsi_lock(host);
527
528                 /* did the command already complete because of a disconnect? */
529                 if (!chip->srb)
530                         ;               /* nothing to do */
531
532                 /* indicate that the command is done */
533                 else if (chip->srb->result != DID_ABORT << 16) {
534                         chip->srb->scsi_done(chip->srb);
535                 } else {
536 SkipForAbort:
537                         printk(KERN_ERR "scsi command aborted\n");
538                 }
539
540                 if (rtsx_chk_stat(chip, RTSX_STAT_ABORT)) {
541                         complete(&(dev->notify));
542
543                         rtsx_set_stat(chip, RTSX_STAT_IDLE);
544                 }
545
546                 /* finished working on this command */
547                 chip->srb = NULL;
548                 scsi_unlock(host);
549
550                 /* unlock the device pointers */
551                 mutex_unlock(&dev->dev_mutex);
552         } /* for (;;) */
553
554         /* notify the exit routine that we're actually exiting now
555          *
556          * complete()/wait_for_completion() is similar to up()/down(),
557          * except that complete() is safe in the case where the structure
558          * is getting deleted in a parallel mode of execution (i.e. just
559          * after the down() -- that's necessary for the thread-shutdown
560          * case.
561          *
562          * complete_and_exit() goes even further than this -- it is safe in
563          * the case that the thread of the caller is going away (not just
564          * the structure) -- this is necessary for the module-remove case.
565          * This is important in preemption kernels, which transfer the flow
566          * of execution immediately upon a complete().
567          */
568         complete_and_exit(&dev->control_exit, 0);
569 }
570
571
572 static int rtsx_polling_thread(void *__dev)
573 {
574         struct rtsx_dev *dev = (struct rtsx_dev *)__dev;
575         struct rtsx_chip *chip = dev->chip;
576         struct sd_info *sd_card = &(chip->sd_card);
577         struct xd_info *xd_card = &(chip->xd_card);
578         struct ms_info *ms_card = &(chip->ms_card);
579
580         sd_card->cleanup_counter = 0;
581         xd_card->cleanup_counter = 0;
582         ms_card->cleanup_counter = 0;
583
584         /* Wait until SCSI scan finished */
585         wait_timeout((delay_use + 5) * 1000);
586
587         for (;;) {
588
589                 set_current_state(TASK_INTERRUPTIBLE);
590                 schedule_timeout(POLLING_INTERVAL);
591
592                 /* lock the device pointers */
593                 mutex_lock(&(dev->dev_mutex));
594
595                 /* if the device has disconnected, we are free to exit */
596                 if (rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT)) {
597                         printk(KERN_INFO "-- rtsx-polling exiting\n");
598                         mutex_unlock(&dev->dev_mutex);
599                         break;
600                 }
601
602                 mutex_unlock(&dev->dev_mutex);
603
604                 mspro_polling_format_status(chip);
605
606                 /* lock the device pointers */
607                 mutex_lock(&(dev->dev_mutex));
608
609                 rtsx_polling_func(chip);
610
611                 /* unlock the device pointers */
612                 mutex_unlock(&dev->dev_mutex);
613         }
614
615         complete_and_exit(&dev->polling_exit, 0);
616 }
617
618 /*
619  * interrupt handler
620  */
621 static irqreturn_t rtsx_interrupt(int irq, void *dev_id)
622 {
623         struct rtsx_dev *dev = dev_id;
624         struct rtsx_chip *chip;
625         int retval;
626         u32 status;
627
628         if (dev)
629                 chip = dev->chip;
630         else
631                 return IRQ_NONE;
632
633         if (!chip)
634                 return IRQ_NONE;
635
636         spin_lock(&dev->reg_lock);
637
638         retval = rtsx_pre_handle_interrupt(chip);
639         if (retval == STATUS_FAIL) {
640                 spin_unlock(&dev->reg_lock);
641                 if (chip->int_reg == 0xFFFFFFFF)
642                         return IRQ_HANDLED;
643                 else
644                         return IRQ_NONE;
645         }
646
647         status = chip->int_reg;
648
649         if (dev->check_card_cd) {
650                 if (!(dev->check_card_cd & status)) {
651                         /* card not exist, return TRANS_RESULT_FAIL */
652                         dev->trans_result = TRANS_RESULT_FAIL;
653                         if (dev->done)
654                                 complete(dev->done);
655                         goto Exit;
656                 }
657         }
658
659         if (status & (NEED_COMPLETE_INT | DELINK_INT)) {
660                 if (status & (TRANS_FAIL_INT | DELINK_INT)) {
661                         if (status & DELINK_INT)
662                                 RTSX_SET_DELINK(chip);
663                         dev->trans_result = TRANS_RESULT_FAIL;
664                         if (dev->done)
665                                 complete(dev->done);
666                 } else if (status & TRANS_OK_INT) {
667                         dev->trans_result = TRANS_RESULT_OK;
668                         if (dev->done)
669                                 complete(dev->done);
670                 } else if (status & DATA_DONE_INT) {
671                         dev->trans_result = TRANS_NOT_READY;
672                         if (dev->done && (dev->trans_state == STATE_TRANS_SG))
673                                 complete(dev->done);
674                 }
675         }
676
677 Exit:
678         spin_unlock(&dev->reg_lock);
679         return IRQ_HANDLED;
680 }
681
682
683 /* Release all our dynamic resources */
684 static void rtsx_release_resources(struct rtsx_dev *dev)
685 {
686         printk(KERN_INFO "-- %s\n", __func__);
687
688         /* Tell the control thread to exit.  The SCSI host must
689          * already have been removed so it won't try to queue
690          * any more commands.
691          */
692         printk(KERN_INFO "-- sending exit command to thread\n");
693         complete(&dev->cmnd_ready);
694         if (dev->ctl_thread)
695                 wait_for_completion(&dev->control_exit);
696         if (dev->polling_thread)
697                 wait_for_completion(&dev->polling_exit);
698
699         wait_timeout(200);
700
701         if (dev->rtsx_resv_buf) {
702                 dma_free_coherent(&(dev->pci->dev), RTSX_RESV_BUF_LEN,
703                                 dev->rtsx_resv_buf, dev->rtsx_resv_buf_addr);
704                 dev->chip->host_cmds_ptr = NULL;
705                 dev->chip->host_sg_tbl_ptr = NULL;
706         }
707
708         if (dev->irq > 0)
709                 free_irq(dev->irq, (void *)dev);
710         if (dev->chip->msi_en)
711                 pci_disable_msi(dev->pci);
712         if (dev->remap_addr)
713                 iounmap(dev->remap_addr);
714
715         pci_disable_device(dev->pci);
716         pci_release_regions(dev->pci);
717
718         rtsx_release_chip(dev->chip);
719         kfree(dev->chip);
720 }
721
722 /* First stage of disconnect processing: stop all commands and remove
723  * the host */
724 static void quiesce_and_remove_host(struct rtsx_dev *dev)
725 {
726         struct Scsi_Host *host = rtsx_to_host(dev);
727         struct rtsx_chip *chip = dev->chip;
728
729         /* Prevent new transfers, stop the current command, and
730          * interrupt a SCSI-scan or device-reset delay */
731         mutex_lock(&dev->dev_mutex);
732         scsi_lock(host);
733         rtsx_set_stat(chip, RTSX_STAT_DISCONNECT);
734         scsi_unlock(host);
735         mutex_unlock(&dev->dev_mutex);
736         wake_up(&dev->delay_wait);
737         wait_for_completion(&dev->scanning_done);
738
739         /* Wait some time to let other threads exist */
740         wait_timeout(100);
741
742         /* queuecommand won't accept any new commands and the control
743          * thread won't execute a previously-queued command.  If there
744          * is such a command pending, complete it with an error. */
745         mutex_lock(&dev->dev_mutex);
746         if (chip->srb) {
747                 chip->srb->result = DID_NO_CONNECT << 16;
748                 scsi_lock(host);
749                 chip->srb->scsi_done(dev->chip->srb);
750                 chip->srb = NULL;
751                 scsi_unlock(host);
752         }
753         mutex_unlock(&dev->dev_mutex);
754
755         /* Now we own no commands so it's safe to remove the SCSI host */
756         scsi_remove_host(host);
757 }
758
759 /* Second stage of disconnect processing: deallocate all resources */
760 static void release_everything(struct rtsx_dev *dev)
761 {
762         rtsx_release_resources(dev);
763
764         /* Drop our reference to the host; the SCSI core will free it
765          * when the refcount becomes 0. */
766         scsi_host_put(rtsx_to_host(dev));
767 }
768
769 /* Thread to carry out delayed SCSI-device scanning */
770 static int rtsx_scan_thread(void *__dev)
771 {
772         struct rtsx_dev *dev = (struct rtsx_dev *)__dev;
773         struct rtsx_chip *chip = dev->chip;
774
775         /* Wait for the timeout to expire or for a disconnect */
776         if (delay_use > 0) {
777                 printk(KERN_INFO "%s: waiting for device "
778                                 "to settle before scanning\n", CR_DRIVER_NAME);
779                 wait_event_interruptible_timeout(dev->delay_wait,
780                                 rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT),
781                                 delay_use * HZ);
782         }
783
784         /* If the device is still connected, perform the scanning */
785         if (!rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT)) {
786                 scsi_scan_host(rtsx_to_host(dev));
787                 printk(KERN_INFO "%s: device scan complete\n", CR_DRIVER_NAME);
788
789                 /* Should we unbind if no devices were detected? */
790         }
791
792         complete_and_exit(&dev->scanning_done, 0);
793 }
794
795 static void rtsx_init_options(struct rtsx_chip *chip)
796 {
797         chip->vendor_id = chip->rtsx->pci->vendor;
798         chip->product_id = chip->rtsx->pci->device;
799         chip->adma_mode = 1;
800         chip->lun_mc = 0;
801         chip->driver_first_load = 1;
802 #ifdef HW_AUTO_SWITCH_SD_BUS
803         chip->sdio_in_charge = 0;
804 #endif
805
806         chip->mspro_formatter_enable = 1;
807         chip->ignore_sd = 0;
808         chip->use_hw_setting = 0;
809         chip->lun_mode = DEFAULT_SINGLE;
810         chip->auto_delink_en = auto_delink_en;
811         chip->ss_en = ss_en;
812         chip->ss_idle_period = ss_interval * 1000;
813         chip->remote_wakeup_en = 0;
814         chip->aspm_l0s_l1_en = aspm_l0s_l1_en;
815         chip->dynamic_aspm = 1;
816         chip->fpga_sd_sdr104_clk = CLK_200;
817         chip->fpga_sd_ddr50_clk = CLK_100;
818         chip->fpga_sd_sdr50_clk = CLK_100;
819         chip->fpga_sd_hs_clk = CLK_100;
820         chip->fpga_mmc_52m_clk = CLK_80;
821         chip->fpga_ms_hg_clk = CLK_80;
822         chip->fpga_ms_4bit_clk = CLK_80;
823         chip->fpga_ms_1bit_clk = CLK_40;
824         chip->asic_sd_sdr104_clk = 203;
825         chip->asic_sd_sdr50_clk = 98;
826         chip->asic_sd_ddr50_clk = 98;
827         chip->asic_sd_hs_clk = 98;
828         chip->asic_mmc_52m_clk = 98;
829         chip->asic_ms_hg_clk = 117;
830         chip->asic_ms_4bit_clk = 78;
831         chip->asic_ms_1bit_clk = 39;
832         chip->ssc_depth_sd_sdr104 = SSC_DEPTH_2M;
833         chip->ssc_depth_sd_sdr50 = SSC_DEPTH_2M;
834         chip->ssc_depth_sd_ddr50 = SSC_DEPTH_1M;
835         chip->ssc_depth_sd_hs = SSC_DEPTH_1M;
836         chip->ssc_depth_mmc_52m = SSC_DEPTH_1M;
837         chip->ssc_depth_ms_hg = SSC_DEPTH_1M;
838         chip->ssc_depth_ms_4bit = SSC_DEPTH_512K;
839         chip->ssc_depth_low_speed = SSC_DEPTH_512K;
840         chip->ssc_en = 1;
841         chip->sd_speed_prior = 0x01040203;
842         chip->sd_current_prior = 0x00010203;
843         chip->sd_ctl = SD_PUSH_POINT_AUTO |
844                        SD_SAMPLE_POINT_AUTO |
845                        SUPPORT_MMC_DDR_MODE;
846         chip->sd_ddr_tx_phase = 0;
847         chip->mmc_ddr_tx_phase = 1;
848         chip->sd_default_tx_phase = 15;
849         chip->sd_default_rx_phase = 15;
850         chip->pmos_pwr_on_interval = 200;
851         chip->sd_voltage_switch_delay = 1000;
852         chip->ms_power_class_en = 3;
853
854         chip->sd_400mA_ocp_thd = 1;
855         chip->sd_800mA_ocp_thd = 5;
856         chip->ms_ocp_thd = 2;
857
858         chip->card_drive_sel = 0x55;
859         chip->sd30_drive_sel_1v8 = 0x03;
860         chip->sd30_drive_sel_3v3 = 0x01;
861
862         chip->do_delink_before_power_down = 1;
863         chip->auto_power_down = 1;
864         chip->polling_config = 0;
865
866         chip->force_clkreq_0 = 1;
867         chip->ft2_fast_mode = 0;
868
869         chip->sdio_retry_cnt = 1;
870
871         chip->xd_timeout = 2000;
872         chip->sd_timeout = 10000;
873         chip->ms_timeout = 2000;
874         chip->mspro_timeout = 15000;
875
876         chip->power_down_in_ss = 1;
877
878         chip->sdr104_en = 1;
879         chip->sdr50_en = 1;
880         chip->ddr50_en = 1;
881
882         chip->delink_stage1_step = 100;
883         chip->delink_stage2_step = 40;
884         chip->delink_stage3_step = 20;
885
886         chip->auto_delink_in_L1 = 1;
887         chip->blink_led = 1;
888         chip->msi_en = msi_en;
889         chip->hp_watch_bios_hotplug = 0;
890         chip->max_payload = 0;
891         chip->phy_voltage = 0;
892
893         chip->support_ms_8bit = 1;
894         chip->s3_pwr_off_delay = 1000;
895 }
896
897 static int __devinit rtsx_probe(struct pci_dev *pci,
898                                 const struct pci_device_id *pci_id)
899 {
900         struct Scsi_Host *host;
901         struct rtsx_dev *dev;
902         int err = 0;
903         struct task_struct *th;
904
905         RTSX_DEBUGP("Realtek PCI-E card reader detected\n");
906
907         err = pci_enable_device(pci);
908         if (err < 0) {
909                 printk(KERN_ERR "PCI enable device failed!\n");
910                 return err;
911         }
912
913         err = pci_request_regions(pci, CR_DRIVER_NAME);
914         if (err < 0) {
915                 printk(KERN_ERR "PCI request regions for %s failed!\n",
916                        CR_DRIVER_NAME);
917                 pci_disable_device(pci);
918                 return err;
919         }
920
921         /*
922          * Ask the SCSI layer to allocate a host structure, with extra
923          * space at the end for our private rtsx_dev structure.
924          */
925         host = scsi_host_alloc(&rtsx_host_template, sizeof(*dev));
926         if (!host) {
927                 printk(KERN_ERR "Unable to allocate the scsi host\n");
928                 pci_release_regions(pci);
929                 pci_disable_device(pci);
930                 return -ENOMEM;
931         }
932
933         dev = host_to_rtsx(host);
934         memset(dev, 0, sizeof(struct rtsx_dev));
935
936         dev->chip = kzalloc(sizeof(struct rtsx_chip), GFP_KERNEL);
937         if (dev->chip == NULL)
938                 goto errout;
939
940         spin_lock_init(&dev->reg_lock);
941         mutex_init(&(dev->dev_mutex));
942         init_completion(&dev->cmnd_ready);
943         init_completion(&dev->control_exit);
944         init_completion(&dev->polling_exit);
945         init_completion(&(dev->notify));
946         init_completion(&dev->scanning_done);
947         init_waitqueue_head(&dev->delay_wait);
948
949         dev->pci = pci;
950         dev->irq = -1;
951
952         printk(KERN_INFO "Resource length: 0x%x\n",
953                (unsigned int)pci_resource_len(pci, 0));
954         dev->addr = pci_resource_start(pci, 0);
955         dev->remap_addr = ioremap_nocache(dev->addr, pci_resource_len(pci, 0));
956         if (dev->remap_addr == NULL) {
957                 printk(KERN_ERR "ioremap error\n");
958                 err = -ENXIO;
959                 goto errout;
960         }
961
962         /*
963          * Using "unsigned long" cast here to eliminate gcc warning in
964          * 64-bit system
965          */
966         printk(KERN_INFO "Original address: 0x%lx, remapped address: 0x%lx\n",
967                (unsigned long)(dev->addr), (unsigned long)(dev->remap_addr));
968
969         dev->rtsx_resv_buf = dma_alloc_coherent(&(pci->dev), RTSX_RESV_BUF_LEN,
970                         &(dev->rtsx_resv_buf_addr), GFP_KERNEL);
971         if (dev->rtsx_resv_buf == NULL) {
972                 printk(KERN_ERR "alloc dma buffer fail\n");
973                 err = -ENXIO;
974                 goto errout;
975         }
976         dev->chip->host_cmds_ptr = dev->rtsx_resv_buf;
977         dev->chip->host_cmds_addr = dev->rtsx_resv_buf_addr;
978         dev->chip->host_sg_tbl_ptr = dev->rtsx_resv_buf + HOST_CMDS_BUF_LEN;
979         dev->chip->host_sg_tbl_addr = dev->rtsx_resv_buf_addr +
980                                       HOST_CMDS_BUF_LEN;
981
982         dev->chip->rtsx = dev;
983
984         rtsx_init_options(dev->chip);
985
986         printk(KERN_INFO "pci->irq = %d\n", pci->irq);
987
988         if (dev->chip->msi_en) {
989                 if (pci_enable_msi(pci) < 0)
990                         dev->chip->msi_en = 0;
991         }
992
993         if (rtsx_acquire_irq(dev) < 0) {
994                 err = -EBUSY;
995                 goto errout;
996         }
997
998         pci_set_master(pci);
999         synchronize_irq(dev->irq);
1000
1001         rtsx_init_chip(dev->chip);
1002
1003         /* Start up our control thread */
1004         th = kthread_run(rtsx_control_thread, dev, CR_DRIVER_NAME);
1005         if (IS_ERR(th)) {
1006                 printk(KERN_ERR "Unable to start control thread\n");
1007                 err = PTR_ERR(th);
1008                 goto errout;
1009         }
1010         dev->ctl_thread = th;
1011
1012         err = scsi_add_host(host, &pci->dev);
1013         if (err) {
1014                 printk(KERN_ERR "Unable to add the scsi host\n");
1015                 goto errout;
1016         }
1017
1018         /* Start up the thread for delayed SCSI-device scanning */
1019         th = kthread_create(rtsx_scan_thread, dev, "rtsx-scan");
1020         if (IS_ERR(th)) {
1021                 printk(KERN_ERR "Unable to start the device-scanning thread\n");
1022                 complete(&dev->scanning_done);
1023                 quiesce_and_remove_host(dev);
1024                 err = PTR_ERR(th);
1025                 goto errout;
1026         }
1027
1028         wake_up_process(th);
1029
1030         /* Start up the thread for polling thread */
1031         th = kthread_run(rtsx_polling_thread, dev, "rtsx-polling");
1032         if (IS_ERR(th)) {
1033                 printk(KERN_ERR "Unable to start the device-polling thread\n");
1034                 quiesce_and_remove_host(dev);
1035                 err = PTR_ERR(th);
1036                 goto errout;
1037         }
1038         dev->polling_thread = th;
1039
1040         pci_set_drvdata(pci, dev);
1041
1042         return 0;
1043
1044         /* We come here if there are any problems */
1045 errout:
1046         printk(KERN_ERR "rtsx_probe() failed\n");
1047         release_everything(dev);
1048
1049         return err;
1050 }
1051
1052
1053 static void __devexit rtsx_remove(struct pci_dev *pci)
1054 {
1055         struct rtsx_dev *dev = (struct rtsx_dev *)pci_get_drvdata(pci);
1056
1057         printk(KERN_INFO "rtsx_remove() called\n");
1058
1059         quiesce_and_remove_host(dev);
1060         release_everything(dev);
1061
1062         pci_set_drvdata(pci, NULL);
1063 }
1064
1065 /* PCI IDs */
1066 static DEFINE_PCI_DEVICE_TABLE(rtsx_ids) = {
1067         { PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x5208), PCI_CLASS_OTHERS << 16, 0xFF0000 },
1068         { PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x5209), PCI_CLASS_OTHERS << 16, 0xFF0000 },
1069         { PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x5288), PCI_CLASS_OTHERS << 16, 0xFF0000 },
1070         { 0, },
1071 };
1072
1073 MODULE_DEVICE_TABLE(pci, rtsx_ids);
1074
1075 /* pci_driver definition */
1076 static struct pci_driver driver = {
1077         .name = CR_DRIVER_NAME,
1078         .id_table = rtsx_ids,
1079         .probe = rtsx_probe,
1080         .remove = __devexit_p(rtsx_remove),
1081 #ifdef CONFIG_PM
1082         .suspend = rtsx_suspend,
1083         .resume = rtsx_resume,
1084 #endif
1085         .shutdown = rtsx_shutdown,
1086 };
1087
1088 static int __init rtsx_init(void)
1089 {
1090         printk(KERN_INFO "Initializing Realtek PCIE storage driver...\n");
1091
1092         return pci_register_driver(&driver);
1093 }
1094
1095 static void __exit rtsx_exit(void)
1096 {
1097         printk(KERN_INFO "rtsx_exit() called\n");
1098
1099         pci_unregister_driver(&driver);
1100
1101         printk(KERN_INFO "%s module exit\n", CR_DRIVER_NAME);
1102 }
1103
1104 module_init(rtsx_init)
1105 module_exit(rtsx_exit)
1106