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