1 /* Driver for Realtek RTS51xx USB card reader
3 * Copyright(c) 2009 Realtek Semiconductor Corp. All rights reserved.
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
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.
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/>.
19 * wwang (wei_wang@realsil.com.cn)
20 * No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
23 #include <linux/module.h>
24 #include <linux/blkdev.h>
25 #include <linux/kthread.h>
26 #include <linux/sched.h>
27 #include <linux/kernel.h>
29 #include <scsi/scsi.h>
30 #include <scsi/scsi_cmnd.h>
31 #include <scsi/scsi_device.h>
32 #include <linux/cdrom.h>
34 #include <linux/usb.h>
35 #include <linux/slab.h>
36 #include <linux/usb_usual.h>
39 #include "transport.h"
43 MODULE_DESCRIPTION("Driver for Realtek USB Card Reader");
44 MODULE_AUTHOR("wwang <wei_wang@realsil.com.cn>");
45 MODULE_LICENSE("GPL");
46 MODULE_VERSION("1.03");
48 static int auto_delink_en
= 1;
49 module_param(auto_delink_en
, int, S_IRUGO
| S_IWUSR
);
50 MODULE_PARM_DESC(auto_delink_en
, "enable auto delink");
52 #ifdef CONFIG_REALTEK_AUTOPM
54 module_param(ss_en
, int, S_IRUGO
| S_IWUSR
);
55 MODULE_PARM_DESC(ss_en
, "enable selective suspend");
57 static int ss_delay
= 50;
58 module_param(ss_delay
, int, S_IRUGO
| S_IWUSR
);
59 MODULE_PARM_DESC(ss_delay
,
60 "seconds to delay before entering selective suspend");
69 #define POLLING_INTERVAL 50
71 #define rts51x_set_stat(chip, stat) \
72 ((chip)->state = (enum RTS51X_STAT)(stat))
73 #define rts51x_get_stat(chip) ((chip)->state)
75 #define SET_LUN_READY(chip, lun) ((chip)->lun_ready |= ((u8)1 << (lun)))
76 #define CLR_LUN_READY(chip, lun) ((chip)->lun_ready &= ~((u8)1 << (lun)))
77 #define TST_LUN_READY(chip, lun) ((chip)->lun_ready & ((u8)1 << (lun)))
81 struct rts51x_status
{
104 struct rts51x_status
*status
;
110 #ifdef CONFIG_REALTEK_AUTOPM
111 struct timer_list rts51x_suspend_timer
;
112 unsigned long timer_expires
;
115 enum RTS51X_STAT state
;
116 int support_auto_delink
;
118 /* used to back up the protocal choosen in probe1 phase */
119 proto_cmnd proto_handler_backup
;
122 /* flag definition */
123 #define FLIDX_AUTO_DELINK 0x01
125 #define SCSI_LUN(srb) ((srb)->device->lun)
128 #define SET_BIT(data, idx) ((data) |= 1 << (idx))
129 #define CLR_BIT(data, idx) ((data) &= ~(1 << (idx)))
130 #define CHK_BIT(data, idx) ((data) & (1 << (idx)))
132 #define SET_AUTO_DELINK(chip) ((chip)->flag |= FLIDX_AUTO_DELINK)
133 #define CLR_AUTO_DELINK(chip) ((chip)->flag &= ~FLIDX_AUTO_DELINK)
134 #define CHK_AUTO_DELINK(chip) ((chip)->flag & FLIDX_AUTO_DELINK)
136 #define RTS51X_GET_VID(chip) ((chip)->vendor_id)
137 #define RTS51X_GET_PID(chip) ((chip)->product_id)
139 #define VENDOR_ID(chip) ((chip)->status[0].vid)
140 #define PRODUCT_ID(chip) ((chip)->status[0].pid)
141 #define FW_VERSION(chip) ((chip)->status[0].fw_ver)
142 #define STATUS_LEN(chip) ((chip)->status_len)
144 #define STATUS_SUCCESS 0
145 #define STATUS_FAIL 1
147 /* Check card reader function */
148 #define SUPPORT_DETAILED_TYPE1(chip) \
149 CHK_BIT((chip)->status[0].function[0], 1)
150 #define SUPPORT_OT(chip) \
151 CHK_BIT((chip)->status[0].function[0], 2)
152 #define SUPPORT_OC(chip) \
153 CHK_BIT((chip)->status[0].function[0], 3)
154 #define SUPPORT_AUTO_DELINK(chip) \
155 CHK_BIT((chip)->status[0].function[0], 4)
156 #define SUPPORT_SDIO(chip) \
157 CHK_BIT((chip)->status[0].function[1], 0)
158 #define SUPPORT_DETAILED_TYPE2(chip) \
159 CHK_BIT((chip)->status[0].function[1], 1)
161 #define CHECK_PID(chip, pid) (RTS51X_GET_PID(chip) == (pid))
162 #define CHECK_FW_VER(chip, fw_ver) (FW_VERSION(chip) == (fw_ver))
163 #define CHECK_ID(chip, pid, fw_ver) \
164 (CHECK_PID((chip), (pid)) && CHECK_FW_VER((chip), (fw_ver)))
166 static int init_realtek_cr(struct us_data
*us
);
169 * The table of devices
171 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
172 vendorName, productName, useProtocol, useTransport, \
173 initFunction, flags) \
175 USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
176 .driver_info = (flags) \
179 static const struct usb_device_id realtek_cr_ids
[] = {
180 # include "unusual_realtek.h"
181 {} /* Terminating entry */
184 MODULE_DEVICE_TABLE(usb
, realtek_cr_ids
);
191 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
192 vendor_name, product_name, use_protocol, use_transport, \
193 init_function, Flags) \
195 .vendorName = vendor_name, \
196 .productName = product_name, \
197 .useProtocol = use_protocol, \
198 .useTransport = use_transport, \
199 .initFunction = init_function, \
202 static struct us_unusual_dev realtek_cr_unusual_dev_list
[] = {
203 # include "unusual_realtek.h"
204 {} /* Terminating entry */
209 static int rts51x_bulk_transport(struct us_data
*us
, u8 lun
,
210 u8
*cmd
, int cmd_len
, u8
*buf
, int buf_len
,
211 enum dma_data_direction dir
, int *act_len
)
213 struct bulk_cb_wrap
*bcb
= (struct bulk_cb_wrap
*)us
->iobuf
;
214 struct bulk_cs_wrap
*bcs
= (struct bulk_cs_wrap
*)us
->iobuf
;
216 unsigned int residue
;
218 unsigned int cbwlen
= US_BULK_CB_WRAP_LEN
;
220 /* set up the command wrapper */
221 bcb
->Signature
= cpu_to_le32(US_BULK_CB_SIGN
);
222 bcb
->DataTransferLength
= cpu_to_le32(buf_len
);
223 bcb
->Flags
= (dir
== DMA_FROM_DEVICE
) ? US_BULK_FLAG_IN
: 0;
224 bcb
->Tag
= ++us
->tag
;
226 bcb
->Length
= cmd_len
;
228 /* copy the command payload */
229 memset(bcb
->CDB
, 0, sizeof(bcb
->CDB
));
230 memcpy(bcb
->CDB
, cmd
, bcb
->Length
);
232 /* send it to out endpoint */
233 result
= usb_stor_bulk_transfer_buf(us
, us
->send_bulk_pipe
,
235 if (result
!= USB_STOR_XFER_GOOD
)
236 return USB_STOR_TRANSPORT_ERROR
;
239 /* send/receive data payload, if there is any */
241 if (buf
&& buf_len
) {
242 unsigned int pipe
= (dir
== DMA_FROM_DEVICE
) ?
243 us
->recv_bulk_pipe
: us
->send_bulk_pipe
;
244 result
= usb_stor_bulk_transfer_buf(us
, pipe
,
246 if (result
== USB_STOR_XFER_ERROR
)
247 return USB_STOR_TRANSPORT_ERROR
;
250 /* get CSW for device status */
251 result
= usb_stor_bulk_transfer_buf(us
, us
->recv_bulk_pipe
,
252 bcs
, US_BULK_CS_WRAP_LEN
, &cswlen
);
253 if (result
!= USB_STOR_XFER_GOOD
)
254 return USB_STOR_TRANSPORT_ERROR
;
256 /* check bulk status */
257 if (bcs
->Signature
!= cpu_to_le32(US_BULK_CS_SIGN
)) {
258 usb_stor_dbg(us
, "Signature mismatch: got %08X, expecting %08X\n",
259 le32_to_cpu(bcs
->Signature
), US_BULK_CS_SIGN
);
260 return USB_STOR_TRANSPORT_ERROR
;
263 residue
= bcs
->Residue
;
264 if (bcs
->Tag
!= us
->tag
)
265 return USB_STOR_TRANSPORT_ERROR
;
267 /* try to compute the actual residue, based on how much data
268 * was really transferred and what the device tells us */
270 residue
= residue
< buf_len
? residue
: buf_len
;
273 *act_len
= buf_len
- residue
;
275 /* based on the status code, we report good or bad */
276 switch (bcs
->Status
) {
277 case US_BULK_STAT_OK
:
278 /* command good -- note that data could be short */
279 return USB_STOR_TRANSPORT_GOOD
;
281 case US_BULK_STAT_FAIL
:
283 return USB_STOR_TRANSPORT_FAILED
;
285 case US_BULK_STAT_PHASE
:
286 /* phase error -- note that a transport reset will be
287 * invoked by the invoke_transport() function
289 return USB_STOR_TRANSPORT_ERROR
;
292 /* we should never get here, but if we do, we're in trouble */
293 return USB_STOR_TRANSPORT_ERROR
;
296 static int rts51x_bulk_transport_special(struct us_data
*us
, u8 lun
,
297 u8
*cmd
, int cmd_len
, u8
*buf
, int buf_len
,
298 enum dma_data_direction dir
, int *act_len
)
300 struct bulk_cb_wrap
*bcb
= (struct bulk_cb_wrap
*) us
->iobuf
;
301 struct bulk_cs_wrap
*bcs
= (struct bulk_cs_wrap
*) us
->iobuf
;
304 unsigned int cbwlen
= US_BULK_CB_WRAP_LEN
;
306 /* set up the command wrapper */
307 bcb
->Signature
= cpu_to_le32(US_BULK_CB_SIGN
);
308 bcb
->DataTransferLength
= cpu_to_le32(buf_len
);
309 bcb
->Flags
= (dir
== DMA_FROM_DEVICE
) ? US_BULK_FLAG_IN
: 0;
310 bcb
->Tag
= ++us
->tag
;
312 bcb
->Length
= cmd_len
;
314 /* copy the command payload */
315 memset(bcb
->CDB
, 0, sizeof(bcb
->CDB
));
316 memcpy(bcb
->CDB
, cmd
, bcb
->Length
);
318 /* send it to out endpoint */
319 result
= usb_stor_bulk_transfer_buf(us
, us
->send_bulk_pipe
,
321 if (result
!= USB_STOR_XFER_GOOD
)
322 return USB_STOR_TRANSPORT_ERROR
;
325 /* send/receive data payload, if there is any */
327 if (buf
&& buf_len
) {
328 unsigned int pipe
= (dir
== DMA_FROM_DEVICE
) ?
329 us
->recv_bulk_pipe
: us
->send_bulk_pipe
;
330 result
= usb_stor_bulk_transfer_buf(us
, pipe
,
332 if (result
== USB_STOR_XFER_ERROR
)
333 return USB_STOR_TRANSPORT_ERROR
;
336 /* get CSW for device status */
337 result
= usb_bulk_msg(us
->pusb_dev
, us
->recv_bulk_pipe
, bcs
,
338 US_BULK_CS_WRAP_LEN
, &cswlen
, 250);
342 /* Determine what the maximum LUN supported is */
343 static int rts51x_get_max_lun(struct us_data
*us
)
347 /* issue the command */
349 result
= usb_stor_control_msg(us
, us
->recv_ctrl_pipe
,
351 USB_DIR_IN
| USB_TYPE_CLASS
|
353 0, us
->ifnum
, us
->iobuf
, 1, 10 * HZ
);
355 usb_stor_dbg(us
, "GetMaxLUN command result is %d, data is %d\n",
356 result
, us
->iobuf
[0]);
358 /* if we have a successful request, return the result */
365 static int rts51x_read_mem(struct us_data
*us
, u16 addr
, u8
*data
, u16 len
)
371 buf
= kmalloc(len
, GFP_NOIO
);
373 return USB_STOR_TRANSPORT_ERROR
;
375 usb_stor_dbg(us
, "addr = 0x%x, len = %d\n", addr
, len
);
379 cmnd
[2] = (u8
) (addr
>> 8);
381 cmnd
[4] = (u8
) (len
>> 8);
384 retval
= rts51x_bulk_transport(us
, 0, cmnd
, 12,
385 buf
, len
, DMA_FROM_DEVICE
, NULL
);
386 if (retval
!= USB_STOR_TRANSPORT_GOOD
) {
391 memcpy(data
, buf
, len
);
396 static int rts51x_write_mem(struct us_data
*us
, u16 addr
, u8
*data
, u16 len
)
402 buf
= kmemdup(data
, len
, GFP_NOIO
);
404 return USB_STOR_TRANSPORT_ERROR
;
406 usb_stor_dbg(us
, "addr = 0x%x, len = %d\n", addr
, len
);
410 cmnd
[2] = (u8
) (addr
>> 8);
412 cmnd
[4] = (u8
) (len
>> 8);
415 retval
= rts51x_bulk_transport(us
, 0, cmnd
, 12,
416 buf
, len
, DMA_TO_DEVICE
, NULL
);
418 if (retval
!= USB_STOR_TRANSPORT_GOOD
)
424 static int rts51x_read_status(struct us_data
*us
,
425 u8 lun
, u8
*status
, int len
, int *actlen
)
431 buf
= kmalloc(len
, GFP_NOIO
);
433 return USB_STOR_TRANSPORT_ERROR
;
435 usb_stor_dbg(us
, "lun = %d\n", lun
);
440 retval
= rts51x_bulk_transport(us
, lun
, cmnd
, 12,
441 buf
, len
, DMA_FROM_DEVICE
, actlen
);
442 if (retval
!= USB_STOR_TRANSPORT_GOOD
) {
447 memcpy(status
, buf
, len
);
452 static int rts51x_check_status(struct us_data
*us
, u8 lun
)
454 struct rts51x_chip
*chip
= (struct rts51x_chip
*)(us
->extra
);
458 retval
= rts51x_read_status(us
, lun
, buf
, 16, &(chip
->status_len
));
459 if (retval
!= STATUS_SUCCESS
)
462 usb_stor_dbg(us
, "chip->status_len = %d\n", chip
->status_len
);
464 chip
->status
[lun
].vid
= ((u16
) buf
[0] << 8) | buf
[1];
465 chip
->status
[lun
].pid
= ((u16
) buf
[2] << 8) | buf
[3];
466 chip
->status
[lun
].cur_lun
= buf
[4];
467 chip
->status
[lun
].card_type
= buf
[5];
468 chip
->status
[lun
].total_lun
= buf
[6];
469 chip
->status
[lun
].fw_ver
= ((u16
) buf
[7] << 8) | buf
[8];
470 chip
->status
[lun
].phy_exist
= buf
[9];
471 chip
->status
[lun
].multi_flag
= buf
[10];
472 chip
->status
[lun
].multi_card
= buf
[11];
473 chip
->status
[lun
].log_exist
= buf
[12];
474 if (chip
->status_len
== 16) {
475 chip
->status
[lun
].detailed_type
.detailed_type1
= buf
[13];
476 chip
->status
[lun
].function
[0] = buf
[14];
477 chip
->status
[lun
].function
[1] = buf
[15];
483 static int enable_oscillator(struct us_data
*us
)
488 retval
= rts51x_read_mem(us
, 0xFE77, &value
, 1);
493 retval
= rts51x_write_mem(us
, 0xFE77, &value
, 1);
497 retval
= rts51x_read_mem(us
, 0xFE77, &value
, 1);
507 static int __do_config_autodelink(struct us_data
*us
, u8
*data
, u16 len
)
513 usb_stor_dbg(us
, "addr = 0xfe47, len = %d\n", len
);
515 buf
= kmemdup(data
, len
, GFP_NOIO
);
517 return USB_STOR_TRANSPORT_ERROR
;
523 cmnd
[4] = (u8
)(len
>> 8);
526 retval
= rts51x_bulk_transport_special(us
, 0, cmnd
, 12, buf
, len
, DMA_TO_DEVICE
, NULL
);
528 if (retval
!= USB_STOR_TRANSPORT_GOOD
) {
535 static int do_config_autodelink(struct us_data
*us
, int enable
, int force
)
540 retval
= rts51x_read_mem(us
, 0xFE47, &value
, 1);
553 usb_stor_dbg(us
, "set 0xfe47 to 0x%x\n", value
);
555 /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */
556 retval
= __do_config_autodelink(us
, &value
, 1);
563 static int config_autodelink_after_power_on(struct us_data
*us
)
565 struct rts51x_chip
*chip
= (struct rts51x_chip
*)(us
->extra
);
569 if (!CHK_AUTO_DELINK(chip
))
572 retval
= rts51x_read_mem(us
, 0xFE47, &value
, 1);
576 if (auto_delink_en
) {
581 if (CHECK_ID(chip
, 0x0138, 0x3882))
586 /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */
587 retval
= __do_config_autodelink(us
, &value
, 1);
591 retval
= enable_oscillator(us
);
593 (void)do_config_autodelink(us
, 1, 0);
595 /* Autodelink controlled by firmware */
599 if (CHECK_ID(chip
, 0x0138, 0x3882))
602 if (CHECK_ID(chip
, 0x0159, 0x5889) ||
603 CHECK_ID(chip
, 0x0138, 0x3880)) {
608 /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */
609 retval
= __do_config_autodelink(us
, &value
, 1);
613 if (CHECK_ID(chip
, 0x0159, 0x5888)) {
615 retval
= rts51x_write_mem(us
, 0xFE79, &value
, 1);
620 retval
= rts51x_write_mem(us
, 0x48, &value
, 1);
629 static int config_autodelink_before_power_down(struct us_data
*us
)
631 struct rts51x_chip
*chip
= (struct rts51x_chip
*)(us
->extra
);
635 if (!CHK_AUTO_DELINK(chip
))
638 if (auto_delink_en
) {
639 retval
= rts51x_read_mem(us
, 0xFE77, &value
, 1);
644 retval
= rts51x_write_mem(us
, 0xFE77, &value
, 1);
648 if (CHECK_ID(chip
, 0x0159, 0x5888)) {
650 retval
= rts51x_write_mem(us
, 0x48, &value
, 1);
655 retval
= rts51x_read_mem(us
, 0xFE47, &value
, 1);
660 if (CHECK_ID(chip
, 0x0138, 0x3882))
662 retval
= rts51x_write_mem(us
, 0xFE77, &value
, 1);
666 if (CHECK_ID(chip
, 0x0159, 0x5889) ||
667 CHECK_ID(chip
, 0x0138, 0x3880) ||
668 CHECK_ID(chip
, 0x0138, 0x3882)) {
669 retval
= rts51x_read_mem(us
, 0xFE47, &value
, 1);
673 if (CHECK_ID(chip
, 0x0159, 0x5889) ||
674 CHECK_ID(chip
, 0x0138, 0x3880)) {
679 if (CHECK_ID(chip
, 0x0138, 0x3882))
682 /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */
683 retval
= __do_config_autodelink(us
, &value
, 1);
688 if (CHECK_ID(chip
, 0x0159, 0x5888)) {
690 retval
= rts51x_write_mem(us
, 0x48, &value
, 1);
699 static void fw5895_init(struct us_data
*us
)
701 struct rts51x_chip
*chip
= (struct rts51x_chip
*)(us
->extra
);
705 if ((PRODUCT_ID(chip
) != 0x0158) || (FW_VERSION(chip
) != 0x5895)) {
706 usb_stor_dbg(us
, "Not the specified device, return immediately!\n");
708 retval
= rts51x_read_mem(us
, 0xFD6F, &val
, 1);
709 if (retval
== STATUS_SUCCESS
&& (val
& 0x1F) == 0) {
711 retval
= rts51x_write_mem(us
, 0xFD70, &val
, 1);
712 if (retval
!= STATUS_SUCCESS
)
713 usb_stor_dbg(us
, "Write memory fail\n");
715 usb_stor_dbg(us
, "Read memory fail, OR (val & 0x1F) != 0\n");
720 #ifdef CONFIG_REALTEK_AUTOPM
721 static void fw5895_set_mmc_wp(struct us_data
*us
)
723 struct rts51x_chip
*chip
= (struct rts51x_chip
*)(us
->extra
);
727 if ((PRODUCT_ID(chip
) != 0x0158) || (FW_VERSION(chip
) != 0x5895)) {
728 usb_stor_dbg(us
, "Not the specified device, return immediately!\n");
730 retval
= rts51x_read_mem(us
, 0xFD6F, buf
, 1);
731 if (retval
== STATUS_SUCCESS
&& (buf
[0] & 0x24) == 0x24) {
732 /* SD Exist and SD WP */
733 retval
= rts51x_read_mem(us
, 0xD04E, buf
, 1);
734 if (retval
== STATUS_SUCCESS
) {
736 retval
= rts51x_write_mem(us
, 0xFD70, buf
, 1);
737 if (retval
!= STATUS_SUCCESS
)
738 usb_stor_dbg(us
, "Write memory fail\n");
740 usb_stor_dbg(us
, "Read memory fail\n");
743 usb_stor_dbg(us
, "Read memory fail, OR (buf[0]&0x24)!=0x24\n");
748 static void rts51x_modi_suspend_timer(struct rts51x_chip
*chip
)
750 struct us_data
*us
= chip
->us
;
752 usb_stor_dbg(us
, "state:%d\n", rts51x_get_stat(chip
));
754 chip
->timer_expires
= jiffies
+ msecs_to_jiffies(1000*ss_delay
);
755 mod_timer(&chip
->rts51x_suspend_timer
, chip
->timer_expires
);
758 static void rts51x_suspend_timer_fn(unsigned long data
)
760 struct rts51x_chip
*chip
= (struct rts51x_chip
*)data
;
761 struct us_data
*us
= chip
->us
;
763 switch (rts51x_get_stat(chip
)) {
764 case RTS51X_STAT_INIT
:
765 case RTS51X_STAT_RUN
:
766 rts51x_modi_suspend_timer(chip
);
768 case RTS51X_STAT_IDLE
:
770 usb_stor_dbg(us
, "RTS51X_STAT_SS, intf->pm_usage_cnt:%d, power.usage:%d\n",
771 atomic_read(&us
->pusb_intf
->pm_usage_cnt
),
772 atomic_read(&us
->pusb_intf
->dev
.power
.usage_count
));
774 if (atomic_read(&us
->pusb_intf
->pm_usage_cnt
) > 0) {
775 usb_stor_dbg(us
, "Ready to enter SS state\n");
776 rts51x_set_stat(chip
, RTS51X_STAT_SS
);
777 /* ignore mass storage interface's children */
778 pm_suspend_ignore_children(&us
->pusb_intf
->dev
, true);
779 usb_autopm_put_interface_async(us
->pusb_intf
);
780 usb_stor_dbg(us
, "RTS51X_STAT_SS 01, intf->pm_usage_cnt:%d, power.usage:%d\n",
781 atomic_read(&us
->pusb_intf
->pm_usage_cnt
),
782 atomic_read(&us
->pusb_intf
->dev
.power
.usage_count
));
786 usb_stor_dbg(us
, "Unknown state !!!\n");
791 static inline int working_scsi(struct scsi_cmnd
*srb
)
793 if ((srb
->cmnd
[0] == TEST_UNIT_READY
) ||
794 (srb
->cmnd
[0] == ALLOW_MEDIUM_REMOVAL
)) {
801 static void rts51x_invoke_transport(struct scsi_cmnd
*srb
, struct us_data
*us
)
803 struct rts51x_chip
*chip
= (struct rts51x_chip
*)(us
->extra
);
804 static int card_first_show
= 1;
805 static u8 media_not_present
[] = { 0x70, 0, 0x02, 0, 0, 0, 0,
806 10, 0, 0, 0, 0, 0x3A, 0, 0, 0, 0, 0
808 static u8 invalid_cmd_field
[] = { 0x70, 0, 0x05, 0, 0, 0, 0,
809 10, 0, 0, 0, 0, 0x24, 0, 0, 0, 0, 0
813 if (working_scsi(srb
)) {
814 usb_stor_dbg(us
, "working scsi, intf->pm_usage_cnt:%d, power.usage:%d\n",
815 atomic_read(&us
->pusb_intf
->pm_usage_cnt
),
816 atomic_read(&us
->pusb_intf
->dev
.power
.usage_count
));
818 if (atomic_read(&us
->pusb_intf
->pm_usage_cnt
) <= 0) {
819 ret
= usb_autopm_get_interface(us
->pusb_intf
);
820 usb_stor_dbg(us
, "working scsi, ret=%d\n", ret
);
822 if (rts51x_get_stat(chip
) != RTS51X_STAT_RUN
)
823 rts51x_set_stat(chip
, RTS51X_STAT_RUN
);
824 chip
->proto_handler_backup(srb
, us
);
826 if (rts51x_get_stat(chip
) == RTS51X_STAT_SS
) {
827 usb_stor_dbg(us
, "NOT working scsi\n");
828 if ((srb
->cmnd
[0] == TEST_UNIT_READY
) &&
829 (chip
->pwr_state
== US_SUSPEND
)) {
830 if (TST_LUN_READY(chip
, srb
->device
->lun
)) {
831 srb
->result
= SAM_STAT_GOOD
;
833 srb
->result
= SAM_STAT_CHECK_CONDITION
;
834 memcpy(srb
->sense_buffer
,
838 usb_stor_dbg(us
, "TEST_UNIT_READY\n");
841 if (srb
->cmnd
[0] == ALLOW_MEDIUM_REMOVAL
) {
842 int prevent
= srb
->cmnd
[4] & 0x1;
844 srb
->result
= SAM_STAT_CHECK_CONDITION
;
845 memcpy(srb
->sense_buffer
,
849 srb
->result
= SAM_STAT_GOOD
;
851 usb_stor_dbg(us
, "ALLOW_MEDIUM_REMOVAL\n");
855 usb_stor_dbg(us
, "NOT working scsi, not SS\n");
856 chip
->proto_handler_backup(srb
, us
);
857 /* Check whether card is plugged in */
858 if (srb
->cmnd
[0] == TEST_UNIT_READY
) {
859 if (srb
->result
== SAM_STAT_GOOD
) {
860 SET_LUN_READY(chip
, srb
->device
->lun
);
861 if (card_first_show
) {
863 fw5895_set_mmc_wp(us
);
866 CLR_LUN_READY(chip
, srb
->device
->lun
);
870 if (rts51x_get_stat(chip
) != RTS51X_STAT_IDLE
)
871 rts51x_set_stat(chip
, RTS51X_STAT_IDLE
);
875 usb_stor_dbg(us
, "state:%d\n", rts51x_get_stat(chip
));
876 if (rts51x_get_stat(chip
) == RTS51X_STAT_RUN
)
877 rts51x_modi_suspend_timer(chip
);
880 static int realtek_cr_autosuspend_setup(struct us_data
*us
)
882 struct rts51x_chip
*chip
;
883 struct rts51x_status
*status
= NULL
;
887 chip
= (struct rts51x_chip
*)us
->extra
;
888 chip
->support_auto_delink
= 0;
889 chip
->pwr_state
= US_RESUME
;
891 rts51x_set_stat(chip
, RTS51X_STAT_INIT
);
893 retval
= rts51x_read_status(us
, 0, buf
, 16, &(chip
->status_len
));
894 if (retval
!= STATUS_SUCCESS
) {
895 usb_stor_dbg(us
, "Read status fail\n");
898 status
= chip
->status
;
899 status
->vid
= ((u16
) buf
[0] << 8) | buf
[1];
900 status
->pid
= ((u16
) buf
[2] << 8) | buf
[3];
901 status
->cur_lun
= buf
[4];
902 status
->card_type
= buf
[5];
903 status
->total_lun
= buf
[6];
904 status
->fw_ver
= ((u16
) buf
[7] << 8) | buf
[8];
905 status
->phy_exist
= buf
[9];
906 status
->multi_flag
= buf
[10];
907 status
->multi_card
= buf
[11];
908 status
->log_exist
= buf
[12];
909 if (chip
->status_len
== 16) {
910 status
->detailed_type
.detailed_type1
= buf
[13];
911 status
->function
[0] = buf
[14];
912 status
->function
[1] = buf
[15];
915 /* back up the proto_handler in us->extra */
916 chip
= (struct rts51x_chip
*)(us
->extra
);
917 chip
->proto_handler_backup
= us
->proto_handler
;
918 /* Set the autosuspend_delay to 0 */
919 pm_runtime_set_autosuspend_delay(&us
->pusb_dev
->dev
, 0);
920 /* override us->proto_handler setted in get_protocol() */
921 us
->proto_handler
= rts51x_invoke_transport
;
923 chip
->timer_expires
= 0;
924 setup_timer(&chip
->rts51x_suspend_timer
, rts51x_suspend_timer_fn
,
925 (unsigned long)chip
);
928 /* enable autosuspend funciton of the usb device */
929 usb_enable_autosuspend(us
->pusb_dev
);
935 static void realtek_cr_destructor(void *extra
)
937 struct rts51x_chip
*chip
= extra
;
942 #ifdef CONFIG_REALTEK_AUTOPM
944 del_timer(&chip
->rts51x_suspend_timer
);
945 chip
->timer_expires
= 0;
952 static int realtek_cr_suspend(struct usb_interface
*iface
, pm_message_t message
)
954 struct us_data
*us
= usb_get_intfdata(iface
);
956 /* wait until no command is running */
957 mutex_lock(&us
->dev_mutex
);
959 config_autodelink_before_power_down(us
);
961 mutex_unlock(&us
->dev_mutex
);
966 static int realtek_cr_resume(struct usb_interface
*iface
)
968 struct us_data
*us
= usb_get_intfdata(iface
);
971 config_autodelink_after_power_on(us
);
976 #define realtek_cr_suspend NULL
977 #define realtek_cr_resume NULL
980 static int init_realtek_cr(struct us_data
*us
)
982 struct rts51x_chip
*chip
;
985 chip
= kzalloc(sizeof(struct rts51x_chip
), GFP_KERNEL
);
990 us
->extra_destructor
= realtek_cr_destructor
;
991 us
->max_lun
= chip
->max_lun
= rts51x_get_max_lun(us
);
994 usb_stor_dbg(us
, "chip->max_lun = %d\n", chip
->max_lun
);
996 size
= (chip
->max_lun
+ 1) * sizeof(struct rts51x_status
);
997 chip
->status
= kzalloc(size
, GFP_KERNEL
);
1001 for (i
= 0; i
<= (int)(chip
->max_lun
); i
++) {
1002 retval
= rts51x_check_status(us
, (u8
) i
);
1007 if (CHECK_FW_VER(chip
, 0x5888) || CHECK_FW_VER(chip
, 0x5889) ||
1008 CHECK_FW_VER(chip
, 0x5901))
1009 SET_AUTO_DELINK(chip
);
1010 if (STATUS_LEN(chip
) == 16) {
1011 if (SUPPORT_AUTO_DELINK(chip
))
1012 SET_AUTO_DELINK(chip
);
1014 #ifdef CONFIG_REALTEK_AUTOPM
1016 realtek_cr_autosuspend_setup(us
);
1019 usb_stor_dbg(us
, "chip->flag = 0x%x\n", chip
->flag
);
1021 (void)config_autodelink_after_power_on(us
);
1027 kfree(chip
->status
);
1035 static int realtek_cr_probe(struct usb_interface
*intf
,
1036 const struct usb_device_id
*id
)
1041 dev_dbg(&intf
->dev
, "Probe Realtek Card Reader!\n");
1043 result
= usb_stor_probe1(&us
, intf
, id
,
1044 (id
- realtek_cr_ids
) +
1045 realtek_cr_unusual_dev_list
);
1049 result
= usb_stor_probe2(us
);
1054 static struct usb_driver realtek_cr_driver
= {
1055 .name
= "ums-realtek",
1056 .probe
= realtek_cr_probe
,
1057 .disconnect
= usb_stor_disconnect
,
1058 /* .suspend = usb_stor_suspend, */
1059 /* .resume = usb_stor_resume, */
1060 .reset_resume
= usb_stor_reset_resume
,
1061 .suspend
= realtek_cr_suspend
,
1062 .resume
= realtek_cr_resume
,
1063 .pre_reset
= usb_stor_pre_reset
,
1064 .post_reset
= usb_stor_post_reset
,
1065 .id_table
= realtek_cr_ids
,
1067 .supports_autosuspend
= 1,
1071 module_usb_driver(realtek_cr_driver
);