Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
realtek_cr.c
Go to the documentation of this file.
1 /* Driver for Realtek RTS51xx USB 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 ([email protected])
20  * No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
21  */
22 
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>
28 
29 #include <scsi/scsi.h>
30 #include <scsi/scsi_cmnd.h>
31 #include <scsi/scsi_device.h>
32 #include <linux/cdrom.h>
33 
34 #include <linux/usb.h>
35 #include <linux/slab.h>
36 #include <linux/usb_usual.h>
37 
38 #include "usb.h"
39 #include "transport.h"
40 #include "protocol.h"
41 #include "debug.h"
42 
43 MODULE_DESCRIPTION("Driver for Realtek USB Card Reader");
44 MODULE_AUTHOR("wwang <[email protected]>");
45 MODULE_LICENSE("GPL");
46 MODULE_VERSION("1.03");
47 
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");
51 
52 #ifdef CONFIG_REALTEK_AUTOPM
53 static int ss_en = 1;
54 module_param(ss_en, int, S_IRUGO | S_IWUSR);
55 MODULE_PARM_DESC(ss_en, "enable selective suspend");
56 
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");
61 
62 enum RTS51X_STAT {
63  RTS51X_STAT_INIT,
64  RTS51X_STAT_IDLE,
65  RTS51X_STAT_RUN,
66  RTS51X_STAT_SS
67 };
68 
69 #define POLLING_INTERVAL 50
70 
71 #define rts51x_set_stat(chip, stat) \
72  ((chip)->state = (enum RTS51X_STAT)(stat))
73 #define rts51x_get_stat(chip) ((chip)->state)
74 
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)))
78 
79 #endif
80 
81 struct rts51x_status {
82  u16 vid;
83  u16 pid;
84  u8 cur_lun;
85  u8 card_type;
86  u8 total_lun;
87  u16 fw_ver;
88  u8 phy_exist;
89  u8 multi_flag;
90  u8 multi_card;
91  u8 log_exist;
92  union {
93  u8 detailed_type1;
94  u8 detailed_type2;
95  } detailed_type;
96  u8 function[2];
97 };
98 
99 struct rts51x_chip {
100  u16 vendor_id;
101  u16 product_id;
102  char max_lun;
103 
104  struct rts51x_status *status;
105  int status_len;
106 
107  u32 flag;
108 #ifdef CONFIG_REALTEK_AUTOPM
109  struct us_data *us;
110  struct timer_list rts51x_suspend_timer;
111  unsigned long timer_expires;
112  int pwr_state;
113  u8 lun_ready;
114  enum RTS51X_STAT state;
115  int support_auto_delink;
116 #endif
117  /* used to back up the protocal choosen in probe1 phase */
118  proto_cmnd proto_handler_backup;
119 };
120 
121 /* flag definition */
122 #define FLIDX_AUTO_DELINK 0x01
123 
124 #define SCSI_LUN(srb) ((srb)->device->lun)
125 
126 /* Bit Operation */
127 #define SET_BIT(data, idx) ((data) |= 1 << (idx))
128 #define CLR_BIT(data, idx) ((data) &= ~(1 << (idx)))
129 #define CHK_BIT(data, idx) ((data) & (1 << (idx)))
130 
131 #define SET_AUTO_DELINK(chip) ((chip)->flag |= FLIDX_AUTO_DELINK)
132 #define CLR_AUTO_DELINK(chip) ((chip)->flag &= ~FLIDX_AUTO_DELINK)
133 #define CHK_AUTO_DELINK(chip) ((chip)->flag & FLIDX_AUTO_DELINK)
134 
135 #define RTS51X_GET_VID(chip) ((chip)->vendor_id)
136 #define RTS51X_GET_PID(chip) ((chip)->product_id)
137 
138 #define VENDOR_ID(chip) ((chip)->status[0].vid)
139 #define PRODUCT_ID(chip) ((chip)->status[0].pid)
140 #define FW_VERSION(chip) ((chip)->status[0].fw_ver)
141 #define STATUS_LEN(chip) ((chip)->status_len)
142 
143 #define STATUS_SUCCESS 0
144 #define STATUS_FAIL 1
145 
146 /* Check card reader function */
147 #define SUPPORT_DETAILED_TYPE1(chip) \
148  CHK_BIT((chip)->status[0].function[0], 1)
149 #define SUPPORT_OT(chip) \
150  CHK_BIT((chip)->status[0].function[0], 2)
151 #define SUPPORT_OC(chip) \
152  CHK_BIT((chip)->status[0].function[0], 3)
153 #define SUPPORT_AUTO_DELINK(chip) \
154  CHK_BIT((chip)->status[0].function[0], 4)
155 #define SUPPORT_SDIO(chip) \
156  CHK_BIT((chip)->status[0].function[1], 0)
157 #define SUPPORT_DETAILED_TYPE2(chip) \
158  CHK_BIT((chip)->status[0].function[1], 1)
159 
160 #define CHECK_PID(chip, pid) (RTS51X_GET_PID(chip) == (pid))
161 #define CHECK_FW_VER(chip, fw_ver) (FW_VERSION(chip) == (fw_ver))
162 #define CHECK_ID(chip, pid, fw_ver) \
163  (CHECK_PID((chip), (pid)) && CHECK_FW_VER((chip), (fw_ver)))
164 
165 static int init_realtek_cr(struct us_data *us);
166 
167 /*
168  * The table of devices
169  */
170 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
171  vendorName, productName, useProtocol, useTransport, \
172  initFunction, flags) \
173 {\
174  USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
175  .driver_info = (flags) \
176 }
177 
178 static const struct usb_device_id realtek_cr_ids[] = {
179 # include "unusual_realtek.h"
180  {} /* Terminating entry */
181 };
182 
183 MODULE_DEVICE_TABLE(usb, realtek_cr_ids);
184 
185 #undef UNUSUAL_DEV
186 
187 /*
188  * The flags table
189  */
190 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
191  vendor_name, product_name, use_protocol, use_transport, \
192  init_function, Flags) \
193 { \
194  .vendorName = vendor_name, \
195  .productName = product_name, \
196  .useProtocol = use_protocol, \
197  .useTransport = use_transport, \
198  .initFunction = init_function, \
199 }
200 
201 static struct us_unusual_dev realtek_cr_unusual_dev_list[] = {
202 # include "unusual_realtek.h"
203  {} /* Terminating entry */
204 };
205 
206 #undef UNUSUAL_DEV
207 
208 static int rts51x_bulk_transport(struct us_data *us, u8 lun,
209  u8 *cmd, int cmd_len, u8 *buf, int buf_len,
210  enum dma_data_direction dir, int *act_len)
211 {
212  struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *)us->iobuf;
213  struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *)us->iobuf;
214  int result;
215  unsigned int residue;
216  unsigned int cswlen;
217  unsigned int cbwlen = US_BULK_CB_WRAP_LEN;
218 
219  /* set up the command wrapper */
220  bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
221  bcb->DataTransferLength = cpu_to_le32(buf_len);
222  bcb->Flags = (dir == DMA_FROM_DEVICE) ? US_BULK_FLAG_IN : 0;
223  bcb->Tag = ++us->tag;
224  bcb->Lun = lun;
225  bcb->Length = cmd_len;
226 
227  /* copy the command payload */
228  memset(bcb->CDB, 0, sizeof(bcb->CDB));
229  memcpy(bcb->CDB, cmd, bcb->Length);
230 
231  /* send it to out endpoint */
232  result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
233  bcb, cbwlen, NULL);
234  if (result != USB_STOR_XFER_GOOD)
235  return USB_STOR_TRANSPORT_ERROR;
236 
237  /* DATA STAGE */
238  /* send/receive data payload, if there is any */
239 
240  if (buf && buf_len) {
241  unsigned int pipe = (dir == DMA_FROM_DEVICE) ?
242  us->recv_bulk_pipe : us->send_bulk_pipe;
243  result = usb_stor_bulk_transfer_buf(us, pipe,
244  buf, buf_len, NULL);
245  if (result == USB_STOR_XFER_ERROR)
246  return USB_STOR_TRANSPORT_ERROR;
247  }
248 
249  /* get CSW for device status */
250  result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
251  bcs, US_BULK_CS_WRAP_LEN, &cswlen);
252  if (result != USB_STOR_XFER_GOOD)
253  return USB_STOR_TRANSPORT_ERROR;
254 
255  /* check bulk status */
256  if (bcs->Signature != cpu_to_le32(US_BULK_CS_SIGN)) {
257  US_DEBUGP("Signature mismatch: got %08X, expecting %08X\n",
258  le32_to_cpu(bcs->Signature), US_BULK_CS_SIGN);
259  return USB_STOR_TRANSPORT_ERROR;
260  }
261 
262  residue = bcs->Residue;
263  if (bcs->Tag != us->tag)
264  return USB_STOR_TRANSPORT_ERROR;
265 
266  /* try to compute the actual residue, based on how much data
267  * was really transferred and what the device tells us */
268  if (residue)
269  residue = residue < buf_len ? residue : buf_len;
270 
271  if (act_len)
272  *act_len = buf_len - residue;
273 
274  /* based on the status code, we report good or bad */
275  switch (bcs->Status) {
276  case US_BULK_STAT_OK:
277  /* command good -- note that data could be short */
278  return USB_STOR_TRANSPORT_GOOD;
279 
280  case US_BULK_STAT_FAIL:
281  /* command failed */
282  return USB_STOR_TRANSPORT_FAILED;
283 
284  case US_BULK_STAT_PHASE:
285  /* phase error -- note that a transport reset will be
286  * invoked by the invoke_transport() function
287  */
288  return USB_STOR_TRANSPORT_ERROR;
289  }
290 
291  /* we should never get here, but if we do, we're in trouble */
292  return USB_STOR_TRANSPORT_ERROR;
293 }
294 
295 static int rts51x_bulk_transport_special(struct us_data *us, u8 lun,
296  u8 *cmd, int cmd_len, u8 *buf, int buf_len,
297  enum dma_data_direction dir, int *act_len)
298 {
299  struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
300  struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
301  int result;
302  unsigned int cswlen;
303  unsigned int cbwlen = US_BULK_CB_WRAP_LEN;
304 
305  /* set up the command wrapper */
306  bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
307  bcb->DataTransferLength = cpu_to_le32(buf_len);
308  bcb->Flags = (dir == DMA_FROM_DEVICE) ? US_BULK_FLAG_IN : 0;
309  bcb->Tag = ++us->tag;
310  bcb->Lun = lun;
311  bcb->Length = cmd_len;
312 
313  /* copy the command payload */
314  memset(bcb->CDB, 0, sizeof(bcb->CDB));
315  memcpy(bcb->CDB, cmd, bcb->Length);
316 
317  /* send it to out endpoint */
318  result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
319  bcb, cbwlen, NULL);
320  if (result != USB_STOR_XFER_GOOD)
321  return USB_STOR_TRANSPORT_ERROR;
322 
323  /* DATA STAGE */
324  /* send/receive data payload, if there is any */
325 
326  if (buf && buf_len) {
327  unsigned int pipe = (dir == DMA_FROM_DEVICE) ?
328  us->recv_bulk_pipe : us->send_bulk_pipe;
329  result = usb_stor_bulk_transfer_buf(us, pipe,
330  buf, buf_len, NULL);
331  if (result == USB_STOR_XFER_ERROR)
332  return USB_STOR_TRANSPORT_ERROR;
333  }
334 
335  /* get CSW for device status */
336  result = usb_bulk_msg(us->pusb_dev, us->recv_bulk_pipe, bcs,
337  US_BULK_CS_WRAP_LEN, &cswlen, 250);
338  return result;
339 }
340 
341 /* Determine what the maximum LUN supported is */
342 static int rts51x_get_max_lun(struct us_data *us)
343 {
344  int result;
345 
346  /* issue the command */
347  us->iobuf[0] = 0;
348  result = usb_stor_control_msg(us, us->recv_ctrl_pipe,
349  US_BULK_GET_MAX_LUN,
350  USB_DIR_IN | USB_TYPE_CLASS |
351  USB_RECIP_INTERFACE,
352  0, us->ifnum, us->iobuf, 1, 10 * HZ);
353 
354  US_DEBUGP("GetMaxLUN command result is %d, data is %d\n",
355  result, us->iobuf[0]);
356 
357  /* if we have a successful request, return the result */
358  if (result > 0)
359  return us->iobuf[0];
360 
361  return 0;
362 }
363 
364 static int rts51x_read_mem(struct us_data *us, u16 addr, u8 *data, u16 len)
365 {
366  int retval;
367  u8 cmnd[12] = { 0 };
368  u8 *buf;
369 
370  buf = kmalloc(len, GFP_NOIO);
371  if (buf == NULL)
372  return USB_STOR_TRANSPORT_ERROR;
373 
374  US_DEBUGP("%s, addr = 0x%x, len = %d\n", __func__, addr, len);
375 
376  cmnd[0] = 0xF0;
377  cmnd[1] = 0x0D;
378  cmnd[2] = (u8) (addr >> 8);
379  cmnd[3] = (u8) addr;
380  cmnd[4] = (u8) (len >> 8);
381  cmnd[5] = (u8) len;
382 
383  retval = rts51x_bulk_transport(us, 0, cmnd, 12,
384  buf, len, DMA_FROM_DEVICE, NULL);
385  if (retval != USB_STOR_TRANSPORT_GOOD) {
386  kfree(buf);
387  return -EIO;
388  }
389 
390  memcpy(data, buf, len);
391  kfree(buf);
392  return 0;
393 }
394 
395 static int rts51x_write_mem(struct us_data *us, u16 addr, u8 *data, u16 len)
396 {
397  int retval;
398  u8 cmnd[12] = { 0 };
399  u8 *buf;
400 
401  buf = kmemdup(data, len, GFP_NOIO);
402  if (buf == NULL)
403  return USB_STOR_TRANSPORT_ERROR;
404 
405  US_DEBUGP("%s, addr = 0x%x, len = %d\n", __func__, addr, len);
406 
407  cmnd[0] = 0xF0;
408  cmnd[1] = 0x0E;
409  cmnd[2] = (u8) (addr >> 8);
410  cmnd[3] = (u8) addr;
411  cmnd[4] = (u8) (len >> 8);
412  cmnd[5] = (u8) len;
413 
414  retval = rts51x_bulk_transport(us, 0, cmnd, 12,
415  buf, len, DMA_TO_DEVICE, NULL);
416  kfree(buf);
417  if (retval != USB_STOR_TRANSPORT_GOOD)
418  return -EIO;
419 
420  return 0;
421 }
422 
423 static int rts51x_read_status(struct us_data *us,
424  u8 lun, u8 *status, int len, int *actlen)
425 {
426  int retval;
427  u8 cmnd[12] = { 0 };
428  u8 *buf;
429 
430  buf = kmalloc(len, GFP_NOIO);
431  if (buf == NULL)
432  return USB_STOR_TRANSPORT_ERROR;
433 
434  US_DEBUGP("%s, lun = %d\n", __func__, lun);
435 
436  cmnd[0] = 0xF0;
437  cmnd[1] = 0x09;
438 
439  retval = rts51x_bulk_transport(us, lun, cmnd, 12,
440  buf, len, DMA_FROM_DEVICE, actlen);
441  if (retval != USB_STOR_TRANSPORT_GOOD) {
442  kfree(buf);
443  return -EIO;
444  }
445 
446  memcpy(status, buf, len);
447  kfree(buf);
448  return 0;
449 }
450 
451 static int rts51x_check_status(struct us_data *us, u8 lun)
452 {
453  struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
454  int retval;
455  u8 buf[16];
456 
457  retval = rts51x_read_status(us, lun, buf, 16, &(chip->status_len));
458  if (retval < 0)
459  return -EIO;
460 
461  US_DEBUGP("chip->status_len = %d\n", chip->status_len);
462 
463  chip->status[lun].vid = ((u16) buf[0] << 8) | buf[1];
464  chip->status[lun].pid = ((u16) buf[2] << 8) | buf[3];
465  chip->status[lun].cur_lun = buf[4];
466  chip->status[lun].card_type = buf[5];
467  chip->status[lun].total_lun = buf[6];
468  chip->status[lun].fw_ver = ((u16) buf[7] << 8) | buf[8];
469  chip->status[lun].phy_exist = buf[9];
470  chip->status[lun].multi_flag = buf[10];
471  chip->status[lun].multi_card = buf[11];
472  chip->status[lun].log_exist = buf[12];
473  if (chip->status_len == 16) {
474  chip->status[lun].detailed_type.detailed_type1 = buf[13];
475  chip->status[lun].function[0] = buf[14];
476  chip->status[lun].function[1] = buf[15];
477  }
478 
479  return 0;
480 }
481 
482 static int enable_oscillator(struct us_data *us)
483 {
484  int retval;
485  u8 value;
486 
487  retval = rts51x_read_mem(us, 0xFE77, &value, 1);
488  if (retval < 0)
489  return -EIO;
490 
491  value |= 0x04;
492  retval = rts51x_write_mem(us, 0xFE77, &value, 1);
493  if (retval < 0)
494  return -EIO;
495 
496  retval = rts51x_read_mem(us, 0xFE77, &value, 1);
497  if (retval < 0)
498  return -EIO;
499 
500  if (!(value & 0x04))
501  return -EIO;
502 
503  return 0;
504 }
505 
506 static int __do_config_autodelink(struct us_data *us, u8 *data, u16 len)
507 {
508  int retval;
509  u8 cmnd[12] = {0};
510  u8 *buf;
511 
512  US_DEBUGP("%s, addr = 0xfe47, len = %d\n", __FUNCTION__, len);
513 
514  buf = kmemdup(data, len, GFP_NOIO);
515  if (!buf)
516  return USB_STOR_TRANSPORT_ERROR;
517 
518  cmnd[0] = 0xF0;
519  cmnd[1] = 0x0E;
520  cmnd[2] = 0xfe;
521  cmnd[3] = 0x47;
522  cmnd[4] = (u8)(len >> 8);
523  cmnd[5] = (u8)len;
524 
525  retval = rts51x_bulk_transport_special(us, 0, cmnd, 12, buf, len, DMA_TO_DEVICE, NULL);
526  kfree(buf);
527  if (retval != USB_STOR_TRANSPORT_GOOD) {
528  return -EIO;
529  }
530 
531  return 0;
532 }
533 
534 static int do_config_autodelink(struct us_data *us, int enable, int force)
535 {
536  int retval;
537  u8 value;
538 
539  retval = rts51x_read_mem(us, 0xFE47, &value, 1);
540  if (retval < 0)
541  return -EIO;
542 
543  if (enable) {
544  if (force)
545  value |= 0x03;
546  else
547  value |= 0x01;
548  } else {
549  value &= ~0x03;
550  }
551 
552  US_DEBUGP("In %s,set 0xfe47 to 0x%x\n", __func__, value);
553 
554  /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */
555  retval = __do_config_autodelink(us, &value, 1);
556  if (retval < 0)
557  return -EIO;
558 
559  return 0;
560 }
561 
562 static int config_autodelink_after_power_on(struct us_data *us)
563 {
564  struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
565  int retval;
566  u8 value;
567 
568  US_DEBUGP("%s: <---\n", __func__);
569 
570  if (!CHK_AUTO_DELINK(chip))
571  return 0;
572 
573  retval = rts51x_read_mem(us, 0xFE47, &value, 1);
574  if (retval < 0)
575  return -EIO;
576 
577  if (auto_delink_en) {
578  CLR_BIT(value, 0);
579  CLR_BIT(value, 1);
580  SET_BIT(value, 2);
581 
582  if (CHECK_ID(chip, 0x0138, 0x3882))
583  CLR_BIT(value, 2);
584 
585  SET_BIT(value, 7);
586 
587  /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */
588  retval = __do_config_autodelink(us, &value, 1);
589  if (retval < 0)
590  return -EIO;
591 
592  retval = enable_oscillator(us);
593  if (retval == 0)
594  (void)do_config_autodelink(us, 1, 0);
595  } else {
596  /* Autodelink controlled by firmware */
597 
598  SET_BIT(value, 2);
599 
600  if (CHECK_ID(chip, 0x0138, 0x3882))
601  CLR_BIT(value, 2);
602 
603  if (CHECK_ID(chip, 0x0159, 0x5889) ||
604  CHECK_ID(chip, 0x0138, 0x3880)) {
605  CLR_BIT(value, 0);
606  CLR_BIT(value, 7);
607  }
608 
609  /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */
610  retval = __do_config_autodelink(us, &value, 1);
611  if (retval < 0)
612  return -EIO;
613 
614  if (CHECK_ID(chip, 0x0159, 0x5888)) {
615  value = 0xFF;
616  retval = rts51x_write_mem(us, 0xFE79, &value, 1);
617  if (retval < 0)
618  return -EIO;
619 
620  value = 0x01;
621  retval = rts51x_write_mem(us, 0x48, &value, 1);
622  if (retval < 0)
623  return -EIO;
624  }
625  }
626 
627  US_DEBUGP("%s: --->\n", __func__);
628 
629  return 0;
630 }
631 
632 static int config_autodelink_before_power_down(struct us_data *us)
633 {
634  struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
635  int retval;
636  u8 value;
637 
638  US_DEBUGP("%s: <---\n", __func__);
639 
640  if (!CHK_AUTO_DELINK(chip))
641  return 0;
642 
643  if (auto_delink_en) {
644  retval = rts51x_read_mem(us, 0xFE77, &value, 1);
645  if (retval < 0)
646  return -EIO;
647 
648  SET_BIT(value, 2);
649  retval = rts51x_write_mem(us, 0xFE77, &value, 1);
650  if (retval < 0)
651  return -EIO;
652 
653  if (CHECK_ID(chip, 0x0159, 0x5888)) {
654  value = 0x01;
655  retval = rts51x_write_mem(us, 0x48, &value, 1);
656  if (retval < 0)
657  return -EIO;
658  }
659 
660  retval = rts51x_read_mem(us, 0xFE47, &value, 1);
661  if (retval < 0)
662  return -EIO;
663 
664  SET_BIT(value, 0);
665  if (CHECK_ID(chip, 0x0138, 0x3882))
666  SET_BIT(value, 2);
667  retval = rts51x_write_mem(us, 0xFE77, &value, 1);
668  if (retval < 0)
669  return -EIO;
670  } else {
671  if (CHECK_ID(chip, 0x0159, 0x5889) ||
672  CHECK_ID(chip, 0x0138, 0x3880) ||
673  CHECK_ID(chip, 0x0138, 0x3882)) {
674  retval = rts51x_read_mem(us, 0xFE47, &value, 1);
675  if (retval < 0)
676  return -EIO;
677 
678  if (CHECK_ID(chip, 0x0159, 0x5889) ||
679  CHECK_ID(chip, 0x0138, 0x3880)) {
680  SET_BIT(value, 0);
681  SET_BIT(value, 7);
682  }
683 
684  if (CHECK_ID(chip, 0x0138, 0x3882))
685  SET_BIT(value, 2);
686 
687  /* retval = rts51x_write_mem(us, 0xFE47, &value, 1); */
688  retval = __do_config_autodelink(us, &value, 1);
689  if (retval < 0)
690  return -EIO;
691  }
692 
693  if (CHECK_ID(chip, 0x0159, 0x5888)) {
694  value = 0x01;
695  retval = rts51x_write_mem(us, 0x48, &value, 1);
696  if (retval < 0)
697  return -EIO;
698  }
699  }
700 
701  US_DEBUGP("%s: --->\n", __func__);
702 
703  return 0;
704 }
705 
706 static void fw5895_init(struct us_data *us)
707 {
708  struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
709  int retval;
710  u8 val;
711 
712  US_DEBUGP("%s: <---\n", __func__);
713 
714  if ((PRODUCT_ID(chip) != 0x0158) || (FW_VERSION(chip) != 0x5895)) {
715  US_DEBUGP("Not the specified device, return immediately!\n");
716  } else {
717  retval = rts51x_read_mem(us, 0xFD6F, &val, 1);
718  if (retval == STATUS_SUCCESS && (val & 0x1F) == 0) {
719  val = 0x1F;
720  retval = rts51x_write_mem(us, 0xFD70, &val, 1);
721  if (retval != STATUS_SUCCESS)
722  US_DEBUGP("Write memory fail\n");
723  } else {
724  US_DEBUGP("Read memory fail, OR (val & 0x1F) != 0\n");
725  }
726  }
727 
728  US_DEBUGP("%s: --->\n", __func__);
729 }
730 
731 #ifdef CONFIG_REALTEK_AUTOPM
732 static void fw5895_set_mmc_wp(struct us_data *us)
733 {
734  struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
735  int retval;
736  u8 buf[13];
737 
738  US_DEBUGP("%s: <---\n", __func__);
739 
740  if ((PRODUCT_ID(chip) != 0x0158) || (FW_VERSION(chip) != 0x5895)) {
741  US_DEBUGP("Not the specified device, return immediately!\n");
742  } else {
743  retval = rts51x_read_mem(us, 0xFD6F, buf, 1);
744  if (retval == STATUS_SUCCESS && (buf[0] & 0x24) == 0x24) {
745  /* SD Exist and SD WP */
746  retval = rts51x_read_mem(us, 0xD04E, buf, 1);
747  if (retval == STATUS_SUCCESS) {
748  buf[0] |= 0x04;
749  retval = rts51x_write_mem(us, 0xFD70, buf, 1);
750  if (retval != STATUS_SUCCESS)
751  US_DEBUGP("Write memory fail\n");
752  } else {
753  US_DEBUGP("Read memory fail\n");
754  }
755  } else {
756  US_DEBUGP("Read memory fail, OR (buf[0]&0x24)!=0x24\n");
757  }
758  }
759 
760  US_DEBUGP("%s: --->\n", __func__);
761 }
762 
763 static void rts51x_modi_suspend_timer(struct rts51x_chip *chip)
764 {
765  US_DEBUGP("%s: <---, state:%d\n", __func__, rts51x_get_stat(chip));
766 
767  chip->timer_expires = jiffies + msecs_to_jiffies(1000*ss_delay);
768  mod_timer(&chip->rts51x_suspend_timer, chip->timer_expires);
769 
770  US_DEBUGP("%s: --->\n", __func__);
771 }
772 
773 static void rts51x_suspend_timer_fn(unsigned long data)
774 {
775  struct rts51x_chip *chip = (struct rts51x_chip *)data;
776  struct us_data *us = chip->us;
777 
778  US_DEBUGP("%s: <---\n", __func__);
779 
780  switch (rts51x_get_stat(chip)) {
781  case RTS51X_STAT_INIT:
782  case RTS51X_STAT_RUN:
783  rts51x_modi_suspend_timer(chip);
784  break;
785  case RTS51X_STAT_IDLE:
786  case RTS51X_STAT_SS:
787  US_DEBUGP("%s: RTS51X_STAT_SS, intf->pm_usage_cnt:%d,"
788  "power.usage:%d\n", __func__,
789  atomic_read(&us->pusb_intf->pm_usage_cnt),
790  atomic_read(&us->pusb_intf->dev.power.usage_count));
791 
792  if (atomic_read(&us->pusb_intf->pm_usage_cnt) > 0) {
793  US_DEBUGP("%s: Ready to enter SS state.\n",
794  __func__);
795  rts51x_set_stat(chip, RTS51X_STAT_SS);
796  /* ignore mass storage interface's children */
797  pm_suspend_ignore_children(&us->pusb_intf->dev, true);
798  usb_autopm_put_interface_async(us->pusb_intf);
799  US_DEBUGP("%s: RTS51X_STAT_SS 01,"
800  "intf->pm_usage_cnt:%d, power.usage:%d\n",
801  __func__,
802  atomic_read(&us->pusb_intf->pm_usage_cnt),
803  atomic_read(
804  &us->pusb_intf->dev.power.usage_count));
805  }
806  break;
807  default:
808  US_DEBUGP("%s: Unknonwn state !!!\n", __func__);
809  break;
810  }
811 
812  US_DEBUGP("%s: --->\n", __func__);
813 }
814 
815 static inline int working_scsi(struct scsi_cmnd *srb)
816 {
817  if ((srb->cmnd[0] == TEST_UNIT_READY) ||
818  (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL)) {
819  return 0;
820  }
821 
822  return 1;
823 }
824 
825 static void rts51x_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
826 {
827  struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
828  static int card_first_show = 1;
829  static u8 media_not_present[] = { 0x70, 0, 0x02, 0, 0, 0, 0,
830  10, 0, 0, 0, 0, 0x3A, 0, 0, 0, 0, 0
831  };
832  static u8 invalid_cmd_field[] = { 0x70, 0, 0x05, 0, 0, 0, 0,
833  10, 0, 0, 0, 0, 0x24, 0, 0, 0, 0, 0
834  };
835  int ret;
836 
837  US_DEBUGP("%s: <---\n", __func__);
838 
839  if (working_scsi(srb)) {
840  US_DEBUGP("%s: working scsi, intf->pm_usage_cnt:%d,"
841  "power.usage:%d\n", __func__,
842  atomic_read(&us->pusb_intf->pm_usage_cnt),
843  atomic_read(&us->pusb_intf->dev.power.usage_count));
844 
845  if (atomic_read(&us->pusb_intf->pm_usage_cnt) <= 0) {
846  ret = usb_autopm_get_interface(us->pusb_intf);
847  US_DEBUGP("%s: working scsi, ret=%d\n", __func__, ret);
848  }
849  if (rts51x_get_stat(chip) != RTS51X_STAT_RUN)
850  rts51x_set_stat(chip, RTS51X_STAT_RUN);
851  chip->proto_handler_backup(srb, us);
852  } else {
853  if (rts51x_get_stat(chip) == RTS51X_STAT_SS) {
854  US_DEBUGP("%s: NOT working scsi\n", __func__);
855  if ((srb->cmnd[0] == TEST_UNIT_READY) &&
856  (chip->pwr_state == US_SUSPEND)) {
857  if (TST_LUN_READY(chip, srb->device->lun)) {
858  srb->result = SAM_STAT_GOOD;
859  } else {
860  srb->result = SAM_STAT_CHECK_CONDITION;
861  memcpy(srb->sense_buffer,
862  media_not_present,
863  US_SENSE_SIZE);
864  }
865  US_DEBUGP("%s: TEST_UNIT_READY--->\n",
866  __func__);
867  goto out;
868  }
869  if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
870  int prevent = srb->cmnd[4] & 0x1;
871  if (prevent) {
872  srb->result = SAM_STAT_CHECK_CONDITION;
873  memcpy(srb->sense_buffer,
874  invalid_cmd_field,
875  US_SENSE_SIZE);
876  } else {
877  srb->result = SAM_STAT_GOOD;
878  }
879  US_DEBUGP("%s: ALLOW_MEDIUM_REMOVAL--->\n",
880  __func__);
881  goto out;
882  }
883  } else {
884  US_DEBUGP("%s: NOT working scsi, not SS\n", __func__);
885  chip->proto_handler_backup(srb, us);
886  /* Check wether card is plugged in */
887  if (srb->cmnd[0] == TEST_UNIT_READY) {
888  if (srb->result == SAM_STAT_GOOD) {
889  SET_LUN_READY(chip, srb->device->lun);
890  if (card_first_show) {
891  card_first_show = 0;
892  fw5895_set_mmc_wp(us);
893  }
894  } else {
895  CLR_LUN_READY(chip, srb->device->lun);
896  card_first_show = 1;
897  }
898  }
899  if (rts51x_get_stat(chip) != RTS51X_STAT_IDLE)
900  rts51x_set_stat(chip, RTS51X_STAT_IDLE);
901  }
902  }
903 out:
904  US_DEBUGP("%s: state:%d\n", __func__, rts51x_get_stat(chip));
905  if (rts51x_get_stat(chip) == RTS51X_STAT_RUN)
906  rts51x_modi_suspend_timer(chip);
907 
908  US_DEBUGP("%s: --->\n", __func__);
909 }
910 
911 static int realtek_cr_autosuspend_setup(struct us_data *us)
912 {
913  struct rts51x_chip *chip;
914  struct rts51x_status *status = NULL;
915  u8 buf[16];
916  int retval;
917 
918  chip = (struct rts51x_chip *)us->extra;
919  chip->support_auto_delink = 0;
920  chip->pwr_state = US_RESUME;
921  chip->lun_ready = 0;
922  rts51x_set_stat(chip, RTS51X_STAT_INIT);
923 
924  retval = rts51x_read_status(us, 0, buf, 16, &(chip->status_len));
925  if (retval != STATUS_SUCCESS) {
926  US_DEBUGP("Read status fail\n");
927  return -EIO;
928  }
929  status = chip->status;
930  status->vid = ((u16) buf[0] << 8) | buf[1];
931  status->pid = ((u16) buf[2] << 8) | buf[3];
932  status->cur_lun = buf[4];
933  status->card_type = buf[5];
934  status->total_lun = buf[6];
935  status->fw_ver = ((u16) buf[7] << 8) | buf[8];
936  status->phy_exist = buf[9];
937  status->multi_flag = buf[10];
938  status->multi_card = buf[11];
939  status->log_exist = buf[12];
940  if (chip->status_len == 16) {
941  status->detailed_type.detailed_type1 = buf[13];
942  status->function[0] = buf[14];
943  status->function[1] = buf[15];
944  }
945 
946  /* back up the proto_handler in us->extra */
947  chip = (struct rts51x_chip *)(us->extra);
948  chip->proto_handler_backup = us->proto_handler;
949  /* Set the autosuspend_delay to 0 */
950  pm_runtime_set_autosuspend_delay(&us->pusb_dev->dev, 0);
951  /* override us->proto_handler setted in get_protocol() */
952  us->proto_handler = rts51x_invoke_transport;
953 
954  chip->timer_expires = 0;
955  setup_timer(&chip->rts51x_suspend_timer, rts51x_suspend_timer_fn,
956  (unsigned long)chip);
957  fw5895_init(us);
958 
959  /* enable autosuspend funciton of the usb device */
960  usb_enable_autosuspend(us->pusb_dev);
961 
962  return 0;
963 }
964 #endif
965 
966 static void realtek_cr_destructor(void *extra)
967 {
968  struct rts51x_chip *chip = (struct rts51x_chip *)extra;
969 
970  US_DEBUGP("%s: <---\n", __func__);
971 
972  if (!chip)
973  return;
974 #ifdef CONFIG_REALTEK_AUTOPM
975  if (ss_en) {
976  del_timer(&chip->rts51x_suspend_timer);
977  chip->timer_expires = 0;
978  }
979 #endif
980  kfree(chip->status);
981 }
982 
983 #ifdef CONFIG_PM
984 static int realtek_cr_suspend(struct usb_interface *iface, pm_message_t message)
985 {
986  struct us_data *us = usb_get_intfdata(iface);
987 
988  US_DEBUGP("%s: <---\n", __func__);
989 
990  /* wait until no command is running */
991  mutex_lock(&us->dev_mutex);
992 
993  config_autodelink_before_power_down(us);
994 
995  mutex_unlock(&us->dev_mutex);
996 
997  US_DEBUGP("%s: --->\n", __func__);
998 
999  return 0;
1000 }
1001 
1002 static int realtek_cr_resume(struct usb_interface *iface)
1003 {
1004  struct us_data *us = usb_get_intfdata(iface);
1005 
1006  US_DEBUGP("%s: <---\n", __func__);
1007 
1008  fw5895_init(us);
1009  config_autodelink_after_power_on(us);
1010 
1011  US_DEBUGP("%s: --->\n", __func__);
1012 
1013  return 0;
1014 }
1015 #else
1016 #define realtek_cr_suspend NULL
1017 #define realtek_cr_resume NULL
1018 #endif
1019 
1020 static int init_realtek_cr(struct us_data *us)
1021 {
1022  struct rts51x_chip *chip;
1023  int size, i, retval;
1024 
1025  chip = kzalloc(sizeof(struct rts51x_chip), GFP_KERNEL);
1026  if (!chip)
1027  return -ENOMEM;
1028 
1029  us->extra = chip;
1030  us->extra_destructor = realtek_cr_destructor;
1031  us->max_lun = chip->max_lun = rts51x_get_max_lun(us);
1032 
1033  US_DEBUGP("chip->max_lun = %d\n", chip->max_lun);
1034 
1035  size = (chip->max_lun + 1) * sizeof(struct rts51x_status);
1036  chip->status = kzalloc(size, GFP_KERNEL);
1037  if (!chip->status)
1038  goto INIT_FAIL;
1039 
1040  for (i = 0; i <= (int)(chip->max_lun); i++) {
1041  retval = rts51x_check_status(us, (u8) i);
1042  if (retval < 0)
1043  goto INIT_FAIL;
1044  }
1045 
1046  if (CHECK_FW_VER(chip, 0x5888) || CHECK_FW_VER(chip, 0x5889) ||
1047  CHECK_FW_VER(chip, 0x5901))
1048  SET_AUTO_DELINK(chip);
1049  if (STATUS_LEN(chip) == 16) {
1050  if (SUPPORT_AUTO_DELINK(chip))
1051  SET_AUTO_DELINK(chip);
1052  }
1053 #ifdef CONFIG_REALTEK_AUTOPM
1054  if (ss_en) {
1055  chip->us = us;
1056  realtek_cr_autosuspend_setup(us);
1057  }
1058 #endif
1059 
1060  US_DEBUGP("chip->flag = 0x%x\n", chip->flag);
1061 
1062  (void)config_autodelink_after_power_on(us);
1063 
1064  return 0;
1065 
1066 INIT_FAIL:
1067  if (us->extra) {
1068  kfree(chip->status);
1069  kfree(us->extra);
1070  us->extra = NULL;
1071  }
1072 
1073  return -EIO;
1074 }
1075 
1076 static int realtek_cr_probe(struct usb_interface *intf,
1077  const struct usb_device_id *id)
1078 {
1079  struct us_data *us;
1080  int result;
1081 
1082  US_DEBUGP("Probe Realtek Card Reader!\n");
1083 
1084  result = usb_stor_probe1(&us, intf, id,
1085  (id - realtek_cr_ids) +
1086  realtek_cr_unusual_dev_list);
1087  if (result)
1088  return result;
1089 
1090  result = usb_stor_probe2(us);
1091 
1092  return result;
1093 }
1094 
1095 static struct usb_driver realtek_cr_driver = {
1096  .name = "ums-realtek",
1097  .probe = realtek_cr_probe,
1098  .disconnect = usb_stor_disconnect,
1099  /* .suspend = usb_stor_suspend, */
1100  /* .resume = usb_stor_resume, */
1101  .reset_resume = usb_stor_reset_resume,
1102  .suspend = realtek_cr_suspend,
1103  .resume = realtek_cr_resume,
1104  .pre_reset = usb_stor_pre_reset,
1105  .post_reset = usb_stor_post_reset,
1106  .id_table = realtek_cr_ids,
1107  .soft_unbind = 1,
1108  .supports_autosuspend = 1,
1109  .no_dynamic_id = 1,
1110 };
1111 
1112 module_usb_driver(realtek_cr_driver);
Generated on Thu Jan 10 2013 14:38:45 for Linux Kernel by   doxygen 1.8.2