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/workqueue.h> 28 #include <linux/kernel.h> 29 #include <linux/version.h> 30 31 #include <scsi/scsi.h> 32 #include <scsi/scsi_cmnd.h> 33 #include <scsi/scsi_device.h> 34 #include <linux/cdrom.h> 35 36 #include <linux/usb.h> 37 #include <linux/slab.h> 38 #include <linux/usb_usual.h> 39 40 #include "usb.h" 41 #include "transport.h" 42 #include "protocol.h" 43 #include "debug.h" 44 45 MODULE_DESCRIPTION("Driver for Realtek USB Card Reader"); 46 MODULE_AUTHOR("wwang <wei_wang@realsil.com.cn>"); 47 MODULE_LICENSE("GPL"); 48 MODULE_VERSION("1.03"); 49 50 static int auto_delink_en = 1; 51 module_param(auto_delink_en, int, S_IRUGO | S_IWUSR); 52 MODULE_PARM_DESC(auto_delink_en, "enable auto delink"); 53 54 struct rts51x_status { 55 u16 vid; 56 u16 pid; 57 u8 cur_lun; 58 u8 card_type; 59 u8 total_lun; 60 u16 fw_ver; 61 u8 phy_exist; 62 u8 multi_flag; 63 u8 multi_card; 64 u8 log_exist; 65 union { 66 u8 detailed_type1; 67 u8 detailed_type2; 68 } detailed_type; 69 u8 function[2]; 70 }; 71 72 struct rts51x_chip { 73 u16 vendor_id; 74 u16 product_id; 75 char max_lun; 76 77 struct rts51x_status *status; 78 int status_len; 79 80 u32 flag; 81 }; 82 83 /* flag definition */ 84 #define FLIDX_AUTO_DELINK 0x01 85 86 #define SCSI_LUN(srb) ((srb)->device->lun) 87 88 /* Bit Operation */ 89 #define SET_BIT(data, idx) ((data) |= 1 << (idx)) 90 #define CLR_BIT(data, idx) ((data) &= ~(1 << (idx))) 91 #define CHK_BIT(data, idx) ((data) & (1 << (idx))) 92 93 #define SET_AUTO_DELINK(chip) ((chip)->flag |= FLIDX_AUTO_DELINK) 94 #define CLR_AUTO_DELINK(chip) ((chip)->flag &= ~FLIDX_AUTO_DELINK) 95 #define CHK_AUTO_DELINK(chip) ((chip)->flag & FLIDX_AUTO_DELINK) 96 97 #define RTS51X_GET_VID(chip) ((chip)->vendor_id) 98 #define RTS51X_GET_PID(chip) ((chip)->product_id) 99 100 #define FW_VERSION(chip) ((chip)->status[0].fw_ver) 101 #define STATUS_LEN(chip) ((chip)->status_len) 102 103 /* Check card reader function */ 104 #define SUPPORT_DETAILED_TYPE1(chip) \ 105 CHK_BIT((chip)->status[0].function[0], 1) 106 #define SUPPORT_OT(chip) \ 107 CHK_BIT((chip)->status[0].function[0], 2) 108 #define SUPPORT_OC(chip) \ 109 CHK_BIT((chip)->status[0].function[0], 3) 110 #define SUPPORT_AUTO_DELINK(chip) \ 111 CHK_BIT((chip)->status[0].function[0], 4) 112 #define SUPPORT_SDIO(chip) \ 113 CHK_BIT((chip)->status[0].function[1], 0) 114 #define SUPPORT_DETAILED_TYPE2(chip) \ 115 CHK_BIT((chip)->status[0].function[1], 1) 116 117 #define CHECK_PID(chip, pid) (RTS51X_GET_PID(chip) == (pid)) 118 #define CHECK_FW_VER(chip, fw_ver) (FW_VERSION(chip) == (fw_ver)) 119 #define CHECK_ID(chip, pid, fw_ver) \ 120 (CHECK_PID((chip), (pid)) && CHECK_FW_VER((chip), (fw_ver))) 121 122 #define wait_timeout_x(task_state, msecs) \ 123 do { \ 124 set_current_state((task_state)); \ 125 schedule_timeout((msecs) * HZ / 1000); \ 126 } while (0) 127 128 #define wait_timeout(msecs) \ 129 wait_timeout_x(TASK_INTERRUPTIBLE, (msecs)) 130 131 static int init_realtek_cr(struct us_data *us); 132 133 /* 134 * The table of devices 135 */ 136 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \ 137 vendorName, productName, useProtocol, useTransport, \ 138 initFunction, flags) \ 139 {\ 140 USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \ 141 .driver_info = (flags)|(USB_US_TYPE_STOR<<24)\ 142 } 143 144 static const struct usb_device_id realtek_cr_ids[] = { 145 # include "unusual_realtek.h" 146 { } /* Terminating entry */ 147 }; 148 MODULE_DEVICE_TABLE(usb, realtek_cr_ids); 149 150 #undef UNUSUAL_DEV 151 152 /* 153 * The flags table 154 */ 155 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \ 156 vendor_name, product_name, use_protocol, use_transport, \ 157 init_function, Flags) \ 158 { \ 159 .vendorName = vendor_name, \ 160 .productName = product_name, \ 161 .useProtocol = use_protocol, \ 162 .useTransport = use_transport, \ 163 .initFunction = init_function, \ 164 } 165 166 static struct us_unusual_dev realtek_cr_unusual_dev_list[] = { 167 # include "unusual_realtek.h" 168 { } /* Terminating entry */ 169 }; 170 171 #undef UNUSUAL_DEV 172 173 static int rts51x_bulk_transport(struct us_data *us, u8 lun, 174 u8 *cmd, int cmd_len, u8 *buf, int buf_len, 175 enum dma_data_direction dir, int *act_len) 176 { 177 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 178 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf; 179 int result; 180 unsigned int residue; 181 unsigned int cswlen; 182 unsigned int cbwlen = US_BULK_CB_WRAP_LEN; 183 184 /* set up the command wrapper */ 185 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 186 bcb->DataTransferLength = cpu_to_le32(buf_len); 187 bcb->Flags = (dir == DMA_FROM_DEVICE) ? 1 << 7 : 0; 188 bcb->Tag = ++us->tag; 189 bcb->Lun = lun; 190 bcb->Length = cmd_len; 191 192 /* copy the command payload */ 193 memset(bcb->CDB, 0, sizeof(bcb->CDB)); 194 memcpy(bcb->CDB, cmd, bcb->Length); 195 196 /* send it to out endpoint */ 197 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, 198 bcb, cbwlen, NULL); 199 if (result != USB_STOR_XFER_GOOD) 200 return USB_STOR_TRANSPORT_ERROR; 201 202 /* DATA STAGE */ 203 /* send/receive data payload, if there is any */ 204 205 if (buf && buf_len) { 206 unsigned int pipe = (dir == DMA_FROM_DEVICE) ? 207 us->recv_bulk_pipe : us->send_bulk_pipe; 208 result = usb_stor_bulk_transfer_buf(us, pipe, 209 buf, buf_len, NULL); 210 if (result == USB_STOR_XFER_ERROR) 211 return USB_STOR_TRANSPORT_ERROR; 212 } 213 214 /* get CSW for device status */ 215 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, 216 bcs, US_BULK_CS_WRAP_LEN, &cswlen); 217 if (result != USB_STOR_XFER_GOOD) 218 return USB_STOR_TRANSPORT_ERROR; 219 220 /* check bulk status */ 221 if (bcs->Signature != cpu_to_le32(US_BULK_CS_SIGN)) { 222 US_DEBUGP("Signature mismatch: got %08X, expecting %08X\n", 223 le32_to_cpu(bcs->Signature), 224 US_BULK_CS_SIGN); 225 return USB_STOR_TRANSPORT_ERROR; 226 } 227 228 residue = bcs->Residue; 229 if (bcs->Tag != us->tag) 230 return USB_STOR_TRANSPORT_ERROR; 231 232 /* try to compute the actual residue, based on how much data 233 * was really transferred and what the device tells us */ 234 if (residue) 235 residue = residue < buf_len ? residue : buf_len; 236 237 if (act_len) 238 *act_len = buf_len - residue; 239 240 /* based on the status code, we report good or bad */ 241 switch (bcs->Status) { 242 case US_BULK_STAT_OK: 243 /* command good -- note that data could be short */ 244 return USB_STOR_TRANSPORT_GOOD; 245 246 case US_BULK_STAT_FAIL: 247 /* command failed */ 248 return USB_STOR_TRANSPORT_FAILED; 249 250 case US_BULK_STAT_PHASE: 251 /* phase error -- note that a transport reset will be 252 * invoked by the invoke_transport() function 253 */ 254 return USB_STOR_TRANSPORT_ERROR; 255 } 256 257 /* we should never get here, but if we do, we're in trouble */ 258 return USB_STOR_TRANSPORT_ERROR; 259 } 260 261 /* Determine what the maximum LUN supported is */ 262 static int rts51x_get_max_lun(struct us_data *us) 263 { 264 int result; 265 266 /* issue the command */ 267 us->iobuf[0] = 0; 268 result = usb_stor_control_msg(us, us->recv_ctrl_pipe, 269 US_BULK_GET_MAX_LUN, 270 USB_DIR_IN | USB_TYPE_CLASS | 271 USB_RECIP_INTERFACE, 272 0, us->ifnum, us->iobuf, 1, 10*HZ); 273 274 US_DEBUGP("GetMaxLUN command result is %d, data is %d\n", 275 result, us->iobuf[0]); 276 277 /* if we have a successful request, return the result */ 278 if (result > 0) 279 return us->iobuf[0]; 280 281 return 0; 282 } 283 284 static int rts51x_read_mem(struct us_data *us, u16 addr, u8 *data, u16 len) 285 { 286 int retval; 287 u8 cmnd[12] = {0}; 288 289 US_DEBUGP("%s, addr = 0x%x, len = %d\n", __func__, addr, len); 290 291 cmnd[0] = 0xF0; 292 cmnd[1] = 0x0D; 293 cmnd[2] = (u8)(addr >> 8); 294 cmnd[3] = (u8)addr; 295 cmnd[4] = (u8)(len >> 8); 296 cmnd[5] = (u8)len; 297 298 retval = rts51x_bulk_transport(us, 0, cmnd, 12, 299 data, len, DMA_FROM_DEVICE, NULL); 300 if (retval != USB_STOR_TRANSPORT_GOOD) 301 return -EIO; 302 303 return 0; 304 } 305 306 static int rts51x_write_mem(struct us_data *us, u16 addr, u8 *data, u16 len) 307 { 308 int retval; 309 u8 cmnd[12] = {0}; 310 311 US_DEBUGP("%s, addr = 0x%x, len = %d\n", __func__, addr, len); 312 313 cmnd[0] = 0xF0; 314 cmnd[1] = 0x0E; 315 cmnd[2] = (u8)(addr >> 8); 316 cmnd[3] = (u8)addr; 317 cmnd[4] = (u8)(len >> 8); 318 cmnd[5] = (u8)len; 319 320 retval = rts51x_bulk_transport(us, 0, cmnd, 12, 321 data, len, DMA_TO_DEVICE, NULL); 322 if (retval != USB_STOR_TRANSPORT_GOOD) 323 return -EIO; 324 325 return 0; 326 } 327 328 static int rts51x_read_status(struct us_data *us, 329 u8 lun, u8 *status, int len, int *actlen) 330 { 331 int retval; 332 u8 cmnd[12] = {0}; 333 334 US_DEBUGP("%s, lun = %d\n", __func__, lun); 335 336 cmnd[0] = 0xF0; 337 cmnd[1] = 0x09; 338 339 retval = rts51x_bulk_transport(us, lun, cmnd, 12, 340 status, len, DMA_FROM_DEVICE, actlen); 341 if (retval != USB_STOR_TRANSPORT_GOOD) 342 return -EIO; 343 344 return 0; 345 } 346 347 static int rts51x_check_status(struct us_data *us, u8 lun) 348 { 349 struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra); 350 int retval; 351 u8 buf[16]; 352 353 retval = rts51x_read_status(us, lun, buf, 16, &(chip->status_len)); 354 if (retval < 0) 355 return -EIO; 356 357 US_DEBUGP("chip->status_len = %d\n", chip->status_len); 358 359 chip->status[lun].vid = ((u16)buf[0] << 8) | buf[1]; 360 chip->status[lun].pid = ((u16)buf[2] << 8) | buf[3]; 361 chip->status[lun].cur_lun = buf[4]; 362 chip->status[lun].card_type = buf[5]; 363 chip->status[lun].total_lun = buf[6]; 364 chip->status[lun].fw_ver = ((u16)buf[7] << 8) | buf[8]; 365 chip->status[lun].phy_exist = buf[9]; 366 chip->status[lun].multi_flag = buf[10]; 367 chip->status[lun].multi_card = buf[11]; 368 chip->status[lun].log_exist = buf[12]; 369 if (chip->status_len == 16) { 370 chip->status[lun].detailed_type.detailed_type1 = buf[13]; 371 chip->status[lun].function[0] = buf[14]; 372 chip->status[lun].function[1] = buf[15]; 373 } 374 375 return 0; 376 } 377 378 static int enable_oscillator(struct us_data *us) 379 { 380 int retval; 381 u8 value; 382 383 retval = rts51x_read_mem(us, 0xFE77, &value, 1); 384 if (retval < 0) 385 return -EIO; 386 387 value |= 0x04; 388 retval = rts51x_write_mem(us, 0xFE77, &value, 1); 389 if (retval < 0) 390 return -EIO; 391 392 retval = rts51x_read_mem(us, 0xFE77, &value, 1); 393 if (retval < 0) 394 return -EIO; 395 396 if (!(value & 0x04)) 397 return -EIO; 398 399 return 0; 400 } 401 402 static int do_config_autodelink(struct us_data *us, int enable, int force) 403 { 404 int retval; 405 u8 value; 406 407 retval = rts51x_read_mem(us, 0xFE47, &value, 1); 408 if (retval < 0) 409 return -EIO; 410 411 if (enable) { 412 if (force) 413 value |= 0x03; 414 else 415 value |= 0x01; 416 } else { 417 value &= ~0x03; 418 } 419 420 US_DEBUGP("In %s,set 0xfe47 to 0x%x\n", __func__, value); 421 422 retval = rts51x_write_mem(us, 0xFE47, &value, 1); 423 if (retval < 0) 424 return -EIO; 425 426 return 0; 427 } 428 429 static int config_autodelink_after_power_on(struct us_data *us) 430 { 431 struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra); 432 int retval; 433 u8 value; 434 435 if (!CHK_AUTO_DELINK(chip)) 436 return 0; 437 438 retval = rts51x_read_mem(us, 0xFE47, &value, 1); 439 if (retval < 0) 440 return -EIO; 441 442 if (auto_delink_en) { 443 CLR_BIT(value, 0); 444 CLR_BIT(value, 1); 445 SET_BIT(value, 2); 446 447 if (CHECK_ID(chip, 0x0138, 0x3882)) 448 CLR_BIT(value, 2); 449 450 SET_BIT(value, 7); 451 452 retval = rts51x_write_mem(us, 0xFE47, &value, 1); 453 if (retval < 0) 454 return -EIO; 455 456 retval = enable_oscillator(us); 457 if (retval == 0) 458 (void)do_config_autodelink(us, 1, 0); 459 } else { 460 /* Autodelink controlled by firmware */ 461 462 SET_BIT(value, 2); 463 464 if (CHECK_ID(chip, 0x0138, 0x3882)) 465 CLR_BIT(value, 2); 466 467 if (CHECK_ID(chip, 0x0159, 0x5889) || 468 CHECK_ID(chip, 0x0138, 0x3880)) { 469 CLR_BIT(value, 0); 470 CLR_BIT(value, 7); 471 } 472 473 retval = rts51x_write_mem(us, 0xFE47, &value, 1); 474 if (retval < 0) 475 return -EIO; 476 477 if (CHECK_ID(chip, 0x0159, 0x5888)) { 478 value = 0xFF; 479 retval = rts51x_write_mem(us, 0xFE79, &value, 1); 480 if (retval < 0) 481 return -EIO; 482 483 value = 0x01; 484 retval = rts51x_write_mem(us, 0x48, &value, 1); 485 if (retval < 0) 486 return -EIO; 487 } 488 } 489 490 return 0; 491 } 492 493 static int config_autodelink_before_power_down(struct us_data *us) 494 { 495 struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra); 496 int retval; 497 u8 value; 498 499 if (!CHK_AUTO_DELINK(chip)) 500 return 0; 501 502 if (auto_delink_en) { 503 retval = rts51x_read_mem(us, 0xFE77, &value, 1); 504 if (retval < 0) 505 return -EIO; 506 507 SET_BIT(value, 2); 508 retval = rts51x_write_mem(us, 0xFE77, &value, 1); 509 if (retval < 0) 510 return -EIO; 511 512 if (CHECK_ID(chip, 0x0159, 0x5888)) { 513 value = 0x01; 514 retval = rts51x_write_mem(us, 0x48, &value, 1); 515 if (retval < 0) 516 return -EIO; 517 } 518 519 retval = rts51x_read_mem(us, 0xFE47, &value, 1); 520 if (retval < 0) 521 return -EIO; 522 523 SET_BIT(value, 0); 524 if (CHECK_ID(chip, 0x0138, 0x3882)) 525 SET_BIT(value, 2); 526 retval = rts51x_write_mem(us, 0xFE77, &value, 1); 527 if (retval < 0) 528 return -EIO; 529 } else { 530 if (CHECK_ID(chip, 0x0159, 0x5889) || 531 CHECK_ID(chip, 0x0138, 0x3880) || 532 CHECK_ID(chip, 0x0138, 0x3882)) { 533 retval = rts51x_read_mem(us, 0xFE47, &value, 1); 534 if (retval < 0) 535 return -EIO; 536 537 if (CHECK_ID(chip, 0x0159, 0x5889) || 538 CHECK_ID(chip, 0x0138, 0x3880)) { 539 SET_BIT(value, 0); 540 SET_BIT(value, 7); 541 } 542 543 if (CHECK_ID(chip, 0x0138, 0x3882)) 544 SET_BIT(value, 2); 545 546 retval = rts51x_write_mem(us, 0xFE47, &value, 1); 547 if (retval < 0) 548 return -EIO; 549 } 550 551 if (CHECK_ID(chip, 0x0159, 0x5888)) { 552 value = 0x01; 553 retval = rts51x_write_mem(us, 0x48, &value, 1); 554 if (retval < 0) 555 return -EIO; 556 } 557 } 558 559 return 0; 560 } 561 562 static void realtek_cr_destructor(void *extra) 563 { 564 struct rts51x_chip *chip = (struct rts51x_chip *)extra; 565 566 if (!chip) 567 return; 568 569 kfree(chip->status); 570 } 571 572 #ifdef CONFIG_PM 573 static void realtek_pm_hook(struct us_data *us, int pm_state) 574 { 575 if (pm_state == US_SUSPEND) 576 (void)config_autodelink_before_power_down(us); 577 } 578 #endif 579 580 static int init_realtek_cr(struct us_data *us) 581 { 582 struct rts51x_chip *chip; 583 int size, i, retval; 584 585 chip = kzalloc(sizeof(struct rts51x_chip), GFP_KERNEL); 586 if (!chip) 587 return -ENOMEM; 588 589 us->extra = chip; 590 us->extra_destructor = realtek_cr_destructor; 591 #ifdef CONFIG_PM 592 us->suspend_resume_hook = realtek_pm_hook; 593 #endif 594 595 us->max_lun = chip->max_lun = rts51x_get_max_lun(us); 596 597 US_DEBUGP("chip->max_lun = %d\n", chip->max_lun); 598 599 size = (chip->max_lun + 1) * sizeof(struct rts51x_status); 600 chip->status = kzalloc(size, GFP_KERNEL); 601 if (!chip->status) 602 goto INIT_FAIL; 603 604 for (i = 0; i <= (int)(chip->max_lun); i++) { 605 retval = rts51x_check_status(us, (u8)i); 606 if (retval < 0) 607 goto INIT_FAIL; 608 } 609 610 if (CHECK_FW_VER(chip, 0x5888) || CHECK_FW_VER(chip, 0x5889) || 611 CHECK_FW_VER(chip, 0x5901)) 612 SET_AUTO_DELINK(chip); 613 if (STATUS_LEN(chip) == 16) { 614 if (SUPPORT_AUTO_DELINK(chip)) 615 SET_AUTO_DELINK(chip); 616 } 617 618 US_DEBUGP("chip->flag = 0x%x\n", chip->flag); 619 620 (void)config_autodelink_after_power_on(us); 621 622 return 0; 623 624 INIT_FAIL: 625 if (us->extra) { 626 kfree(chip->status); 627 kfree(us->extra); 628 us->extra = NULL; 629 } 630 631 return -EIO; 632 } 633 634 static int realtek_cr_probe(struct usb_interface *intf, 635 const struct usb_device_id *id) 636 { 637 struct us_data *us; 638 int result; 639 640 US_DEBUGP("Probe Realtek Card Reader!\n"); 641 642 result = usb_stor_probe1(&us, intf, id, 643 (id - realtek_cr_ids) + realtek_cr_unusual_dev_list); 644 if (result) 645 return result; 646 647 result = usb_stor_probe2(us); 648 return result; 649 } 650 651 static struct usb_driver realtek_cr_driver = { 652 .name = "ums-realtek", 653 .probe = realtek_cr_probe, 654 .disconnect = usb_stor_disconnect, 655 .suspend = usb_stor_suspend, 656 .resume = usb_stor_resume, 657 .reset_resume = usb_stor_reset_resume, 658 .pre_reset = usb_stor_pre_reset, 659 .post_reset = usb_stor_post_reset, 660 .id_table = realtek_cr_ids, 661 .soft_unbind = 1, 662 }; 663 664 static int __init realtek_cr_init(void) 665 { 666 return usb_register(&realtek_cr_driver); 667 } 668 669 static void __exit realtek_cr_exit(void) 670 { 671 usb_deregister(&realtek_cr_driver); 672 } 673 674 module_init(realtek_cr_init); 675 module_exit(realtek_cr_exit); 676