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 33void 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 324void 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 399void 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 422static 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 456static 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 474static 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 == NULL) { 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 562static int start_stop_unit(struct scsi_cmnd *srb, struct rtsx_chip *chip) 563{ 564 unsigned int lun = SCSI_LUN(srb); 565 566 scsi_set_resid(srb, scsi_bufflen(srb)); 567 568 if (srb->cmnd[1] == 1) 569 return TRANSPORT_GOOD; 570 571 switch (srb->cmnd[0x4]) { 572 case STOP_MEDIUM: 573 /* Media disabled */ 574 return TRANSPORT_GOOD; 575 576 case UNLOAD_MEDIUM: 577 /* Media shall be unload */ 578 if (check_card_ready(chip, lun)) 579 eject_card(chip, lun); 580 return TRANSPORT_GOOD; 581 582 case MAKE_MEDIUM_READY: 583 case LOAD_MEDIUM: 584 if (check_card_ready(chip, lun)) 585 return TRANSPORT_GOOD; 586 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 587 rtsx_trace(chip); 588 return TRANSPORT_FAILED; 589 590 break; 591 } 592 593 rtsx_trace(chip); 594 return TRANSPORT_ERROR; 595} 596 597 598static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip) 599{ 600 int prevent; 601 602 prevent = srb->cmnd[4] & 0x1; 603 604 scsi_set_resid(srb, 0); 605 606 if (prevent) { 607 set_sense_type(chip, SCSI_LUN(srb), 608 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 609 rtsx_trace(chip); 610 return TRANSPORT_FAILED; 611 } 612 613 return TRANSPORT_GOOD; 614} 615 616 617static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip) 618{ 619 struct sense_data_t *sense; 620 unsigned int lun = SCSI_LUN(srb); 621 struct ms_info *ms_card = &(chip->ms_card); 622 unsigned char *tmp, *buf; 623 624 sense = &(chip->sense_buffer[lun]); 625 626 if ((get_lun_card(chip, lun) == MS_CARD) && 627 ms_card->pro_under_formatting) { 628 if (ms_card->format_status == FORMAT_SUCCESS) { 629 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE); 630 ms_card->pro_under_formatting = 0; 631 ms_card->progress = 0; 632 } else if (ms_card->format_status == FORMAT_IN_PROGRESS) { 633 /* Logical Unit Not Ready Format in Progress */ 634 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 635 0, (u16)(ms_card->progress)); 636 } else { 637 /* Format Command Failed */ 638 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED); 639 ms_card->pro_under_formatting = 0; 640 ms_card->progress = 0; 641 } 642 643 rtsx_set_stat(chip, RTSX_STAT_RUN); 644 } 645 646 buf = vmalloc(scsi_bufflen(srb)); 647 if (buf == NULL) { 648 rtsx_trace(chip); 649 return TRANSPORT_ERROR; 650 } 651 652 tmp = (unsigned char *)sense; 653 memcpy(buf, tmp, scsi_bufflen(srb)); 654 655 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb); 656 vfree(buf); 657 658 scsi_set_resid(srb, 0); 659 /* Reset Sense Data */ 660 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE); 661 return TRANSPORT_GOOD; 662} 663 664static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd, 665 int lun, u8 *buf, int buf_len) 666{ 667 struct ms_info *ms_card = &(chip->ms_card); 668 int sys_info_offset; 669 int data_size = buf_len; 670 bool support_format = false; 671 int i = 0; 672 673 if (cmd == MODE_SENSE) { 674 sys_info_offset = 8; 675 if (data_size > 0x68) 676 data_size = 0x68; 677 678 buf[i++] = 0x67; /* Mode Data Length */ 679 } else { 680 sys_info_offset = 12; 681 if (data_size > 0x6C) 682 data_size = 0x6C; 683 684 buf[i++] = 0x00; /* Mode Data Length (MSB) */ 685 buf[i++] = 0x6A; /* Mode Data Length (LSB) */ 686 } 687 688 /* Medium Type Code */ 689 if (check_card_ready(chip, lun)) { 690 if (CHK_MSXC(ms_card)) { 691 support_format = true; 692 buf[i++] = 0x40; 693 } else if (CHK_MSPRO(ms_card)) { 694 support_format = true; 695 buf[i++] = 0x20; 696 } else { 697 buf[i++] = 0x10; 698 } 699 700 /* WP */ 701 if (check_card_wp(chip, lun)) 702 buf[i++] = 0x80; 703 else 704 buf[i++] = 0x00; 705 706 } else { 707 buf[i++] = 0x00; /* MediaType */ 708 buf[i++] = 0x00; /* WP */ 709 } 710 711 buf[i++] = 0x00; /* Reserved */ 712 713 if (cmd == MODE_SENSE_10) { 714 buf[i++] = 0x00; /* Reserved */ 715 buf[i++] = 0x00; /* Block descriptor length(MSB) */ 716 buf[i++] = 0x00; /* Block descriptor length(LSB) */ 717 718 /* The Following Data is the content of "Page 0x20" */ 719 if (data_size >= 9) 720 buf[i++] = 0x20; /* Page Code */ 721 if (data_size >= 10) 722 buf[i++] = 0x62; /* Page Length */ 723 if (data_size >= 11) 724 buf[i++] = 0x00; /* No Access Control */ 725 if (data_size >= 12) { 726 if (support_format) 727 buf[i++] = 0xC0; /* SF, SGM */ 728 else 729 buf[i++] = 0x00; 730 } 731 } else { 732 /* The Following Data is the content of "Page 0x20" */ 733 if (data_size >= 5) 734 buf[i++] = 0x20; /* Page Code */ 735 if (data_size >= 6) 736 buf[i++] = 0x62; /* Page Length */ 737 if (data_size >= 7) 738 buf[i++] = 0x00; /* No Access Control */ 739 if (data_size >= 8) { 740 if (support_format) 741 buf[i++] = 0xC0; /* SF, SGM */ 742 else 743 buf[i++] = 0x00; 744 } 745 } 746 747 if (data_size > sys_info_offset) { 748 /* 96 Bytes Attribute Data */ 749 int len = data_size - sys_info_offset; 750 751 len = (len < 96) ? len : 96; 752 753 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len); 754 } 755} 756 757static int mode_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip) 758{ 759 unsigned int lun = SCSI_LUN(srb); 760 unsigned int dataSize; 761 int status; 762 bool pro_formatter_flag; 763 unsigned char pageCode, *buf; 764 u8 card = get_lun_card(chip, lun); 765 766#ifndef SUPPORT_MAGIC_GATE 767 if (!check_card_ready(chip, lun)) { 768 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 769 scsi_set_resid(srb, scsi_bufflen(srb)); 770 rtsx_trace(chip); 771 return TRANSPORT_FAILED; 772 } 773#endif 774 775 pro_formatter_flag = false; 776 dataSize = 8; 777#ifdef SUPPORT_MAGIC_GATE 778 if ((chip->lun2card[lun] & MS_CARD)) { 779 if (!card || (card == MS_CARD)) { 780 dataSize = 108; 781 if (chip->mspro_formatter_enable) 782 pro_formatter_flag = true; 783 } 784 } 785#else 786 if (card == MS_CARD) { 787 if (chip->mspro_formatter_enable) { 788 pro_formatter_flag = true; 789 dataSize = 108; 790 } 791 } 792#endif 793 794 buf = kmalloc(dataSize, GFP_KERNEL); 795 if (buf == NULL) { 796 rtsx_trace(chip); 797 return TRANSPORT_ERROR; 798 } 799 800 pageCode = srb->cmnd[2] & 0x3f; 801 802 if ((pageCode == 0x3F) || (pageCode == 0x1C) || 803 (pageCode == 0x00) || 804 (pro_formatter_flag && (pageCode == 0x20))) { 805 if (srb->cmnd[0] == MODE_SENSE) { 806 if ((pageCode == 0x3F) || (pageCode == 0x20)) { 807 ms_mode_sense(chip, srb->cmnd[0], 808 lun, buf, dataSize); 809 } else { 810 dataSize = 4; 811 buf[0] = 0x03; 812 buf[1] = 0x00; 813 if (check_card_wp(chip, lun)) 814 buf[2] = 0x80; 815 else 816 buf[2] = 0x00; 817 818 buf[3] = 0x00; 819 } 820 } else { 821 if ((pageCode == 0x3F) || (pageCode == 0x20)) { 822 ms_mode_sense(chip, srb->cmnd[0], 823 lun, buf, dataSize); 824 } else { 825 dataSize = 8; 826 buf[0] = 0x00; 827 buf[1] = 0x06; 828 buf[2] = 0x00; 829 if (check_card_wp(chip, lun)) 830 buf[3] = 0x80; 831 else 832 buf[3] = 0x00; 833 buf[4] = 0x00; 834 buf[5] = 0x00; 835 buf[6] = 0x00; 836 buf[7] = 0x00; 837 } 838 } 839 status = TRANSPORT_GOOD; 840 } else { 841 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 842 scsi_set_resid(srb, scsi_bufflen(srb)); 843 status = TRANSPORT_FAILED; 844 } 845 846 if (status == TRANSPORT_GOOD) { 847 unsigned int len = min_t(unsigned int, scsi_bufflen(srb), 848 dataSize); 849 rtsx_stor_set_xfer_buf(buf, len, srb); 850 scsi_set_resid(srb, scsi_bufflen(srb) - len); 851 } 852 kfree(buf); 853 854 return status; 855} 856 857static int read_write(struct scsi_cmnd *srb, struct rtsx_chip *chip) 858{ 859#ifdef SUPPORT_SD_LOCK 860 struct sd_info *sd_card = &(chip->sd_card); 861#endif 862 unsigned int lun = SCSI_LUN(srb); 863 int retval; 864 u32 start_sec; 865 u16 sec_cnt; 866 867 rtsx_disable_aspm(chip); 868 869 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 870 rtsx_exit_ss(chip); 871 wait_timeout(100); 872 } 873 rtsx_set_stat(chip, RTSX_STAT_RUN); 874 875 if (!check_card_ready(chip, lun) || (get_card_size(chip, lun) == 0)) { 876 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 877 rtsx_trace(chip); 878 return TRANSPORT_FAILED; 879 } 880 881 if (!(CHK_BIT(chip->lun_mc, lun))) { 882 SET_BIT(chip->lun_mc, lun); 883 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE); 884 return TRANSPORT_FAILED; 885 } 886 887#ifdef SUPPORT_SD_LOCK 888 if (sd_card->sd_erase_status) { 889 /* Accessing to any card is forbidden 890 * until the erase procedure of SD is completed 891 */ 892 dev_dbg(rtsx_dev(chip), "SD card being erased!\n"); 893 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN); 894 rtsx_trace(chip); 895 return TRANSPORT_FAILED; 896 } 897 898 if (get_lun_card(chip, lun) == SD_CARD) { 899 if (sd_card->sd_lock_status & SD_LOCKED) { 900 dev_dbg(rtsx_dev(chip), "SD card locked!\n"); 901 set_sense_type(chip, lun, 902 SENSE_TYPE_MEDIA_READ_FORBIDDEN); 903 rtsx_trace(chip); 904 return TRANSPORT_FAILED; 905 } 906 } 907#endif 908 909 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) { 910 start_sec = ((u32)srb->cmnd[2] << 24) | 911 ((u32)srb->cmnd[3] << 16) | 912 ((u32)srb->cmnd[4] << 8) | ((u32)srb->cmnd[5]); 913 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8]; 914 } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) { 915 start_sec = ((u32)(srb->cmnd[1] & 0x1F) << 16) | 916 ((u32)srb->cmnd[2] << 8) | ((u32)srb->cmnd[3]); 917 sec_cnt = srb->cmnd[4]; 918 } else if ((srb->cmnd[0] == VENDOR_CMND) && 919 (srb->cmnd[1] == SCSI_APP_CMD) && 920 ((srb->cmnd[2] == PP_READ10) || (srb->cmnd[2] == PP_WRITE10))) { 921 start_sec = ((u32)srb->cmnd[4] << 24) | 922 ((u32)srb->cmnd[5] << 16) | 923 ((u32)srb->cmnd[6] << 8) | ((u32)srb->cmnd[7]); 924 sec_cnt = ((u16)(srb->cmnd[9]) << 8) | srb->cmnd[10]; 925 } else { 926 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 927 rtsx_trace(chip); 928 return TRANSPORT_FAILED; 929 } 930 931 /* In some test, we will receive a start_sec like 0xFFFFFFFF. 932 * In this situation, start_sec + sec_cnt will overflow, so we 933 * need to judge start_sec at first 934 */ 935 if ((start_sec > get_card_size(chip, lun)) || 936 ((start_sec + sec_cnt) > get_card_size(chip, lun))) { 937 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE); 938 rtsx_trace(chip); 939 return TRANSPORT_FAILED; 940 } 941 942 if (sec_cnt == 0) { 943 scsi_set_resid(srb, 0); 944 return TRANSPORT_GOOD; 945 } 946 947 if (chip->rw_fail_cnt[lun] == 3) { 948 dev_dbg(rtsx_dev(chip), "read/write fail three times in succession\n"); 949 if (srb->sc_data_direction == DMA_FROM_DEVICE) 950 set_sense_type(chip, lun, 951 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 952 else 953 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR); 954 955 rtsx_trace(chip); 956 return TRANSPORT_FAILED; 957 } 958 959 if (srb->sc_data_direction == DMA_TO_DEVICE) { 960 if (check_card_wp(chip, lun)) { 961 dev_dbg(rtsx_dev(chip), "Write protected card!\n"); 962 set_sense_type(chip, lun, 963 SENSE_TYPE_MEDIA_WRITE_PROTECT); 964 rtsx_trace(chip); 965 return TRANSPORT_FAILED; 966 } 967 } 968 969 retval = card_rw(srb, chip, start_sec, sec_cnt); 970 if (retval != STATUS_SUCCESS) { 971 if (chip->need_release & chip->lun2card[lun]) { 972 chip->rw_fail_cnt[lun] = 0; 973 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 974 } else { 975 chip->rw_fail_cnt[lun]++; 976 if (srb->sc_data_direction == DMA_FROM_DEVICE) 977 set_sense_type(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 993Exit: 994 return retval; 995} 996 997static 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 == NULL) { 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 1078static 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 == NULL) { 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 1121static 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 1172static 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 == NULL) { 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 1232static 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 1290static 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 == NULL) { 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 1348static 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 1371static 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 1391static 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) == NULL)) { 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 == NULL) { 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 1461static 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 1492static 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 1520static int set_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1521{ 1522 unsigned 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 1585static 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 1629static 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, 1000); 1653 if (retval < 0) { 1654 if (srb->sc_data_direction == DMA_FROM_DEVICE) 1655 set_sense_type(chip, lun, 1656 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1657 else 1658 set_sense_type(chip, lun, 1659 SENSE_TYPE_MEDIA_WRITE_ERR); 1660 1661 rtsx_trace(chip); 1662 return TRANSPORT_FAILED; 1663 } 1664 scsi_set_resid(srb, 0); 1665 1666 return TRANSPORT_GOOD; 1667} 1668 1669static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1670{ 1671 struct sd_info *sd_card = &(chip->sd_card); 1672 struct ms_info *ms_card = &(chip->ms_card); 1673 int buf_len; 1674 unsigned int lun = SCSI_LUN(srb); 1675 u8 card = get_lun_card(chip, lun); 1676 u8 status[32]; 1677#ifdef SUPPORT_OCP 1678 u8 oc_now_mask = 0, oc_ever_mask = 0; 1679#endif 1680 1681 memset(status, 0, 32); 1682 1683 status[0] = (u8)(chip->product_id); 1684 status[1] = chip->ic_version; 1685 1686 if (chip->auto_delink_en) 1687 status[2] = 0x10; 1688 else 1689 status[2] = 0x00; 1690 1691 status[3] = 20; 1692 status[4] = 10; 1693 status[5] = 05; 1694 status[6] = 21; 1695 1696 if (chip->card_wp) 1697 status[7] = 0x20; 1698 else 1699 status[7] = 0x00; 1700 1701#ifdef SUPPORT_OCP 1702 status[8] = 0; 1703 if (CHECK_LUN_MODE(chip, 1704 SD_MS_2LUN) && (chip->lun2card[lun] == MS_CARD)) { 1705 oc_now_mask = MS_OC_NOW; 1706 oc_ever_mask = MS_OC_EVER; 1707 } else { 1708 oc_now_mask = SD_OC_NOW; 1709 oc_ever_mask = SD_OC_EVER; 1710 } 1711 1712 if (chip->ocp_stat & oc_now_mask) 1713 status[8] |= 0x02; 1714 1715 if (chip->ocp_stat & oc_ever_mask) 1716 status[8] |= 0x01; 1717#endif 1718 1719 if (card == SD_CARD) { 1720 if (CHK_SD(sd_card)) { 1721 if (CHK_SD_HCXC(sd_card)) { 1722 if (sd_card->capacity > 0x4000000) 1723 status[0x0E] = 0x02; 1724 else 1725 status[0x0E] = 0x01; 1726 } else { 1727 status[0x0E] = 0x00; 1728 } 1729 1730 if (CHK_SD_SDR104(sd_card)) 1731 status[0x0F] = 0x03; 1732 else if (CHK_SD_DDR50(sd_card)) 1733 status[0x0F] = 0x04; 1734 else if (CHK_SD_SDR50(sd_card)) 1735 status[0x0F] = 0x02; 1736 else if (CHK_SD_HS(sd_card)) 1737 status[0x0F] = 0x01; 1738 else 1739 status[0x0F] = 0x00; 1740 } else { 1741 if (CHK_MMC_SECTOR_MODE(sd_card)) 1742 status[0x0E] = 0x01; 1743 else 1744 status[0x0E] = 0x00; 1745 1746 if (CHK_MMC_DDR52(sd_card)) 1747 status[0x0F] = 0x03; 1748 else if (CHK_MMC_52M(sd_card)) 1749 status[0x0F] = 0x02; 1750 else if (CHK_MMC_26M(sd_card)) 1751 status[0x0F] = 0x01; 1752 else 1753 status[0x0F] = 0x00; 1754 } 1755 } else if (card == MS_CARD) { 1756 if (CHK_MSPRO(ms_card)) { 1757 if (CHK_MSXC(ms_card)) 1758 status[0x0E] = 0x01; 1759 else 1760 status[0x0E] = 0x00; 1761 1762 if (CHK_HG8BIT(ms_card)) 1763 status[0x0F] = 0x01; 1764 else 1765 status[0x0F] = 0x00; 1766 } 1767 } 1768 1769#ifdef SUPPORT_SD_LOCK 1770 if (card == SD_CARD) { 1771 status[0x17] = 0x80; 1772 if (sd_card->sd_erase_status) 1773 status[0x17] |= 0x01; 1774 if (sd_card->sd_lock_status & SD_LOCKED) { 1775 status[0x17] |= 0x02; 1776 status[0x07] |= 0x40; 1777 } 1778 if (sd_card->sd_lock_status & SD_PWD_EXIST) 1779 status[0x17] |= 0x04; 1780 } else { 1781 status[0x17] = 0x00; 1782 } 1783 1784 dev_dbg(rtsx_dev(chip), "status[0x17] = 0x%x\n", status[0x17]); 1785#endif 1786 1787 status[0x18] = 0x8A; 1788 status[0x1A] = 0x28; 1789#ifdef SUPPORT_SD_LOCK 1790 status[0x1F] = 0x01; 1791#endif 1792 1793 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(status)); 1794 rtsx_stor_set_xfer_buf(status, buf_len, srb); 1795 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len); 1796 1797 return TRANSPORT_GOOD; 1798} 1799 1800static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1801{ 1802 int phy_debug_mode; 1803 int retval; 1804 u16 reg; 1805 1806 if (!CHECK_PID(chip, 0x5208)) { 1807 set_sense_type(chip, SCSI_LUN(srb), 1808 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1809 rtsx_trace(chip); 1810 return TRANSPORT_FAILED; 1811 } 1812 1813 phy_debug_mode = (int)(srb->cmnd[3]); 1814 1815 if (phy_debug_mode) { 1816 chip->phy_debug_mode = 1; 1817 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0); 1818 if (retval != STATUS_SUCCESS) { 1819 rtsx_trace(chip); 1820 return TRANSPORT_FAILED; 1821 } 1822 1823 rtsx_disable_bus_int(chip); 1824 1825 retval = rtsx_read_phy_register(chip, 0x1C, ®); 1826 if (retval != STATUS_SUCCESS) { 1827 rtsx_trace(chip); 1828 return TRANSPORT_FAILED; 1829 } 1830 1831 reg |= 0x0001; 1832 retval = rtsx_write_phy_register(chip, 0x1C, reg); 1833 if (retval != STATUS_SUCCESS) { 1834 rtsx_trace(chip); 1835 return TRANSPORT_FAILED; 1836 } 1837 } else { 1838 chip->phy_debug_mode = 0; 1839 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77); 1840 if (retval != STATUS_SUCCESS) { 1841 rtsx_trace(chip); 1842 return TRANSPORT_FAILED; 1843 } 1844 1845 rtsx_enable_bus_int(chip); 1846 1847 retval = rtsx_read_phy_register(chip, 0x1C, ®); 1848 if (retval != STATUS_SUCCESS) { 1849 rtsx_trace(chip); 1850 return TRANSPORT_FAILED; 1851 } 1852 1853 reg &= 0xFFFE; 1854 retval = rtsx_write_phy_register(chip, 0x1C, reg); 1855 if (retval != STATUS_SUCCESS) { 1856 rtsx_trace(chip); 1857 return TRANSPORT_FAILED; 1858 } 1859 } 1860 1861 return TRANSPORT_GOOD; 1862} 1863 1864static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1865{ 1866 int retval = STATUS_SUCCESS; 1867 unsigned int lun = SCSI_LUN(srb); 1868 u8 cmd_type, mask, value, idx; 1869 u16 addr; 1870 1871 rtsx_disable_aspm(chip); 1872 1873 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1874 rtsx_exit_ss(chip); 1875 wait_timeout(100); 1876 } 1877 rtsx_set_stat(chip, RTSX_STAT_RUN); 1878 1879 switch (srb->cmnd[3]) { 1880 case INIT_BATCHCMD: 1881 rtsx_init_cmd(chip); 1882 break; 1883 1884 case ADD_BATCHCMD: 1885 cmd_type = srb->cmnd[4]; 1886 if (cmd_type > 2) { 1887 set_sense_type(chip, lun, 1888 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1889 rtsx_trace(chip); 1890 return TRANSPORT_FAILED; 1891 } 1892 addr = (srb->cmnd[5] << 8) | srb->cmnd[6]; 1893 mask = srb->cmnd[7]; 1894 value = srb->cmnd[8]; 1895 rtsx_add_cmd(chip, cmd_type, addr, mask, value); 1896 break; 1897 1898 case SEND_BATCHCMD: 1899 retval = rtsx_send_cmd(chip, 0, 1000); 1900 break; 1901 1902 case GET_BATCHRSP: 1903 idx = srb->cmnd[4]; 1904 value = *(rtsx_get_cmd_data(chip) + idx); 1905 if (scsi_bufflen(srb) < 1) { 1906 set_sense_type(chip, lun, 1907 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1908 rtsx_trace(chip); 1909 return TRANSPORT_FAILED; 1910 } 1911 rtsx_stor_set_xfer_buf(&value, 1, srb); 1912 scsi_set_resid(srb, 0); 1913 break; 1914 1915 default: 1916 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 1917 rtsx_trace(chip); 1918 return TRANSPORT_FAILED; 1919 } 1920 1921 if (retval != STATUS_SUCCESS) { 1922 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR); 1923 rtsx_trace(chip); 1924 return TRANSPORT_FAILED; 1925 } 1926 1927 return TRANSPORT_GOOD; 1928} 1929 1930static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1931{ 1932 int result; 1933 1934 switch (srb->cmnd[3]) { 1935 case INIT_BATCHCMD: 1936 case ADD_BATCHCMD: 1937 case SEND_BATCHCMD: 1938 case GET_BATCHRSP: 1939 result = rw_mem_cmd_buf(srb, chip); 1940 break; 1941 default: 1942 result = TRANSPORT_ERROR; 1943 } 1944 1945 return result; 1946} 1947 1948static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip) 1949{ 1950 unsigned short addr, len, i; 1951 int retval; 1952 u8 *buf; 1953 u16 val; 1954 1955 rtsx_disable_aspm(chip); 1956 1957 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 1958 rtsx_exit_ss(chip); 1959 wait_timeout(100); 1960 } 1961 rtsx_set_stat(chip, RTSX_STAT_RUN); 1962 1963 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 1964 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7]; 1965 1966 if (len % 2) 1967 len -= len % 2; 1968 1969 if (len) { 1970 buf = vmalloc(len); 1971 if (!buf) { 1972 rtsx_trace(chip); 1973 return TRANSPORT_ERROR; 1974 } 1975 1976 retval = rtsx_force_power_on(chip, SSC_PDCTL); 1977 if (retval != STATUS_SUCCESS) { 1978 vfree(buf); 1979 set_sense_type(chip, SCSI_LUN(srb), 1980 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1981 rtsx_trace(chip); 1982 return TRANSPORT_FAILED; 1983 } 1984 1985 for (i = 0; i < len / 2; i++) { 1986 retval = rtsx_read_phy_register(chip, addr + i, &val); 1987 if (retval != STATUS_SUCCESS) { 1988 vfree(buf); 1989 set_sense_type(chip, SCSI_LUN(srb), 1990 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 1991 rtsx_trace(chip); 1992 return TRANSPORT_FAILED; 1993 } 1994 1995 buf[2*i] = (u8)(val >> 8); 1996 buf[2*i+1] = (u8)val; 1997 } 1998 1999 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), 2000 len); 2001 rtsx_stor_set_xfer_buf(buf, len, srb); 2002 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2003 2004 vfree(buf); 2005 } 2006 2007 return TRANSPORT_GOOD; 2008} 2009 2010static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2011{ 2012 unsigned short addr, len, i; 2013 int retval; 2014 u8 *buf; 2015 u16 val; 2016 2017 rtsx_disable_aspm(chip); 2018 2019 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2020 rtsx_exit_ss(chip); 2021 wait_timeout(100); 2022 } 2023 rtsx_set_stat(chip, RTSX_STAT_RUN); 2024 2025 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 2026 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7]; 2027 2028 if (len % 2) 2029 len -= len % 2; 2030 2031 if (len) { 2032 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), 2033 len); 2034 2035 buf = vmalloc(len); 2036 if (buf == NULL) { 2037 rtsx_trace(chip); 2038 return TRANSPORT_ERROR; 2039 } 2040 2041 rtsx_stor_get_xfer_buf(buf, len, srb); 2042 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2043 2044 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2045 if (retval != STATUS_SUCCESS) { 2046 vfree(buf); 2047 set_sense_type(chip, SCSI_LUN(srb), 2048 SENSE_TYPE_MEDIA_WRITE_ERR); 2049 rtsx_trace(chip); 2050 return TRANSPORT_FAILED; 2051 } 2052 2053 for (i = 0; i < len / 2; i++) { 2054 val = ((u16)buf[2*i] << 8) | buf[2*i+1]; 2055 retval = rtsx_write_phy_register(chip, addr + i, val); 2056 if (retval != STATUS_SUCCESS) { 2057 vfree(buf); 2058 set_sense_type(chip, SCSI_LUN(srb), 2059 SENSE_TYPE_MEDIA_WRITE_ERR); 2060 rtsx_trace(chip); 2061 return TRANSPORT_FAILED; 2062 } 2063 } 2064 2065 vfree(buf); 2066 } 2067 2068 return TRANSPORT_GOOD; 2069} 2070 2071static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2072{ 2073 unsigned short addr; 2074 int retval; 2075 u8 mode; 2076 2077 rtsx_disable_aspm(chip); 2078 2079 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2080 rtsx_exit_ss(chip); 2081 wait_timeout(100); 2082 } 2083 rtsx_set_stat(chip, RTSX_STAT_RUN); 2084 2085 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2086 if (retval != STATUS_SUCCESS) { 2087 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 2088 rtsx_trace(chip); 2089 return TRANSPORT_FAILED; 2090 } 2091 2092 mode = srb->cmnd[3]; 2093 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 2094 2095 if (mode == 0) { 2096 retval = spi_erase_eeprom_chip(chip); 2097 if (retval != STATUS_SUCCESS) { 2098 set_sense_type(chip, SCSI_LUN(srb), 2099 SENSE_TYPE_MEDIA_WRITE_ERR); 2100 rtsx_trace(chip); 2101 return TRANSPORT_FAILED; 2102 } 2103 } else if (mode == 1) { 2104 retval = spi_erase_eeprom_byte(chip, addr); 2105 if (retval != STATUS_SUCCESS) { 2106 set_sense_type(chip, SCSI_LUN(srb), 2107 SENSE_TYPE_MEDIA_WRITE_ERR); 2108 rtsx_trace(chip); 2109 return TRANSPORT_FAILED; 2110 } 2111 } else { 2112 set_sense_type(chip, SCSI_LUN(srb), 2113 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2114 rtsx_trace(chip); 2115 return TRANSPORT_FAILED; 2116 } 2117 2118 return TRANSPORT_GOOD; 2119} 2120 2121static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2122{ 2123 unsigned short addr, len, i; 2124 int retval; 2125 u8 *buf; 2126 2127 rtsx_disable_aspm(chip); 2128 2129 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2130 rtsx_exit_ss(chip); 2131 wait_timeout(100); 2132 } 2133 rtsx_set_stat(chip, RTSX_STAT_RUN); 2134 2135 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 2136 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7]; 2137 2138 buf = vmalloc(len); 2139 if (!buf) { 2140 rtsx_trace(chip); 2141 return TRANSPORT_ERROR; 2142 } 2143 2144 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2145 if (retval != STATUS_SUCCESS) { 2146 vfree(buf); 2147 set_sense_type(chip, SCSI_LUN(srb), 2148 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2149 rtsx_trace(chip); 2150 return TRANSPORT_FAILED; 2151 } 2152 2153 for (i = 0; i < len; i++) { 2154 retval = spi_read_eeprom(chip, addr + i, buf + i); 2155 if (retval != STATUS_SUCCESS) { 2156 vfree(buf); 2157 set_sense_type(chip, SCSI_LUN(srb), 2158 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2159 rtsx_trace(chip); 2160 return TRANSPORT_FAILED; 2161 } 2162 } 2163 2164 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len); 2165 rtsx_stor_set_xfer_buf(buf, len, srb); 2166 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2167 2168 vfree(buf); 2169 2170 return TRANSPORT_GOOD; 2171} 2172 2173static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2174{ 2175 unsigned short addr, len, i; 2176 int retval; 2177 u8 *buf; 2178 2179 rtsx_disable_aspm(chip); 2180 2181 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2182 rtsx_exit_ss(chip); 2183 wait_timeout(100); 2184 } 2185 rtsx_set_stat(chip, RTSX_STAT_RUN); 2186 2187 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5]; 2188 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7]; 2189 2190 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len); 2191 buf = vmalloc(len); 2192 if (buf == NULL) { 2193 rtsx_trace(chip); 2194 return TRANSPORT_ERROR; 2195 } 2196 2197 rtsx_stor_get_xfer_buf(buf, len, srb); 2198 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2199 2200 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2201 if (retval != STATUS_SUCCESS) { 2202 vfree(buf); 2203 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 2204 rtsx_trace(chip); 2205 return TRANSPORT_FAILED; 2206 } 2207 2208 for (i = 0; i < len; i++) { 2209 retval = spi_write_eeprom(chip, addr + i, buf[i]); 2210 if (retval != STATUS_SUCCESS) { 2211 vfree(buf); 2212 set_sense_type(chip, SCSI_LUN(srb), 2213 SENSE_TYPE_MEDIA_WRITE_ERR); 2214 rtsx_trace(chip); 2215 return TRANSPORT_FAILED; 2216 } 2217 } 2218 2219 vfree(buf); 2220 2221 return TRANSPORT_GOOD; 2222} 2223 2224static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2225{ 2226 int retval; 2227 u8 addr, len, i; 2228 u8 *buf; 2229 2230 rtsx_disable_aspm(chip); 2231 2232 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2233 rtsx_exit_ss(chip); 2234 wait_timeout(100); 2235 } 2236 rtsx_set_stat(chip, RTSX_STAT_RUN); 2237 2238 addr = srb->cmnd[4]; 2239 len = srb->cmnd[5]; 2240 2241 buf = vmalloc(len); 2242 if (!buf) { 2243 rtsx_trace(chip); 2244 return TRANSPORT_ERROR; 2245 } 2246 2247 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2248 if (retval != STATUS_SUCCESS) { 2249 vfree(buf); 2250 set_sense_type(chip, SCSI_LUN(srb), 2251 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2252 rtsx_trace(chip); 2253 return TRANSPORT_FAILED; 2254 } 2255 2256 for (i = 0; i < len; i++) { 2257 retval = rtsx_read_efuse(chip, addr + i, buf + i); 2258 if (retval != STATUS_SUCCESS) { 2259 vfree(buf); 2260 set_sense_type(chip, SCSI_LUN(srb), 2261 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2262 rtsx_trace(chip); 2263 return TRANSPORT_FAILED; 2264 } 2265 } 2266 2267 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len); 2268 rtsx_stor_set_xfer_buf(buf, len, srb); 2269 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2270 2271 vfree(buf); 2272 2273 return TRANSPORT_GOOD; 2274} 2275 2276static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2277{ 2278 int retval, result = TRANSPORT_GOOD; 2279 u16 val; 2280 u8 addr, len, i; 2281 u8 *buf; 2282 2283 rtsx_disable_aspm(chip); 2284 2285 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2286 rtsx_exit_ss(chip); 2287 wait_timeout(100); 2288 } 2289 rtsx_set_stat(chip, RTSX_STAT_RUN); 2290 2291 addr = srb->cmnd[4]; 2292 len = srb->cmnd[5]; 2293 2294 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len); 2295 buf = vmalloc(len); 2296 if (buf == NULL) { 2297 rtsx_trace(chip); 2298 return TRANSPORT_ERROR; 2299 } 2300 2301 rtsx_stor_get_xfer_buf(buf, len, srb); 2302 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2303 2304 retval = rtsx_force_power_on(chip, SSC_PDCTL); 2305 if (retval != STATUS_SUCCESS) { 2306 vfree(buf); 2307 rtsx_trace(chip); 2308 return TRANSPORT_ERROR; 2309 } 2310 2311 if (chip->asic_code) { 2312 retval = rtsx_read_phy_register(chip, 0x08, &val); 2313 if (retval != STATUS_SUCCESS) { 2314 vfree(buf); 2315 rtsx_trace(chip); 2316 return TRANSPORT_ERROR; 2317 } 2318 2319 retval = rtsx_write_register(chip, PWR_GATE_CTRL, 2320 LDO3318_PWR_MASK, LDO_OFF); 2321 if (retval != STATUS_SUCCESS) { 2322 vfree(buf); 2323 rtsx_trace(chip); 2324 return TRANSPORT_ERROR; 2325 } 2326 2327 wait_timeout(600); 2328 2329 retval = rtsx_write_phy_register(chip, 0x08, 2330 0x4C00 | chip->phy_voltage); 2331 if (retval != STATUS_SUCCESS) { 2332 vfree(buf); 2333 rtsx_trace(chip); 2334 return TRANSPORT_ERROR; 2335 } 2336 2337 retval = rtsx_write_register(chip, PWR_GATE_CTRL, 2338 LDO3318_PWR_MASK, LDO_ON); 2339 if (retval != STATUS_SUCCESS) { 2340 vfree(buf); 2341 rtsx_trace(chip); 2342 return TRANSPORT_ERROR; 2343 } 2344 2345 wait_timeout(600); 2346 } 2347 2348 retval = card_power_on(chip, SPI_CARD); 2349 if (retval != STATUS_SUCCESS) { 2350 vfree(buf); 2351 rtsx_trace(chip); 2352 return TRANSPORT_ERROR; 2353 } 2354 2355 wait_timeout(50); 2356 2357 for (i = 0; i < len; i++) { 2358 retval = rtsx_write_efuse(chip, addr + i, buf[i]); 2359 if (retval != STATUS_SUCCESS) { 2360 set_sense_type(chip, SCSI_LUN(srb), 2361 SENSE_TYPE_MEDIA_WRITE_ERR); 2362 result = TRANSPORT_FAILED; 2363 rtsx_trace(chip); 2364 goto Exit; 2365 } 2366 } 2367 2368Exit: 2369 vfree(buf); 2370 2371 retval = card_power_off(chip, SPI_CARD); 2372 if (retval != STATUS_SUCCESS) { 2373 rtsx_trace(chip); 2374 return TRANSPORT_ERROR; 2375 } 2376 2377 if (chip->asic_code) { 2378 retval = rtsx_write_register(chip, PWR_GATE_CTRL, 2379 LDO3318_PWR_MASK, LDO_OFF); 2380 if (retval != STATUS_SUCCESS) { 2381 rtsx_trace(chip); 2382 return TRANSPORT_ERROR; 2383 } 2384 2385 wait_timeout(600); 2386 2387 retval = rtsx_write_phy_register(chip, 0x08, val); 2388 if (retval != STATUS_SUCCESS) { 2389 rtsx_trace(chip); 2390 return TRANSPORT_ERROR; 2391 } 2392 2393 retval = rtsx_write_register(chip, PWR_GATE_CTRL, 2394 LDO3318_PWR_MASK, LDO_ON); 2395 if (retval != STATUS_SUCCESS) { 2396 rtsx_trace(chip); 2397 return TRANSPORT_ERROR; 2398 } 2399 } 2400 2401 return result; 2402} 2403 2404static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2405{ 2406 int retval; 2407 bool func_max; 2408 u8 func; 2409 u16 addr, len; 2410 u8 *buf; 2411 2412 rtsx_disable_aspm(chip); 2413 2414 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2415 rtsx_exit_ss(chip); 2416 wait_timeout(100); 2417 } 2418 rtsx_set_stat(chip, RTSX_STAT_RUN); 2419 2420 func = srb->cmnd[3]; 2421 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5]; 2422 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7]; 2423 2424 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x, len = %d\n", 2425 __func__, func, addr, len); 2426 2427 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) 2428 func_max = true; 2429 else 2430 func_max = false; 2431 2432 if (func > func_max) { 2433 set_sense_type(chip, SCSI_LUN(srb), 2434 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2435 rtsx_trace(chip); 2436 return TRANSPORT_FAILED; 2437 } 2438 2439 buf = vmalloc(len); 2440 if (!buf) { 2441 rtsx_trace(chip); 2442 return TRANSPORT_ERROR; 2443 } 2444 2445 retval = rtsx_read_cfg_seq(chip, func, addr, buf, len); 2446 if (retval != STATUS_SUCCESS) { 2447 set_sense_type(chip, SCSI_LUN(srb), 2448 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2449 vfree(buf); 2450 rtsx_trace(chip); 2451 return TRANSPORT_FAILED; 2452 } 2453 2454 len = (u16)min_t(unsigned int, scsi_bufflen(srb), len); 2455 rtsx_stor_set_xfer_buf(buf, len, srb); 2456 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2457 2458 vfree(buf); 2459 2460 return TRANSPORT_GOOD; 2461} 2462 2463static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2464{ 2465 int retval; 2466 bool func_max; 2467 u8 func; 2468 u16 addr, len; 2469 u8 *buf; 2470 2471 rtsx_disable_aspm(chip); 2472 2473 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2474 rtsx_exit_ss(chip); 2475 wait_timeout(100); 2476 } 2477 rtsx_set_stat(chip, RTSX_STAT_RUN); 2478 2479 func = srb->cmnd[3]; 2480 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5]; 2481 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7]; 2482 2483 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x\n", 2484 __func__, func, addr); 2485 2486 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) 2487 func_max = true; 2488 else 2489 func_max = false; 2490 2491 if (func > func_max) { 2492 set_sense_type(chip, SCSI_LUN(srb), 2493 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2494 rtsx_trace(chip); 2495 return TRANSPORT_FAILED; 2496 } 2497 2498 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len); 2499 buf = vmalloc(len); 2500 if (!buf) { 2501 rtsx_trace(chip); 2502 return TRANSPORT_ERROR; 2503 } 2504 2505 rtsx_stor_get_xfer_buf(buf, len, srb); 2506 scsi_set_resid(srb, scsi_bufflen(srb) - len); 2507 2508 retval = rtsx_write_cfg_seq(chip, func, addr, buf, len); 2509 if (retval != STATUS_SUCCESS) { 2510 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 2511 vfree(buf); 2512 rtsx_trace(chip); 2513 return TRANSPORT_FAILED; 2514 } 2515 2516 vfree(buf); 2517 2518 return TRANSPORT_GOOD; 2519} 2520 2521static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2522{ 2523 int result; 2524 2525 switch (srb->cmnd[2]) { 2526 case PP_READ10: 2527 case PP_WRITE10: 2528 result = read_write(srb, chip); 2529 break; 2530 2531 case READ_HOST_REG: 2532 result = read_host_reg(srb, chip); 2533 break; 2534 2535 case WRITE_HOST_REG: 2536 result = write_host_reg(srb, chip); 2537 break; 2538 2539 case GET_VAR: 2540 result = get_variable(srb, chip); 2541 break; 2542 2543 case SET_VAR: 2544 result = set_variable(srb, chip); 2545 break; 2546 2547 case DMA_READ: 2548 case DMA_WRITE: 2549 result = dma_access_ring_buffer(srb, chip); 2550 break; 2551 2552 case READ_PHY: 2553 result = read_phy_register(srb, chip); 2554 break; 2555 2556 case WRITE_PHY: 2557 result = write_phy_register(srb, chip); 2558 break; 2559 2560 case ERASE_EEPROM2: 2561 result = erase_eeprom2(srb, chip); 2562 break; 2563 2564 case READ_EEPROM2: 2565 result = read_eeprom2(srb, chip); 2566 break; 2567 2568 case WRITE_EEPROM2: 2569 result = write_eeprom2(srb, chip); 2570 break; 2571 2572 case READ_EFUSE: 2573 result = read_efuse(srb, chip); 2574 break; 2575 2576 case WRITE_EFUSE: 2577 result = write_efuse(srb, chip); 2578 break; 2579 2580 case READ_CFG: 2581 result = read_cfg_byte(srb, chip); 2582 break; 2583 2584 case WRITE_CFG: 2585 result = write_cfg_byte(srb, chip); 2586 break; 2587 2588 case SET_CHIP_MODE: 2589 result = set_chip_mode(srb, chip); 2590 break; 2591 2592 case SUIT_CMD: 2593 result = suit_cmd(srb, chip); 2594 break; 2595 2596 case GET_DEV_STATUS: 2597 result = get_dev_status(srb, chip); 2598 break; 2599 2600 default: 2601 set_sense_type(chip, SCSI_LUN(srb), 2602 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2603 rtsx_trace(chip); 2604 return TRANSPORT_FAILED; 2605 } 2606 2607 return result; 2608} 2609 2610 2611static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2612{ 2613 u8 rtsx_status[16]; 2614 int buf_len; 2615 unsigned int lun = SCSI_LUN(srb); 2616 2617 rtsx_status[0] = (u8)(chip->vendor_id >> 8); 2618 rtsx_status[1] = (u8)(chip->vendor_id); 2619 2620 rtsx_status[2] = (u8)(chip->product_id >> 8); 2621 rtsx_status[3] = (u8)(chip->product_id); 2622 2623 rtsx_status[4] = (u8)lun; 2624 2625 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) { 2626 if (chip->lun2card[lun] == SD_CARD) 2627 rtsx_status[5] = 2; 2628 else 2629 rtsx_status[5] = 3; 2630 } else { 2631 if (chip->card_exist) { 2632 if (chip->card_exist & XD_CARD) 2633 rtsx_status[5] = 4; 2634 else if (chip->card_exist & SD_CARD) 2635 rtsx_status[5] = 2; 2636 else if (chip->card_exist & MS_CARD) 2637 rtsx_status[5] = 3; 2638 else 2639 rtsx_status[5] = 7; 2640 } else { 2641 rtsx_status[5] = 7; 2642 } 2643 } 2644 2645 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) 2646 rtsx_status[6] = 2; 2647 else 2648 rtsx_status[6] = 1; 2649 2650 rtsx_status[7] = (u8)(chip->product_id); 2651 rtsx_status[8] = chip->ic_version; 2652 2653 if (check_card_exist(chip, lun)) 2654 rtsx_status[9] = 1; 2655 else 2656 rtsx_status[9] = 0; 2657 2658 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) 2659 rtsx_status[10] = 0; 2660 else 2661 rtsx_status[10] = 1; 2662 2663 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) { 2664 if (chip->lun2card[lun] == SD_CARD) 2665 rtsx_status[11] = SD_CARD; 2666 else 2667 rtsx_status[11] = MS_CARD; 2668 } else { 2669 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD; 2670 } 2671 2672 if (check_card_ready(chip, lun)) 2673 rtsx_status[12] = 1; 2674 else 2675 rtsx_status[12] = 0; 2676 2677 if (get_lun_card(chip, lun) == XD_CARD) { 2678 rtsx_status[13] = 0x40; 2679 } else if (get_lun_card(chip, lun) == SD_CARD) { 2680 struct sd_info *sd_card = &(chip->sd_card); 2681 2682 rtsx_status[13] = 0x20; 2683 if (CHK_SD(sd_card)) { 2684 if (CHK_SD_HCXC(sd_card)) 2685 rtsx_status[13] |= 0x04; 2686 if (CHK_SD_HS(sd_card)) 2687 rtsx_status[13] |= 0x02; 2688 } else { 2689 rtsx_status[13] |= 0x08; 2690 if (CHK_MMC_52M(sd_card)) 2691 rtsx_status[13] |= 0x02; 2692 if (CHK_MMC_SECTOR_MODE(sd_card)) 2693 rtsx_status[13] |= 0x04; 2694 } 2695 } else if (get_lun_card(chip, lun) == MS_CARD) { 2696 struct ms_info *ms_card = &(chip->ms_card); 2697 2698 if (CHK_MSPRO(ms_card)) { 2699 rtsx_status[13] = 0x38; 2700 if (CHK_HG8BIT(ms_card)) 2701 rtsx_status[13] |= 0x04; 2702#ifdef SUPPORT_MSXC 2703 if (CHK_MSXC(ms_card)) 2704 rtsx_status[13] |= 0x01; 2705#endif 2706 } else { 2707 rtsx_status[13] = 0x30; 2708 } 2709 } else { 2710 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) { 2711#ifdef SUPPORT_SDIO 2712 if (chip->sd_io && chip->sd_int) 2713 rtsx_status[13] = 0x60; 2714 else 2715 rtsx_status[13] = 0x70; 2716#else 2717 rtsx_status[13] = 0x70; 2718#endif 2719 } else { 2720 if (chip->lun2card[lun] == SD_CARD) 2721 rtsx_status[13] = 0x20; 2722 else 2723 rtsx_status[13] = 0x30; 2724 } 2725 } 2726 2727 rtsx_status[14] = 0x78; 2728 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) 2729 rtsx_status[15] = 0x83; 2730 else 2731 rtsx_status[15] = 0x82; 2732 2733 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(rtsx_status)); 2734 rtsx_stor_set_xfer_buf(rtsx_status, buf_len, srb); 2735 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len); 2736 2737 return TRANSPORT_GOOD; 2738} 2739 2740static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2741{ 2742 unsigned int lun = SCSI_LUN(srb); 2743 u8 card, bus_width; 2744 2745 if (!check_card_ready(chip, lun)) { 2746 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 2747 rtsx_trace(chip); 2748 return TRANSPORT_FAILED; 2749 } 2750 2751 card = get_lun_card(chip, lun); 2752 if ((card == SD_CARD) || (card == MS_CARD)) { 2753 bus_width = chip->card_bus_width[lun]; 2754 } else { 2755 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 2756 rtsx_trace(chip); 2757 return TRANSPORT_FAILED; 2758 } 2759 2760 scsi_set_resid(srb, 0); 2761 rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb); 2762 2763 return TRANSPORT_GOOD; 2764} 2765 2766static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2767{ 2768 int result; 2769 unsigned int lun = SCSI_LUN(srb); 2770 u8 gpio_dir; 2771 2772 if (CHECK_PID(chip, 0x5208) || CHECK_PID(chip, 0x5288)) { 2773 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2774 rtsx_trace(chip); 2775 return TRANSPORT_FAILED; 2776 } 2777 2778 rtsx_disable_aspm(chip); 2779 2780 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2781 rtsx_exit_ss(chip); 2782 wait_timeout(100); 2783 } 2784 rtsx_set_stat(chip, RTSX_STAT_RUN); 2785 2786 rtsx_force_power_on(chip, SSC_PDCTL); 2787 2788 rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir); 2789 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06); 2790 2791 switch (srb->cmnd[2]) { 2792 case SCSI_SPI_GETSTATUS: 2793 result = spi_get_status(srb, chip); 2794 break; 2795 2796 case SCSI_SPI_SETPARAMETER: 2797 result = spi_set_parameter(srb, chip); 2798 break; 2799 2800 case SCSI_SPI_READFALSHID: 2801 result = spi_read_flash_id(srb, chip); 2802 break; 2803 2804 case SCSI_SPI_READFLASH: 2805 result = spi_read_flash(srb, chip); 2806 break; 2807 2808 case SCSI_SPI_WRITEFLASH: 2809 result = spi_write_flash(srb, chip); 2810 break; 2811 2812 case SCSI_SPI_WRITEFLASHSTATUS: 2813 result = spi_write_flash_status(srb, chip); 2814 break; 2815 2816 case SCSI_SPI_ERASEFLASH: 2817 result = spi_erase_flash(srb, chip); 2818 break; 2819 2820 default: 2821 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir); 2822 2823 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2824 rtsx_trace(chip); 2825 return TRANSPORT_FAILED; 2826 } 2827 2828 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir); 2829 2830 if (result != STATUS_SUCCESS) { 2831 rtsx_trace(chip); 2832 return TRANSPORT_FAILED; 2833 } 2834 2835 return TRANSPORT_GOOD; 2836} 2837 2838static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2839{ 2840 int result; 2841 2842 switch (srb->cmnd[1]) { 2843 case READ_STATUS: 2844 result = read_status(srb, chip); 2845 break; 2846 2847 case READ_MEM: 2848 result = read_mem(srb, chip); 2849 break; 2850 2851 case WRITE_MEM: 2852 result = write_mem(srb, chip); 2853 break; 2854 2855 case READ_EEPROM: 2856 result = read_eeprom(srb, chip); 2857 break; 2858 2859 case WRITE_EEPROM: 2860 result = write_eeprom(srb, chip); 2861 break; 2862 2863 case TOGGLE_GPIO: 2864 result = toggle_gpio_cmd(srb, chip); 2865 break; 2866 2867 case GET_SD_CSD: 2868 result = get_sd_csd(srb, chip); 2869 break; 2870 2871 case GET_BUS_WIDTH: 2872 result = get_card_bus_width(srb, chip); 2873 break; 2874 2875#ifdef _MSG_TRACE 2876 case TRACE_MSG: 2877 result = trace_msg_cmd(srb, chip); 2878 break; 2879#endif 2880 2881 case SCSI_APP_CMD: 2882 result = app_cmd(srb, chip); 2883 break; 2884 2885 case SPI_VENDOR_COMMAND: 2886 result = spi_vendor_cmd(srb, chip); 2887 break; 2888 2889 default: 2890 set_sense_type(chip, SCSI_LUN(srb), 2891 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2892 rtsx_trace(chip); 2893 return TRANSPORT_FAILED; 2894 } 2895 2896 return result; 2897} 2898 2899#if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK) 2900void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2901{ 2902 unsigned int lun = SCSI_LUN(srb); 2903 u16 sec_cnt; 2904 2905 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) 2906 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8]; 2907 else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) 2908 sec_cnt = srb->cmnd[4]; 2909 else 2910 return; 2911 2912 if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) { 2913 toggle_gpio(chip, LED_GPIO); 2914 chip->rw_cap[lun] = 0; 2915 } else { 2916 chip->rw_cap[lun] += sec_cnt; 2917 } 2918} 2919#endif 2920 2921static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2922{ 2923 struct ms_info *ms_card = &(chip->ms_card); 2924 unsigned int lun = SCSI_LUN(srb); 2925 bool quick_format; 2926 int retval; 2927 2928 if (get_lun_card(chip, lun) != MS_CARD) { 2929 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 2930 rtsx_trace(chip); 2931 return TRANSPORT_FAILED; 2932 } 2933 2934 if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47) || 2935 (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D) || 2936 (srb->cmnd[7] != 0x74)) { 2937 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 2938 rtsx_trace(chip); 2939 return TRANSPORT_FAILED; 2940 } 2941 2942 rtsx_disable_aspm(chip); 2943 2944 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 2945 rtsx_exit_ss(chip); 2946 wait_timeout(100); 2947 2948 if (!check_card_ready(chip, lun) || 2949 (get_card_size(chip, lun) == 0)) { 2950 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 2951 rtsx_trace(chip); 2952 return TRANSPORT_FAILED; 2953 } 2954 } 2955 rtsx_set_stat(chip, RTSX_STAT_RUN); 2956 2957 if (srb->cmnd[8] & 0x01) 2958 quick_format = false; 2959 else 2960 quick_format = true; 2961 2962 if (!(chip->card_ready & MS_CARD)) { 2963 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 2964 rtsx_trace(chip); 2965 return TRANSPORT_FAILED; 2966 } 2967 2968 if (chip->card_wp & MS_CARD) { 2969 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT); 2970 rtsx_trace(chip); 2971 return TRANSPORT_FAILED; 2972 } 2973 2974 if (!CHK_MSPRO(ms_card)) { 2975 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 2976 rtsx_trace(chip); 2977 return TRANSPORT_FAILED; 2978 } 2979 2980 retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format); 2981 if (retval != STATUS_SUCCESS) { 2982 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED); 2983 rtsx_trace(chip); 2984 return TRANSPORT_FAILED; 2985 } 2986 2987 scsi_set_resid(srb, 0); 2988 return TRANSPORT_GOOD; 2989} 2990 2991#ifdef SUPPORT_PCGL_1P18 2992static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip) 2993{ 2994 struct ms_info *ms_card = &(chip->ms_card); 2995 unsigned int lun = SCSI_LUN(srb); 2996 u8 dev_info_id, data_len; 2997 u8 *buf; 2998 unsigned int buf_len; 2999 int i; 3000 3001 if (!check_card_ready(chip, lun)) { 3002 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 3003 rtsx_trace(chip); 3004 return TRANSPORT_FAILED; 3005 } 3006 if (get_lun_card(chip, lun) != MS_CARD) { 3007 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 3008 rtsx_trace(chip); 3009 return TRANSPORT_FAILED; 3010 } 3011 3012 if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) || 3013 (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) || 3014 (srb->cmnd[7] != 0x44)) { 3015 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3016 rtsx_trace(chip); 3017 return TRANSPORT_FAILED; 3018 } 3019 3020 dev_info_id = srb->cmnd[3]; 3021 if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) || 3022 (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) || 3023 !CHK_MSPRO(ms_card)) { 3024 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3025 rtsx_trace(chip); 3026 return TRANSPORT_FAILED; 3027 } 3028 3029 if (dev_info_id == 0x15) 3030 buf_len = data_len = 0x3A; 3031 else 3032 buf_len = data_len = 0x6A; 3033 3034 buf = kmalloc(buf_len, GFP_KERNEL); 3035 if (!buf) { 3036 rtsx_trace(chip); 3037 return TRANSPORT_ERROR; 3038 } 3039 3040 i = 0; 3041 /* GET Memory Stick Media Information Response Header */ 3042 buf[i++] = 0x00; /* Data length MSB */ 3043 buf[i++] = data_len; /* Data length LSB */ 3044 /* Device Information Type Code */ 3045 if (CHK_MSXC(ms_card)) 3046 buf[i++] = 0x03; 3047 else 3048 buf[i++] = 0x02; 3049 3050 /* SGM bit */ 3051 buf[i++] = 0x01; 3052 /* Reserved */ 3053 buf[i++] = 0x00; 3054 buf[i++] = 0x00; 3055 buf[i++] = 0x00; 3056 /* Number of Device Information */ 3057 buf[i++] = 0x01; 3058 3059 /* Device Information Body */ 3060 3061 /* Device Information ID Number */ 3062 buf[i++] = dev_info_id; 3063 /* Device Information Length */ 3064 if (dev_info_id == 0x15) 3065 data_len = 0x31; 3066 else 3067 data_len = 0x61; 3068 3069 buf[i++] = 0x00; /* Data length MSB */ 3070 buf[i++] = data_len; /* Data length LSB */ 3071 /* Valid Bit */ 3072 buf[i++] = 0x80; 3073 if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) { 3074 /* System Information */ 3075 memcpy(buf+i, ms_card->raw_sys_info, 96); 3076 } else { 3077 /* Model Name */ 3078 memcpy(buf+i, ms_card->raw_model_name, 48); 3079 } 3080 3081 rtsx_stor_set_xfer_buf(buf, buf_len, srb); 3082 3083 if (dev_info_id == 0x15) 3084 scsi_set_resid(srb, scsi_bufflen(srb)-0x3C); 3085 else 3086 scsi_set_resid(srb, scsi_bufflen(srb)-0x6C); 3087 3088 kfree(buf); 3089 return STATUS_SUCCESS; 3090} 3091#endif 3092 3093static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3094{ 3095 int retval = TRANSPORT_ERROR; 3096 3097 if (srb->cmnd[2] == MS_FORMAT) 3098 retval = ms_format_cmnd(srb, chip); 3099#ifdef SUPPORT_PCGL_1P18 3100 else if (srb->cmnd[2] == GET_MS_INFORMATION) 3101 retval = get_ms_information(srb, chip); 3102#endif 3103 3104 return retval; 3105} 3106 3107#ifdef SUPPORT_CPRM 3108static int sd_extention_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3109{ 3110 unsigned int lun = SCSI_LUN(srb); 3111 int result; 3112 3113 rtsx_disable_aspm(chip); 3114 3115 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 3116 rtsx_exit_ss(chip); 3117 wait_timeout(100); 3118 } 3119 rtsx_set_stat(chip, RTSX_STAT_RUN); 3120 3121 sd_cleanup_work(chip); 3122 3123 if (!check_card_ready(chip, lun)) { 3124 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 3125 rtsx_trace(chip); 3126 return TRANSPORT_FAILED; 3127 } 3128 if (get_lun_card(chip, lun) != SD_CARD) { 3129 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 3130 rtsx_trace(chip); 3131 return TRANSPORT_FAILED; 3132 } 3133 3134 switch (srb->cmnd[0]) { 3135 case SD_PASS_THRU_MODE: 3136 result = sd_pass_thru_mode(srb, chip); 3137 break; 3138 3139 case SD_EXECUTE_NO_DATA: 3140 result = sd_execute_no_data(srb, chip); 3141 break; 3142 3143 case SD_EXECUTE_READ: 3144 result = sd_execute_read_data(srb, chip); 3145 break; 3146 3147 case SD_EXECUTE_WRITE: 3148 result = sd_execute_write_data(srb, chip); 3149 break; 3150 3151 case SD_GET_RSP: 3152 result = sd_get_cmd_rsp(srb, chip); 3153 break; 3154 3155 case SD_HW_RST: 3156 result = sd_hw_rst(srb, chip); 3157 break; 3158 3159 default: 3160 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3161 rtsx_trace(chip); 3162 return TRANSPORT_FAILED; 3163 } 3164 3165 return result; 3166} 3167#endif 3168 3169#ifdef SUPPORT_MAGIC_GATE 3170static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3171{ 3172 struct ms_info *ms_card = &(chip->ms_card); 3173 unsigned int lun = SCSI_LUN(srb); 3174 int retval; 3175 u8 key_format; 3176 3177 rtsx_disable_aspm(chip); 3178 3179 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 3180 rtsx_exit_ss(chip); 3181 wait_timeout(100); 3182 } 3183 rtsx_set_stat(chip, RTSX_STAT_RUN); 3184 3185 ms_cleanup_work(chip); 3186 3187 if (!check_card_ready(chip, lun)) { 3188 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 3189 rtsx_trace(chip); 3190 return TRANSPORT_FAILED; 3191 } 3192 if (get_lun_card(chip, lun) != MS_CARD) { 3193 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 3194 rtsx_trace(chip); 3195 return TRANSPORT_FAILED; 3196 } 3197 3198 if (srb->cmnd[7] != KC_MG_R_PRO) { 3199 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3200 rtsx_trace(chip); 3201 return TRANSPORT_FAILED; 3202 } 3203 3204 if (!CHK_MSPRO(ms_card)) { 3205 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM); 3206 rtsx_trace(chip); 3207 return TRANSPORT_FAILED; 3208 } 3209 3210 key_format = srb->cmnd[10] & 0x3F; 3211 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format); 3212 3213 switch (key_format) { 3214 case KF_GET_LOC_EKB: 3215 if ((scsi_bufflen(srb) == 0x41C) && 3216 (srb->cmnd[8] == 0x04) && 3217 (srb->cmnd[9] == 0x1C)) { 3218 retval = mg_get_local_EKB(srb, chip); 3219 if (retval != STATUS_SUCCESS) { 3220 rtsx_trace(chip); 3221 return TRANSPORT_FAILED; 3222 } 3223 3224 } else { 3225 set_sense_type(chip, lun, 3226 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3227 rtsx_trace(chip); 3228 return TRANSPORT_FAILED; 3229 } 3230 break; 3231 3232 case KF_RSP_CHG: 3233 if ((scsi_bufflen(srb) == 0x24) && 3234 (srb->cmnd[8] == 0x00) && 3235 (srb->cmnd[9] == 0x24)) { 3236 retval = mg_get_rsp_chg(srb, chip); 3237 if (retval != STATUS_SUCCESS) { 3238 rtsx_trace(chip); 3239 return TRANSPORT_FAILED; 3240 } 3241 3242 } else { 3243 set_sense_type(chip, lun, 3244 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3245 rtsx_trace(chip); 3246 return TRANSPORT_FAILED; 3247 } 3248 break; 3249 3250 case KF_GET_ICV: 3251 ms_card->mg_entry_num = srb->cmnd[5]; 3252 if ((scsi_bufflen(srb) == 0x404) && 3253 (srb->cmnd[8] == 0x04) && 3254 (srb->cmnd[9] == 0x04) && 3255 (srb->cmnd[2] == 0x00) && 3256 (srb->cmnd[3] == 0x00) && 3257 (srb->cmnd[4] == 0x00) && 3258 (srb->cmnd[5] < 32)) { 3259 retval = mg_get_ICV(srb, chip); 3260 if (retval != STATUS_SUCCESS) { 3261 rtsx_trace(chip); 3262 return TRANSPORT_FAILED; 3263 } 3264 3265 } else { 3266 set_sense_type(chip, lun, 3267 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3268 rtsx_trace(chip); 3269 return TRANSPORT_FAILED; 3270 } 3271 break; 3272 3273 default: 3274 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3275 rtsx_trace(chip); 3276 return TRANSPORT_FAILED; 3277 } 3278 3279 scsi_set_resid(srb, 0); 3280 return TRANSPORT_GOOD; 3281} 3282 3283static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3284{ 3285 struct ms_info *ms_card = &(chip->ms_card); 3286 unsigned int lun = SCSI_LUN(srb); 3287 int retval; 3288 u8 key_format; 3289 3290 rtsx_disable_aspm(chip); 3291 3292 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) { 3293 rtsx_exit_ss(chip); 3294 wait_timeout(100); 3295 } 3296 rtsx_set_stat(chip, RTSX_STAT_RUN); 3297 3298 ms_cleanup_work(chip); 3299 3300 if (!check_card_ready(chip, lun)) { 3301 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 3302 rtsx_trace(chip); 3303 return TRANSPORT_FAILED; 3304 } 3305 if (check_card_wp(chip, lun)) { 3306 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT); 3307 rtsx_trace(chip); 3308 return TRANSPORT_FAILED; 3309 } 3310 if (get_lun_card(chip, lun) != MS_CARD) { 3311 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT); 3312 rtsx_trace(chip); 3313 return TRANSPORT_FAILED; 3314 } 3315 3316 if (srb->cmnd[7] != KC_MG_R_PRO) { 3317 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3318 rtsx_trace(chip); 3319 return TRANSPORT_FAILED; 3320 } 3321 3322 if (!CHK_MSPRO(ms_card)) { 3323 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM); 3324 rtsx_trace(chip); 3325 return TRANSPORT_FAILED; 3326 } 3327 3328 key_format = srb->cmnd[10] & 0x3F; 3329 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format); 3330 3331 switch (key_format) { 3332 case KF_SET_LEAF_ID: 3333 if ((scsi_bufflen(srb) == 0x0C) && 3334 (srb->cmnd[8] == 0x00) && 3335 (srb->cmnd[9] == 0x0C)) { 3336 retval = mg_set_leaf_id(srb, chip); 3337 if (retval != STATUS_SUCCESS) { 3338 rtsx_trace(chip); 3339 return TRANSPORT_FAILED; 3340 } 3341 3342 } else { 3343 set_sense_type(chip, lun, 3344 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3345 rtsx_trace(chip); 3346 return TRANSPORT_FAILED; 3347 } 3348 break; 3349 3350 case KF_CHG_HOST: 3351 if ((scsi_bufflen(srb) == 0x0C) && 3352 (srb->cmnd[8] == 0x00) && 3353 (srb->cmnd[9] == 0x0C)) { 3354 retval = mg_chg(srb, chip); 3355 if (retval != STATUS_SUCCESS) { 3356 rtsx_trace(chip); 3357 return TRANSPORT_FAILED; 3358 } 3359 3360 } else { 3361 set_sense_type(chip, lun, 3362 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3363 rtsx_trace(chip); 3364 return TRANSPORT_FAILED; 3365 } 3366 break; 3367 3368 case KF_RSP_HOST: 3369 if ((scsi_bufflen(srb) == 0x0C) && 3370 (srb->cmnd[8] == 0x00) && 3371 (srb->cmnd[9] == 0x0C)) { 3372 retval = mg_rsp(srb, chip); 3373 if (retval != STATUS_SUCCESS) { 3374 rtsx_trace(chip); 3375 return TRANSPORT_FAILED; 3376 } 3377 3378 } else { 3379 set_sense_type(chip, lun, 3380 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3381 rtsx_trace(chip); 3382 return TRANSPORT_FAILED; 3383 } 3384 break; 3385 3386 case KF_SET_ICV: 3387 ms_card->mg_entry_num = srb->cmnd[5]; 3388 if ((scsi_bufflen(srb) == 0x404) && 3389 (srb->cmnd[8] == 0x04) && 3390 (srb->cmnd[9] == 0x04) && 3391 (srb->cmnd[2] == 0x00) && 3392 (srb->cmnd[3] == 0x00) && 3393 (srb->cmnd[4] == 0x00) && 3394 (srb->cmnd[5] < 32)) { 3395 retval = mg_set_ICV(srb, chip); 3396 if (retval != STATUS_SUCCESS) { 3397 rtsx_trace(chip); 3398 return TRANSPORT_FAILED; 3399 } 3400 3401 } else { 3402 set_sense_type(chip, lun, 3403 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3404 rtsx_trace(chip); 3405 return TRANSPORT_FAILED; 3406 } 3407 break; 3408 3409 default: 3410 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3411 rtsx_trace(chip); 3412 return TRANSPORT_FAILED; 3413 } 3414 3415 scsi_set_resid(srb, 0); 3416 return TRANSPORT_GOOD; 3417} 3418#endif 3419 3420int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3421{ 3422#ifdef SUPPORT_SD_LOCK 3423 struct sd_info *sd_card = &(chip->sd_card); 3424#endif 3425 struct ms_info *ms_card = &(chip->ms_card); 3426 unsigned int lun = SCSI_LUN(srb); 3427 int result; 3428 3429#ifdef SUPPORT_SD_LOCK 3430 if (sd_card->sd_erase_status) { 3431 /* Block all SCSI command except for 3432 * REQUEST_SENSE and rs_ppstatus 3433 */ 3434 if (!((srb->cmnd[0] == VENDOR_CMND) && 3435 (srb->cmnd[1] == SCSI_APP_CMD) && 3436 (srb->cmnd[2] == GET_DEV_STATUS)) && 3437 (srb->cmnd[0] != REQUEST_SENSE)) { 3438 /* Logical Unit Not Ready Format in Progress */ 3439 set_sense_data(chip, lun, CUR_ERR, 3440 0x02, 0, 0x04, 0x04, 0, 0); 3441 rtsx_trace(chip); 3442 return TRANSPORT_FAILED; 3443 } 3444 } 3445#endif 3446 3447 if ((get_lun_card(chip, lun) == MS_CARD) && 3448 (ms_card->format_status == FORMAT_IN_PROGRESS)) { 3449 if ((srb->cmnd[0] != REQUEST_SENSE) && 3450 (srb->cmnd[0] != INQUIRY)) { 3451 /* Logical Unit Not Ready Format in Progress */ 3452 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 3453 0, (u16)(ms_card->progress)); 3454 rtsx_trace(chip); 3455 return TRANSPORT_FAILED; 3456 } 3457 } 3458 3459 switch (srb->cmnd[0]) { 3460 case READ_10: 3461 case WRITE_10: 3462 case READ_6: 3463 case WRITE_6: 3464 result = read_write(srb, chip); 3465#if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK) 3466 led_shine(srb, chip); 3467#endif 3468 break; 3469 3470 case TEST_UNIT_READY: 3471 result = test_unit_ready(srb, chip); 3472 break; 3473 3474 case INQUIRY: 3475 result = inquiry(srb, chip); 3476 break; 3477 3478 case READ_CAPACITY: 3479 result = read_capacity(srb, chip); 3480 break; 3481 3482 case START_STOP: 3483 result = start_stop_unit(srb, chip); 3484 break; 3485 3486 case ALLOW_MEDIUM_REMOVAL: 3487 result = allow_medium_removal(srb, chip); 3488 break; 3489 3490 case REQUEST_SENSE: 3491 result = request_sense(srb, chip); 3492 break; 3493 3494 case MODE_SENSE: 3495 case MODE_SENSE_10: 3496 result = mode_sense(srb, chip); 3497 break; 3498 3499 case 0x23: 3500 result = read_format_capacity(srb, chip); 3501 break; 3502 3503 case VENDOR_CMND: 3504 result = vendor_cmnd(srb, chip); 3505 break; 3506 3507 case MS_SP_CMND: 3508 result = ms_sp_cmnd(srb, chip); 3509 break; 3510 3511#ifdef SUPPORT_CPRM 3512 case SD_PASS_THRU_MODE: 3513 case SD_EXECUTE_NO_DATA: 3514 case SD_EXECUTE_READ: 3515 case SD_EXECUTE_WRITE: 3516 case SD_GET_RSP: 3517 case SD_HW_RST: 3518 result = sd_extention_cmnd(srb, chip); 3519 break; 3520#endif 3521 3522#ifdef SUPPORT_MAGIC_GATE 3523 case CMD_MSPRO_MG_RKEY: 3524 result = mg_report_key(srb, chip); 3525 break; 3526 3527 case CMD_MSPRO_MG_SKEY: 3528 result = mg_send_key(srb, chip); 3529 break; 3530#endif 3531 3532 case FORMAT_UNIT: 3533 case MODE_SELECT: 3534 case VERIFY: 3535 result = TRANSPORT_GOOD; 3536 break; 3537 3538 default: 3539 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3540 result = TRANSPORT_FAILED; 3541 } 3542 3543 return result; 3544} 3545