1 /* Driver for Realtek PCI-Express card reader 2 * 3 * Copyright(c) 2009-2013 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 * Wei WANG (wei_wang@realsil.com.cn) 20 * Micky Ching (micky_ching@realsil.com.cn) 21 */ 22 23 #include <linux/blkdev.h> 24 #include <linux/kthread.h> 25 #include <linux/sched.h> 26 #include <linux/vmalloc.h> 27 28 #include "rtsx.h" 29 #include "sd.h" 30 #include "ms.h" 31 #include "spi.h" 32 33 void scsi_show_command(struct rtsx_chip *chip) 34 { 35 struct scsi_cmnd *srb = chip->srb; 36 char *what = NULL; 37 bool unknown_cmd = false; 38 int len; 39 40 switch (srb->cmnd[0]) { 41 case TEST_UNIT_READY: 42 what = "TEST_UNIT_READY"; 43 break; 44 case REZERO_UNIT: 45 what = "REZERO_UNIT"; 46 break; 47 case REQUEST_SENSE: 48 what = "REQUEST_SENSE"; 49 break; 50 case FORMAT_UNIT: 51 what = "FORMAT_UNIT"; 52 break; 53 case READ_BLOCK_LIMITS: 54 what = "READ_BLOCK_LIMITS"; 55 break; 56 case REASSIGN_BLOCKS: 57 what = "REASSIGN_BLOCKS"; 58 break; 59 case READ_6: 60 what = "READ_6"; 61 break; 62 case WRITE_6: 63 what = "WRITE_6"; 64 break; 65 case SEEK_6: 66 what = "SEEK_6"; 67 break; 68 case READ_REVERSE: 69 what = "READ_REVERSE"; 70 break; 71 case WRITE_FILEMARKS: 72 what = "WRITE_FILEMARKS"; 73 break; 74 case SPACE: 75 what = "SPACE"; 76 break; 77 case INQUIRY: 78 what = "INQUIRY"; 79 break; 80 case RECOVER_BUFFERED_DATA: 81 what = "RECOVER_BUFFERED_DATA"; 82 break; 83 case MODE_SELECT: 84 what = "MODE_SELECT"; 85 break; 86 case RESERVE: 87 what = "RESERVE"; 88 break; 89 case RELEASE: 90 what = "RELEASE"; 91 break; 92 case COPY: 93 what = "COPY"; 94 break; 95 case ERASE: 96 what = "ERASE"; 97 break; 98 case MODE_SENSE: 99 what = "MODE_SENSE"; 100 break; 101 case START_STOP: 102 what = "START_STOP"; 103 break; 104 case RECEIVE_DIAGNOSTIC: 105 what = "RECEIVE_DIAGNOSTIC"; 106 break; 107 case SEND_DIAGNOSTIC: 108 what = "SEND_DIAGNOSTIC"; 109 break; 110 case ALLOW_MEDIUM_REMOVAL: 111 what = "ALLOW_MEDIUM_REMOVAL"; 112 break; 113 case SET_WINDOW: 114 what = "SET_WINDOW"; 115 break; 116 case READ_CAPACITY: 117 what = "READ_CAPACITY"; 118 break; 119 case READ_10: 120 what = "READ_10"; 121 break; 122 case WRITE_10: 123 what = "WRITE_10"; 124 break; 125 case SEEK_10: 126 what = "SEEK_10"; 127 break; 128 case WRITE_VERIFY: 129 what = "WRITE_VERIFY"; 130 break; 131 case VERIFY: 132 what = "VERIFY"; 133 break; 134 case SEARCH_HIGH: 135 what = "SEARCH_HIGH"; 136 break; 137 case SEARCH_EQUAL: 138 what = "SEARCH_EQUAL"; 139 break; 140 case SEARCH_LOW: 141 what = "SEARCH_LOW"; 142 break; 143 case SET_LIMITS: 144 what = "SET_LIMITS"; 145 break; 146 case READ_POSITION: 147 what = "READ_POSITION"; 148 break; 149 case SYNCHRONIZE_CACHE: 150 what = "SYNCHRONIZE_CACHE"; 151 break; 152 case LOCK_UNLOCK_CACHE: 153 what = "LOCK_UNLOCK_CACHE"; 154 break; 155 case READ_DEFECT_DATA: 156 what = "READ_DEFECT_DATA"; 157 break; 158 case MEDIUM_SCAN: 159 what = "MEDIUM_SCAN"; 160 break; 161 case COMPARE: 162 what = "COMPARE"; 163 break; 164 case COPY_VERIFY: 165 what = "COPY_VERIFY"; 166 break; 167 case WRITE_BUFFER: 168 what = "WRITE_BUFFER"; 169 break; 170 case READ_BUFFER: 171 what = "READ_BUFFER"; 172 break; 173 case UPDATE_BLOCK: 174 what = "UPDATE_BLOCK"; 175 break; 176 case READ_LONG: 177 what = "READ_LONG"; 178 break; 179 case WRITE_LONG: 180 what = "WRITE_LONG"; 181 break; 182 case CHANGE_DEFINITION: 183 what = "CHANGE_DEFINITION"; 184 break; 185 case WRITE_SAME: 186 what = "WRITE_SAME"; 187 break; 188 case GPCMD_READ_SUBCHANNEL: 189 what = "READ SUBCHANNEL"; 190 break; 191 case READ_TOC: 192 what = "READ_TOC"; 193 break; 194 case GPCMD_READ_HEADER: 195 what = "READ HEADER"; 196 break; 197 case GPCMD_PLAY_AUDIO_10: 198 what = "PLAY AUDIO (10)"; 199 break; 200 case GPCMD_PLAY_AUDIO_MSF: 201 what = "PLAY AUDIO MSF"; 202 break; 203 case GPCMD_GET_EVENT_STATUS_NOTIFICATION: 204 what = "GET EVENT/STATUS NOTIFICATION"; 205 break; 206 case GPCMD_PAUSE_RESUME: 207 what = "PAUSE/RESUME"; 208 break; 209 case LOG_SELECT: 210 what = "LOG_SELECT"; 211 break; 212 case LOG_SENSE: 213 what = "LOG_SENSE"; 214 break; 215 case GPCMD_STOP_PLAY_SCAN: 216 what = "STOP PLAY/SCAN"; 217 break; 218 case GPCMD_READ_DISC_INFO: 219 what = "READ DISC INFORMATION"; 220 break; 221 case GPCMD_READ_TRACK_RZONE_INFO: 222 what = "READ TRACK INFORMATION"; 223 break; 224 case GPCMD_RESERVE_RZONE_TRACK: 225 what = "RESERVE TRACK"; 226 break; 227 case GPCMD_SEND_OPC: 228 what = "SEND OPC"; 229 break; 230 case MODE_SELECT_10: 231 what = "MODE_SELECT_10"; 232 break; 233 case GPCMD_REPAIR_RZONE_TRACK: 234 what = "REPAIR TRACK"; 235 break; 236 case 0x59: 237 what = "READ MASTER CUE"; 238 break; 239 case MODE_SENSE_10: 240 what = "MODE_SENSE_10"; 241 break; 242 case GPCMD_CLOSE_TRACK: 243 what = "CLOSE TRACK/SESSION"; 244 break; 245 case 0x5C: 246 what = "READ BUFFER CAPACITY"; 247 break; 248 case 0x5D: 249 what = "SEND CUE SHEET"; 250 break; 251 case GPCMD_BLANK: 252 what = "BLANK"; 253 break; 254 case REPORT_LUNS: 255 what = "REPORT LUNS"; 256 break; 257 case MOVE_MEDIUM: 258 what = "MOVE_MEDIUM or PLAY AUDIO (12)"; 259 break; 260 case READ_12: 261 what = "READ_12"; 262 break; 263 case WRITE_12: 264 what = "WRITE_12"; 265 break; 266 case WRITE_VERIFY_12: 267 what = "WRITE_VERIFY_12"; 268 break; 269 case SEARCH_HIGH_12: 270 what = "SEARCH_HIGH_12"; 271 break; 272 case SEARCH_EQUAL_12: 273 what = "SEARCH_EQUAL_12"; 274 break; 275 case SEARCH_LOW_12: 276 what = "SEARCH_LOW_12"; 277 break; 278 case SEND_VOLUME_TAG: 279 what = "SEND_VOLUME_TAG"; 280 break; 281 case READ_ELEMENT_STATUS: 282 what = "READ_ELEMENT_STATUS"; 283 break; 284 case GPCMD_READ_CD_MSF: 285 what = "READ CD MSF"; 286 break; 287 case GPCMD_SCAN: 288 what = "SCAN"; 289 break; 290 case GPCMD_SET_SPEED: 291 what = "SET CD SPEED"; 292 break; 293 case GPCMD_MECHANISM_STATUS: 294 what = "MECHANISM STATUS"; 295 break; 296 case GPCMD_READ_CD: 297 what = "READ CD"; 298 break; 299 case 0xE1: 300 what = "WRITE CONTINUE"; 301 break; 302 case WRITE_LONG_2: 303 what = "WRITE_LONG_2"; 304 break; 305 case VENDOR_CMND: 306 what = "Realtek's vendor command"; 307 break; 308 default: 309 what = "(unknown command)"; 310 unknown_cmd = true; 311 break; 312 } 313 314 if (srb->cmnd[0] != TEST_UNIT_READY) 315 dev_dbg(rtsx_dev(chip), "Command %s (%d bytes)\n", 316 what, srb->cmd_len); 317 318 if (unknown_cmd) { 319 len = min_t(unsigned short, srb->cmd_len, 16); 320 dev_dbg(rtsx_dev(chip), "%*ph\n", len, srb->cmnd); 321 } 322 } 323 324 void set_sense_type(struct rtsx_chip *chip, unsigned int lun, int sense_type) 325 { 326 switch (sense_type) { 327 case SENSE_TYPE_MEDIA_CHANGE: 328 set_sense_data(chip, lun, CUR_ERR, 0x06, 0, 0x28, 0, 0, 0); 329 break; 330 331 case SENSE_TYPE_MEDIA_NOT_PRESENT: 332 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x3A, 0, 0, 0); 333 break; 334 335 case SENSE_TYPE_MEDIA_LBA_OVER_RANGE: 336 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x21, 0, 0, 0); 337 break; 338 339 case SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT: 340 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x25, 0, 0, 0); 341 break; 342 343 case SENSE_TYPE_MEDIA_WRITE_PROTECT: 344 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x27, 0, 0, 0); 345 break; 346 347 case SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR: 348 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x11, 0, 0, 0); 349 break; 350 351 case SENSE_TYPE_MEDIA_WRITE_ERR: 352 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x02, 0, 0); 353 break; 354 355 case SENSE_TYPE_MEDIA_INVALID_CMD_FIELD: 356 set_sense_data(chip, lun, CUR_ERR, ILGAL_REQ, 0, 357 ASC_INVLD_CDB, ASCQ_INVLD_CDB, CDB_ILLEGAL, 1); 358 break; 359 360 case SENSE_TYPE_FORMAT_IN_PROGRESS: 361 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 0, 0); 362 break; 363 364 case SENSE_TYPE_FORMAT_CMD_FAILED: 365 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x31, 0x01, 0, 0); 366 break; 367 368 #ifdef SUPPORT_MAGIC_GATE 369 case SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB: 370 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x02, 0, 0); 371 break; 372 373 case SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN: 374 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x00, 0, 0); 375 break; 376 377 case SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM: 378 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x30, 0x00, 0, 0); 379 break; 380 381 case SENSE_TYPE_MG_WRITE_ERR: 382 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x00, 0, 0); 383 break; 384 #endif 385 386 #ifdef SUPPORT_SD_LOCK 387 case SENSE_TYPE_MEDIA_READ_FORBIDDEN: 388 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x11, 0x13, 0, 0); 389 break; 390 #endif 391 392 case SENSE_TYPE_NO_SENSE: 393 default: 394 set_sense_data(chip, lun, CUR_ERR, 0, 0, 0, 0, 0, 0); 395 break; 396 } 397 } 398 399 void set_sense_data(struct rtsx_chip *chip, unsigned int lun, u8 err_code, 400 u8 sense_key, u32 info, u8 asc, u8 ascq, u8 sns_key_info0, 401 u16 sns_key_info1) 402 { 403 struct sense_data_t *sense = &chip->sense_buffer[lun]; 404 405 sense->err_code = err_code; 406 sense->sense_key = sense_key; 407 sense->info[0] = (u8)(info >> 24); 408 sense->info[1] = (u8)(info >> 16); 409 sense->info[2] = (u8)(info >> 8); 410 sense->info[3] = (u8)info; 411 412 sense->ad_sense_len = sizeof(struct sense_data_t) - 8; 413 sense->asc = asc; 414 sense->ascq = ascq; 415 if (sns_key_info0 != 0) { 416 sense->sns_key_info[0] = SKSV | sns_key_info0; 417 sense->sns_key_info[1] = (sns_key_info1 & 0xf0) >> 8; 418 sense->sns_key_info[2] = sns_key_info1 & 0x0f; 419 } 420 } 421 422 static int test_unit_ready(struct scsi_cmnd *srb, struct rtsx_chip *chip) 423 { 424 unsigned int lun = SCSI_LUN(srb); 425 426 if (!check_card_ready(chip, lun)) { 427 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 428 return TRANSPORT_FAILED; 429 } 430 431 if (!(CHK_BIT(chip->lun_mc, lun))) { 432 SET_BIT(chip->lun_mc, lun); 433 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE); 434 return TRANSPORT_FAILED; 435 } 436 437 #ifdef SUPPORT_SD_LOCK 438 if (get_lun_card(chip, SCSI_LUN(srb)) == SD_CARD) { 439 struct sd_info *sd_card = &chip->sd_card; 440 441 if (sd_card->sd_lock_notify) { 442 sd_card->sd_lock_notify = 0; 443 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE); 444 return TRANSPORT_FAILED; 445 } else if (sd_card->sd_lock_status & SD_LOCKED) { 446 set_sense_type(chip, lun, 447 SENSE_TYPE_MEDIA_READ_FORBIDDEN); 448 return TRANSPORT_FAILED; 449 } 450 } 451 #endif 452 453 return TRANSPORT_GOOD; 454 } 455 456 static unsigned char formatter_inquiry_str[20] = { 457 'M', 'E', 'M', 'O', 'R', 'Y', 'S', 'T', 'I', 'C', 'K', 458 #ifdef SUPPORT_MAGIC_GATE 459 '-', 'M', 'G', /* Byte[47:49] */ 460 #else 461 0x20, 0x20, 0x20, /* Byte[47:49] */ 462 #endif 463 464 #ifdef SUPPORT_MAGIC_GATE 465 0x0B, /* Byte[50]: MG, MS, MSPro, MSXC */ 466 #else 467 0x09, /* Byte[50]: MS, MSPro, MSXC */ 468 #endif 469 0x00, /* Byte[51]: Category Specific Commands */ 470 0x00, /* Byte[52]: Access Control and feature */ 471 0x20, 0x20, 0x20, /* Byte[53:55] */ 472 }; 473 474 static int inquiry(struct scsi_cmnd *srb, struct rtsx_chip *chip) 475 { 476 unsigned int lun = SCSI_LUN(srb); 477 char *inquiry_default = (char *)"Generic-xD/SD/M.S. 1.00 "; 478 char *inquiry_sdms = (char *)"Generic-SD/MemoryStick 1.00 "; 479 char *inquiry_sd = (char *)"Generic-SD/MMC 1.00 "; 480 char *inquiry_ms = (char *)"Generic-MemoryStick 1.00 "; 481 char *inquiry_string; 482 unsigned char sendbytes; 483 unsigned char *buf; 484 u8 card = get_lun_card(chip, lun); 485 bool pro_formatter_flag = false; 486 unsigned char inquiry_buf[] = { 487 QULIFIRE | DRCT_ACCESS_DEV, 488 RMB_DISC | 0x0D, 489 0x00, 490 0x01, 491 0x1f, 492 0x02, 493 0, 494 REL_ADR | WBUS_32 | WBUS_16 | SYNC | LINKED | CMD_QUE | SFT_RE, 495 }; 496 497 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) { 498 if (chip->lun2card[lun] == SD_CARD) 499 inquiry_string = inquiry_sd; 500 else 501 inquiry_string = inquiry_ms; 502 503 } else if (CHECK_LUN_MODE(chip, SD_MS_1LUN)) { 504 inquiry_string = inquiry_sdms; 505 } else { 506 inquiry_string = inquiry_default; 507 } 508 509 buf = vmalloc(scsi_bufflen(srb)); 510 if (!buf) { 511 rtsx_trace(chip); 512 return TRANSPORT_ERROR; 513 } 514 515 #ifdef SUPPORT_MAGIC_GATE 516 if ((chip->mspro_formatter_enable) && 517 (chip->lun2card[lun] & MS_CARD)) 518 #else 519 if (chip->mspro_formatter_enable) 520 #endif 521 if (!card || (card == MS_CARD)) 522 pro_formatter_flag = true; 523 524 if (pro_formatter_flag) { 525 if (scsi_bufflen(srb) < 56) 526 sendbytes = (unsigned char)(scsi_bufflen(srb)); 527 else 528 sendbytes = 56; 529 530 } else { 531 if (scsi_bufflen(srb) < 36) 532 sendbytes = (unsigned char)(scsi_bufflen(srb)); 533 else 534 sendbytes = 36; 535 } 536 537 if (sendbytes > 8) { 538 memcpy(buf, inquiry_buf, 8); 539 memcpy(buf + 8, inquiry_string, sendbytes - 8); 540 if (pro_formatter_flag) { 541 /* Additional Length */ 542 buf[4] = 0x33; 543 } 544 } else { 545 memcpy(buf, inquiry_buf, sendbytes); 546 } 547 548 if (pro_formatter_flag) { 549 if (sendbytes > 36) 550 memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36); 551 } 552 553 scsi_set_resid(srb, 0); 554 555 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb); 556 vfree(buf); 557 558 return TRANSPORT_GOOD; 559 } 560 561 static int start_stop_unit(struct scsi_cmnd *srb, struct rtsx_chip *chip) 562 { 563 unsigned int lun = SCSI_LUN(srb); 564 565 scsi_set_resid(srb, scsi_bufflen(srb)); 566 567 if (srb->cmnd[1] == 1) 568 return TRANSPORT_GOOD; 569 570 switch (srb->cmnd[0x4]) { 571 case STOP_MEDIUM: 572 /* Media disabled */ 573 return TRANSPORT_GOOD; 574 575 case UNLOAD_MEDIUM: 576 /* Media shall be unload */ 577 if (check_card_ready(chip, lun)) 578 eject_card(chip, lun); 579 return TRANSPORT_GOOD; 580 581 case MAKE_MEDIUM_READY: 582 case LOAD_MEDIUM: 583 if (check_card_ready(chip, lun)) 584 return TRANSPORT_GOOD; 585 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 586 rtsx_trace(chip); 587 return TRANSPORT_FAILED; 588 589 break; 590 } 591 592 rtsx_trace(chip); 593 return TRANSPORT_ERROR; 594 } 595 596 static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip) 597 { 598 int prevent; 599 600 prevent = srb->cmnd[4] & 0x1; 601 602 scsi_set_resid(srb, 0); 603 604 if (prevent) { 605 set_sense_type(chip, SCSI_LUN(srb), 606 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 607 rtsx_trace(chip); 608 return TRANSPORT_FAILED; 609 } 610 611 return TRANSPORT_GOOD; 612 } 613 614 static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip) 615 { 616 struct sense_data_t *sense; 617 unsigned int lun = SCSI_LUN(srb); 618 struct ms_info *ms_card = &chip->ms_card; 619 unsigned char *tmp, *buf; 620 621 sense = &chip->sense_buffer[lun]; 622 623 if ((get_lun_card(chip, lun) == MS_CARD) && 624 ms_card->pro_under_formatting) { 625 if (ms_card->format_status == FORMAT_SUCCESS) { 626 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE); 627 ms_card->pro_under_formatting = 0; 628 ms_card->progress = 0; 629 } else if (ms_card->format_status == FORMAT_IN_PROGRESS) { 630 /* Logical Unit Not Ready Format in Progress */ 631 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 632 0, (u16)(ms_card->progress)); 633 } else { 634 /* Format Command Failed */ 635 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED); 636 ms_card->pro_under_formatting = 0; 637 ms_card->progress = 0; 638 } 639 640 rtsx_set_stat(chip, RTSX_STAT_RUN); 641 } 642 643 buf = vmalloc(scsi_bufflen(srb)); 644 if (!buf) { 645 rtsx_trace(chip); 646 return TRANSPORT_ERROR; 647 } 648 649 tmp = (unsigned char *)sense; 650 memcpy(buf, tmp, scsi_bufflen(srb)); 651 652 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb); 653 vfree(buf); 654 655 scsi_set_resid(srb, 0); 656 /* Reset Sense Data */ 657 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE); 658 return TRANSPORT_GOOD; 659 } 660 661 static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd, 662 int lun, u8 *buf, int buf_len) 663 { 664 struct ms_info *ms_card = &chip->ms_card; 665 int sys_info_offset; 666 int data_size = buf_len; 667 bool support_format = false; 668 int i = 0; 669 670 if (cmd == MODE_SENSE) { 671 sys_info_offset = 8; 672 if (data_size > 0x68) 673 data_size = 0x68; 674 675 buf[i++] = 0x67; /* Mode Data Length */ 676 } else { 677 sys_info_offset = 12; 678 if (data_size > 0x6C) 679 data_size = 0x6C; 680 681 buf[i++] = 0x00; /* Mode Data Length (MSB) */ 682 buf[i++] = 0x6A; /* Mode Data Length (LSB) */ 683 } 684 685 /* Medium Type Code */ 686 if (check_card_ready(chip, lun)) { 687 if (CHK_MSXC(ms_card)) { 688 support_format = true; 689 buf[i++] = 0x40; 690 } else if (CHK_MSPRO(ms_card)) { 691 support_format = true; 692 buf[i++] = 0x20; 693 } else { 694 buf[i++] = 0x10; 695 } 696 697 /* WP */ 698 if (check_card_wp(chip, lun)) 699 buf[i++] = 0x80; 700 else 701 buf[i++] = 0x00; 702 703 } else { 704 buf[i++] = 0x00; /* MediaType */ 705 buf[i++] = 0x00; /* WP */ 706 } 707 708 buf[i++] = 0x00; /* Reserved */ 709 710 if (cmd == MODE_SENSE_10) { 711 buf[i++] = 0x00; /* Reserved */ 712 buf[i++] = 0x00; /* Block descriptor length(MSB) */ 713 buf[i++] = 0x00; /* Block descriptor length(LSB) */ 714 715 /* The Following Data is the content of "Page 0x20" */ 716 if (data_size >= 9) 717 buf[i++] = 0x20; /* Page Code */ 718 if (data_size >= 10) 719 buf[i++] = 0x62; /* Page Length */ 720 if (data_size >= 11) 721 buf[i++] = 0x00; /* No Access Control */ 722 if (data_size >= 12) { 723 if (support_format) 724 buf[i++] = 0xC0; /* SF, SGM */ 725 else 726 buf[i++] = 0x00; 727 } 728 } else { 729 /* The Following Data is the content of "Page 0x20" */ 730 if (data_size >= 5) 731 buf[i++] = 0x20; /* Page Code */ 732 if (data_size >= 6) 733 buf[i++] = 0x62; /* Page Length */ 734 if (data_size >= 7) 735 buf[i++] = 0x00; /* No Access Control */ 736 if (data_size >= 8) { 737 if (support_format) 738 buf[i++] = 0xC0; /* SF, SGM */ 739 else 740 buf[i++] = 0x00; 741 } 742 } 743 744 if (data_size > sys_info_offset) { 745 /* 96 Bytes Attribute Data */ 746 int len = data_size - sys_info_offset; 747 748 len = (len < 96) ? len : 96; 749 750 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len); 751 } 752 } 753 754 static int mode_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip) 755 { 756 unsigned int lun = SCSI_LUN(srb); 757 unsigned int data_size; 758 int status; 759 bool pro_formatter_flag; 760 unsigned char page_code, *buf; 761 u8 card = get_lun_card(chip, lun); 762 763 #ifndef SUPPORT_MAGIC_GATE 764 if (!check_card_ready(chip, lun)) { 765 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 766 scsi_set_resid(srb, scsi_bufflen(srb)); 767 rtsx_trace(chip); 768 return TRANSPORT_FAILED; 769 } 770 #endif 771 772 pro_formatter_flag = false; 773 data_size = 8; 774 #ifdef SUPPORT_MAGIC_GATE 775 if ((chip->lun2card[lun] & MS_CARD)) { 776 if (!card || (card == MS_CARD)) { 777 data_size = 108; 778 if (chip->mspro_formatter_enable) 779 pro_formatter_flag = true; 780 } 781 } 782 #else 783 if (card == MS_CARD) { 784 if (chip->mspro_formatter_enable) { 785 pro_formatter_flag = true; 786 data_size = 108; 787 } 788 } 789 #endif 790 791 buf = kmalloc(data_size, GFP_KERNEL); 792 if (!buf) { 793 rtsx_trace(chip); 794 return TRANSPORT_ERROR; 795 } 796 797 page_code = srb->cmnd[2] & 0x3f; 798 799 if ((page_code == 0x3F) || (page_code == 0x1C) || 800 (page_code == 0x00) || 801 (pro_formatter_flag && (page_code == 0x20))) { 802 if (srb->cmnd[0] == MODE_SENSE) { 803 if ((page_code == 0x3F) || (page_code == 0x20)) { 804 ms_mode_sense(chip, srb->cmnd[0], 805 lun, buf, data_size); 806 } else { 807 data_size = 4; 808 buf[0] = 0x03; 809 buf[1] = 0x00; 810 if (check_card_wp(chip, lun)) 811 buf[2] = 0x80; 812 else 813 buf[2] = 0x00; 814 815 buf[3] = 0x00; 816 } 817 } else { 818 if ((page_code == 0x3F) || (page_code == 0x20)) { 819 ms_mode_sense(chip, srb->cmnd[0], 820 lun, buf, data_size); 821 } else { 822 data_size = 8; 823 buf[0] = 0x00; 824 buf[1] = 0x06; 825 buf[2] = 0x00; 826 if (check_card_wp(chip, lun)) 827 buf[3] = 0x80; 828 else 829 buf[3] = 0x00; 830 buf[4] = 0x00; 831 buf[5] = 0x00; 832 buf[6] = 0x00; 833 buf[7] = 0x00; 834 } 835 } 836 status = TRANSPORT_GOOD; 837 } else { 838 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 839 scsi_set_resid(srb, scsi_bufflen(srb)); 840 status = TRANSPORT_FAILED; 841 } 842 843 if (status == TRANSPORT_GOOD) { 844 unsigned int len = min_t(unsigned int, scsi_bufflen(srb), 845 data_size); 846 rtsx_stor_set_xfer_buf(buf, len, srb); 847 scsi_set_resid(srb, scsi_bufflen(srb) - len); 848 } 849 kfree(buf); 850 851 return status; 852 } 853 854 static int read_write(struct scsi_cmnd *srb, struct rtsx_chip *chip) 855 { 856 #ifdef SUPPORT_SD_LOCK 857 struct sd_info *sd_card = &chip->sd_card; 858 #endif 859 unsigned int lun = SCSI_LUN(srb); 860 int retval; 861 u32 start_sec; 862 u16 sec_cnt; 863 864 rtsx_disable_aspm(chip); 865 866 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 867 rtsx_exit_ss(chip); 868 wait_timeout(100); 869 } 870 rtsx_set_stat(chip, RTSX_STAT_RUN); 871 872 if (!check_card_ready(chip, lun) || (get_card_size(chip, lun) == 0)) { 873 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 874 rtsx_trace(chip); 875 return TRANSPORT_FAILED; 876 } 877 878 if (!(CHK_BIT(chip->lun_mc, lun))) { 879 SET_BIT(chip->lun_mc, lun); 880 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE); 881 return TRANSPORT_FAILED; 882 } 883 884 #ifdef SUPPORT_SD_LOCK 885 if (sd_card->sd_erase_status) { 886 /* Accessing to any card is forbidden 887 * until the erase procedure of SD is completed 888 */ 889 dev_dbg(rtsx_dev(chip), "SD card being erased!\n"); 890 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN); 891 rtsx_trace(chip); 892 return TRANSPORT_FAILED; 893 } 894 895 if (get_lun_card(chip, lun) == SD_CARD) { 896 if (sd_card->sd_lock_status & SD_LOCKED) { 897 dev_dbg(rtsx_dev(chip), "SD card locked!\n"); 898 set_sense_type(chip, lun, 899 SENSE_TYPE_MEDIA_READ_FORBIDDEN); 900 rtsx_trace(chip); 901 return TRANSPORT_FAILED; 902 } 903 } 904 #endif 905 906 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) { 907 start_sec = ((u32)srb->cmnd[2] << 24) | 908 ((u32)srb->cmnd[3] << 16) | 909 ((u32)srb->cmnd[4] << 8) | ((u32)srb->cmnd[5]); 910 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8]; 911 } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) { 912 start_sec = ((u32)(srb->cmnd[1] & 0x1F) << 16) | 913 ((u32)srb->cmnd[2] << 8) | ((u32)srb->cmnd[3]); 914 sec_cnt = srb->cmnd[4]; 915 if (sec_cnt == 0) 916 sec_cnt = 256; 917 } else if ((srb->cmnd[0] == VENDOR_CMND) && 918 (srb->cmnd[1] == SCSI_APP_CMD) && 919 ((srb->cmnd[2] == PP_READ10) || (srb->cmnd[2] == PP_WRITE10))) { 920 start_sec = ((u32)srb->cmnd[4] << 24) | 921 ((u32)srb->cmnd[5] << 16) | 922 ((u32)srb->cmnd[6] << 8) | ((u32)srb->cmnd[7]); 923 sec_cnt = ((u16)(srb->cmnd[9]) << 8) | srb->cmnd[10]; 924 } else { 925 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 926 rtsx_trace(chip); 927 return TRANSPORT_FAILED; 928 } 929 930 /* In some test, we will receive a start_sec like 0xFFFFFFFF. 931 * In this situation, start_sec + sec_cnt will overflow, so we 932 * need to judge start_sec at first 933 */ 934 if ((start_sec > get_card_size(chip, lun)) || 935 ((start_sec + sec_cnt) > get_card_size(chip, lun))) { 936 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE); 937 rtsx_trace(chip); 938 return TRANSPORT_FAILED; 939 } 940 941 if (sec_cnt == 0) { 942 scsi_set_resid(srb, 0); 943 return TRANSPORT_GOOD; 944 } 945 946 if (chip->rw_fail_cnt[lun] == 3) { 947 dev_dbg(rtsx_dev(chip), "read/write fail three times in succession\n"); 948 if (srb->sc_data_direction == DMA_FROM_DEVICE) 949 set_sense_type(chip, lun, 950 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 951 else 952 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR); 953 954 rtsx_trace(chip); 955 return TRANSPORT_FAILED; 956 } 957 958 if (srb->sc_data_direction == DMA_TO_DEVICE) { 959 if (check_card_wp(chip, lun)) { 960 dev_dbg(rtsx_dev(chip), "Write protected card!\n"); 961 set_sense_type(chip, lun, 962 SENSE_TYPE_MEDIA_WRITE_PROTECT); 963 rtsx_trace(chip); 964 return TRANSPORT_FAILED; 965 } 966 } 967 968 retval = card_rw(srb, chip, start_sec, sec_cnt); 969 if (retval != STATUS_SUCCESS) { 970 if (chip->need_release & chip->lun2card[lun]) { 971 chip->rw_fail_cnt[lun] = 0; 972 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 973 } else { 974 chip->rw_fail_cnt[lun]++; 975 if (srb->sc_data_direction == DMA_FROM_DEVICE) 976 set_sense_type 977 (chip, lun, 978 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 979 else 980 set_sense_type(chip, lun, 981 SENSE_TYPE_MEDIA_WRITE_ERR); 982 } 983 retval = TRANSPORT_FAILED; 984 rtsx_trace(chip); 985 goto exit; 986 } else { 987 chip->rw_fail_cnt[lun] = 0; 988 retval = TRANSPORT_GOOD; 989 } 990 991 scsi_set_resid(srb, 0); 992 993 exit: 994 return retval; 995 } 996 997 static int read_format_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip) 998 { 999 unsigned char *buf; 1000 unsigned int lun = SCSI_LUN(srb); 1001 unsigned int buf_len; 1002 u8 card = get_lun_card(chip, lun); 1003 u32 card_size; 1004 int desc_cnt; 1005 int i = 0; 1006 1007 if (!check_card_ready(chip, lun)) { 1008 if (!chip->mspro_formatter_enable) { 1009 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 1010 rtsx_trace(chip); 1011 return TRANSPORT_FAILED; 1012 } 1013 } 1014 1015 buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12; 1016 1017 buf = kmalloc(buf_len, GFP_KERNEL); 1018 if (!buf) { 1019 rtsx_trace(chip); 1020 return TRANSPORT_ERROR; 1021 } 1022 1023 buf[i++] = 0; 1024 buf[i++] = 0; 1025 buf[i++] = 0; 1026 1027 /* Capacity List Length */ 1028 if ((buf_len > 12) && chip->mspro_formatter_enable && 1029 (chip->lun2card[lun] & MS_CARD) && 1030 (!card || (card == MS_CARD))) { 1031 buf[i++] = 0x10; 1032 desc_cnt = 2; 1033 } else { 1034 buf[i++] = 0x08; 1035 desc_cnt = 1; 1036 } 1037 1038 while (desc_cnt) { 1039 if (check_card_ready(chip, lun)) { 1040 card_size = get_card_size(chip, lun); 1041 buf[i++] = (unsigned char)(card_size >> 24); 1042 buf[i++] = (unsigned char)(card_size >> 16); 1043 buf[i++] = (unsigned char)(card_size >> 8); 1044 buf[i++] = (unsigned char)card_size; 1045 1046 if (desc_cnt == 2) 1047 buf[i++] = 2; 1048 else 1049 buf[i++] = 0; 1050 } else { 1051 buf[i++] = 0xFF; 1052 buf[i++] = 0xFF; 1053 buf[i++] = 0xFF; 1054 buf[i++] = 0xFF; 1055 1056 if (desc_cnt == 2) 1057 buf[i++] = 3; 1058 else 1059 buf[i++] = 0; 1060 } 1061 1062 buf[i++] = 0x00; 1063 buf[i++] = 0x02; 1064 buf[i++] = 0x00; 1065 1066 desc_cnt--; 1067 } 1068 1069 buf_len = min_t(unsigned int, scsi_bufflen(srb), buf_len); 1070 rtsx_stor_set_xfer_buf(buf, buf_len, srb); 1071 kfree(buf); 1072 1073 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len); 1074 1075 return TRANSPORT_GOOD; 1076 } 1077 1078 static int read_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1079 { 1080 unsigned char *buf; 1081 unsigned int lun = SCSI_LUN(srb); 1082 u32 card_size; 1083 1084 if (!check_card_ready(chip, lun)) { 1085 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 1086 rtsx_trace(chip); 1087 return TRANSPORT_FAILED; 1088 } 1089 1090 if (!(CHK_BIT(chip->lun_mc, lun))) { 1091 SET_BIT(chip->lun_mc, lun); 1092 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE); 1093 return TRANSPORT_FAILED; 1094 } 1095 1096 buf = kmalloc(8, GFP_KERNEL); 1097 if (!buf) { 1098 rtsx_trace(chip); 1099 return TRANSPORT_ERROR; 1100 } 1101 1102 card_size = get_card_size(chip, lun); 1103 buf[0] = (unsigned char)((card_size - 1) >> 24); 1104 buf[1] = (unsigned char)((card_size - 1) >> 16); 1105 buf[2] = (unsigned char)((card_size - 1) >> 8); 1106 buf[3] = (unsigned char)(card_size - 1); 1107 1108 buf[4] = 0x00; 1109 buf[5] = 0x00; 1110 buf[6] = 0x02; 1111 buf[7] = 0x00; 1112 1113 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb); 1114 kfree(buf); 1115 1116 scsi_set_resid(srb, 0); 1117 1118 return TRANSPORT_GOOD; 1119 } 1120 1121 static int read_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1122 { 1123 unsigned short len, i; 1124 int retval; 1125 u8 *buf; 1126 1127 rtsx_disable_aspm(chip); 1128 1129 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1130 rtsx_exit_ss(chip); 1131 wait_timeout(100); 1132 } 1133 rtsx_set_stat(chip, RTSX_STAT_RUN); 1134 1135 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 1136 1137 buf = vmalloc(len); 1138 if (!buf) { 1139 rtsx_trace(chip); 1140 return TRANSPORT_ERROR; 1141 } 1142 1143 retval = rtsx_force_power_on(chip, SSC_PDCTL); 1144 if (retval != STATUS_SUCCESS) { 1145 vfree(buf); 1146 set_sense_type(chip, SCSI_LUN(srb), 1147 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1148 rtsx_trace(chip); 1149 return TRANSPORT_FAILED; 1150 } 1151 1152 for (i = 0; i < len; i++) { 1153 retval = spi_read_eeprom(chip, i, buf + i); 1154 if (retval != STATUS_SUCCESS) { 1155 vfree(buf); 1156 set_sense_type(chip, SCSI_LUN(srb), 1157 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1158 rtsx_trace(chip); 1159 return TRANSPORT_FAILED; 1160 } 1161 } 1162 1163 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len); 1164 rtsx_stor_set_xfer_buf(buf, len, srb); 1165 scsi_set_resid(srb, scsi_bufflen(srb) - len); 1166 1167 vfree(buf); 1168 1169 return TRANSPORT_GOOD; 1170 } 1171 1172 static int write_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1173 { 1174 unsigned short len, i; 1175 int retval; 1176 u8 *buf; 1177 1178 rtsx_disable_aspm(chip); 1179 1180 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1181 rtsx_exit_ss(chip); 1182 wait_timeout(100); 1183 } 1184 rtsx_set_stat(chip, RTSX_STAT_RUN); 1185 1186 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 1187 1188 retval = rtsx_force_power_on(chip, SSC_PDCTL); 1189 if (retval != STATUS_SUCCESS) { 1190 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 1191 rtsx_trace(chip); 1192 return TRANSPORT_FAILED; 1193 } 1194 1195 if (len == 511) { 1196 retval = spi_erase_eeprom_chip(chip); 1197 if (retval != STATUS_SUCCESS) { 1198 set_sense_type(chip, SCSI_LUN(srb), 1199 SENSE_TYPE_MEDIA_WRITE_ERR); 1200 rtsx_trace(chip); 1201 return TRANSPORT_FAILED; 1202 } 1203 } else { 1204 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), 1205 len); 1206 buf = vmalloc(len); 1207 if (!buf) { 1208 rtsx_trace(chip); 1209 return TRANSPORT_ERROR; 1210 } 1211 1212 rtsx_stor_get_xfer_buf(buf, len, srb); 1213 scsi_set_resid(srb, scsi_bufflen(srb) - len); 1214 1215 for (i = 0; i < len; i++) { 1216 retval = spi_write_eeprom(chip, i, buf[i]); 1217 if (retval != STATUS_SUCCESS) { 1218 vfree(buf); 1219 set_sense_type(chip, SCSI_LUN(srb), 1220 SENSE_TYPE_MEDIA_WRITE_ERR); 1221 rtsx_trace(chip); 1222 return TRANSPORT_FAILED; 1223 } 1224 } 1225 1226 vfree(buf); 1227 } 1228 1229 return TRANSPORT_GOOD; 1230 } 1231 1232 static int read_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1233 { 1234 unsigned short addr, len, i; 1235 int retval; 1236 u8 *buf; 1237 1238 rtsx_disable_aspm(chip); 1239 1240 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1241 rtsx_exit_ss(chip); 1242 wait_timeout(100); 1243 } 1244 rtsx_set_stat(chip, RTSX_STAT_RUN); 1245 1246 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3]; 1247 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 1248 1249 if (addr < 0xFC00) { 1250 set_sense_type(chip, SCSI_LUN(srb), 1251 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1252 rtsx_trace(chip); 1253 return TRANSPORT_FAILED; 1254 } 1255 1256 buf = vmalloc(len); 1257 if (!buf) { 1258 rtsx_trace(chip); 1259 return TRANSPORT_ERROR; 1260 } 1261 1262 retval = rtsx_force_power_on(chip, SSC_PDCTL); 1263 if (retval != STATUS_SUCCESS) { 1264 vfree(buf); 1265 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 1266 rtsx_trace(chip); 1267 return TRANSPORT_FAILED; 1268 } 1269 1270 for (i = 0; i < len; i++) { 1271 retval = rtsx_read_register(chip, addr + i, buf + i); 1272 if (retval != STATUS_SUCCESS) { 1273 vfree(buf); 1274 set_sense_type(chip, SCSI_LUN(srb), 1275 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1276 rtsx_trace(chip); 1277 return TRANSPORT_FAILED; 1278 } 1279 } 1280 1281 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len); 1282 rtsx_stor_set_xfer_buf(buf, len, srb); 1283 scsi_set_resid(srb, scsi_bufflen(srb) - len); 1284 1285 vfree(buf); 1286 1287 return TRANSPORT_GOOD; 1288 } 1289 1290 static int write_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1291 { 1292 unsigned short addr, len, i; 1293 int retval; 1294 u8 *buf; 1295 1296 rtsx_disable_aspm(chip); 1297 1298 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1299 rtsx_exit_ss(chip); 1300 wait_timeout(100); 1301 } 1302 rtsx_set_stat(chip, RTSX_STAT_RUN); 1303 1304 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3]; 1305 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 1306 1307 if (addr < 0xFC00) { 1308 set_sense_type(chip, SCSI_LUN(srb), 1309 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1310 rtsx_trace(chip); 1311 return TRANSPORT_FAILED; 1312 } 1313 1314 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len); 1315 buf = vmalloc(len); 1316 if (!buf) { 1317 rtsx_trace(chip); 1318 return TRANSPORT_ERROR; 1319 } 1320 1321 rtsx_stor_get_xfer_buf(buf, len, srb); 1322 scsi_set_resid(srb, scsi_bufflen(srb) - len); 1323 1324 retval = rtsx_force_power_on(chip, SSC_PDCTL); 1325 if (retval != STATUS_SUCCESS) { 1326 vfree(buf); 1327 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 1328 rtsx_trace(chip); 1329 return TRANSPORT_FAILED; 1330 } 1331 1332 for (i = 0; i < len; i++) { 1333 retval = rtsx_write_register(chip, addr + i, 0xFF, buf[i]); 1334 if (retval != STATUS_SUCCESS) { 1335 vfree(buf); 1336 set_sense_type(chip, SCSI_LUN(srb), 1337 SENSE_TYPE_MEDIA_WRITE_ERR); 1338 rtsx_trace(chip); 1339 return TRANSPORT_FAILED; 1340 } 1341 } 1342 1343 vfree(buf); 1344 1345 return TRANSPORT_GOOD; 1346 } 1347 1348 static int get_sd_csd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1349 { 1350 struct sd_info *sd_card = &chip->sd_card; 1351 unsigned int lun = SCSI_LUN(srb); 1352 1353 if (!check_card_ready(chip, lun)) { 1354 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 1355 rtsx_trace(chip); 1356 return TRANSPORT_FAILED; 1357 } 1358 1359 if (get_lun_card(chip, lun) != SD_CARD) { 1360 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1361 rtsx_trace(chip); 1362 return TRANSPORT_FAILED; 1363 } 1364 1365 scsi_set_resid(srb, 0); 1366 rtsx_stor_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb); 1367 1368 return TRANSPORT_GOOD; 1369 } 1370 1371 static int toggle_gpio_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1372 { 1373 u8 gpio = srb->cmnd[2]; 1374 1375 rtsx_disable_aspm(chip); 1376 1377 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1378 rtsx_exit_ss(chip); 1379 wait_timeout(100); 1380 } 1381 rtsx_set_stat(chip, RTSX_STAT_RUN); 1382 1383 if (gpio > 3) 1384 gpio = 1; 1385 toggle_gpio(chip, gpio); 1386 1387 return TRANSPORT_GOOD; 1388 } 1389 1390 #ifdef _MSG_TRACE 1391 static int trace_msg_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1392 { 1393 unsigned char *ptr, *buf = NULL; 1394 int i, msg_cnt; 1395 u8 clear; 1396 unsigned int buf_len; 1397 1398 buf_len = 4 + ((2 + MSG_FUNC_LEN + MSG_FILE_LEN + TIME_VAL_LEN) * 1399 TRACE_ITEM_CNT); 1400 1401 if ((scsi_bufflen(srb) < buf_len) || !scsi_sglist(srb)) { 1402 set_sense_type(chip, SCSI_LUN(srb), 1403 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1404 rtsx_trace(chip); 1405 return TRANSPORT_FAILED; 1406 } 1407 1408 clear = srb->cmnd[2]; 1409 1410 buf = vmalloc(scsi_bufflen(srb)); 1411 if (!buf) { 1412 rtsx_trace(chip); 1413 return TRANSPORT_ERROR; 1414 } 1415 ptr = buf; 1416 1417 if (chip->trace_msg[chip->msg_idx].valid) 1418 msg_cnt = TRACE_ITEM_CNT; 1419 else 1420 msg_cnt = chip->msg_idx; 1421 1422 *(ptr++) = (u8)(msg_cnt >> 24); 1423 *(ptr++) = (u8)(msg_cnt >> 16); 1424 *(ptr++) = (u8)(msg_cnt >> 8); 1425 *(ptr++) = (u8)msg_cnt; 1426 dev_dbg(rtsx_dev(chip), "Trace message count is %d\n", msg_cnt); 1427 1428 for (i = 1; i <= msg_cnt; i++) { 1429 int j, idx; 1430 1431 idx = chip->msg_idx - i; 1432 if (idx < 0) 1433 idx += TRACE_ITEM_CNT; 1434 1435 *(ptr++) = (u8)(chip->trace_msg[idx].line >> 8); 1436 *(ptr++) = (u8)(chip->trace_msg[idx].line); 1437 for (j = 0; j < MSG_FUNC_LEN; j++) 1438 *(ptr++) = chip->trace_msg[idx].func[j]; 1439 1440 for (j = 0; j < MSG_FILE_LEN; j++) 1441 *(ptr++) = chip->trace_msg[idx].file[j]; 1442 1443 for (j = 0; j < TIME_VAL_LEN; j++) 1444 *(ptr++) = chip->trace_msg[idx].timeval_buf[j]; 1445 } 1446 1447 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb); 1448 vfree(buf); 1449 1450 if (clear) { 1451 chip->msg_idx = 0; 1452 for (i = 0; i < TRACE_ITEM_CNT; i++) 1453 chip->trace_msg[i].valid = 0; 1454 } 1455 1456 scsi_set_resid(srb, 0); 1457 return TRANSPORT_GOOD; 1458 } 1459 #endif 1460 1461 static int read_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1462 { 1463 u8 addr, buf[4]; 1464 u32 val; 1465 unsigned int len; 1466 1467 rtsx_disable_aspm(chip); 1468 1469 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1470 rtsx_exit_ss(chip); 1471 wait_timeout(100); 1472 } 1473 rtsx_set_stat(chip, RTSX_STAT_RUN); 1474 1475 addr = srb->cmnd[4]; 1476 1477 val = rtsx_readl(chip, addr); 1478 dev_dbg(rtsx_dev(chip), "Host register (0x%x): 0x%x\n", addr, val); 1479 1480 buf[0] = (u8)(val >> 24); 1481 buf[1] = (u8)(val >> 16); 1482 buf[2] = (u8)(val >> 8); 1483 buf[3] = (u8)val; 1484 1485 len = min_t(unsigned int, scsi_bufflen(srb), 4); 1486 rtsx_stor_set_xfer_buf(buf, len, srb); 1487 scsi_set_resid(srb, scsi_bufflen(srb) - len); 1488 1489 return TRANSPORT_GOOD; 1490 } 1491 1492 static int write_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1493 { 1494 u8 addr, buf[4]; 1495 u32 val; 1496 unsigned int len; 1497 1498 rtsx_disable_aspm(chip); 1499 1500 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1501 rtsx_exit_ss(chip); 1502 wait_timeout(100); 1503 } 1504 rtsx_set_stat(chip, RTSX_STAT_RUN); 1505 1506 addr = srb->cmnd[4]; 1507 1508 len = min_t(unsigned int, scsi_bufflen(srb), 4); 1509 rtsx_stor_get_xfer_buf(buf, len, srb); 1510 scsi_set_resid(srb, scsi_bufflen(srb) - len); 1511 1512 val = ((u32)buf[0] << 24) | ((u32)buf[1] << 16) | ((u32)buf[2] 1513 << 8) | buf[3]; 1514 1515 rtsx_writel(chip, addr, val); 1516 1517 return TRANSPORT_GOOD; 1518 } 1519 1520 static int set_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1521 { 1522 unsigned int lun = SCSI_LUN(srb); 1523 1524 if (srb->cmnd[3] == 1) { 1525 /* Variable Clock */ 1526 struct xd_info *xd_card = &chip->xd_card; 1527 struct sd_info *sd_card = &chip->sd_card; 1528 struct ms_info *ms_card = &chip->ms_card; 1529 1530 switch (srb->cmnd[4]) { 1531 case XD_CARD: 1532 xd_card->xd_clock = srb->cmnd[5]; 1533 break; 1534 1535 case SD_CARD: 1536 sd_card->sd_clock = srb->cmnd[5]; 1537 break; 1538 1539 case MS_CARD: 1540 ms_card->ms_clock = srb->cmnd[5]; 1541 break; 1542 1543 default: 1544 set_sense_type(chip, lun, 1545 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1546 rtsx_trace(chip); 1547 return TRANSPORT_FAILED; 1548 } 1549 } else if (srb->cmnd[3] == 2) { 1550 if (srb->cmnd[4]) { 1551 chip->blink_led = 1; 1552 } else { 1553 int retval; 1554 1555 chip->blink_led = 0; 1556 1557 rtsx_disable_aspm(chip); 1558 1559 if (chip->ss_en && 1560 (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1561 rtsx_exit_ss(chip); 1562 wait_timeout(100); 1563 } 1564 rtsx_set_stat(chip, RTSX_STAT_RUN); 1565 1566 retval = rtsx_force_power_on(chip, SSC_PDCTL); 1567 if (retval != STATUS_SUCCESS) { 1568 set_sense_type(chip, SCSI_LUN(srb), 1569 SENSE_TYPE_MEDIA_WRITE_ERR); 1570 rtsx_trace(chip); 1571 return TRANSPORT_FAILED; 1572 } 1573 1574 turn_off_led(chip, LED_GPIO); 1575 } 1576 } else { 1577 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1578 rtsx_trace(chip); 1579 return TRANSPORT_FAILED; 1580 } 1581 1582 return TRANSPORT_GOOD; 1583 } 1584 1585 static int get_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1586 { 1587 unsigned int lun = SCSI_LUN(srb); 1588 1589 if (srb->cmnd[3] == 1) { 1590 struct xd_info *xd_card = &chip->xd_card; 1591 struct sd_info *sd_card = &chip->sd_card; 1592 struct ms_info *ms_card = &chip->ms_card; 1593 u8 tmp; 1594 1595 switch (srb->cmnd[4]) { 1596 case XD_CARD: 1597 tmp = (u8)(xd_card->xd_clock); 1598 break; 1599 1600 case SD_CARD: 1601 tmp = (u8)(sd_card->sd_clock); 1602 break; 1603 1604 case MS_CARD: 1605 tmp = (u8)(ms_card->ms_clock); 1606 break; 1607 1608 default: 1609 set_sense_type(chip, lun, 1610 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1611 rtsx_trace(chip); 1612 return TRANSPORT_FAILED; 1613 } 1614 1615 rtsx_stor_set_xfer_buf(&tmp, 1, srb); 1616 } else if (srb->cmnd[3] == 2) { 1617 u8 tmp = chip->blink_led; 1618 1619 rtsx_stor_set_xfer_buf(&tmp, 1, srb); 1620 } else { 1621 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1622 rtsx_trace(chip); 1623 return TRANSPORT_FAILED; 1624 } 1625 1626 return TRANSPORT_GOOD; 1627 } 1628 1629 static int dma_access_ring_buffer(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1630 { 1631 int retval; 1632 unsigned int lun = SCSI_LUN(srb); 1633 u16 len; 1634 1635 rtsx_disable_aspm(chip); 1636 1637 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1638 rtsx_exit_ss(chip); 1639 wait_timeout(100); 1640 } 1641 rtsx_set_stat(chip, RTSX_STAT_RUN); 1642 1643 len = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5]; 1644 len = min_t(u16, len, scsi_bufflen(srb)); 1645 1646 if (srb->sc_data_direction == DMA_FROM_DEVICE) 1647 dev_dbg(rtsx_dev(chip), "Read from device\n"); 1648 else 1649 dev_dbg(rtsx_dev(chip), "Write to device\n"); 1650 1651 retval = rtsx_transfer_data(chip, 0, scsi_sglist(srb), len, 1652 scsi_sg_count(srb), srb->sc_data_direction, 1653 1000); 1654 if (retval < 0) { 1655 if (srb->sc_data_direction == DMA_FROM_DEVICE) 1656 set_sense_type(chip, lun, 1657 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1658 else 1659 set_sense_type(chip, lun, 1660 SENSE_TYPE_MEDIA_WRITE_ERR); 1661 1662 rtsx_trace(chip); 1663 return TRANSPORT_FAILED; 1664 } 1665 scsi_set_resid(srb, 0); 1666 1667 return TRANSPORT_GOOD; 1668 } 1669 1670 static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1671 { 1672 struct sd_info *sd_card = &chip->sd_card; 1673 struct ms_info *ms_card = &chip->ms_card; 1674 int buf_len; 1675 unsigned int lun = SCSI_LUN(srb); 1676 u8 card = get_lun_card(chip, lun); 1677 u8 status[32]; 1678 #ifdef SUPPORT_OCP 1679 u8 oc_now_mask = 0, oc_ever_mask = 0; 1680 #endif 1681 1682 memset(status, 0, 32); 1683 1684 status[0] = (u8)(chip->product_id); 1685 status[1] = chip->ic_version; 1686 1687 if (chip->auto_delink_en) 1688 status[2] = 0x10; 1689 else 1690 status[2] = 0x00; 1691 1692 status[3] = 20; 1693 status[4] = 10; 1694 status[5] = 05; 1695 status[6] = 21; 1696 1697 if (chip->card_wp) 1698 status[7] = 0x20; 1699 else 1700 status[7] = 0x00; 1701 1702 #ifdef SUPPORT_OCP 1703 status[8] = 0; 1704 if (CHECK_LUN_MODE(chip, SD_MS_2LUN) && 1705 (chip->lun2card[lun] == MS_CARD)) { 1706 oc_now_mask = MS_OC_NOW; 1707 oc_ever_mask = MS_OC_EVER; 1708 } else { 1709 oc_now_mask = SD_OC_NOW; 1710 oc_ever_mask = SD_OC_EVER; 1711 } 1712 1713 if (chip->ocp_stat & oc_now_mask) 1714 status[8] |= 0x02; 1715 1716 if (chip->ocp_stat & oc_ever_mask) 1717 status[8] |= 0x01; 1718 #endif 1719 1720 if (card == SD_CARD) { 1721 if (CHK_SD(sd_card)) { 1722 if (CHK_SD_HCXC(sd_card)) { 1723 if (sd_card->capacity > 0x4000000) 1724 status[0x0E] = 0x02; 1725 else 1726 status[0x0E] = 0x01; 1727 } else { 1728 status[0x0E] = 0x00; 1729 } 1730 1731 if (CHK_SD_SDR104(sd_card)) 1732 status[0x0F] = 0x03; 1733 else if (CHK_SD_DDR50(sd_card)) 1734 status[0x0F] = 0x04; 1735 else if (CHK_SD_SDR50(sd_card)) 1736 status[0x0F] = 0x02; 1737 else if (CHK_SD_HS(sd_card)) 1738 status[0x0F] = 0x01; 1739 else 1740 status[0x0F] = 0x00; 1741 } else { 1742 if (CHK_MMC_SECTOR_MODE(sd_card)) 1743 status[0x0E] = 0x01; 1744 else 1745 status[0x0E] = 0x00; 1746 1747 if (CHK_MMC_DDR52(sd_card)) 1748 status[0x0F] = 0x03; 1749 else if (CHK_MMC_52M(sd_card)) 1750 status[0x0F] = 0x02; 1751 else if (CHK_MMC_26M(sd_card)) 1752 status[0x0F] = 0x01; 1753 else 1754 status[0x0F] = 0x00; 1755 } 1756 } else if (card == MS_CARD) { 1757 if (CHK_MSPRO(ms_card)) { 1758 if (CHK_MSXC(ms_card)) 1759 status[0x0E] = 0x01; 1760 else 1761 status[0x0E] = 0x00; 1762 1763 if (CHK_HG8BIT(ms_card)) 1764 status[0x0F] = 0x01; 1765 else 1766 status[0x0F] = 0x00; 1767 } 1768 } 1769 1770 #ifdef SUPPORT_SD_LOCK 1771 if (card == SD_CARD) { 1772 status[0x17] = 0x80; 1773 if (sd_card->sd_erase_status) 1774 status[0x17] |= 0x01; 1775 if (sd_card->sd_lock_status & SD_LOCKED) { 1776 status[0x17] |= 0x02; 1777 status[0x07] |= 0x40; 1778 } 1779 if (sd_card->sd_lock_status & SD_PWD_EXIST) 1780 status[0x17] |= 0x04; 1781 } else { 1782 status[0x17] = 0x00; 1783 } 1784 1785 dev_dbg(rtsx_dev(chip), "status[0x17] = 0x%x\n", status[0x17]); 1786 #endif 1787 1788 status[0x18] = 0x8A; 1789 status[0x1A] = 0x28; 1790 #ifdef SUPPORT_SD_LOCK 1791 status[0x1F] = 0x01; 1792 #endif 1793 1794 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(status)); 1795 rtsx_stor_set_xfer_buf(status, buf_len, srb); 1796 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len); 1797 1798 return TRANSPORT_GOOD; 1799 } 1800 1801 static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1802 { 1803 int phy_debug_mode; 1804 int retval; 1805 u16 reg; 1806 1807 if (!CHECK_PID(chip, 0x5208)) { 1808 set_sense_type(chip, SCSI_LUN(srb), 1809 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1810 rtsx_trace(chip); 1811 return TRANSPORT_FAILED; 1812 } 1813 1814 phy_debug_mode = (int)(srb->cmnd[3]); 1815 1816 if (phy_debug_mode) { 1817 chip->phy_debug_mode = 1; 1818 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0); 1819 if (retval != STATUS_SUCCESS) { 1820 rtsx_trace(chip); 1821 return TRANSPORT_FAILED; 1822 } 1823 1824 rtsx_disable_bus_int(chip); 1825 1826 retval = rtsx_read_phy_register(chip, 0x1C, ®); 1827 if (retval != STATUS_SUCCESS) { 1828 rtsx_trace(chip); 1829 return TRANSPORT_FAILED; 1830 } 1831 1832 reg |= 0x0001; 1833 retval = rtsx_write_phy_register(chip, 0x1C, reg); 1834 if (retval != STATUS_SUCCESS) { 1835 rtsx_trace(chip); 1836 return TRANSPORT_FAILED; 1837 } 1838 } else { 1839 chip->phy_debug_mode = 0; 1840 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77); 1841 if (retval != STATUS_SUCCESS) { 1842 rtsx_trace(chip); 1843 return TRANSPORT_FAILED; 1844 } 1845 1846 rtsx_enable_bus_int(chip); 1847 1848 retval = rtsx_read_phy_register(chip, 0x1C, ®); 1849 if (retval != STATUS_SUCCESS) { 1850 rtsx_trace(chip); 1851 return TRANSPORT_FAILED; 1852 } 1853 1854 reg &= 0xFFFE; 1855 retval = rtsx_write_phy_register(chip, 0x1C, reg); 1856 if (retval != STATUS_SUCCESS) { 1857 rtsx_trace(chip); 1858 return TRANSPORT_FAILED; 1859 } 1860 } 1861 1862 return TRANSPORT_GOOD; 1863 } 1864 1865 static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1866 { 1867 int retval = STATUS_SUCCESS; 1868 unsigned int lun = SCSI_LUN(srb); 1869 u8 cmd_type, mask, value, idx; 1870 u16 addr; 1871 1872 rtsx_disable_aspm(chip); 1873 1874 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1875 rtsx_exit_ss(chip); 1876 wait_timeout(100); 1877 } 1878 rtsx_set_stat(chip, RTSX_STAT_RUN); 1879 1880 switch (srb->cmnd[3]) { 1881 case INIT_BATCHCMD: 1882 rtsx_init_cmd(chip); 1883 break; 1884 1885 case ADD_BATCHCMD: 1886 cmd_type = srb->cmnd[4]; 1887 if (cmd_type > 2) { 1888 set_sense_type(chip, lun, 1889 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1890 rtsx_trace(chip); 1891 return TRANSPORT_FAILED; 1892 } 1893 addr = (srb->cmnd[5] << 8) | srb->cmnd[6]; 1894 mask = srb->cmnd[7]; 1895 value = srb->cmnd[8]; 1896 rtsx_add_cmd(chip, cmd_type, addr, mask, value); 1897 break; 1898 1899 case SEND_BATCHCMD: 1900 retval = rtsx_send_cmd(chip, 0, 1000); 1901 break; 1902 1903 case GET_BATCHRSP: 1904 idx = srb->cmnd[4]; 1905 value = *(rtsx_get_cmd_data(chip) + idx); 1906 if (scsi_bufflen(srb) < 1) { 1907 set_sense_type(chip, lun, 1908 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1909 rtsx_trace(chip); 1910 return TRANSPORT_FAILED; 1911 } 1912 rtsx_stor_set_xfer_buf(&value, 1, srb); 1913 scsi_set_resid(srb, 0); 1914 break; 1915 1916 default: 1917 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1918 rtsx_trace(chip); 1919 return TRANSPORT_FAILED; 1920 } 1921 1922 if (retval != STATUS_SUCCESS) { 1923 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR); 1924 rtsx_trace(chip); 1925 return TRANSPORT_FAILED; 1926 } 1927 1928 return TRANSPORT_GOOD; 1929 } 1930 1931 static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1932 { 1933 switch (srb->cmnd[3]) { 1934 case INIT_BATCHCMD: 1935 case ADD_BATCHCMD: 1936 case SEND_BATCHCMD: 1937 case GET_BATCHRSP: 1938 return rw_mem_cmd_buf(srb, chip); 1939 default: 1940 return TRANSPORT_ERROR; 1941 } 1942 } 1943 1944 static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1945 { 1946 unsigned short addr, len, i; 1947 int retval; 1948 u8 *buf; 1949 u16 val; 1950 1951 rtsx_disable_aspm(chip); 1952 1953 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1954 rtsx_exit_ss(chip); 1955 wait_timeout(100); 1956 } 1957 rtsx_set_stat(chip, RTSX_STAT_RUN); 1958 1959 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 1960 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7]; 1961 1962 if (len % 2) 1963 len -= len % 2; 1964 1965 if (len) { 1966 buf = vmalloc(len); 1967 if (!buf) { 1968 rtsx_trace(chip); 1969 return TRANSPORT_ERROR; 1970 } 1971 1972 retval = rtsx_force_power_on(chip, SSC_PDCTL); 1973 if (retval != STATUS_SUCCESS) { 1974 vfree(buf); 1975 set_sense_type(chip, SCSI_LUN(srb), 1976 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1977 rtsx_trace(chip); 1978 return TRANSPORT_FAILED; 1979 } 1980 1981 for (i = 0; i < len / 2; i++) { 1982 retval = rtsx_read_phy_register(chip, addr + i, &val); 1983 if (retval != STATUS_SUCCESS) { 1984 vfree(buf); 1985 set_sense_type 1986 (chip, SCSI_LUN(srb), 1987 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1988 rtsx_trace(chip); 1989 return TRANSPORT_FAILED; 1990 } 1991 1992 buf[2 * i] = (u8)(val >> 8); 1993 buf[2 * i + 1] = (u8)val; 1994 } 1995 1996 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), 1997 len); 1998 rtsx_stor_set_xfer_buf(buf, len, srb); 1999 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2000 2001 vfree(buf); 2002 } 2003 2004 return TRANSPORT_GOOD; 2005 } 2006 2007 static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2008 { 2009 unsigned short addr, len, i; 2010 int retval; 2011 u8 *buf; 2012 u16 val; 2013 2014 rtsx_disable_aspm(chip); 2015 2016 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2017 rtsx_exit_ss(chip); 2018 wait_timeout(100); 2019 } 2020 rtsx_set_stat(chip, RTSX_STAT_RUN); 2021 2022 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 2023 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7]; 2024 2025 if (len % 2) 2026 len -= len % 2; 2027 2028 if (len) { 2029 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), 2030 len); 2031 2032 buf = vmalloc(len); 2033 if (!buf) { 2034 rtsx_trace(chip); 2035 return TRANSPORT_ERROR; 2036 } 2037 2038 rtsx_stor_get_xfer_buf(buf, len, srb); 2039 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2040 2041 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2042 if (retval != STATUS_SUCCESS) { 2043 vfree(buf); 2044 set_sense_type(chip, SCSI_LUN(srb), 2045 SENSE_TYPE_MEDIA_WRITE_ERR); 2046 rtsx_trace(chip); 2047 return TRANSPORT_FAILED; 2048 } 2049 2050 for (i = 0; i < len / 2; i++) { 2051 val = ((u16)buf[2 * i] << 8) | buf[2 * i + 1]; 2052 retval = rtsx_write_phy_register(chip, addr + i, val); 2053 if (retval != STATUS_SUCCESS) { 2054 vfree(buf); 2055 set_sense_type(chip, SCSI_LUN(srb), 2056 SENSE_TYPE_MEDIA_WRITE_ERR); 2057 rtsx_trace(chip); 2058 return TRANSPORT_FAILED; 2059 } 2060 } 2061 2062 vfree(buf); 2063 } 2064 2065 return TRANSPORT_GOOD; 2066 } 2067 2068 static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2069 { 2070 unsigned short addr; 2071 int retval; 2072 u8 mode; 2073 2074 rtsx_disable_aspm(chip); 2075 2076 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2077 rtsx_exit_ss(chip); 2078 wait_timeout(100); 2079 } 2080 rtsx_set_stat(chip, RTSX_STAT_RUN); 2081 2082 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2083 if (retval != STATUS_SUCCESS) { 2084 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 2085 rtsx_trace(chip); 2086 return TRANSPORT_FAILED; 2087 } 2088 2089 mode = srb->cmnd[3]; 2090 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 2091 2092 if (mode == 0) { 2093 retval = spi_erase_eeprom_chip(chip); 2094 if (retval != STATUS_SUCCESS) { 2095 set_sense_type(chip, SCSI_LUN(srb), 2096 SENSE_TYPE_MEDIA_WRITE_ERR); 2097 rtsx_trace(chip); 2098 return TRANSPORT_FAILED; 2099 } 2100 } else if (mode == 1) { 2101 retval = spi_erase_eeprom_byte(chip, addr); 2102 if (retval != STATUS_SUCCESS) { 2103 set_sense_type(chip, SCSI_LUN(srb), 2104 SENSE_TYPE_MEDIA_WRITE_ERR); 2105 rtsx_trace(chip); 2106 return TRANSPORT_FAILED; 2107 } 2108 } else { 2109 set_sense_type(chip, SCSI_LUN(srb), 2110 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2111 rtsx_trace(chip); 2112 return TRANSPORT_FAILED; 2113 } 2114 2115 return TRANSPORT_GOOD; 2116 } 2117 2118 static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2119 { 2120 unsigned short addr, len, i; 2121 int retval; 2122 u8 *buf; 2123 2124 rtsx_disable_aspm(chip); 2125 2126 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2127 rtsx_exit_ss(chip); 2128 wait_timeout(100); 2129 } 2130 rtsx_set_stat(chip, RTSX_STAT_RUN); 2131 2132 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 2133 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7]; 2134 2135 buf = vmalloc(len); 2136 if (!buf) { 2137 rtsx_trace(chip); 2138 return TRANSPORT_ERROR; 2139 } 2140 2141 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2142 if (retval != STATUS_SUCCESS) { 2143 vfree(buf); 2144 set_sense_type(chip, SCSI_LUN(srb), 2145 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2146 rtsx_trace(chip); 2147 return TRANSPORT_FAILED; 2148 } 2149 2150 for (i = 0; i < len; i++) { 2151 retval = spi_read_eeprom(chip, addr + i, buf + i); 2152 if (retval != STATUS_SUCCESS) { 2153 vfree(buf); 2154 set_sense_type(chip, SCSI_LUN(srb), 2155 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2156 rtsx_trace(chip); 2157 return TRANSPORT_FAILED; 2158 } 2159 } 2160 2161 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len); 2162 rtsx_stor_set_xfer_buf(buf, len, srb); 2163 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2164 2165 vfree(buf); 2166 2167 return TRANSPORT_GOOD; 2168 } 2169 2170 static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2171 { 2172 unsigned short addr, len, i; 2173 int retval; 2174 u8 *buf; 2175 2176 rtsx_disable_aspm(chip); 2177 2178 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2179 rtsx_exit_ss(chip); 2180 wait_timeout(100); 2181 } 2182 rtsx_set_stat(chip, RTSX_STAT_RUN); 2183 2184 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 2185 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7]; 2186 2187 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len); 2188 buf = vmalloc(len); 2189 if (!buf) { 2190 rtsx_trace(chip); 2191 return TRANSPORT_ERROR; 2192 } 2193 2194 rtsx_stor_get_xfer_buf(buf, len, srb); 2195 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2196 2197 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2198 if (retval != STATUS_SUCCESS) { 2199 vfree(buf); 2200 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 2201 rtsx_trace(chip); 2202 return TRANSPORT_FAILED; 2203 } 2204 2205 for (i = 0; i < len; i++) { 2206 retval = spi_write_eeprom(chip, addr + i, buf[i]); 2207 if (retval != STATUS_SUCCESS) { 2208 vfree(buf); 2209 set_sense_type(chip, SCSI_LUN(srb), 2210 SENSE_TYPE_MEDIA_WRITE_ERR); 2211 rtsx_trace(chip); 2212 return TRANSPORT_FAILED; 2213 } 2214 } 2215 2216 vfree(buf); 2217 2218 return TRANSPORT_GOOD; 2219 } 2220 2221 static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2222 { 2223 int retval; 2224 u8 addr, len, i; 2225 u8 *buf; 2226 2227 rtsx_disable_aspm(chip); 2228 2229 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2230 rtsx_exit_ss(chip); 2231 wait_timeout(100); 2232 } 2233 rtsx_set_stat(chip, RTSX_STAT_RUN); 2234 2235 addr = srb->cmnd[4]; 2236 len = srb->cmnd[5]; 2237 2238 buf = vmalloc(len); 2239 if (!buf) { 2240 rtsx_trace(chip); 2241 return TRANSPORT_ERROR; 2242 } 2243 2244 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2245 if (retval != STATUS_SUCCESS) { 2246 vfree(buf); 2247 set_sense_type(chip, SCSI_LUN(srb), 2248 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2249 rtsx_trace(chip); 2250 return TRANSPORT_FAILED; 2251 } 2252 2253 for (i = 0; i < len; i++) { 2254 retval = rtsx_read_efuse(chip, addr + i, buf + i); 2255 if (retval != STATUS_SUCCESS) { 2256 vfree(buf); 2257 set_sense_type(chip, SCSI_LUN(srb), 2258 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2259 rtsx_trace(chip); 2260 return TRANSPORT_FAILED; 2261 } 2262 } 2263 2264 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len); 2265 rtsx_stor_set_xfer_buf(buf, len, srb); 2266 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2267 2268 vfree(buf); 2269 2270 return TRANSPORT_GOOD; 2271 } 2272 2273 static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2274 { 2275 int retval, result = TRANSPORT_GOOD; 2276 u16 val; 2277 u8 addr, len, i; 2278 u8 *buf; 2279 2280 rtsx_disable_aspm(chip); 2281 2282 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2283 rtsx_exit_ss(chip); 2284 wait_timeout(100); 2285 } 2286 rtsx_set_stat(chip, RTSX_STAT_RUN); 2287 2288 addr = srb->cmnd[4]; 2289 len = srb->cmnd[5]; 2290 2291 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len); 2292 buf = vmalloc(len); 2293 if (!buf) { 2294 rtsx_trace(chip); 2295 return TRANSPORT_ERROR; 2296 } 2297 2298 rtsx_stor_get_xfer_buf(buf, len, srb); 2299 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2300 2301 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2302 if (retval != STATUS_SUCCESS) { 2303 vfree(buf); 2304 rtsx_trace(chip); 2305 return TRANSPORT_ERROR; 2306 } 2307 2308 if (chip->asic_code) { 2309 retval = rtsx_read_phy_register(chip, 0x08, &val); 2310 if (retval != STATUS_SUCCESS) { 2311 vfree(buf); 2312 rtsx_trace(chip); 2313 return TRANSPORT_ERROR; 2314 } 2315 2316 retval = rtsx_write_register(chip, PWR_GATE_CTRL, 2317 LDO3318_PWR_MASK, LDO_OFF); 2318 if (retval != STATUS_SUCCESS) { 2319 vfree(buf); 2320 rtsx_trace(chip); 2321 return TRANSPORT_ERROR; 2322 } 2323 2324 wait_timeout(600); 2325 2326 retval = rtsx_write_phy_register(chip, 0x08, 2327 0x4C00 | chip->phy_voltage); 2328 if (retval != STATUS_SUCCESS) { 2329 vfree(buf); 2330 rtsx_trace(chip); 2331 return TRANSPORT_ERROR; 2332 } 2333 2334 retval = rtsx_write_register(chip, PWR_GATE_CTRL, 2335 LDO3318_PWR_MASK, LDO_ON); 2336 if (retval != STATUS_SUCCESS) { 2337 vfree(buf); 2338 rtsx_trace(chip); 2339 return TRANSPORT_ERROR; 2340 } 2341 2342 wait_timeout(600); 2343 } 2344 2345 retval = card_power_on(chip, SPI_CARD); 2346 if (retval != STATUS_SUCCESS) { 2347 vfree(buf); 2348 rtsx_trace(chip); 2349 return TRANSPORT_ERROR; 2350 } 2351 2352 wait_timeout(50); 2353 2354 for (i = 0; i < len; i++) { 2355 retval = rtsx_write_efuse(chip, addr + i, buf[i]); 2356 if (retval != STATUS_SUCCESS) { 2357 set_sense_type(chip, SCSI_LUN(srb), 2358 SENSE_TYPE_MEDIA_WRITE_ERR); 2359 result = TRANSPORT_FAILED; 2360 rtsx_trace(chip); 2361 goto exit; 2362 } 2363 } 2364 2365 exit: 2366 vfree(buf); 2367 2368 retval = card_power_off(chip, SPI_CARD); 2369 if (retval != STATUS_SUCCESS) { 2370 rtsx_trace(chip); 2371 return TRANSPORT_ERROR; 2372 } 2373 2374 if (chip->asic_code) { 2375 retval = rtsx_write_register(chip, PWR_GATE_CTRL, 2376 LDO3318_PWR_MASK, LDO_OFF); 2377 if (retval != STATUS_SUCCESS) { 2378 rtsx_trace(chip); 2379 return TRANSPORT_ERROR; 2380 } 2381 2382 wait_timeout(600); 2383 2384 retval = rtsx_write_phy_register(chip, 0x08, val); 2385 if (retval != STATUS_SUCCESS) { 2386 rtsx_trace(chip); 2387 return TRANSPORT_ERROR; 2388 } 2389 2390 retval = rtsx_write_register(chip, PWR_GATE_CTRL, 2391 LDO3318_PWR_MASK, LDO_ON); 2392 if (retval != STATUS_SUCCESS) { 2393 rtsx_trace(chip); 2394 return TRANSPORT_ERROR; 2395 } 2396 } 2397 2398 return result; 2399 } 2400 2401 static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2402 { 2403 int retval; 2404 bool func_max; 2405 u8 func; 2406 u16 addr, len; 2407 u8 *buf; 2408 2409 rtsx_disable_aspm(chip); 2410 2411 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2412 rtsx_exit_ss(chip); 2413 wait_timeout(100); 2414 } 2415 rtsx_set_stat(chip, RTSX_STAT_RUN); 2416 2417 func = srb->cmnd[3]; 2418 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5]; 2419 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7]; 2420 2421 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x, len = %d\n", 2422 __func__, func, addr, len); 2423 2424 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) 2425 func_max = true; 2426 else 2427 func_max = false; 2428 2429 if (func > func_max) { 2430 set_sense_type(chip, SCSI_LUN(srb), 2431 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2432 rtsx_trace(chip); 2433 return TRANSPORT_FAILED; 2434 } 2435 2436 buf = vmalloc(len); 2437 if (!buf) { 2438 rtsx_trace(chip); 2439 return TRANSPORT_ERROR; 2440 } 2441 2442 retval = rtsx_read_cfg_seq(chip, func, addr, buf, len); 2443 if (retval != STATUS_SUCCESS) { 2444 set_sense_type(chip, SCSI_LUN(srb), 2445 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2446 vfree(buf); 2447 rtsx_trace(chip); 2448 return TRANSPORT_FAILED; 2449 } 2450 2451 len = (u16)min_t(unsigned int, scsi_bufflen(srb), len); 2452 rtsx_stor_set_xfer_buf(buf, len, srb); 2453 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2454 2455 vfree(buf); 2456 2457 return TRANSPORT_GOOD; 2458 } 2459 2460 static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2461 { 2462 int retval; 2463 bool func_max; 2464 u8 func; 2465 u16 addr, len; 2466 u8 *buf; 2467 2468 rtsx_disable_aspm(chip); 2469 2470 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2471 rtsx_exit_ss(chip); 2472 wait_timeout(100); 2473 } 2474 rtsx_set_stat(chip, RTSX_STAT_RUN); 2475 2476 func = srb->cmnd[3]; 2477 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5]; 2478 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7]; 2479 2480 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x\n", 2481 __func__, func, addr); 2482 2483 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) 2484 func_max = true; 2485 else 2486 func_max = false; 2487 2488 if (func > func_max) { 2489 set_sense_type(chip, SCSI_LUN(srb), 2490 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2491 rtsx_trace(chip); 2492 return TRANSPORT_FAILED; 2493 } 2494 2495 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len); 2496 buf = vmalloc(len); 2497 if (!buf) { 2498 rtsx_trace(chip); 2499 return TRANSPORT_ERROR; 2500 } 2501 2502 rtsx_stor_get_xfer_buf(buf, len, srb); 2503 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2504 2505 retval = rtsx_write_cfg_seq(chip, func, addr, buf, len); 2506 if (retval != STATUS_SUCCESS) { 2507 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 2508 vfree(buf); 2509 rtsx_trace(chip); 2510 return TRANSPORT_FAILED; 2511 } 2512 2513 vfree(buf); 2514 2515 return TRANSPORT_GOOD; 2516 } 2517 2518 static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2519 { 2520 int result; 2521 2522 switch (srb->cmnd[2]) { 2523 case PP_READ10: 2524 case PP_WRITE10: 2525 result = read_write(srb, chip); 2526 break; 2527 2528 case READ_HOST_REG: 2529 result = read_host_reg(srb, chip); 2530 break; 2531 2532 case WRITE_HOST_REG: 2533 result = write_host_reg(srb, chip); 2534 break; 2535 2536 case GET_VAR: 2537 result = get_variable(srb, chip); 2538 break; 2539 2540 case SET_VAR: 2541 result = set_variable(srb, chip); 2542 break; 2543 2544 case DMA_READ: 2545 case DMA_WRITE: 2546 result = dma_access_ring_buffer(srb, chip); 2547 break; 2548 2549 case READ_PHY: 2550 result = read_phy_register(srb, chip); 2551 break; 2552 2553 case WRITE_PHY: 2554 result = write_phy_register(srb, chip); 2555 break; 2556 2557 case ERASE_EEPROM2: 2558 result = erase_eeprom2(srb, chip); 2559 break; 2560 2561 case READ_EEPROM2: 2562 result = read_eeprom2(srb, chip); 2563 break; 2564 2565 case WRITE_EEPROM2: 2566 result = write_eeprom2(srb, chip); 2567 break; 2568 2569 case READ_EFUSE: 2570 result = read_efuse(srb, chip); 2571 break; 2572 2573 case WRITE_EFUSE: 2574 result = write_efuse(srb, chip); 2575 break; 2576 2577 case READ_CFG: 2578 result = read_cfg_byte(srb, chip); 2579 break; 2580 2581 case WRITE_CFG: 2582 result = write_cfg_byte(srb, chip); 2583 break; 2584 2585 case SET_CHIP_MODE: 2586 result = set_chip_mode(srb, chip); 2587 break; 2588 2589 case SUIT_CMD: 2590 result = suit_cmd(srb, chip); 2591 break; 2592 2593 case GET_DEV_STATUS: 2594 result = get_dev_status(srb, chip); 2595 break; 2596 2597 default: 2598 set_sense_type(chip, SCSI_LUN(srb), 2599 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2600 rtsx_trace(chip); 2601 return TRANSPORT_FAILED; 2602 } 2603 2604 return result; 2605 } 2606 2607 static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2608 { 2609 u8 rtsx_status[16]; 2610 int buf_len; 2611 unsigned int lun = SCSI_LUN(srb); 2612 2613 rtsx_status[0] = (u8)(chip->vendor_id >> 8); 2614 rtsx_status[1] = (u8)(chip->vendor_id); 2615 2616 rtsx_status[2] = (u8)(chip->product_id >> 8); 2617 rtsx_status[3] = (u8)(chip->product_id); 2618 2619 rtsx_status[4] = (u8)lun; 2620 2621 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) { 2622 if (chip->lun2card[lun] == SD_CARD) 2623 rtsx_status[5] = 2; 2624 else 2625 rtsx_status[5] = 3; 2626 } else { 2627 if (chip->card_exist) { 2628 if (chip->card_exist & XD_CARD) 2629 rtsx_status[5] = 4; 2630 else if (chip->card_exist & SD_CARD) 2631 rtsx_status[5] = 2; 2632 else if (chip->card_exist & MS_CARD) 2633 rtsx_status[5] = 3; 2634 else 2635 rtsx_status[5] = 7; 2636 } else { 2637 rtsx_status[5] = 7; 2638 } 2639 } 2640 2641 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) 2642 rtsx_status[6] = 2; 2643 else 2644 rtsx_status[6] = 1; 2645 2646 rtsx_status[7] = (u8)(chip->product_id); 2647 rtsx_status[8] = chip->ic_version; 2648 2649 if (check_card_exist(chip, lun)) 2650 rtsx_status[9] = 1; 2651 else 2652 rtsx_status[9] = 0; 2653 2654 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) 2655 rtsx_status[10] = 0; 2656 else 2657 rtsx_status[10] = 1; 2658 2659 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) { 2660 if (chip->lun2card[lun] == SD_CARD) 2661 rtsx_status[11] = SD_CARD; 2662 else 2663 rtsx_status[11] = MS_CARD; 2664 } else { 2665 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD; 2666 } 2667 2668 if (check_card_ready(chip, lun)) 2669 rtsx_status[12] = 1; 2670 else 2671 rtsx_status[12] = 0; 2672 2673 if (get_lun_card(chip, lun) == XD_CARD) { 2674 rtsx_status[13] = 0x40; 2675 } else if (get_lun_card(chip, lun) == SD_CARD) { 2676 struct sd_info *sd_card = &chip->sd_card; 2677 2678 rtsx_status[13] = 0x20; 2679 if (CHK_SD(sd_card)) { 2680 if (CHK_SD_HCXC(sd_card)) 2681 rtsx_status[13] |= 0x04; 2682 if (CHK_SD_HS(sd_card)) 2683 rtsx_status[13] |= 0x02; 2684 } else { 2685 rtsx_status[13] |= 0x08; 2686 if (CHK_MMC_52M(sd_card)) 2687 rtsx_status[13] |= 0x02; 2688 if (CHK_MMC_SECTOR_MODE(sd_card)) 2689 rtsx_status[13] |= 0x04; 2690 } 2691 } else if (get_lun_card(chip, lun) == MS_CARD) { 2692 struct ms_info *ms_card = &chip->ms_card; 2693 2694 if (CHK_MSPRO(ms_card)) { 2695 rtsx_status[13] = 0x38; 2696 if (CHK_HG8BIT(ms_card)) 2697 rtsx_status[13] |= 0x04; 2698 #ifdef SUPPORT_MSXC 2699 if (CHK_MSXC(ms_card)) 2700 rtsx_status[13] |= 0x01; 2701 #endif 2702 } else { 2703 rtsx_status[13] = 0x30; 2704 } 2705 } else { 2706 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) { 2707 #ifdef SUPPORT_SDIO 2708 if (chip->sd_io && chip->sd_int) 2709 rtsx_status[13] = 0x60; 2710 else 2711 rtsx_status[13] = 0x70; 2712 #else 2713 rtsx_status[13] = 0x70; 2714 #endif 2715 } else { 2716 if (chip->lun2card[lun] == SD_CARD) 2717 rtsx_status[13] = 0x20; 2718 else 2719 rtsx_status[13] = 0x30; 2720 } 2721 } 2722 2723 rtsx_status[14] = 0x78; 2724 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) 2725 rtsx_status[15] = 0x83; 2726 else 2727 rtsx_status[15] = 0x82; 2728 2729 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(rtsx_status)); 2730 rtsx_stor_set_xfer_buf(rtsx_status, buf_len, srb); 2731 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len); 2732 2733 return TRANSPORT_GOOD; 2734 } 2735 2736 static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2737 { 2738 unsigned int lun = SCSI_LUN(srb); 2739 u8 card, bus_width; 2740 2741 if (!check_card_ready(chip, lun)) { 2742 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 2743 rtsx_trace(chip); 2744 return TRANSPORT_FAILED; 2745 } 2746 2747 card = get_lun_card(chip, lun); 2748 if ((card == SD_CARD) || (card == MS_CARD)) { 2749 bus_width = chip->card_bus_width[lun]; 2750 } else { 2751 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2752 rtsx_trace(chip); 2753 return TRANSPORT_FAILED; 2754 } 2755 2756 scsi_set_resid(srb, 0); 2757 rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb); 2758 2759 return TRANSPORT_GOOD; 2760 } 2761 2762 static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2763 { 2764 int result; 2765 unsigned int lun = SCSI_LUN(srb); 2766 u8 gpio_dir; 2767 2768 if (CHECK_PID(chip, 0x5208) || CHECK_PID(chip, 0x5288)) { 2769 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2770 rtsx_trace(chip); 2771 return TRANSPORT_FAILED; 2772 } 2773 2774 rtsx_disable_aspm(chip); 2775 2776 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2777 rtsx_exit_ss(chip); 2778 wait_timeout(100); 2779 } 2780 rtsx_set_stat(chip, RTSX_STAT_RUN); 2781 2782 rtsx_force_power_on(chip, SSC_PDCTL); 2783 2784 rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir); 2785 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06); 2786 2787 switch (srb->cmnd[2]) { 2788 case SCSI_SPI_GETSTATUS: 2789 result = spi_get_status(srb, chip); 2790 break; 2791 2792 case SCSI_SPI_SETPARAMETER: 2793 result = spi_set_parameter(srb, chip); 2794 break; 2795 2796 case SCSI_SPI_READFALSHID: 2797 result = spi_read_flash_id(srb, chip); 2798 break; 2799 2800 case SCSI_SPI_READFLASH: 2801 result = spi_read_flash(srb, chip); 2802 break; 2803 2804 case SCSI_SPI_WRITEFLASH: 2805 result = spi_write_flash(srb, chip); 2806 break; 2807 2808 case SCSI_SPI_WRITEFLASHSTATUS: 2809 result = spi_write_flash_status(srb, chip); 2810 break; 2811 2812 case SCSI_SPI_ERASEFLASH: 2813 result = spi_erase_flash(srb, chip); 2814 break; 2815 2816 default: 2817 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir); 2818 2819 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2820 rtsx_trace(chip); 2821 return TRANSPORT_FAILED; 2822 } 2823 2824 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir); 2825 2826 if (result != STATUS_SUCCESS) { 2827 rtsx_trace(chip); 2828 return TRANSPORT_FAILED; 2829 } 2830 2831 return TRANSPORT_GOOD; 2832 } 2833 2834 static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2835 { 2836 int result; 2837 2838 switch (srb->cmnd[1]) { 2839 case READ_STATUS: 2840 result = read_status(srb, chip); 2841 break; 2842 2843 case READ_MEM: 2844 result = read_mem(srb, chip); 2845 break; 2846 2847 case WRITE_MEM: 2848 result = write_mem(srb, chip); 2849 break; 2850 2851 case READ_EEPROM: 2852 result = read_eeprom(srb, chip); 2853 break; 2854 2855 case WRITE_EEPROM: 2856 result = write_eeprom(srb, chip); 2857 break; 2858 2859 case TOGGLE_GPIO: 2860 result = toggle_gpio_cmd(srb, chip); 2861 break; 2862 2863 case GET_SD_CSD: 2864 result = get_sd_csd(srb, chip); 2865 break; 2866 2867 case GET_BUS_WIDTH: 2868 result = get_card_bus_width(srb, chip); 2869 break; 2870 2871 #ifdef _MSG_TRACE 2872 case TRACE_MSG: 2873 result = trace_msg_cmd(srb, chip); 2874 break; 2875 #endif 2876 2877 case SCSI_APP_CMD: 2878 result = app_cmd(srb, chip); 2879 break; 2880 2881 case SPI_VENDOR_COMMAND: 2882 result = spi_vendor_cmd(srb, chip); 2883 break; 2884 2885 default: 2886 set_sense_type(chip, SCSI_LUN(srb), 2887 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2888 rtsx_trace(chip); 2889 return TRANSPORT_FAILED; 2890 } 2891 2892 return result; 2893 } 2894 2895 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK) 2896 void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2897 { 2898 unsigned int lun = SCSI_LUN(srb); 2899 u16 sec_cnt; 2900 2901 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) { 2902 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8]; 2903 } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) { 2904 sec_cnt = srb->cmnd[4]; 2905 if (sec_cnt == 0) 2906 sec_cnt = 256; 2907 } else { 2908 return; 2909 } 2910 2911 if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) { 2912 toggle_gpio(chip, LED_GPIO); 2913 chip->rw_cap[lun] = 0; 2914 } else { 2915 chip->rw_cap[lun] += sec_cnt; 2916 } 2917 } 2918 #endif 2919 2920 static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2921 { 2922 struct ms_info *ms_card = &chip->ms_card; 2923 unsigned int lun = SCSI_LUN(srb); 2924 bool quick_format; 2925 int retval; 2926 2927 if (get_lun_card(chip, lun) != MS_CARD) { 2928 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 2929 rtsx_trace(chip); 2930 return TRANSPORT_FAILED; 2931 } 2932 2933 if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47) || 2934 (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D) || 2935 (srb->cmnd[7] != 0x74)) { 2936 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2937 rtsx_trace(chip); 2938 return TRANSPORT_FAILED; 2939 } 2940 2941 rtsx_disable_aspm(chip); 2942 2943 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2944 rtsx_exit_ss(chip); 2945 wait_timeout(100); 2946 2947 if (!check_card_ready(chip, lun) || 2948 (get_card_size(chip, lun) == 0)) { 2949 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 2950 rtsx_trace(chip); 2951 return TRANSPORT_FAILED; 2952 } 2953 } 2954 rtsx_set_stat(chip, RTSX_STAT_RUN); 2955 2956 if (srb->cmnd[8] & 0x01) 2957 quick_format = false; 2958 else 2959 quick_format = true; 2960 2961 if (!(chip->card_ready & MS_CARD)) { 2962 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 2963 rtsx_trace(chip); 2964 return TRANSPORT_FAILED; 2965 } 2966 2967 if (chip->card_wp & MS_CARD) { 2968 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT); 2969 rtsx_trace(chip); 2970 return TRANSPORT_FAILED; 2971 } 2972 2973 if (!CHK_MSPRO(ms_card)) { 2974 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 2975 rtsx_trace(chip); 2976 return TRANSPORT_FAILED; 2977 } 2978 2979 retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format); 2980 if (retval != STATUS_SUCCESS) { 2981 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED); 2982 rtsx_trace(chip); 2983 return TRANSPORT_FAILED; 2984 } 2985 2986 scsi_set_resid(srb, 0); 2987 return TRANSPORT_GOOD; 2988 } 2989 2990 #ifdef SUPPORT_PCGL_1P18 2991 static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2992 { 2993 struct ms_info *ms_card = &chip->ms_card; 2994 unsigned int lun = SCSI_LUN(srb); 2995 u8 dev_info_id, data_len; 2996 u8 *buf; 2997 unsigned int buf_len; 2998 int i; 2999 3000 if (!check_card_ready(chip, lun)) { 3001 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 3002 rtsx_trace(chip); 3003 return TRANSPORT_FAILED; 3004 } 3005 if (get_lun_card(chip, lun) != MS_CARD) { 3006 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 3007 rtsx_trace(chip); 3008 return TRANSPORT_FAILED; 3009 } 3010 3011 if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) || 3012 (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) || 3013 (srb->cmnd[7] != 0x44)) { 3014 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3015 rtsx_trace(chip); 3016 return TRANSPORT_FAILED; 3017 } 3018 3019 dev_info_id = srb->cmnd[3]; 3020 if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) || 3021 (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) || 3022 !CHK_MSPRO(ms_card)) { 3023 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3024 rtsx_trace(chip); 3025 return TRANSPORT_FAILED; 3026 } 3027 3028 if (dev_info_id == 0x15) { 3029 buf_len = 0x3A; 3030 data_len = 0x3A; 3031 } else { 3032 buf_len = 0x6A; 3033 data_len = 0x6A; 3034 } 3035 3036 buf = kmalloc(buf_len, GFP_KERNEL); 3037 if (!buf) { 3038 rtsx_trace(chip); 3039 return TRANSPORT_ERROR; 3040 } 3041 3042 i = 0; 3043 /* GET Memory Stick Media Information Response Header */ 3044 buf[i++] = 0x00; /* Data length MSB */ 3045 buf[i++] = data_len; /* Data length LSB */ 3046 /* Device Information Type Code */ 3047 if (CHK_MSXC(ms_card)) 3048 buf[i++] = 0x03; 3049 else 3050 buf[i++] = 0x02; 3051 3052 /* SGM bit */ 3053 buf[i++] = 0x01; 3054 /* Reserved */ 3055 buf[i++] = 0x00; 3056 buf[i++] = 0x00; 3057 buf[i++] = 0x00; 3058 /* Number of Device Information */ 3059 buf[i++] = 0x01; 3060 3061 /* Device Information Body */ 3062 3063 /* Device Information ID Number */ 3064 buf[i++] = dev_info_id; 3065 /* Device Information Length */ 3066 if (dev_info_id == 0x15) 3067 data_len = 0x31; 3068 else 3069 data_len = 0x61; 3070 3071 buf[i++] = 0x00; /* Data length MSB */ 3072 buf[i++] = data_len; /* Data length LSB */ 3073 /* Valid Bit */ 3074 buf[i++] = 0x80; 3075 if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) { 3076 /* System Information */ 3077 memcpy(buf + i, ms_card->raw_sys_info, 96); 3078 } else { 3079 /* Model Name */ 3080 memcpy(buf + i, ms_card->raw_model_name, 48); 3081 } 3082 3083 rtsx_stor_set_xfer_buf(buf, buf_len, srb); 3084 3085 if (dev_info_id == 0x15) 3086 scsi_set_resid(srb, scsi_bufflen(srb) - 0x3C); 3087 else 3088 scsi_set_resid(srb, scsi_bufflen(srb) - 0x6C); 3089 3090 kfree(buf); 3091 return STATUS_SUCCESS; 3092 } 3093 #endif 3094 3095 static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3096 { 3097 int retval = TRANSPORT_ERROR; 3098 3099 if (srb->cmnd[2] == MS_FORMAT) 3100 retval = ms_format_cmnd(srb, chip); 3101 #ifdef SUPPORT_PCGL_1P18 3102 else if (srb->cmnd[2] == GET_MS_INFORMATION) 3103 retval = get_ms_information(srb, chip); 3104 #endif 3105 3106 return retval; 3107 } 3108 3109 #ifdef SUPPORT_CPRM 3110 static int sd_extension_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3111 { 3112 unsigned int lun = SCSI_LUN(srb); 3113 int result; 3114 3115 rtsx_disable_aspm(chip); 3116 3117 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 3118 rtsx_exit_ss(chip); 3119 wait_timeout(100); 3120 } 3121 rtsx_set_stat(chip, RTSX_STAT_RUN); 3122 3123 sd_cleanup_work(chip); 3124 3125 if (!check_card_ready(chip, lun)) { 3126 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 3127 rtsx_trace(chip); 3128 return TRANSPORT_FAILED; 3129 } 3130 if (get_lun_card(chip, lun) != SD_CARD) { 3131 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 3132 rtsx_trace(chip); 3133 return TRANSPORT_FAILED; 3134 } 3135 3136 switch (srb->cmnd[0]) { 3137 case SD_PASS_THRU_MODE: 3138 result = sd_pass_thru_mode(srb, chip); 3139 break; 3140 3141 case SD_EXECUTE_NO_DATA: 3142 result = sd_execute_no_data(srb, chip); 3143 break; 3144 3145 case SD_EXECUTE_READ: 3146 result = sd_execute_read_data(srb, chip); 3147 break; 3148 3149 case SD_EXECUTE_WRITE: 3150 result = sd_execute_write_data(srb, chip); 3151 break; 3152 3153 case SD_GET_RSP: 3154 result = sd_get_cmd_rsp(srb, chip); 3155 break; 3156 3157 case SD_HW_RST: 3158 result = sd_hw_rst(srb, chip); 3159 break; 3160 3161 default: 3162 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3163 rtsx_trace(chip); 3164 return TRANSPORT_FAILED; 3165 } 3166 3167 return result; 3168 } 3169 #endif 3170 3171 #ifdef SUPPORT_MAGIC_GATE 3172 static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3173 { 3174 struct ms_info *ms_card = &chip->ms_card; 3175 unsigned int lun = SCSI_LUN(srb); 3176 int retval; 3177 u8 key_format; 3178 3179 rtsx_disable_aspm(chip); 3180 3181 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 3182 rtsx_exit_ss(chip); 3183 wait_timeout(100); 3184 } 3185 rtsx_set_stat(chip, RTSX_STAT_RUN); 3186 3187 ms_cleanup_work(chip); 3188 3189 if (!check_card_ready(chip, lun)) { 3190 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 3191 rtsx_trace(chip); 3192 return TRANSPORT_FAILED; 3193 } 3194 if (get_lun_card(chip, lun) != MS_CARD) { 3195 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 3196 rtsx_trace(chip); 3197 return TRANSPORT_FAILED; 3198 } 3199 3200 if (srb->cmnd[7] != KC_MG_R_PRO) { 3201 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3202 rtsx_trace(chip); 3203 return TRANSPORT_FAILED; 3204 } 3205 3206 if (!CHK_MSPRO(ms_card)) { 3207 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM); 3208 rtsx_trace(chip); 3209 return TRANSPORT_FAILED; 3210 } 3211 3212 key_format = srb->cmnd[10] & 0x3F; 3213 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format); 3214 3215 switch (key_format) { 3216 case KF_GET_LOC_EKB: 3217 if ((scsi_bufflen(srb) == 0x41C) && 3218 (srb->cmnd[8] == 0x04) && 3219 (srb->cmnd[9] == 0x1C)) { 3220 retval = mg_get_local_EKB(srb, chip); 3221 if (retval != STATUS_SUCCESS) { 3222 rtsx_trace(chip); 3223 return TRANSPORT_FAILED; 3224 } 3225 3226 } else { 3227 set_sense_type(chip, lun, 3228 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3229 rtsx_trace(chip); 3230 return TRANSPORT_FAILED; 3231 } 3232 break; 3233 3234 case KF_RSP_CHG: 3235 if ((scsi_bufflen(srb) == 0x24) && 3236 (srb->cmnd[8] == 0x00) && 3237 (srb->cmnd[9] == 0x24)) { 3238 retval = mg_get_rsp_chg(srb, chip); 3239 if (retval != STATUS_SUCCESS) { 3240 rtsx_trace(chip); 3241 return TRANSPORT_FAILED; 3242 } 3243 3244 } else { 3245 set_sense_type(chip, lun, 3246 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3247 rtsx_trace(chip); 3248 return TRANSPORT_FAILED; 3249 } 3250 break; 3251 3252 case KF_GET_ICV: 3253 ms_card->mg_entry_num = srb->cmnd[5]; 3254 if ((scsi_bufflen(srb) == 0x404) && 3255 (srb->cmnd[8] == 0x04) && 3256 (srb->cmnd[9] == 0x04) && 3257 (srb->cmnd[2] == 0x00) && 3258 (srb->cmnd[3] == 0x00) && 3259 (srb->cmnd[4] == 0x00) && 3260 (srb->cmnd[5] < 32)) { 3261 retval = mg_get_ICV(srb, chip); 3262 if (retval != STATUS_SUCCESS) { 3263 rtsx_trace(chip); 3264 return TRANSPORT_FAILED; 3265 } 3266 3267 } else { 3268 set_sense_type(chip, lun, 3269 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3270 rtsx_trace(chip); 3271 return TRANSPORT_FAILED; 3272 } 3273 break; 3274 3275 default: 3276 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3277 rtsx_trace(chip); 3278 return TRANSPORT_FAILED; 3279 } 3280 3281 scsi_set_resid(srb, 0); 3282 return TRANSPORT_GOOD; 3283 } 3284 3285 static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3286 { 3287 struct ms_info *ms_card = &chip->ms_card; 3288 unsigned int lun = SCSI_LUN(srb); 3289 int retval; 3290 u8 key_format; 3291 3292 rtsx_disable_aspm(chip); 3293 3294 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 3295 rtsx_exit_ss(chip); 3296 wait_timeout(100); 3297 } 3298 rtsx_set_stat(chip, RTSX_STAT_RUN); 3299 3300 ms_cleanup_work(chip); 3301 3302 if (!check_card_ready(chip, lun)) { 3303 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 3304 rtsx_trace(chip); 3305 return TRANSPORT_FAILED; 3306 } 3307 if (check_card_wp(chip, lun)) { 3308 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT); 3309 rtsx_trace(chip); 3310 return TRANSPORT_FAILED; 3311 } 3312 if (get_lun_card(chip, lun) != MS_CARD) { 3313 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 3314 rtsx_trace(chip); 3315 return TRANSPORT_FAILED; 3316 } 3317 3318 if (srb->cmnd[7] != KC_MG_R_PRO) { 3319 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3320 rtsx_trace(chip); 3321 return TRANSPORT_FAILED; 3322 } 3323 3324 if (!CHK_MSPRO(ms_card)) { 3325 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM); 3326 rtsx_trace(chip); 3327 return TRANSPORT_FAILED; 3328 } 3329 3330 key_format = srb->cmnd[10] & 0x3F; 3331 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format); 3332 3333 switch (key_format) { 3334 case KF_SET_LEAF_ID: 3335 if ((scsi_bufflen(srb) == 0x0C) && 3336 (srb->cmnd[8] == 0x00) && 3337 (srb->cmnd[9] == 0x0C)) { 3338 retval = mg_set_leaf_id(srb, chip); 3339 if (retval != STATUS_SUCCESS) { 3340 rtsx_trace(chip); 3341 return TRANSPORT_FAILED; 3342 } 3343 3344 } else { 3345 set_sense_type(chip, lun, 3346 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3347 rtsx_trace(chip); 3348 return TRANSPORT_FAILED; 3349 } 3350 break; 3351 3352 case KF_CHG_HOST: 3353 if ((scsi_bufflen(srb) == 0x0C) && 3354 (srb->cmnd[8] == 0x00) && 3355 (srb->cmnd[9] == 0x0C)) { 3356 retval = mg_chg(srb, chip); 3357 if (retval != STATUS_SUCCESS) { 3358 rtsx_trace(chip); 3359 return TRANSPORT_FAILED; 3360 } 3361 3362 } else { 3363 set_sense_type(chip, lun, 3364 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3365 rtsx_trace(chip); 3366 return TRANSPORT_FAILED; 3367 } 3368 break; 3369 3370 case KF_RSP_HOST: 3371 if ((scsi_bufflen(srb) == 0x0C) && 3372 (srb->cmnd[8] == 0x00) && 3373 (srb->cmnd[9] == 0x0C)) { 3374 retval = mg_rsp(srb, chip); 3375 if (retval != STATUS_SUCCESS) { 3376 rtsx_trace(chip); 3377 return TRANSPORT_FAILED; 3378 } 3379 3380 } else { 3381 set_sense_type(chip, lun, 3382 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3383 rtsx_trace(chip); 3384 return TRANSPORT_FAILED; 3385 } 3386 break; 3387 3388 case KF_SET_ICV: 3389 ms_card->mg_entry_num = srb->cmnd[5]; 3390 if ((scsi_bufflen(srb) == 0x404) && 3391 (srb->cmnd[8] == 0x04) && 3392 (srb->cmnd[9] == 0x04) && 3393 (srb->cmnd[2] == 0x00) && 3394 (srb->cmnd[3] == 0x00) && 3395 (srb->cmnd[4] == 0x00) && 3396 (srb->cmnd[5] < 32)) { 3397 retval = mg_set_ICV(srb, chip); 3398 if (retval != STATUS_SUCCESS) { 3399 rtsx_trace(chip); 3400 return TRANSPORT_FAILED; 3401 } 3402 3403 } else { 3404 set_sense_type(chip, lun, 3405 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3406 rtsx_trace(chip); 3407 return TRANSPORT_FAILED; 3408 } 3409 break; 3410 3411 default: 3412 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3413 rtsx_trace(chip); 3414 return TRANSPORT_FAILED; 3415 } 3416 3417 scsi_set_resid(srb, 0); 3418 return TRANSPORT_GOOD; 3419 } 3420 #endif 3421 3422 int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3423 { 3424 #ifdef SUPPORT_SD_LOCK 3425 struct sd_info *sd_card = &chip->sd_card; 3426 #endif 3427 struct ms_info *ms_card = &chip->ms_card; 3428 unsigned int lun = SCSI_LUN(srb); 3429 int result; 3430 3431 #ifdef SUPPORT_SD_LOCK 3432 if (sd_card->sd_erase_status) { 3433 /* Block all SCSI command except for 3434 * REQUEST_SENSE and rs_ppstatus 3435 */ 3436 if (!((srb->cmnd[0] == VENDOR_CMND) && 3437 (srb->cmnd[1] == SCSI_APP_CMD) && 3438 (srb->cmnd[2] == GET_DEV_STATUS)) && 3439 (srb->cmnd[0] != REQUEST_SENSE)) { 3440 /* Logical Unit Not Ready Format in Progress */ 3441 set_sense_data(chip, lun, CUR_ERR, 3442 0x02, 0, 0x04, 0x04, 0, 0); 3443 rtsx_trace(chip); 3444 return TRANSPORT_FAILED; 3445 } 3446 } 3447 #endif 3448 3449 if ((get_lun_card(chip, lun) == MS_CARD) && 3450 (ms_card->format_status == FORMAT_IN_PROGRESS)) { 3451 if ((srb->cmnd[0] != REQUEST_SENSE) && 3452 (srb->cmnd[0] != INQUIRY)) { 3453 /* Logical Unit Not Ready Format in Progress */ 3454 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 3455 0, (u16)(ms_card->progress)); 3456 rtsx_trace(chip); 3457 return TRANSPORT_FAILED; 3458 } 3459 } 3460 3461 switch (srb->cmnd[0]) { 3462 case READ_10: 3463 case WRITE_10: 3464 case READ_6: 3465 case WRITE_6: 3466 result = read_write(srb, chip); 3467 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK) 3468 led_shine(srb, chip); 3469 #endif 3470 break; 3471 3472 case TEST_UNIT_READY: 3473 result = test_unit_ready(srb, chip); 3474 break; 3475 3476 case INQUIRY: 3477 result = inquiry(srb, chip); 3478 break; 3479 3480 case READ_CAPACITY: 3481 result = read_capacity(srb, chip); 3482 break; 3483 3484 case START_STOP: 3485 result = start_stop_unit(srb, chip); 3486 break; 3487 3488 case ALLOW_MEDIUM_REMOVAL: 3489 result = allow_medium_removal(srb, chip); 3490 break; 3491 3492 case REQUEST_SENSE: 3493 result = request_sense(srb, chip); 3494 break; 3495 3496 case MODE_SENSE: 3497 case MODE_SENSE_10: 3498 result = mode_sense(srb, chip); 3499 break; 3500 3501 case 0x23: 3502 result = read_format_capacity(srb, chip); 3503 break; 3504 3505 case VENDOR_CMND: 3506 result = vendor_cmnd(srb, chip); 3507 break; 3508 3509 case MS_SP_CMND: 3510 result = ms_sp_cmnd(srb, chip); 3511 break; 3512 3513 #ifdef SUPPORT_CPRM 3514 case SD_PASS_THRU_MODE: 3515 case SD_EXECUTE_NO_DATA: 3516 case SD_EXECUTE_READ: 3517 case SD_EXECUTE_WRITE: 3518 case SD_GET_RSP: 3519 case SD_HW_RST: 3520 result = sd_extension_cmnd(srb, chip); 3521 break; 3522 #endif 3523 3524 #ifdef SUPPORT_MAGIC_GATE 3525 case CMD_MSPRO_MG_RKEY: 3526 result = mg_report_key(srb, chip); 3527 break; 3528 3529 case CMD_MSPRO_MG_SKEY: 3530 result = mg_send_key(srb, chip); 3531 break; 3532 #endif 3533 3534 case FORMAT_UNIT: 3535 case MODE_SELECT: 3536 case VERIFY: 3537 result = TRANSPORT_GOOD; 3538 break; 3539 3540 default: 3541 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3542 result = TRANSPORT_FAILED; 3543 } 3544 3545 return result; 3546 } 3547