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) >> 4; 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 return TRANSPORT_ERROR; 512 } 513 514 #ifdef SUPPORT_MAGIC_GATE 515 if ((chip->mspro_formatter_enable) && 516 (chip->lun2card[lun] & MS_CARD)) 517 #else 518 if (chip->mspro_formatter_enable) 519 #endif 520 if (!card || (card == MS_CARD)) 521 pro_formatter_flag = true; 522 523 if (pro_formatter_flag) { 524 if (scsi_bufflen(srb) < 56) 525 sendbytes = (unsigned char)(scsi_bufflen(srb)); 526 else 527 sendbytes = 56; 528 529 } else { 530 if (scsi_bufflen(srb) < 36) 531 sendbytes = (unsigned char)(scsi_bufflen(srb)); 532 else 533 sendbytes = 36; 534 } 535 536 if (sendbytes > 8) { 537 memcpy(buf, inquiry_buf, 8); 538 strncpy(buf + 8, inquiry_string, sendbytes - 8); 539 if (pro_formatter_flag) { 540 /* Additional Length */ 541 buf[4] = 0x33; 542 } 543 } else { 544 memcpy(buf, inquiry_buf, sendbytes); 545 } 546 547 if (pro_formatter_flag) { 548 if (sendbytes > 36) 549 memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36); 550 } 551 552 scsi_set_resid(srb, 0); 553 554 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb); 555 vfree(buf); 556 557 return TRANSPORT_GOOD; 558 } 559 560 static int start_stop_unit(struct scsi_cmnd *srb, struct rtsx_chip *chip) 561 { 562 unsigned int lun = SCSI_LUN(srb); 563 564 scsi_set_resid(srb, scsi_bufflen(srb)); 565 566 if (srb->cmnd[1] == 1) 567 return TRANSPORT_GOOD; 568 569 switch (srb->cmnd[0x4]) { 570 case STOP_MEDIUM: 571 /* Media disabled */ 572 return TRANSPORT_GOOD; 573 574 case UNLOAD_MEDIUM: 575 /* Media shall be unload */ 576 if (check_card_ready(chip, lun)) 577 eject_card(chip, lun); 578 return TRANSPORT_GOOD; 579 580 case MAKE_MEDIUM_READY: 581 case LOAD_MEDIUM: 582 if (check_card_ready(chip, lun)) 583 return TRANSPORT_GOOD; 584 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 585 return TRANSPORT_FAILED; 586 587 break; 588 } 589 590 return TRANSPORT_ERROR; 591 } 592 593 static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip) 594 { 595 int prevent; 596 597 prevent = srb->cmnd[4] & 0x1; 598 599 scsi_set_resid(srb, 0); 600 601 if (prevent) { 602 set_sense_type(chip, SCSI_LUN(srb), 603 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 604 return TRANSPORT_FAILED; 605 } 606 607 return TRANSPORT_GOOD; 608 } 609 610 static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip) 611 { 612 struct sense_data_t *sense; 613 unsigned int lun = SCSI_LUN(srb); 614 struct ms_info *ms_card = &chip->ms_card; 615 unsigned char *tmp, *buf; 616 617 sense = &chip->sense_buffer[lun]; 618 619 if ((get_lun_card(chip, lun) == MS_CARD) && 620 ms_card->pro_under_formatting) { 621 if (ms_card->format_status == FORMAT_SUCCESS) { 622 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE); 623 ms_card->pro_under_formatting = 0; 624 ms_card->progress = 0; 625 } else if (ms_card->format_status == FORMAT_IN_PROGRESS) { 626 /* Logical Unit Not Ready Format in Progress */ 627 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 628 0, (u16)(ms_card->progress)); 629 } else { 630 /* Format Command Failed */ 631 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED); 632 ms_card->pro_under_formatting = 0; 633 ms_card->progress = 0; 634 } 635 636 rtsx_set_stat(chip, RTSX_STAT_RUN); 637 } 638 639 buf = vmalloc(scsi_bufflen(srb)); 640 if (!buf) { 641 return TRANSPORT_ERROR; 642 } 643 644 tmp = (unsigned char *)sense; 645 memcpy(buf, tmp, scsi_bufflen(srb)); 646 647 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb); 648 vfree(buf); 649 650 scsi_set_resid(srb, 0); 651 /* Reset Sense Data */ 652 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE); 653 return TRANSPORT_GOOD; 654 } 655 656 static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd, 657 int lun, u8 *buf, int buf_len) 658 { 659 struct ms_info *ms_card = &chip->ms_card; 660 int sys_info_offset; 661 int data_size = buf_len; 662 bool support_format = false; 663 int i = 0; 664 665 if (cmd == MODE_SENSE) { 666 sys_info_offset = 8; 667 if (data_size > 0x68) 668 data_size = 0x68; 669 670 buf[i++] = 0x67; /* Mode Data Length */ 671 } else { 672 sys_info_offset = 12; 673 if (data_size > 0x6C) 674 data_size = 0x6C; 675 676 buf[i++] = 0x00; /* Mode Data Length (MSB) */ 677 buf[i++] = 0x6A; /* Mode Data Length (LSB) */ 678 } 679 680 /* Medium Type Code */ 681 if (check_card_ready(chip, lun)) { 682 if (CHK_MSXC(ms_card)) { 683 support_format = true; 684 buf[i++] = 0x40; 685 } else if (CHK_MSPRO(ms_card)) { 686 support_format = true; 687 buf[i++] = 0x20; 688 } else { 689 buf[i++] = 0x10; 690 } 691 692 /* WP */ 693 if (check_card_wp(chip, lun)) 694 buf[i++] = 0x80; 695 else 696 buf[i++] = 0x00; 697 698 } else { 699 buf[i++] = 0x00; /* MediaType */ 700 buf[i++] = 0x00; /* WP */ 701 } 702 703 buf[i++] = 0x00; /* Reserved */ 704 705 if (cmd == MODE_SENSE_10) { 706 buf[i++] = 0x00; /* Reserved */ 707 buf[i++] = 0x00; /* Block descriptor length(MSB) */ 708 buf[i++] = 0x00; /* Block descriptor length(LSB) */ 709 710 /* The Following Data is the content of "Page 0x20" */ 711 if (data_size >= 9) 712 buf[i++] = 0x20; /* Page Code */ 713 if (data_size >= 10) 714 buf[i++] = 0x62; /* Page Length */ 715 if (data_size >= 11) 716 buf[i++] = 0x00; /* No Access Control */ 717 if (data_size >= 12) { 718 if (support_format) 719 buf[i++] = 0xC0; /* SF, SGM */ 720 else 721 buf[i++] = 0x00; 722 } 723 } else { 724 /* The Following Data is the content of "Page 0x20" */ 725 if (data_size >= 5) 726 buf[i++] = 0x20; /* Page Code */ 727 if (data_size >= 6) 728 buf[i++] = 0x62; /* Page Length */ 729 if (data_size >= 7) 730 buf[i++] = 0x00; /* No Access Control */ 731 if (data_size >= 8) { 732 if (support_format) 733 buf[i++] = 0xC0; /* SF, SGM */ 734 else 735 buf[i++] = 0x00; 736 } 737 } 738 739 if (data_size > sys_info_offset) { 740 /* 96 Bytes Attribute Data */ 741 int len = data_size - sys_info_offset; 742 743 len = (len < 96) ? len : 96; 744 745 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len); 746 } 747 } 748 749 static int mode_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip) 750 { 751 unsigned int lun = SCSI_LUN(srb); 752 unsigned int data_size; 753 int status; 754 bool pro_formatter_flag; 755 unsigned char page_code, *buf; 756 u8 card = get_lun_card(chip, lun); 757 758 #ifndef SUPPORT_MAGIC_GATE 759 if (!check_card_ready(chip, lun)) { 760 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 761 scsi_set_resid(srb, scsi_bufflen(srb)); 762 return TRANSPORT_FAILED; 763 } 764 #endif 765 766 pro_formatter_flag = false; 767 data_size = 8; 768 #ifdef SUPPORT_MAGIC_GATE 769 if ((chip->lun2card[lun] & MS_CARD)) { 770 if (!card || (card == MS_CARD)) { 771 data_size = 108; 772 if (chip->mspro_formatter_enable) 773 pro_formatter_flag = true; 774 } 775 } 776 #else 777 if (card == MS_CARD) { 778 if (chip->mspro_formatter_enable) { 779 pro_formatter_flag = true; 780 data_size = 108; 781 } 782 } 783 #endif 784 785 buf = kmalloc(data_size, GFP_KERNEL); 786 if (!buf) { 787 return TRANSPORT_ERROR; 788 } 789 790 page_code = srb->cmnd[2] & 0x3f; 791 792 if ((page_code == 0x3F) || (page_code == 0x1C) || 793 (page_code == 0x00) || 794 (pro_formatter_flag && (page_code == 0x20))) { 795 if (srb->cmnd[0] == MODE_SENSE) { 796 if ((page_code == 0x3F) || (page_code == 0x20)) { 797 ms_mode_sense(chip, srb->cmnd[0], 798 lun, buf, data_size); 799 } else { 800 data_size = 4; 801 buf[0] = 0x03; 802 buf[1] = 0x00; 803 if (check_card_wp(chip, lun)) 804 buf[2] = 0x80; 805 else 806 buf[2] = 0x00; 807 808 buf[3] = 0x00; 809 } 810 } else { 811 if ((page_code == 0x3F) || (page_code == 0x20)) { 812 ms_mode_sense(chip, srb->cmnd[0], 813 lun, buf, data_size); 814 } else { 815 data_size = 8; 816 buf[0] = 0x00; 817 buf[1] = 0x06; 818 buf[2] = 0x00; 819 if (check_card_wp(chip, lun)) 820 buf[3] = 0x80; 821 else 822 buf[3] = 0x00; 823 buf[4] = 0x00; 824 buf[5] = 0x00; 825 buf[6] = 0x00; 826 buf[7] = 0x00; 827 } 828 } 829 status = TRANSPORT_GOOD; 830 } else { 831 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 832 scsi_set_resid(srb, scsi_bufflen(srb)); 833 status = TRANSPORT_FAILED; 834 } 835 836 if (status == TRANSPORT_GOOD) { 837 unsigned int len = min_t(unsigned int, scsi_bufflen(srb), 838 data_size); 839 rtsx_stor_set_xfer_buf(buf, len, srb); 840 scsi_set_resid(srb, scsi_bufflen(srb) - len); 841 } 842 kfree(buf); 843 844 return status; 845 } 846 847 static int read_write(struct scsi_cmnd *srb, struct rtsx_chip *chip) 848 { 849 #ifdef SUPPORT_SD_LOCK 850 struct sd_info *sd_card = &chip->sd_card; 851 #endif 852 unsigned int lun = SCSI_LUN(srb); 853 int retval; 854 u32 start_sec; 855 u16 sec_cnt; 856 857 rtsx_disable_aspm(chip); 858 859 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 860 rtsx_exit_ss(chip); 861 wait_timeout(100); 862 } 863 rtsx_set_stat(chip, RTSX_STAT_RUN); 864 865 if (!check_card_ready(chip, lun) || (get_card_size(chip, lun) == 0)) { 866 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 867 return TRANSPORT_FAILED; 868 } 869 870 if (!(CHK_BIT(chip->lun_mc, lun))) { 871 SET_BIT(chip->lun_mc, lun); 872 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE); 873 return TRANSPORT_FAILED; 874 } 875 876 #ifdef SUPPORT_SD_LOCK 877 if (sd_card->sd_erase_status) { 878 /* Accessing to any card is forbidden 879 * until the erase procedure of SD is completed 880 */ 881 dev_dbg(rtsx_dev(chip), "SD card being erased!\n"); 882 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN); 883 return TRANSPORT_FAILED; 884 } 885 886 if (get_lun_card(chip, lun) == SD_CARD) { 887 if (sd_card->sd_lock_status & SD_LOCKED) { 888 dev_dbg(rtsx_dev(chip), "SD card locked!\n"); 889 set_sense_type(chip, lun, 890 SENSE_TYPE_MEDIA_READ_FORBIDDEN); 891 return TRANSPORT_FAILED; 892 } 893 } 894 #endif 895 896 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) { 897 start_sec = ((u32)srb->cmnd[2] << 24) | 898 ((u32)srb->cmnd[3] << 16) | 899 ((u32)srb->cmnd[4] << 8) | ((u32)srb->cmnd[5]); 900 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8]; 901 } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) { 902 start_sec = ((u32)(srb->cmnd[1] & 0x1F) << 16) | 903 ((u32)srb->cmnd[2] << 8) | ((u32)srb->cmnd[3]); 904 sec_cnt = srb->cmnd[4]; 905 if (sec_cnt == 0) 906 sec_cnt = 256; 907 } else if ((srb->cmnd[0] == VENDOR_CMND) && 908 (srb->cmnd[1] == SCSI_APP_CMD) && 909 ((srb->cmnd[2] == PP_READ10) || (srb->cmnd[2] == PP_WRITE10))) { 910 start_sec = ((u32)srb->cmnd[4] << 24) | 911 ((u32)srb->cmnd[5] << 16) | 912 ((u32)srb->cmnd[6] << 8) | ((u32)srb->cmnd[7]); 913 sec_cnt = ((u16)(srb->cmnd[9]) << 8) | srb->cmnd[10]; 914 } else { 915 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 916 return TRANSPORT_FAILED; 917 } 918 919 /* In some test, we will receive a start_sec like 0xFFFFFFFF. 920 * In this situation, start_sec + sec_cnt will overflow, so we 921 * need to judge start_sec at first 922 */ 923 if ((start_sec > get_card_size(chip, lun)) || 924 ((start_sec + sec_cnt) > get_card_size(chip, lun))) { 925 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE); 926 return TRANSPORT_FAILED; 927 } 928 929 if (sec_cnt == 0) { 930 scsi_set_resid(srb, 0); 931 return TRANSPORT_GOOD; 932 } 933 934 if (chip->rw_fail_cnt[lun] == 3) { 935 dev_dbg(rtsx_dev(chip), "read/write fail three times in succession\n"); 936 if (srb->sc_data_direction == DMA_FROM_DEVICE) 937 set_sense_type(chip, lun, 938 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 939 else 940 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR); 941 942 return TRANSPORT_FAILED; 943 } 944 945 if (srb->sc_data_direction == DMA_TO_DEVICE) { 946 if (check_card_wp(chip, lun)) { 947 dev_dbg(rtsx_dev(chip), "Write protected card!\n"); 948 set_sense_type(chip, lun, 949 SENSE_TYPE_MEDIA_WRITE_PROTECT); 950 return TRANSPORT_FAILED; 951 } 952 } 953 954 retval = card_rw(srb, chip, start_sec, sec_cnt); 955 if (retval != STATUS_SUCCESS) { 956 if (chip->need_release & chip->lun2card[lun]) { 957 chip->rw_fail_cnt[lun] = 0; 958 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 959 } else { 960 chip->rw_fail_cnt[lun]++; 961 if (srb->sc_data_direction == DMA_FROM_DEVICE) 962 set_sense_type 963 (chip, lun, 964 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 965 else 966 set_sense_type(chip, lun, 967 SENSE_TYPE_MEDIA_WRITE_ERR); 968 } 969 retval = TRANSPORT_FAILED; 970 goto exit; 971 } else { 972 chip->rw_fail_cnt[lun] = 0; 973 retval = TRANSPORT_GOOD; 974 } 975 976 scsi_set_resid(srb, 0); 977 978 exit: 979 return retval; 980 } 981 982 static int read_format_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip) 983 { 984 unsigned char *buf; 985 unsigned int lun = SCSI_LUN(srb); 986 unsigned int buf_len; 987 u8 card = get_lun_card(chip, lun); 988 u32 card_size; 989 int desc_cnt; 990 int i = 0; 991 992 if (!check_card_ready(chip, lun)) { 993 if (!chip->mspro_formatter_enable) { 994 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 995 return TRANSPORT_FAILED; 996 } 997 } 998 999 buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12; 1000 1001 buf = kmalloc(buf_len, GFP_KERNEL); 1002 if (!buf) { 1003 return TRANSPORT_ERROR; 1004 } 1005 1006 buf[i++] = 0; 1007 buf[i++] = 0; 1008 buf[i++] = 0; 1009 1010 /* Capacity List Length */ 1011 if ((buf_len > 12) && chip->mspro_formatter_enable && 1012 (chip->lun2card[lun] & MS_CARD) && 1013 (!card || (card == MS_CARD))) { 1014 buf[i++] = 0x10; 1015 desc_cnt = 2; 1016 } else { 1017 buf[i++] = 0x08; 1018 desc_cnt = 1; 1019 } 1020 1021 while (desc_cnt) { 1022 if (check_card_ready(chip, lun)) { 1023 card_size = get_card_size(chip, lun); 1024 buf[i++] = (unsigned char)(card_size >> 24); 1025 buf[i++] = (unsigned char)(card_size >> 16); 1026 buf[i++] = (unsigned char)(card_size >> 8); 1027 buf[i++] = (unsigned char)card_size; 1028 1029 if (desc_cnt == 2) 1030 buf[i++] = 2; 1031 else 1032 buf[i++] = 0; 1033 } else { 1034 buf[i++] = 0xFF; 1035 buf[i++] = 0xFF; 1036 buf[i++] = 0xFF; 1037 buf[i++] = 0xFF; 1038 1039 if (desc_cnt == 2) 1040 buf[i++] = 3; 1041 else 1042 buf[i++] = 0; 1043 } 1044 1045 buf[i++] = 0x00; 1046 buf[i++] = 0x02; 1047 buf[i++] = 0x00; 1048 1049 desc_cnt--; 1050 } 1051 1052 buf_len = min_t(unsigned int, scsi_bufflen(srb), buf_len); 1053 rtsx_stor_set_xfer_buf(buf, buf_len, srb); 1054 kfree(buf); 1055 1056 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len); 1057 1058 return TRANSPORT_GOOD; 1059 } 1060 1061 static int read_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1062 { 1063 unsigned char *buf; 1064 unsigned int lun = SCSI_LUN(srb); 1065 u32 card_size; 1066 1067 if (!check_card_ready(chip, lun)) { 1068 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 1069 return TRANSPORT_FAILED; 1070 } 1071 1072 if (!(CHK_BIT(chip->lun_mc, lun))) { 1073 SET_BIT(chip->lun_mc, lun); 1074 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE); 1075 return TRANSPORT_FAILED; 1076 } 1077 1078 buf = kmalloc(8, GFP_KERNEL); 1079 if (!buf) { 1080 return TRANSPORT_ERROR; 1081 } 1082 1083 card_size = get_card_size(chip, lun); 1084 buf[0] = (unsigned char)((card_size - 1) >> 24); 1085 buf[1] = (unsigned char)((card_size - 1) >> 16); 1086 buf[2] = (unsigned char)((card_size - 1) >> 8); 1087 buf[3] = (unsigned char)(card_size - 1); 1088 1089 buf[4] = 0x00; 1090 buf[5] = 0x00; 1091 buf[6] = 0x02; 1092 buf[7] = 0x00; 1093 1094 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb); 1095 kfree(buf); 1096 1097 scsi_set_resid(srb, 0); 1098 1099 return TRANSPORT_GOOD; 1100 } 1101 1102 static int read_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1103 { 1104 unsigned short len, i; 1105 int retval; 1106 u8 *buf; 1107 1108 rtsx_disable_aspm(chip); 1109 1110 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1111 rtsx_exit_ss(chip); 1112 wait_timeout(100); 1113 } 1114 rtsx_set_stat(chip, RTSX_STAT_RUN); 1115 1116 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 1117 1118 buf = vmalloc(len); 1119 if (!buf) { 1120 return TRANSPORT_ERROR; 1121 } 1122 1123 retval = rtsx_force_power_on(chip, SSC_PDCTL); 1124 if (retval != STATUS_SUCCESS) { 1125 vfree(buf); 1126 set_sense_type(chip, SCSI_LUN(srb), 1127 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1128 return TRANSPORT_FAILED; 1129 } 1130 1131 for (i = 0; i < len; i++) { 1132 retval = spi_read_eeprom(chip, i, buf + i); 1133 if (retval != STATUS_SUCCESS) { 1134 vfree(buf); 1135 set_sense_type(chip, SCSI_LUN(srb), 1136 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1137 return TRANSPORT_FAILED; 1138 } 1139 } 1140 1141 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len); 1142 rtsx_stor_set_xfer_buf(buf, len, srb); 1143 scsi_set_resid(srb, scsi_bufflen(srb) - len); 1144 1145 vfree(buf); 1146 1147 return TRANSPORT_GOOD; 1148 } 1149 1150 static int write_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1151 { 1152 unsigned short len, i; 1153 int retval; 1154 u8 *buf; 1155 1156 rtsx_disable_aspm(chip); 1157 1158 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1159 rtsx_exit_ss(chip); 1160 wait_timeout(100); 1161 } 1162 rtsx_set_stat(chip, RTSX_STAT_RUN); 1163 1164 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 1165 1166 retval = rtsx_force_power_on(chip, SSC_PDCTL); 1167 if (retval != STATUS_SUCCESS) { 1168 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 1169 return TRANSPORT_FAILED; 1170 } 1171 1172 if (len == 511) { 1173 retval = spi_erase_eeprom_chip(chip); 1174 if (retval != STATUS_SUCCESS) { 1175 set_sense_type(chip, SCSI_LUN(srb), 1176 SENSE_TYPE_MEDIA_WRITE_ERR); 1177 return TRANSPORT_FAILED; 1178 } 1179 } else { 1180 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), 1181 len); 1182 buf = vmalloc(len); 1183 if (!buf) { 1184 return TRANSPORT_ERROR; 1185 } 1186 1187 rtsx_stor_get_xfer_buf(buf, len, srb); 1188 scsi_set_resid(srb, scsi_bufflen(srb) - len); 1189 1190 for (i = 0; i < len; i++) { 1191 retval = spi_write_eeprom(chip, i, buf[i]); 1192 if (retval != STATUS_SUCCESS) { 1193 vfree(buf); 1194 set_sense_type(chip, SCSI_LUN(srb), 1195 SENSE_TYPE_MEDIA_WRITE_ERR); 1196 return TRANSPORT_FAILED; 1197 } 1198 } 1199 1200 vfree(buf); 1201 } 1202 1203 return TRANSPORT_GOOD; 1204 } 1205 1206 static int read_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1207 { 1208 unsigned short addr, len, i; 1209 int retval; 1210 u8 *buf; 1211 1212 rtsx_disable_aspm(chip); 1213 1214 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1215 rtsx_exit_ss(chip); 1216 wait_timeout(100); 1217 } 1218 rtsx_set_stat(chip, RTSX_STAT_RUN); 1219 1220 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3]; 1221 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 1222 1223 if (addr < 0xFC00) { 1224 set_sense_type(chip, SCSI_LUN(srb), 1225 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1226 return TRANSPORT_FAILED; 1227 } 1228 1229 buf = vmalloc(len); 1230 if (!buf) { 1231 return TRANSPORT_ERROR; 1232 } 1233 1234 retval = rtsx_force_power_on(chip, SSC_PDCTL); 1235 if (retval != STATUS_SUCCESS) { 1236 vfree(buf); 1237 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 1238 return TRANSPORT_FAILED; 1239 } 1240 1241 for (i = 0; i < len; i++) { 1242 retval = rtsx_read_register(chip, addr + i, buf + i); 1243 if (retval != STATUS_SUCCESS) { 1244 vfree(buf); 1245 set_sense_type(chip, SCSI_LUN(srb), 1246 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1247 return TRANSPORT_FAILED; 1248 } 1249 } 1250 1251 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len); 1252 rtsx_stor_set_xfer_buf(buf, len, srb); 1253 scsi_set_resid(srb, scsi_bufflen(srb) - len); 1254 1255 vfree(buf); 1256 1257 return TRANSPORT_GOOD; 1258 } 1259 1260 static int write_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1261 { 1262 unsigned short addr, len, i; 1263 int retval; 1264 u8 *buf; 1265 1266 rtsx_disable_aspm(chip); 1267 1268 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1269 rtsx_exit_ss(chip); 1270 wait_timeout(100); 1271 } 1272 rtsx_set_stat(chip, RTSX_STAT_RUN); 1273 1274 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3]; 1275 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 1276 1277 if (addr < 0xFC00) { 1278 set_sense_type(chip, SCSI_LUN(srb), 1279 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1280 return TRANSPORT_FAILED; 1281 } 1282 1283 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len); 1284 buf = vmalloc(len); 1285 if (!buf) { 1286 return TRANSPORT_ERROR; 1287 } 1288 1289 rtsx_stor_get_xfer_buf(buf, len, srb); 1290 scsi_set_resid(srb, scsi_bufflen(srb) - len); 1291 1292 retval = rtsx_force_power_on(chip, SSC_PDCTL); 1293 if (retval != STATUS_SUCCESS) { 1294 vfree(buf); 1295 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 1296 return TRANSPORT_FAILED; 1297 } 1298 1299 for (i = 0; i < len; i++) { 1300 retval = rtsx_write_register(chip, addr + i, 0xFF, buf[i]); 1301 if (retval != STATUS_SUCCESS) { 1302 vfree(buf); 1303 set_sense_type(chip, SCSI_LUN(srb), 1304 SENSE_TYPE_MEDIA_WRITE_ERR); 1305 return TRANSPORT_FAILED; 1306 } 1307 } 1308 1309 vfree(buf); 1310 1311 return TRANSPORT_GOOD; 1312 } 1313 1314 static int get_sd_csd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1315 { 1316 struct sd_info *sd_card = &chip->sd_card; 1317 unsigned int lun = SCSI_LUN(srb); 1318 1319 if (!check_card_ready(chip, lun)) { 1320 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 1321 return TRANSPORT_FAILED; 1322 } 1323 1324 if (get_lun_card(chip, lun) != SD_CARD) { 1325 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1326 return TRANSPORT_FAILED; 1327 } 1328 1329 scsi_set_resid(srb, 0); 1330 rtsx_stor_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb); 1331 1332 return TRANSPORT_GOOD; 1333 } 1334 1335 static int toggle_gpio_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1336 { 1337 u8 gpio = srb->cmnd[2]; 1338 1339 rtsx_disable_aspm(chip); 1340 1341 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1342 rtsx_exit_ss(chip); 1343 wait_timeout(100); 1344 } 1345 rtsx_set_stat(chip, RTSX_STAT_RUN); 1346 1347 if (gpio > 3) 1348 gpio = 1; 1349 toggle_gpio(chip, gpio); 1350 1351 return TRANSPORT_GOOD; 1352 } 1353 1354 static int read_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1355 { 1356 u8 addr, buf[4]; 1357 u32 val; 1358 unsigned int len; 1359 1360 rtsx_disable_aspm(chip); 1361 1362 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1363 rtsx_exit_ss(chip); 1364 wait_timeout(100); 1365 } 1366 rtsx_set_stat(chip, RTSX_STAT_RUN); 1367 1368 addr = srb->cmnd[4]; 1369 1370 val = rtsx_readl(chip, addr); 1371 dev_dbg(rtsx_dev(chip), "Host register (0x%x): 0x%x\n", addr, val); 1372 1373 buf[0] = (u8)(val >> 24); 1374 buf[1] = (u8)(val >> 16); 1375 buf[2] = (u8)(val >> 8); 1376 buf[3] = (u8)val; 1377 1378 len = min_t(unsigned int, scsi_bufflen(srb), 4); 1379 rtsx_stor_set_xfer_buf(buf, len, srb); 1380 scsi_set_resid(srb, scsi_bufflen(srb) - len); 1381 1382 return TRANSPORT_GOOD; 1383 } 1384 1385 static int write_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1386 { 1387 u8 addr, buf[4]; 1388 u32 val; 1389 unsigned int len; 1390 1391 rtsx_disable_aspm(chip); 1392 1393 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1394 rtsx_exit_ss(chip); 1395 wait_timeout(100); 1396 } 1397 rtsx_set_stat(chip, RTSX_STAT_RUN); 1398 1399 addr = srb->cmnd[4]; 1400 1401 len = min_t(unsigned int, scsi_bufflen(srb), 4); 1402 rtsx_stor_get_xfer_buf(buf, len, srb); 1403 scsi_set_resid(srb, scsi_bufflen(srb) - len); 1404 1405 val = ((u32)buf[0] << 24) | ((u32)buf[1] << 16) | ((u32)buf[2] 1406 << 8) | buf[3]; 1407 1408 rtsx_writel(chip, addr, val); 1409 1410 return TRANSPORT_GOOD; 1411 } 1412 1413 static int set_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1414 { 1415 unsigned int lun = SCSI_LUN(srb); 1416 1417 if (srb->cmnd[3] == 1) { 1418 /* Variable Clock */ 1419 struct xd_info *xd_card = &chip->xd_card; 1420 struct sd_info *sd_card = &chip->sd_card; 1421 struct ms_info *ms_card = &chip->ms_card; 1422 1423 switch (srb->cmnd[4]) { 1424 case XD_CARD: 1425 xd_card->xd_clock = srb->cmnd[5]; 1426 break; 1427 1428 case SD_CARD: 1429 sd_card->sd_clock = srb->cmnd[5]; 1430 break; 1431 1432 case MS_CARD: 1433 ms_card->ms_clock = srb->cmnd[5]; 1434 break; 1435 1436 default: 1437 set_sense_type(chip, lun, 1438 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1439 return TRANSPORT_FAILED; 1440 } 1441 } else if (srb->cmnd[3] == 2) { 1442 if (srb->cmnd[4]) { 1443 chip->blink_led = 1; 1444 } else { 1445 int retval; 1446 1447 chip->blink_led = 0; 1448 1449 rtsx_disable_aspm(chip); 1450 1451 if (chip->ss_en && 1452 (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1453 rtsx_exit_ss(chip); 1454 wait_timeout(100); 1455 } 1456 rtsx_set_stat(chip, RTSX_STAT_RUN); 1457 1458 retval = rtsx_force_power_on(chip, SSC_PDCTL); 1459 if (retval != STATUS_SUCCESS) { 1460 set_sense_type(chip, SCSI_LUN(srb), 1461 SENSE_TYPE_MEDIA_WRITE_ERR); 1462 return TRANSPORT_FAILED; 1463 } 1464 1465 turn_off_led(chip, LED_GPIO); 1466 } 1467 } else { 1468 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1469 return TRANSPORT_FAILED; 1470 } 1471 1472 return TRANSPORT_GOOD; 1473 } 1474 1475 static int get_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1476 { 1477 unsigned int lun = SCSI_LUN(srb); 1478 1479 if (srb->cmnd[3] == 1) { 1480 struct xd_info *xd_card = &chip->xd_card; 1481 struct sd_info *sd_card = &chip->sd_card; 1482 struct ms_info *ms_card = &chip->ms_card; 1483 u8 tmp; 1484 1485 switch (srb->cmnd[4]) { 1486 case XD_CARD: 1487 tmp = (u8)(xd_card->xd_clock); 1488 break; 1489 1490 case SD_CARD: 1491 tmp = (u8)(sd_card->sd_clock); 1492 break; 1493 1494 case MS_CARD: 1495 tmp = (u8)(ms_card->ms_clock); 1496 break; 1497 1498 default: 1499 set_sense_type(chip, lun, 1500 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1501 return TRANSPORT_FAILED; 1502 } 1503 1504 rtsx_stor_set_xfer_buf(&tmp, 1, srb); 1505 } else if (srb->cmnd[3] == 2) { 1506 u8 tmp = chip->blink_led; 1507 1508 rtsx_stor_set_xfer_buf(&tmp, 1, srb); 1509 } else { 1510 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1511 return TRANSPORT_FAILED; 1512 } 1513 1514 return TRANSPORT_GOOD; 1515 } 1516 1517 static int dma_access_ring_buffer(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1518 { 1519 int retval; 1520 unsigned int lun = SCSI_LUN(srb); 1521 u16 len; 1522 1523 rtsx_disable_aspm(chip); 1524 1525 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1526 rtsx_exit_ss(chip); 1527 wait_timeout(100); 1528 } 1529 rtsx_set_stat(chip, RTSX_STAT_RUN); 1530 1531 len = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5]; 1532 len = min_t(u16, len, scsi_bufflen(srb)); 1533 1534 if (srb->sc_data_direction == DMA_FROM_DEVICE) 1535 dev_dbg(rtsx_dev(chip), "Read from device\n"); 1536 else 1537 dev_dbg(rtsx_dev(chip), "Write to device\n"); 1538 1539 retval = rtsx_transfer_data(chip, 0, scsi_sglist(srb), len, 1540 scsi_sg_count(srb), srb->sc_data_direction, 1541 1000); 1542 if (retval < 0) { 1543 if (srb->sc_data_direction == DMA_FROM_DEVICE) 1544 set_sense_type(chip, lun, 1545 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1546 else 1547 set_sense_type(chip, lun, 1548 SENSE_TYPE_MEDIA_WRITE_ERR); 1549 1550 return TRANSPORT_FAILED; 1551 } 1552 scsi_set_resid(srb, 0); 1553 1554 return TRANSPORT_GOOD; 1555 } 1556 1557 static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1558 { 1559 struct sd_info *sd_card = &chip->sd_card; 1560 struct ms_info *ms_card = &chip->ms_card; 1561 int buf_len; 1562 unsigned int lun = SCSI_LUN(srb); 1563 u8 card = get_lun_card(chip, lun); 1564 u8 status[32]; 1565 #ifdef SUPPORT_OCP 1566 u8 oc_now_mask = 0, oc_ever_mask = 0; 1567 #endif 1568 1569 memset(status, 0, 32); 1570 1571 status[0] = (u8)(chip->product_id); 1572 status[1] = chip->ic_version; 1573 1574 if (chip->auto_delink_en) 1575 status[2] = 0x10; 1576 else 1577 status[2] = 0x00; 1578 1579 status[3] = 20; 1580 status[4] = 10; 1581 status[5] = 05; 1582 status[6] = 21; 1583 1584 if (chip->card_wp) 1585 status[7] = 0x20; 1586 else 1587 status[7] = 0x00; 1588 1589 #ifdef SUPPORT_OCP 1590 status[8] = 0; 1591 if (CHECK_LUN_MODE(chip, SD_MS_2LUN) && 1592 (chip->lun2card[lun] == MS_CARD)) { 1593 oc_now_mask = MS_OC_NOW; 1594 oc_ever_mask = MS_OC_EVER; 1595 } else { 1596 oc_now_mask = SD_OC_NOW; 1597 oc_ever_mask = SD_OC_EVER; 1598 } 1599 1600 if (chip->ocp_stat & oc_now_mask) 1601 status[8] |= 0x02; 1602 1603 if (chip->ocp_stat & oc_ever_mask) 1604 status[8] |= 0x01; 1605 #endif 1606 1607 if (card == SD_CARD) { 1608 if (CHK_SD(sd_card)) { 1609 if (CHK_SD_HCXC(sd_card)) { 1610 if (sd_card->capacity > 0x4000000) 1611 status[0x0E] = 0x02; 1612 else 1613 status[0x0E] = 0x01; 1614 } else { 1615 status[0x0E] = 0x00; 1616 } 1617 1618 if (CHK_SD_SDR104(sd_card)) 1619 status[0x0F] = 0x03; 1620 else if (CHK_SD_DDR50(sd_card)) 1621 status[0x0F] = 0x04; 1622 else if (CHK_SD_SDR50(sd_card)) 1623 status[0x0F] = 0x02; 1624 else if (CHK_SD_HS(sd_card)) 1625 status[0x0F] = 0x01; 1626 else 1627 status[0x0F] = 0x00; 1628 } else { 1629 if (CHK_MMC_SECTOR_MODE(sd_card)) 1630 status[0x0E] = 0x01; 1631 else 1632 status[0x0E] = 0x00; 1633 1634 if (CHK_MMC_DDR52(sd_card)) 1635 status[0x0F] = 0x03; 1636 else if (CHK_MMC_52M(sd_card)) 1637 status[0x0F] = 0x02; 1638 else if (CHK_MMC_26M(sd_card)) 1639 status[0x0F] = 0x01; 1640 else 1641 status[0x0F] = 0x00; 1642 } 1643 } else if (card == MS_CARD) { 1644 if (CHK_MSPRO(ms_card)) { 1645 if (CHK_MSXC(ms_card)) 1646 status[0x0E] = 0x01; 1647 else 1648 status[0x0E] = 0x00; 1649 1650 if (CHK_HG8BIT(ms_card)) 1651 status[0x0F] = 0x01; 1652 else 1653 status[0x0F] = 0x00; 1654 } 1655 } 1656 1657 #ifdef SUPPORT_SD_LOCK 1658 if (card == SD_CARD) { 1659 status[0x17] = 0x80; 1660 if (sd_card->sd_erase_status) 1661 status[0x17] |= 0x01; 1662 if (sd_card->sd_lock_status & SD_LOCKED) { 1663 status[0x17] |= 0x02; 1664 status[0x07] |= 0x40; 1665 } 1666 if (sd_card->sd_lock_status & SD_PWD_EXIST) 1667 status[0x17] |= 0x04; 1668 } else { 1669 status[0x17] = 0x00; 1670 } 1671 1672 dev_dbg(rtsx_dev(chip), "status[0x17] = 0x%x\n", status[0x17]); 1673 #endif 1674 1675 status[0x18] = 0x8A; 1676 status[0x1A] = 0x28; 1677 #ifdef SUPPORT_SD_LOCK 1678 status[0x1F] = 0x01; 1679 #endif 1680 1681 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(status)); 1682 rtsx_stor_set_xfer_buf(status, buf_len, srb); 1683 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len); 1684 1685 return TRANSPORT_GOOD; 1686 } 1687 1688 static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1689 { 1690 int phy_debug_mode; 1691 int retval; 1692 u16 reg; 1693 1694 if (!CHECK_PID(chip, 0x5208)) { 1695 set_sense_type(chip, SCSI_LUN(srb), 1696 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1697 return TRANSPORT_FAILED; 1698 } 1699 1700 phy_debug_mode = (int)(srb->cmnd[3]); 1701 1702 if (phy_debug_mode) { 1703 chip->phy_debug_mode = 1; 1704 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0); 1705 if (retval != STATUS_SUCCESS) { 1706 return TRANSPORT_FAILED; 1707 } 1708 1709 rtsx_disable_bus_int(chip); 1710 1711 retval = rtsx_read_phy_register(chip, 0x1C, ®); 1712 if (retval != STATUS_SUCCESS) { 1713 return TRANSPORT_FAILED; 1714 } 1715 1716 reg |= 0x0001; 1717 retval = rtsx_write_phy_register(chip, 0x1C, reg); 1718 if (retval != STATUS_SUCCESS) { 1719 return TRANSPORT_FAILED; 1720 } 1721 } else { 1722 chip->phy_debug_mode = 0; 1723 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77); 1724 if (retval != STATUS_SUCCESS) { 1725 return TRANSPORT_FAILED; 1726 } 1727 1728 rtsx_enable_bus_int(chip); 1729 1730 retval = rtsx_read_phy_register(chip, 0x1C, ®); 1731 if (retval != STATUS_SUCCESS) { 1732 return TRANSPORT_FAILED; 1733 } 1734 1735 reg &= 0xFFFE; 1736 retval = rtsx_write_phy_register(chip, 0x1C, reg); 1737 if (retval != STATUS_SUCCESS) { 1738 return TRANSPORT_FAILED; 1739 } 1740 } 1741 1742 return TRANSPORT_GOOD; 1743 } 1744 1745 static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1746 { 1747 int retval = STATUS_SUCCESS; 1748 unsigned int lun = SCSI_LUN(srb); 1749 u8 cmd_type, mask, value, idx; 1750 u16 addr; 1751 1752 rtsx_disable_aspm(chip); 1753 1754 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1755 rtsx_exit_ss(chip); 1756 wait_timeout(100); 1757 } 1758 rtsx_set_stat(chip, RTSX_STAT_RUN); 1759 1760 switch (srb->cmnd[3]) { 1761 case INIT_BATCHCMD: 1762 rtsx_init_cmd(chip); 1763 break; 1764 1765 case ADD_BATCHCMD: 1766 cmd_type = srb->cmnd[4]; 1767 if (cmd_type > 2) { 1768 set_sense_type(chip, lun, 1769 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1770 return TRANSPORT_FAILED; 1771 } 1772 addr = (srb->cmnd[5] << 8) | srb->cmnd[6]; 1773 mask = srb->cmnd[7]; 1774 value = srb->cmnd[8]; 1775 rtsx_add_cmd(chip, cmd_type, addr, mask, value); 1776 break; 1777 1778 case SEND_BATCHCMD: 1779 retval = rtsx_send_cmd(chip, 0, 1000); 1780 break; 1781 1782 case GET_BATCHRSP: 1783 idx = srb->cmnd[4]; 1784 value = *(rtsx_get_cmd_data(chip) + idx); 1785 if (scsi_bufflen(srb) < 1) { 1786 set_sense_type(chip, lun, 1787 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1788 return TRANSPORT_FAILED; 1789 } 1790 rtsx_stor_set_xfer_buf(&value, 1, srb); 1791 scsi_set_resid(srb, 0); 1792 break; 1793 1794 default: 1795 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1796 return TRANSPORT_FAILED; 1797 } 1798 1799 if (retval != STATUS_SUCCESS) { 1800 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR); 1801 return TRANSPORT_FAILED; 1802 } 1803 1804 return TRANSPORT_GOOD; 1805 } 1806 1807 static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1808 { 1809 switch (srb->cmnd[3]) { 1810 case INIT_BATCHCMD: 1811 case ADD_BATCHCMD: 1812 case SEND_BATCHCMD: 1813 case GET_BATCHRSP: 1814 return rw_mem_cmd_buf(srb, chip); 1815 default: 1816 return TRANSPORT_ERROR; 1817 } 1818 } 1819 1820 static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1821 { 1822 unsigned short addr, len, i; 1823 int retval; 1824 u8 *buf; 1825 u16 val; 1826 1827 rtsx_disable_aspm(chip); 1828 1829 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1830 rtsx_exit_ss(chip); 1831 wait_timeout(100); 1832 } 1833 rtsx_set_stat(chip, RTSX_STAT_RUN); 1834 1835 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 1836 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7]; 1837 1838 if (len % 2) 1839 len -= len % 2; 1840 1841 if (len) { 1842 buf = vmalloc(len); 1843 if (!buf) { 1844 return TRANSPORT_ERROR; 1845 } 1846 1847 retval = rtsx_force_power_on(chip, SSC_PDCTL); 1848 if (retval != STATUS_SUCCESS) { 1849 vfree(buf); 1850 set_sense_type(chip, SCSI_LUN(srb), 1851 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1852 return TRANSPORT_FAILED; 1853 } 1854 1855 for (i = 0; i < len / 2; i++) { 1856 retval = rtsx_read_phy_register(chip, addr + i, &val); 1857 if (retval != STATUS_SUCCESS) { 1858 vfree(buf); 1859 set_sense_type 1860 (chip, SCSI_LUN(srb), 1861 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1862 return TRANSPORT_FAILED; 1863 } 1864 1865 buf[2 * i] = (u8)(val >> 8); 1866 buf[2 * i + 1] = (u8)val; 1867 } 1868 1869 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), 1870 len); 1871 rtsx_stor_set_xfer_buf(buf, len, srb); 1872 scsi_set_resid(srb, scsi_bufflen(srb) - len); 1873 1874 vfree(buf); 1875 } 1876 1877 return TRANSPORT_GOOD; 1878 } 1879 1880 static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1881 { 1882 unsigned short addr, len, i; 1883 int retval; 1884 u8 *buf; 1885 u16 val; 1886 1887 rtsx_disable_aspm(chip); 1888 1889 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1890 rtsx_exit_ss(chip); 1891 wait_timeout(100); 1892 } 1893 rtsx_set_stat(chip, RTSX_STAT_RUN); 1894 1895 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 1896 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7]; 1897 1898 if (len % 2) 1899 len -= len % 2; 1900 1901 if (len) { 1902 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), 1903 len); 1904 1905 buf = vmalloc(len); 1906 if (!buf) { 1907 return TRANSPORT_ERROR; 1908 } 1909 1910 rtsx_stor_get_xfer_buf(buf, len, srb); 1911 scsi_set_resid(srb, scsi_bufflen(srb) - len); 1912 1913 retval = rtsx_force_power_on(chip, SSC_PDCTL); 1914 if (retval != STATUS_SUCCESS) { 1915 vfree(buf); 1916 set_sense_type(chip, SCSI_LUN(srb), 1917 SENSE_TYPE_MEDIA_WRITE_ERR); 1918 return TRANSPORT_FAILED; 1919 } 1920 1921 for (i = 0; i < len / 2; i++) { 1922 val = ((u16)buf[2 * i] << 8) | buf[2 * i + 1]; 1923 retval = rtsx_write_phy_register(chip, addr + i, val); 1924 if (retval != STATUS_SUCCESS) { 1925 vfree(buf); 1926 set_sense_type(chip, SCSI_LUN(srb), 1927 SENSE_TYPE_MEDIA_WRITE_ERR); 1928 return TRANSPORT_FAILED; 1929 } 1930 } 1931 1932 vfree(buf); 1933 } 1934 1935 return TRANSPORT_GOOD; 1936 } 1937 1938 static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1939 { 1940 unsigned short addr; 1941 int retval; 1942 u8 mode; 1943 1944 rtsx_disable_aspm(chip); 1945 1946 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1947 rtsx_exit_ss(chip); 1948 wait_timeout(100); 1949 } 1950 rtsx_set_stat(chip, RTSX_STAT_RUN); 1951 1952 retval = rtsx_force_power_on(chip, SSC_PDCTL); 1953 if (retval != STATUS_SUCCESS) { 1954 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 1955 return TRANSPORT_FAILED; 1956 } 1957 1958 mode = srb->cmnd[3]; 1959 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 1960 1961 if (mode == 0) { 1962 retval = spi_erase_eeprom_chip(chip); 1963 if (retval != STATUS_SUCCESS) { 1964 set_sense_type(chip, SCSI_LUN(srb), 1965 SENSE_TYPE_MEDIA_WRITE_ERR); 1966 return TRANSPORT_FAILED; 1967 } 1968 } else if (mode == 1) { 1969 retval = spi_erase_eeprom_byte(chip, addr); 1970 if (retval != STATUS_SUCCESS) { 1971 set_sense_type(chip, SCSI_LUN(srb), 1972 SENSE_TYPE_MEDIA_WRITE_ERR); 1973 return TRANSPORT_FAILED; 1974 } 1975 } else { 1976 set_sense_type(chip, SCSI_LUN(srb), 1977 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1978 return TRANSPORT_FAILED; 1979 } 1980 1981 return TRANSPORT_GOOD; 1982 } 1983 1984 static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1985 { 1986 unsigned short addr, len, i; 1987 int retval; 1988 u8 *buf; 1989 1990 rtsx_disable_aspm(chip); 1991 1992 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1993 rtsx_exit_ss(chip); 1994 wait_timeout(100); 1995 } 1996 rtsx_set_stat(chip, RTSX_STAT_RUN); 1997 1998 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 1999 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7]; 2000 2001 buf = vmalloc(len); 2002 if (!buf) { 2003 return TRANSPORT_ERROR; 2004 } 2005 2006 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2007 if (retval != STATUS_SUCCESS) { 2008 vfree(buf); 2009 set_sense_type(chip, SCSI_LUN(srb), 2010 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2011 return TRANSPORT_FAILED; 2012 } 2013 2014 for (i = 0; i < len; i++) { 2015 retval = spi_read_eeprom(chip, addr + i, buf + i); 2016 if (retval != STATUS_SUCCESS) { 2017 vfree(buf); 2018 set_sense_type(chip, SCSI_LUN(srb), 2019 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2020 return TRANSPORT_FAILED; 2021 } 2022 } 2023 2024 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len); 2025 rtsx_stor_set_xfer_buf(buf, len, srb); 2026 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2027 2028 vfree(buf); 2029 2030 return TRANSPORT_GOOD; 2031 } 2032 2033 static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2034 { 2035 unsigned short addr, len, i; 2036 int retval; 2037 u8 *buf; 2038 2039 rtsx_disable_aspm(chip); 2040 2041 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2042 rtsx_exit_ss(chip); 2043 wait_timeout(100); 2044 } 2045 rtsx_set_stat(chip, RTSX_STAT_RUN); 2046 2047 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 2048 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7]; 2049 2050 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len); 2051 buf = vmalloc(len); 2052 if (!buf) { 2053 return TRANSPORT_ERROR; 2054 } 2055 2056 rtsx_stor_get_xfer_buf(buf, len, srb); 2057 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2058 2059 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2060 if (retval != STATUS_SUCCESS) { 2061 vfree(buf); 2062 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 2063 return TRANSPORT_FAILED; 2064 } 2065 2066 for (i = 0; i < len; i++) { 2067 retval = spi_write_eeprom(chip, addr + i, buf[i]); 2068 if (retval != STATUS_SUCCESS) { 2069 vfree(buf); 2070 set_sense_type(chip, SCSI_LUN(srb), 2071 SENSE_TYPE_MEDIA_WRITE_ERR); 2072 return TRANSPORT_FAILED; 2073 } 2074 } 2075 2076 vfree(buf); 2077 2078 return TRANSPORT_GOOD; 2079 } 2080 2081 static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2082 { 2083 int retval; 2084 u8 addr, len, i; 2085 u8 *buf; 2086 2087 rtsx_disable_aspm(chip); 2088 2089 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2090 rtsx_exit_ss(chip); 2091 wait_timeout(100); 2092 } 2093 rtsx_set_stat(chip, RTSX_STAT_RUN); 2094 2095 addr = srb->cmnd[4]; 2096 len = srb->cmnd[5]; 2097 2098 buf = vmalloc(len); 2099 if (!buf) { 2100 return TRANSPORT_ERROR; 2101 } 2102 2103 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2104 if (retval != STATUS_SUCCESS) { 2105 vfree(buf); 2106 set_sense_type(chip, SCSI_LUN(srb), 2107 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2108 return TRANSPORT_FAILED; 2109 } 2110 2111 for (i = 0; i < len; i++) { 2112 retval = rtsx_read_efuse(chip, addr + i, buf + i); 2113 if (retval != STATUS_SUCCESS) { 2114 vfree(buf); 2115 set_sense_type(chip, SCSI_LUN(srb), 2116 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2117 return TRANSPORT_FAILED; 2118 } 2119 } 2120 2121 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len); 2122 rtsx_stor_set_xfer_buf(buf, len, srb); 2123 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2124 2125 vfree(buf); 2126 2127 return TRANSPORT_GOOD; 2128 } 2129 2130 static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2131 { 2132 int retval, result = TRANSPORT_GOOD; 2133 u16 val; 2134 u8 addr, len, i; 2135 u8 *buf; 2136 2137 rtsx_disable_aspm(chip); 2138 2139 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2140 rtsx_exit_ss(chip); 2141 wait_timeout(100); 2142 } 2143 rtsx_set_stat(chip, RTSX_STAT_RUN); 2144 2145 addr = srb->cmnd[4]; 2146 len = srb->cmnd[5]; 2147 2148 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len); 2149 buf = vmalloc(len); 2150 if (!buf) { 2151 return TRANSPORT_ERROR; 2152 } 2153 2154 rtsx_stor_get_xfer_buf(buf, len, srb); 2155 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2156 2157 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2158 if (retval != STATUS_SUCCESS) { 2159 vfree(buf); 2160 return TRANSPORT_ERROR; 2161 } 2162 2163 if (chip->asic_code) { 2164 retval = rtsx_read_phy_register(chip, 0x08, &val); 2165 if (retval != STATUS_SUCCESS) { 2166 vfree(buf); 2167 return TRANSPORT_ERROR; 2168 } 2169 2170 retval = rtsx_write_register(chip, PWR_GATE_CTRL, 2171 LDO3318_PWR_MASK, LDO_OFF); 2172 if (retval != STATUS_SUCCESS) { 2173 vfree(buf); 2174 return TRANSPORT_ERROR; 2175 } 2176 2177 wait_timeout(600); 2178 2179 retval = rtsx_write_phy_register(chip, 0x08, 2180 0x4C00 | chip->phy_voltage); 2181 if (retval != STATUS_SUCCESS) { 2182 vfree(buf); 2183 return TRANSPORT_ERROR; 2184 } 2185 2186 retval = rtsx_write_register(chip, PWR_GATE_CTRL, 2187 LDO3318_PWR_MASK, LDO_ON); 2188 if (retval != STATUS_SUCCESS) { 2189 vfree(buf); 2190 return TRANSPORT_ERROR; 2191 } 2192 2193 wait_timeout(600); 2194 } 2195 2196 retval = card_power_on(chip, SPI_CARD); 2197 if (retval != STATUS_SUCCESS) { 2198 vfree(buf); 2199 return TRANSPORT_ERROR; 2200 } 2201 2202 wait_timeout(50); 2203 2204 for (i = 0; i < len; i++) { 2205 retval = rtsx_write_efuse(chip, addr + i, buf[i]); 2206 if (retval != STATUS_SUCCESS) { 2207 set_sense_type(chip, SCSI_LUN(srb), 2208 SENSE_TYPE_MEDIA_WRITE_ERR); 2209 result = TRANSPORT_FAILED; 2210 goto exit; 2211 } 2212 } 2213 2214 exit: 2215 vfree(buf); 2216 2217 retval = card_power_off(chip, SPI_CARD); 2218 if (retval != STATUS_SUCCESS) { 2219 return TRANSPORT_ERROR; 2220 } 2221 2222 if (chip->asic_code) { 2223 retval = rtsx_write_register(chip, PWR_GATE_CTRL, 2224 LDO3318_PWR_MASK, LDO_OFF); 2225 if (retval != STATUS_SUCCESS) { 2226 return TRANSPORT_ERROR; 2227 } 2228 2229 wait_timeout(600); 2230 2231 retval = rtsx_write_phy_register(chip, 0x08, val); 2232 if (retval != STATUS_SUCCESS) { 2233 return TRANSPORT_ERROR; 2234 } 2235 2236 retval = rtsx_write_register(chip, PWR_GATE_CTRL, 2237 LDO3318_PWR_MASK, LDO_ON); 2238 if (retval != STATUS_SUCCESS) { 2239 return TRANSPORT_ERROR; 2240 } 2241 } 2242 2243 return result; 2244 } 2245 2246 static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2247 { 2248 int retval; 2249 bool func_max; 2250 u8 func; 2251 u16 addr, len; 2252 u8 *buf; 2253 2254 rtsx_disable_aspm(chip); 2255 2256 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2257 rtsx_exit_ss(chip); 2258 wait_timeout(100); 2259 } 2260 rtsx_set_stat(chip, RTSX_STAT_RUN); 2261 2262 func = srb->cmnd[3]; 2263 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5]; 2264 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7]; 2265 2266 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x, len = %d\n", 2267 __func__, func, addr, len); 2268 2269 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) 2270 func_max = true; 2271 else 2272 func_max = false; 2273 2274 if (func > func_max) { 2275 set_sense_type(chip, SCSI_LUN(srb), 2276 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2277 return TRANSPORT_FAILED; 2278 } 2279 2280 buf = vmalloc(len); 2281 if (!buf) { 2282 return TRANSPORT_ERROR; 2283 } 2284 2285 retval = rtsx_read_cfg_seq(chip, func, addr, buf, len); 2286 if (retval != STATUS_SUCCESS) { 2287 set_sense_type(chip, SCSI_LUN(srb), 2288 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2289 vfree(buf); 2290 return TRANSPORT_FAILED; 2291 } 2292 2293 len = (u16)min_t(unsigned int, scsi_bufflen(srb), len); 2294 rtsx_stor_set_xfer_buf(buf, len, srb); 2295 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2296 2297 vfree(buf); 2298 2299 return TRANSPORT_GOOD; 2300 } 2301 2302 static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2303 { 2304 int retval; 2305 bool func_max; 2306 u8 func; 2307 u16 addr, len; 2308 u8 *buf; 2309 2310 rtsx_disable_aspm(chip); 2311 2312 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2313 rtsx_exit_ss(chip); 2314 wait_timeout(100); 2315 } 2316 rtsx_set_stat(chip, RTSX_STAT_RUN); 2317 2318 func = srb->cmnd[3]; 2319 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5]; 2320 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7]; 2321 2322 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x\n", 2323 __func__, func, addr); 2324 2325 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) 2326 func_max = true; 2327 else 2328 func_max = false; 2329 2330 if (func > func_max) { 2331 set_sense_type(chip, SCSI_LUN(srb), 2332 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2333 return TRANSPORT_FAILED; 2334 } 2335 2336 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len); 2337 buf = vmalloc(len); 2338 if (!buf) { 2339 return TRANSPORT_ERROR; 2340 } 2341 2342 rtsx_stor_get_xfer_buf(buf, len, srb); 2343 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2344 2345 retval = rtsx_write_cfg_seq(chip, func, addr, buf, len); 2346 if (retval != STATUS_SUCCESS) { 2347 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 2348 vfree(buf); 2349 return TRANSPORT_FAILED; 2350 } 2351 2352 vfree(buf); 2353 2354 return TRANSPORT_GOOD; 2355 } 2356 2357 static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2358 { 2359 int result; 2360 2361 switch (srb->cmnd[2]) { 2362 case PP_READ10: 2363 case PP_WRITE10: 2364 result = read_write(srb, chip); 2365 break; 2366 2367 case READ_HOST_REG: 2368 result = read_host_reg(srb, chip); 2369 break; 2370 2371 case WRITE_HOST_REG: 2372 result = write_host_reg(srb, chip); 2373 break; 2374 2375 case GET_VAR: 2376 result = get_variable(srb, chip); 2377 break; 2378 2379 case SET_VAR: 2380 result = set_variable(srb, chip); 2381 break; 2382 2383 case DMA_READ: 2384 case DMA_WRITE: 2385 result = dma_access_ring_buffer(srb, chip); 2386 break; 2387 2388 case READ_PHY: 2389 result = read_phy_register(srb, chip); 2390 break; 2391 2392 case WRITE_PHY: 2393 result = write_phy_register(srb, chip); 2394 break; 2395 2396 case ERASE_EEPROM2: 2397 result = erase_eeprom2(srb, chip); 2398 break; 2399 2400 case READ_EEPROM2: 2401 result = read_eeprom2(srb, chip); 2402 break; 2403 2404 case WRITE_EEPROM2: 2405 result = write_eeprom2(srb, chip); 2406 break; 2407 2408 case READ_EFUSE: 2409 result = read_efuse(srb, chip); 2410 break; 2411 2412 case WRITE_EFUSE: 2413 result = write_efuse(srb, chip); 2414 break; 2415 2416 case READ_CFG: 2417 result = read_cfg_byte(srb, chip); 2418 break; 2419 2420 case WRITE_CFG: 2421 result = write_cfg_byte(srb, chip); 2422 break; 2423 2424 case SET_CHIP_MODE: 2425 result = set_chip_mode(srb, chip); 2426 break; 2427 2428 case SUIT_CMD: 2429 result = suit_cmd(srb, chip); 2430 break; 2431 2432 case GET_DEV_STATUS: 2433 result = get_dev_status(srb, chip); 2434 break; 2435 2436 default: 2437 set_sense_type(chip, SCSI_LUN(srb), 2438 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2439 return TRANSPORT_FAILED; 2440 } 2441 2442 return result; 2443 } 2444 2445 static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2446 { 2447 u8 rtsx_status[16]; 2448 int buf_len; 2449 unsigned int lun = SCSI_LUN(srb); 2450 2451 rtsx_status[0] = (u8)(chip->vendor_id >> 8); 2452 rtsx_status[1] = (u8)(chip->vendor_id); 2453 2454 rtsx_status[2] = (u8)(chip->product_id >> 8); 2455 rtsx_status[3] = (u8)(chip->product_id); 2456 2457 rtsx_status[4] = (u8)lun; 2458 2459 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) { 2460 if (chip->lun2card[lun] == SD_CARD) 2461 rtsx_status[5] = 2; 2462 else 2463 rtsx_status[5] = 3; 2464 } else { 2465 if (chip->card_exist) { 2466 if (chip->card_exist & XD_CARD) 2467 rtsx_status[5] = 4; 2468 else if (chip->card_exist & SD_CARD) 2469 rtsx_status[5] = 2; 2470 else if (chip->card_exist & MS_CARD) 2471 rtsx_status[5] = 3; 2472 else 2473 rtsx_status[5] = 7; 2474 } else { 2475 rtsx_status[5] = 7; 2476 } 2477 } 2478 2479 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) 2480 rtsx_status[6] = 2; 2481 else 2482 rtsx_status[6] = 1; 2483 2484 rtsx_status[7] = (u8)(chip->product_id); 2485 rtsx_status[8] = chip->ic_version; 2486 2487 if (check_card_exist(chip, lun)) 2488 rtsx_status[9] = 1; 2489 else 2490 rtsx_status[9] = 0; 2491 2492 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) 2493 rtsx_status[10] = 0; 2494 else 2495 rtsx_status[10] = 1; 2496 2497 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) { 2498 if (chip->lun2card[lun] == SD_CARD) 2499 rtsx_status[11] = SD_CARD; 2500 else 2501 rtsx_status[11] = MS_CARD; 2502 } else { 2503 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD; 2504 } 2505 2506 if (check_card_ready(chip, lun)) 2507 rtsx_status[12] = 1; 2508 else 2509 rtsx_status[12] = 0; 2510 2511 if (get_lun_card(chip, lun) == XD_CARD) { 2512 rtsx_status[13] = 0x40; 2513 } else if (get_lun_card(chip, lun) == SD_CARD) { 2514 struct sd_info *sd_card = &chip->sd_card; 2515 2516 rtsx_status[13] = 0x20; 2517 if (CHK_SD(sd_card)) { 2518 if (CHK_SD_HCXC(sd_card)) 2519 rtsx_status[13] |= 0x04; 2520 if (CHK_SD_HS(sd_card)) 2521 rtsx_status[13] |= 0x02; 2522 } else { 2523 rtsx_status[13] |= 0x08; 2524 if (CHK_MMC_52M(sd_card)) 2525 rtsx_status[13] |= 0x02; 2526 if (CHK_MMC_SECTOR_MODE(sd_card)) 2527 rtsx_status[13] |= 0x04; 2528 } 2529 } else if (get_lun_card(chip, lun) == MS_CARD) { 2530 struct ms_info *ms_card = &chip->ms_card; 2531 2532 if (CHK_MSPRO(ms_card)) { 2533 rtsx_status[13] = 0x38; 2534 if (CHK_HG8BIT(ms_card)) 2535 rtsx_status[13] |= 0x04; 2536 #ifdef SUPPORT_MSXC 2537 if (CHK_MSXC(ms_card)) 2538 rtsx_status[13] |= 0x01; 2539 #endif 2540 } else { 2541 rtsx_status[13] = 0x30; 2542 } 2543 } else { 2544 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) { 2545 #ifdef SUPPORT_SDIO 2546 if (chip->sd_io && chip->sd_int) 2547 rtsx_status[13] = 0x60; 2548 else 2549 rtsx_status[13] = 0x70; 2550 #else 2551 rtsx_status[13] = 0x70; 2552 #endif 2553 } else { 2554 if (chip->lun2card[lun] == SD_CARD) 2555 rtsx_status[13] = 0x20; 2556 else 2557 rtsx_status[13] = 0x30; 2558 } 2559 } 2560 2561 rtsx_status[14] = 0x78; 2562 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) 2563 rtsx_status[15] = 0x83; 2564 else 2565 rtsx_status[15] = 0x82; 2566 2567 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(rtsx_status)); 2568 rtsx_stor_set_xfer_buf(rtsx_status, buf_len, srb); 2569 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len); 2570 2571 return TRANSPORT_GOOD; 2572 } 2573 2574 static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2575 { 2576 unsigned int lun = SCSI_LUN(srb); 2577 u8 card, bus_width; 2578 2579 if (!check_card_ready(chip, lun)) { 2580 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 2581 return TRANSPORT_FAILED; 2582 } 2583 2584 card = get_lun_card(chip, lun); 2585 if ((card == SD_CARD) || (card == MS_CARD)) { 2586 bus_width = chip->card_bus_width[lun]; 2587 } else { 2588 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2589 return TRANSPORT_FAILED; 2590 } 2591 2592 scsi_set_resid(srb, 0); 2593 rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb); 2594 2595 return TRANSPORT_GOOD; 2596 } 2597 2598 static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2599 { 2600 int result; 2601 unsigned int lun = SCSI_LUN(srb); 2602 u8 gpio_dir; 2603 2604 if (CHECK_PID(chip, 0x5208) || CHECK_PID(chip, 0x5288)) { 2605 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2606 return TRANSPORT_FAILED; 2607 } 2608 2609 rtsx_disable_aspm(chip); 2610 2611 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2612 rtsx_exit_ss(chip); 2613 wait_timeout(100); 2614 } 2615 rtsx_set_stat(chip, RTSX_STAT_RUN); 2616 2617 rtsx_force_power_on(chip, SSC_PDCTL); 2618 2619 rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir); 2620 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06); 2621 2622 switch (srb->cmnd[2]) { 2623 case SCSI_SPI_GETSTATUS: 2624 result = spi_get_status(srb, chip); 2625 break; 2626 2627 case SCSI_SPI_SETPARAMETER: 2628 result = spi_set_parameter(srb, chip); 2629 break; 2630 2631 case SCSI_SPI_READFALSHID: 2632 result = spi_read_flash_id(srb, chip); 2633 break; 2634 2635 case SCSI_SPI_READFLASH: 2636 result = spi_read_flash(srb, chip); 2637 break; 2638 2639 case SCSI_SPI_WRITEFLASH: 2640 result = spi_write_flash(srb, chip); 2641 break; 2642 2643 case SCSI_SPI_WRITEFLASHSTATUS: 2644 result = spi_write_flash_status(srb, chip); 2645 break; 2646 2647 case SCSI_SPI_ERASEFLASH: 2648 result = spi_erase_flash(srb, chip); 2649 break; 2650 2651 default: 2652 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir); 2653 2654 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2655 return TRANSPORT_FAILED; 2656 } 2657 2658 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir); 2659 2660 if (result != STATUS_SUCCESS) { 2661 return TRANSPORT_FAILED; 2662 } 2663 2664 return TRANSPORT_GOOD; 2665 } 2666 2667 static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2668 { 2669 int result; 2670 2671 switch (srb->cmnd[1]) { 2672 case READ_STATUS: 2673 result = read_status(srb, chip); 2674 break; 2675 2676 case READ_MEM: 2677 result = read_mem(srb, chip); 2678 break; 2679 2680 case WRITE_MEM: 2681 result = write_mem(srb, chip); 2682 break; 2683 2684 case READ_EEPROM: 2685 result = read_eeprom(srb, chip); 2686 break; 2687 2688 case WRITE_EEPROM: 2689 result = write_eeprom(srb, chip); 2690 break; 2691 2692 case TOGGLE_GPIO: 2693 result = toggle_gpio_cmd(srb, chip); 2694 break; 2695 2696 case GET_SD_CSD: 2697 result = get_sd_csd(srb, chip); 2698 break; 2699 2700 case GET_BUS_WIDTH: 2701 result = get_card_bus_width(srb, chip); 2702 break; 2703 2704 case SCSI_APP_CMD: 2705 result = app_cmd(srb, chip); 2706 break; 2707 2708 case SPI_VENDOR_COMMAND: 2709 result = spi_vendor_cmd(srb, chip); 2710 break; 2711 2712 default: 2713 set_sense_type(chip, SCSI_LUN(srb), 2714 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2715 return TRANSPORT_FAILED; 2716 } 2717 2718 return result; 2719 } 2720 2721 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK) 2722 void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2723 { 2724 unsigned int lun = SCSI_LUN(srb); 2725 u16 sec_cnt; 2726 2727 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) { 2728 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8]; 2729 } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) { 2730 sec_cnt = srb->cmnd[4]; 2731 if (sec_cnt == 0) 2732 sec_cnt = 256; 2733 } else { 2734 return; 2735 } 2736 2737 if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) { 2738 toggle_gpio(chip, LED_GPIO); 2739 chip->rw_cap[lun] = 0; 2740 } else { 2741 chip->rw_cap[lun] += sec_cnt; 2742 } 2743 } 2744 #endif 2745 2746 static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2747 { 2748 struct ms_info *ms_card = &chip->ms_card; 2749 unsigned int lun = SCSI_LUN(srb); 2750 bool quick_format; 2751 int retval; 2752 2753 if (get_lun_card(chip, lun) != MS_CARD) { 2754 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 2755 return TRANSPORT_FAILED; 2756 } 2757 2758 if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47) || 2759 (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D) || 2760 (srb->cmnd[7] != 0x74)) { 2761 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2762 return TRANSPORT_FAILED; 2763 } 2764 2765 rtsx_disable_aspm(chip); 2766 2767 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2768 rtsx_exit_ss(chip); 2769 wait_timeout(100); 2770 2771 if (!check_card_ready(chip, lun) || 2772 (get_card_size(chip, lun) == 0)) { 2773 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 2774 return TRANSPORT_FAILED; 2775 } 2776 } 2777 rtsx_set_stat(chip, RTSX_STAT_RUN); 2778 2779 if (srb->cmnd[8] & 0x01) 2780 quick_format = false; 2781 else 2782 quick_format = true; 2783 2784 if (!(chip->card_ready & MS_CARD)) { 2785 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 2786 return TRANSPORT_FAILED; 2787 } 2788 2789 if (chip->card_wp & MS_CARD) { 2790 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT); 2791 return TRANSPORT_FAILED; 2792 } 2793 2794 if (!CHK_MSPRO(ms_card)) { 2795 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 2796 return TRANSPORT_FAILED; 2797 } 2798 2799 retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format); 2800 if (retval != STATUS_SUCCESS) { 2801 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED); 2802 return TRANSPORT_FAILED; 2803 } 2804 2805 scsi_set_resid(srb, 0); 2806 return TRANSPORT_GOOD; 2807 } 2808 2809 #ifdef SUPPORT_PCGL_1P18 2810 static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2811 { 2812 struct ms_info *ms_card = &chip->ms_card; 2813 unsigned int lun = SCSI_LUN(srb); 2814 u8 dev_info_id, data_len; 2815 u8 *buf; 2816 unsigned int buf_len; 2817 int i; 2818 2819 if (!check_card_ready(chip, lun)) { 2820 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 2821 return TRANSPORT_FAILED; 2822 } 2823 if (get_lun_card(chip, lun) != MS_CARD) { 2824 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 2825 return TRANSPORT_FAILED; 2826 } 2827 2828 if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) || 2829 (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) || 2830 (srb->cmnd[7] != 0x44)) { 2831 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2832 return TRANSPORT_FAILED; 2833 } 2834 2835 dev_info_id = srb->cmnd[3]; 2836 if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) || 2837 (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) || 2838 !CHK_MSPRO(ms_card)) { 2839 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2840 return TRANSPORT_FAILED; 2841 } 2842 2843 if (dev_info_id == 0x15) { 2844 buf_len = 0x3A; 2845 data_len = 0x3A; 2846 } else { 2847 buf_len = 0x6A; 2848 data_len = 0x6A; 2849 } 2850 2851 buf = kmalloc(buf_len, GFP_KERNEL); 2852 if (!buf) { 2853 return TRANSPORT_ERROR; 2854 } 2855 2856 i = 0; 2857 /* GET Memory Stick Media Information Response Header */ 2858 buf[i++] = 0x00; /* Data length MSB */ 2859 buf[i++] = data_len; /* Data length LSB */ 2860 /* Device Information Type Code */ 2861 if (CHK_MSXC(ms_card)) 2862 buf[i++] = 0x03; 2863 else 2864 buf[i++] = 0x02; 2865 2866 /* SGM bit */ 2867 buf[i++] = 0x01; 2868 /* Reserved */ 2869 buf[i++] = 0x00; 2870 buf[i++] = 0x00; 2871 buf[i++] = 0x00; 2872 /* Number of Device Information */ 2873 buf[i++] = 0x01; 2874 2875 /* Device Information Body */ 2876 2877 /* Device Information ID Number */ 2878 buf[i++] = dev_info_id; 2879 /* Device Information Length */ 2880 if (dev_info_id == 0x15) 2881 data_len = 0x31; 2882 else 2883 data_len = 0x61; 2884 2885 buf[i++] = 0x00; /* Data length MSB */ 2886 buf[i++] = data_len; /* Data length LSB */ 2887 /* Valid Bit */ 2888 buf[i++] = 0x80; 2889 if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) { 2890 /* System Information */ 2891 memcpy(buf + i, ms_card->raw_sys_info, 96); 2892 } else { 2893 /* Model Name */ 2894 memcpy(buf + i, ms_card->raw_model_name, 48); 2895 } 2896 2897 rtsx_stor_set_xfer_buf(buf, buf_len, srb); 2898 2899 if (dev_info_id == 0x15) 2900 scsi_set_resid(srb, scsi_bufflen(srb) - 0x3C); 2901 else 2902 scsi_set_resid(srb, scsi_bufflen(srb) - 0x6C); 2903 2904 kfree(buf); 2905 return STATUS_SUCCESS; 2906 } 2907 #endif 2908 2909 static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2910 { 2911 int retval = TRANSPORT_ERROR; 2912 2913 if (srb->cmnd[2] == MS_FORMAT) 2914 retval = ms_format_cmnd(srb, chip); 2915 #ifdef SUPPORT_PCGL_1P18 2916 else if (srb->cmnd[2] == GET_MS_INFORMATION) 2917 retval = get_ms_information(srb, chip); 2918 #endif 2919 2920 return retval; 2921 } 2922 2923 #ifdef SUPPORT_CPRM 2924 static int sd_extension_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2925 { 2926 unsigned int lun = SCSI_LUN(srb); 2927 int result; 2928 2929 rtsx_disable_aspm(chip); 2930 2931 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2932 rtsx_exit_ss(chip); 2933 wait_timeout(100); 2934 } 2935 rtsx_set_stat(chip, RTSX_STAT_RUN); 2936 2937 sd_cleanup_work(chip); 2938 2939 if (!check_card_ready(chip, lun)) { 2940 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 2941 return TRANSPORT_FAILED; 2942 } 2943 if (get_lun_card(chip, lun) != SD_CARD) { 2944 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 2945 return TRANSPORT_FAILED; 2946 } 2947 2948 switch (srb->cmnd[0]) { 2949 case SD_PASS_THRU_MODE: 2950 result = sd_pass_thru_mode(srb, chip); 2951 break; 2952 2953 case SD_EXECUTE_NO_DATA: 2954 result = sd_execute_no_data(srb, chip); 2955 break; 2956 2957 case SD_EXECUTE_READ: 2958 result = sd_execute_read_data(srb, chip); 2959 break; 2960 2961 case SD_EXECUTE_WRITE: 2962 result = sd_execute_write_data(srb, chip); 2963 break; 2964 2965 case SD_GET_RSP: 2966 result = sd_get_cmd_rsp(srb, chip); 2967 break; 2968 2969 case SD_HW_RST: 2970 result = sd_hw_rst(srb, chip); 2971 break; 2972 2973 default: 2974 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2975 return TRANSPORT_FAILED; 2976 } 2977 2978 return result; 2979 } 2980 #endif 2981 2982 #ifdef SUPPORT_MAGIC_GATE 2983 static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2984 { 2985 struct ms_info *ms_card = &chip->ms_card; 2986 unsigned int lun = SCSI_LUN(srb); 2987 int retval; 2988 u8 key_format; 2989 2990 rtsx_disable_aspm(chip); 2991 2992 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2993 rtsx_exit_ss(chip); 2994 wait_timeout(100); 2995 } 2996 rtsx_set_stat(chip, RTSX_STAT_RUN); 2997 2998 ms_cleanup_work(chip); 2999 3000 if (!check_card_ready(chip, lun)) { 3001 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 3002 return TRANSPORT_FAILED; 3003 } 3004 if (get_lun_card(chip, lun) != MS_CARD) { 3005 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 3006 return TRANSPORT_FAILED; 3007 } 3008 3009 if (srb->cmnd[7] != KC_MG_R_PRO) { 3010 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3011 return TRANSPORT_FAILED; 3012 } 3013 3014 if (!CHK_MSPRO(ms_card)) { 3015 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM); 3016 return TRANSPORT_FAILED; 3017 } 3018 3019 key_format = srb->cmnd[10] & 0x3F; 3020 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format); 3021 3022 switch (key_format) { 3023 case KF_GET_LOC_EKB: 3024 if ((scsi_bufflen(srb) == 0x41C) && 3025 (srb->cmnd[8] == 0x04) && 3026 (srb->cmnd[9] == 0x1C)) { 3027 retval = mg_get_local_EKB(srb, chip); 3028 if (retval != STATUS_SUCCESS) { 3029 return TRANSPORT_FAILED; 3030 } 3031 3032 } else { 3033 set_sense_type(chip, lun, 3034 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3035 return TRANSPORT_FAILED; 3036 } 3037 break; 3038 3039 case KF_RSP_CHG: 3040 if ((scsi_bufflen(srb) == 0x24) && 3041 (srb->cmnd[8] == 0x00) && 3042 (srb->cmnd[9] == 0x24)) { 3043 retval = mg_get_rsp_chg(srb, chip); 3044 if (retval != STATUS_SUCCESS) { 3045 return TRANSPORT_FAILED; 3046 } 3047 3048 } else { 3049 set_sense_type(chip, lun, 3050 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3051 return TRANSPORT_FAILED; 3052 } 3053 break; 3054 3055 case KF_GET_ICV: 3056 ms_card->mg_entry_num = srb->cmnd[5]; 3057 if ((scsi_bufflen(srb) == 0x404) && 3058 (srb->cmnd[8] == 0x04) && 3059 (srb->cmnd[9] == 0x04) && 3060 (srb->cmnd[2] == 0x00) && 3061 (srb->cmnd[3] == 0x00) && 3062 (srb->cmnd[4] == 0x00) && 3063 (srb->cmnd[5] < 32)) { 3064 retval = mg_get_ICV(srb, chip); 3065 if (retval != STATUS_SUCCESS) { 3066 return TRANSPORT_FAILED; 3067 } 3068 3069 } else { 3070 set_sense_type(chip, lun, 3071 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3072 return TRANSPORT_FAILED; 3073 } 3074 break; 3075 3076 default: 3077 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3078 return TRANSPORT_FAILED; 3079 } 3080 3081 scsi_set_resid(srb, 0); 3082 return TRANSPORT_GOOD; 3083 } 3084 3085 static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3086 { 3087 struct ms_info *ms_card = &chip->ms_card; 3088 unsigned int lun = SCSI_LUN(srb); 3089 int retval; 3090 u8 key_format; 3091 3092 rtsx_disable_aspm(chip); 3093 3094 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 3095 rtsx_exit_ss(chip); 3096 wait_timeout(100); 3097 } 3098 rtsx_set_stat(chip, RTSX_STAT_RUN); 3099 3100 ms_cleanup_work(chip); 3101 3102 if (!check_card_ready(chip, lun)) { 3103 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 3104 return TRANSPORT_FAILED; 3105 } 3106 if (check_card_wp(chip, lun)) { 3107 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT); 3108 return TRANSPORT_FAILED; 3109 } 3110 if (get_lun_card(chip, lun) != MS_CARD) { 3111 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 3112 return TRANSPORT_FAILED; 3113 } 3114 3115 if (srb->cmnd[7] != KC_MG_R_PRO) { 3116 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3117 return TRANSPORT_FAILED; 3118 } 3119 3120 if (!CHK_MSPRO(ms_card)) { 3121 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM); 3122 return TRANSPORT_FAILED; 3123 } 3124 3125 key_format = srb->cmnd[10] & 0x3F; 3126 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format); 3127 3128 switch (key_format) { 3129 case KF_SET_LEAF_ID: 3130 if ((scsi_bufflen(srb) == 0x0C) && 3131 (srb->cmnd[8] == 0x00) && 3132 (srb->cmnd[9] == 0x0C)) { 3133 retval = mg_set_leaf_id(srb, chip); 3134 if (retval != STATUS_SUCCESS) { 3135 return TRANSPORT_FAILED; 3136 } 3137 3138 } else { 3139 set_sense_type(chip, lun, 3140 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3141 return TRANSPORT_FAILED; 3142 } 3143 break; 3144 3145 case KF_CHG_HOST: 3146 if ((scsi_bufflen(srb) == 0x0C) && 3147 (srb->cmnd[8] == 0x00) && 3148 (srb->cmnd[9] == 0x0C)) { 3149 retval = mg_chg(srb, chip); 3150 if (retval != STATUS_SUCCESS) { 3151 return TRANSPORT_FAILED; 3152 } 3153 3154 } else { 3155 set_sense_type(chip, lun, 3156 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3157 return TRANSPORT_FAILED; 3158 } 3159 break; 3160 3161 case KF_RSP_HOST: 3162 if ((scsi_bufflen(srb) == 0x0C) && 3163 (srb->cmnd[8] == 0x00) && 3164 (srb->cmnd[9] == 0x0C)) { 3165 retval = mg_rsp(srb, chip); 3166 if (retval != STATUS_SUCCESS) { 3167 return TRANSPORT_FAILED; 3168 } 3169 3170 } else { 3171 set_sense_type(chip, lun, 3172 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3173 return TRANSPORT_FAILED; 3174 } 3175 break; 3176 3177 case KF_SET_ICV: 3178 ms_card->mg_entry_num = srb->cmnd[5]; 3179 if ((scsi_bufflen(srb) == 0x404) && 3180 (srb->cmnd[8] == 0x04) && 3181 (srb->cmnd[9] == 0x04) && 3182 (srb->cmnd[2] == 0x00) && 3183 (srb->cmnd[3] == 0x00) && 3184 (srb->cmnd[4] == 0x00) && 3185 (srb->cmnd[5] < 32)) { 3186 retval = mg_set_ICV(srb, chip); 3187 if (retval != STATUS_SUCCESS) { 3188 return TRANSPORT_FAILED; 3189 } 3190 3191 } else { 3192 set_sense_type(chip, lun, 3193 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3194 return TRANSPORT_FAILED; 3195 } 3196 break; 3197 3198 default: 3199 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3200 return TRANSPORT_FAILED; 3201 } 3202 3203 scsi_set_resid(srb, 0); 3204 return TRANSPORT_GOOD; 3205 } 3206 #endif 3207 3208 int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3209 { 3210 #ifdef SUPPORT_SD_LOCK 3211 struct sd_info *sd_card = &chip->sd_card; 3212 #endif 3213 struct ms_info *ms_card = &chip->ms_card; 3214 unsigned int lun = SCSI_LUN(srb); 3215 int result; 3216 3217 #ifdef SUPPORT_SD_LOCK 3218 if (sd_card->sd_erase_status) { 3219 /* Block all SCSI command except for 3220 * REQUEST_SENSE and rs_ppstatus 3221 */ 3222 if (!((srb->cmnd[0] == VENDOR_CMND) && 3223 (srb->cmnd[1] == SCSI_APP_CMD) && 3224 (srb->cmnd[2] == GET_DEV_STATUS)) && 3225 (srb->cmnd[0] != REQUEST_SENSE)) { 3226 /* Logical Unit Not Ready Format in Progress */ 3227 set_sense_data(chip, lun, CUR_ERR, 3228 0x02, 0, 0x04, 0x04, 0, 0); 3229 return TRANSPORT_FAILED; 3230 } 3231 } 3232 #endif 3233 3234 if ((get_lun_card(chip, lun) == MS_CARD) && 3235 (ms_card->format_status == FORMAT_IN_PROGRESS)) { 3236 if ((srb->cmnd[0] != REQUEST_SENSE) && 3237 (srb->cmnd[0] != INQUIRY)) { 3238 /* Logical Unit Not Ready Format in Progress */ 3239 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 3240 0, (u16)(ms_card->progress)); 3241 return TRANSPORT_FAILED; 3242 } 3243 } 3244 3245 switch (srb->cmnd[0]) { 3246 case READ_10: 3247 case WRITE_10: 3248 case READ_6: 3249 case WRITE_6: 3250 result = read_write(srb, chip); 3251 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK) 3252 led_shine(srb, chip); 3253 #endif 3254 break; 3255 3256 case TEST_UNIT_READY: 3257 result = test_unit_ready(srb, chip); 3258 break; 3259 3260 case INQUIRY: 3261 result = inquiry(srb, chip); 3262 break; 3263 3264 case READ_CAPACITY: 3265 result = read_capacity(srb, chip); 3266 break; 3267 3268 case START_STOP: 3269 result = start_stop_unit(srb, chip); 3270 break; 3271 3272 case ALLOW_MEDIUM_REMOVAL: 3273 result = allow_medium_removal(srb, chip); 3274 break; 3275 3276 case REQUEST_SENSE: 3277 result = request_sense(srb, chip); 3278 break; 3279 3280 case MODE_SENSE: 3281 case MODE_SENSE_10: 3282 result = mode_sense(srb, chip); 3283 break; 3284 3285 case 0x23: 3286 result = read_format_capacity(srb, chip); 3287 break; 3288 3289 case VENDOR_CMND: 3290 result = vendor_cmnd(srb, chip); 3291 break; 3292 3293 case MS_SP_CMND: 3294 result = ms_sp_cmnd(srb, chip); 3295 break; 3296 3297 #ifdef SUPPORT_CPRM 3298 case SD_PASS_THRU_MODE: 3299 case SD_EXECUTE_NO_DATA: 3300 case SD_EXECUTE_READ: 3301 case SD_EXECUTE_WRITE: 3302 case SD_GET_RSP: 3303 case SD_HW_RST: 3304 result = sd_extension_cmnd(srb, chip); 3305 break; 3306 #endif 3307 3308 #ifdef SUPPORT_MAGIC_GATE 3309 case CMD_MSPRO_MG_RKEY: 3310 result = mg_report_key(srb, chip); 3311 break; 3312 3313 case CMD_MSPRO_MG_SKEY: 3314 result = mg_send_key(srb, chip); 3315 break; 3316 #endif 3317 3318 case FORMAT_UNIT: 3319 case MODE_SELECT: 3320 case VERIFY: 3321 result = TRANSPORT_GOOD; 3322 break; 3323 3324 default: 3325 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3326 result = TRANSPORT_FAILED; 3327 } 3328 3329 return result; 3330 } 3331