1 /* Driver for Realtek PCI-Express card reader
3 * Copyright(c) 2009-2013 Realtek Semiconductor Corp. All rights reserved.
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
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.
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/>.
19 * Wei WANG (wei_wang@realsil.com.cn)
20 * Micky Ching (micky_ching@realsil.com.cn)
23 #include <linux/blkdev.h>
24 #include <linux/kthread.h>
25 #include <linux/sched.h>
26 #include <linux/vmalloc.h>
33 void scsi_show_command(struct rtsx_chip *chip)
35 struct scsi_cmnd *srb = chip->srb;
37 bool unknown_cmd = false;
40 switch (srb->cmnd[0]) {
42 what = "TEST_UNIT_READY";
48 what = "REQUEST_SENSE";
53 case READ_BLOCK_LIMITS:
54 what = "READ_BLOCK_LIMITS";
57 what = "REASSIGN_BLOCKS";
69 what = "READ_REVERSE";
72 what = "WRITE_FILEMARKS";
80 case RECOVER_BUFFERED_DATA:
81 what = "RECOVER_BUFFERED_DATA";
104 case RECEIVE_DIAGNOSTIC:
105 what = "RECEIVE_DIAGNOSTIC";
107 case SEND_DIAGNOSTIC:
108 what = "SEND_DIAGNOSTIC";
110 case ALLOW_MEDIUM_REMOVAL:
111 what = "ALLOW_MEDIUM_REMOVAL";
117 what = "READ_CAPACITY";
129 what = "WRITE_VERIFY";
135 what = "SEARCH_HIGH";
138 what = "SEARCH_EQUAL";
147 what = "READ_POSITION";
149 case SYNCHRONIZE_CACHE:
150 what = "SYNCHRONIZE_CACHE";
152 case LOCK_UNLOCK_CACHE:
153 what = "LOCK_UNLOCK_CACHE";
155 case READ_DEFECT_DATA:
156 what = "READ_DEFECT_DATA";
159 what = "MEDIUM_SCAN";
165 what = "COPY_VERIFY";
168 what = "WRITE_BUFFER";
171 what = "READ_BUFFER";
174 what = "UPDATE_BLOCK";
182 case CHANGE_DEFINITION:
183 what = "CHANGE_DEFINITION";
188 case GPCMD_READ_SUBCHANNEL:
189 what = "READ SUBCHANNEL";
194 case GPCMD_READ_HEADER:
195 what = "READ HEADER";
197 case GPCMD_PLAY_AUDIO_10:
198 what = "PLAY AUDIO (10)";
200 case GPCMD_PLAY_AUDIO_MSF:
201 what = "PLAY AUDIO MSF";
203 case GPCMD_GET_EVENT_STATUS_NOTIFICATION:
204 what = "GET EVENT/STATUS NOTIFICATION";
206 case GPCMD_PAUSE_RESUME:
207 what = "PAUSE/RESUME";
215 case GPCMD_STOP_PLAY_SCAN:
216 what = "STOP PLAY/SCAN";
218 case GPCMD_READ_DISC_INFO:
219 what = "READ DISC INFORMATION";
221 case GPCMD_READ_TRACK_RZONE_INFO:
222 what = "READ TRACK INFORMATION";
224 case GPCMD_RESERVE_RZONE_TRACK:
225 what = "RESERVE TRACK";
231 what = "MODE_SELECT_10";
233 case GPCMD_REPAIR_RZONE_TRACK:
234 what = "REPAIR TRACK";
237 what = "READ MASTER CUE";
240 what = "MODE_SENSE_10";
242 case GPCMD_CLOSE_TRACK:
243 what = "CLOSE TRACK/SESSION";
246 what = "READ BUFFER CAPACITY";
249 what = "SEND CUE SHEET";
255 what = "REPORT LUNS";
258 what = "MOVE_MEDIUM or PLAY AUDIO (12)";
266 case WRITE_VERIFY_12:
267 what = "WRITE_VERIFY_12";
270 what = "SEARCH_HIGH_12";
272 case SEARCH_EQUAL_12:
273 what = "SEARCH_EQUAL_12";
276 what = "SEARCH_LOW_12";
278 case SEND_VOLUME_TAG:
279 what = "SEND_VOLUME_TAG";
281 case READ_ELEMENT_STATUS:
282 what = "READ_ELEMENT_STATUS";
284 case GPCMD_READ_CD_MSF:
285 what = "READ CD MSF";
290 case GPCMD_SET_SPEED:
291 what = "SET CD SPEED";
293 case GPCMD_MECHANISM_STATUS:
294 what = "MECHANISM STATUS";
300 what = "WRITE CONTINUE";
303 what = "WRITE_LONG_2";
306 what = "Realtek's vendor command";
309 what = "(unknown command)";
314 if (srb->cmnd[0] != TEST_UNIT_READY)
315 dev_dbg(rtsx_dev(chip), "Command %s (%d bytes)\n",
319 len = min_t(unsigned short, srb->cmd_len, 16);
320 dev_dbg(rtsx_dev(chip), "%*ph\n", len, srb->cmnd);
324 void set_sense_type(struct rtsx_chip *chip, unsigned int lun, int sense_type)
326 switch (sense_type) {
327 case SENSE_TYPE_MEDIA_CHANGE:
328 set_sense_data(chip, lun, CUR_ERR, 0x06, 0, 0x28, 0, 0, 0);
331 case SENSE_TYPE_MEDIA_NOT_PRESENT:
332 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x3A, 0, 0, 0);
335 case SENSE_TYPE_MEDIA_LBA_OVER_RANGE:
336 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x21, 0, 0, 0);
339 case SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT:
340 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x25, 0, 0, 0);
343 case SENSE_TYPE_MEDIA_WRITE_PROTECT:
344 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x27, 0, 0, 0);
347 case SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR:
348 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x11, 0, 0, 0);
351 case SENSE_TYPE_MEDIA_WRITE_ERR:
352 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x02, 0, 0);
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);
360 case SENSE_TYPE_FORMAT_IN_PROGRESS:
361 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 0, 0);
364 case SENSE_TYPE_FORMAT_CMD_FAILED:
365 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x31, 0x01, 0, 0);
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);
373 case SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN:
374 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x00, 0, 0);
377 case SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM:
378 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x30, 0x00, 0, 0);
381 case SENSE_TYPE_MG_WRITE_ERR:
382 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x00, 0, 0);
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);
392 case SENSE_TYPE_NO_SENSE:
394 set_sense_data(chip, lun, CUR_ERR, 0, 0, 0, 0, 0, 0);
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,
403 struct sense_data_t *sense = &chip->sense_buffer[lun];
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;
412 sense->ad_sense_len = sizeof(struct sense_data_t) - 8;
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;
422 static int test_unit_ready(struct scsi_cmnd *srb, struct rtsx_chip *chip)
424 unsigned int lun = SCSI_LUN(srb);
426 if (!check_card_ready(chip, lun)) {
427 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
428 return TRANSPORT_FAILED;
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;
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;
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;
453 return TRANSPORT_GOOD;
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] */
461 0x20, 0x20, 0x20, /* Byte[47:49] */
464 #ifdef SUPPORT_MAGIC_GATE
465 0x0B, /* Byte[50]: MG, MS, MSPro, MSXC */
467 0x09, /* Byte[50]: MS, MSPro, MSXC */
469 0x00, /* Byte[51]: Category Specific Commands */
470 0x00, /* Byte[52]: Access Control and feature */
471 0x20, 0x20, 0x20, /* Byte[53:55] */
474 static int inquiry(struct scsi_cmnd *srb, struct rtsx_chip *chip)
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;
484 u8 card = get_lun_card(chip, lun);
485 bool pro_formatter_flag = false;
486 unsigned char inquiry_buf[] = {
487 QULIFIRE | DRCT_ACCESS_DEV,
494 REL_ADR | WBUS_32 | WBUS_16 | SYNC | LINKED | CMD_QUE | SFT_RE,
497 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
498 if (chip->lun2card[lun] == SD_CARD)
499 inquiry_string = inquiry_sd;
501 inquiry_string = inquiry_ms;
503 } else if (CHECK_LUN_MODE(chip, SD_MS_1LUN)) {
504 inquiry_string = inquiry_sdms;
506 inquiry_string = inquiry_default;
509 buf = vmalloc(scsi_bufflen(srb));
511 return TRANSPORT_ERROR;
514 #ifdef SUPPORT_MAGIC_GATE
515 if ((chip->mspro_formatter_enable) &&
516 (chip->lun2card[lun] & MS_CARD))
518 if (chip->mspro_formatter_enable)
520 if (!card || (card == MS_CARD))
521 pro_formatter_flag = true;
523 if (pro_formatter_flag) {
524 if (scsi_bufflen(srb) < 56)
525 sendbytes = (unsigned char)(scsi_bufflen(srb));
530 if (scsi_bufflen(srb) < 36)
531 sendbytes = (unsigned char)(scsi_bufflen(srb));
537 memcpy(buf, inquiry_buf, 8);
538 strncpy(buf + 8, inquiry_string, sendbytes - 8);
539 if (pro_formatter_flag) {
540 /* Additional Length */
544 memcpy(buf, inquiry_buf, sendbytes);
547 if (pro_formatter_flag) {
549 memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36);
552 scsi_set_resid(srb, 0);
554 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
557 return TRANSPORT_GOOD;
560 static int start_stop_unit(struct scsi_cmnd *srb, struct rtsx_chip *chip)
562 unsigned int lun = SCSI_LUN(srb);
564 scsi_set_resid(srb, scsi_bufflen(srb));
566 if (srb->cmnd[1] == 1)
567 return TRANSPORT_GOOD;
569 switch (srb->cmnd[0x4]) {
572 return TRANSPORT_GOOD;
575 /* Media shall be unload */
576 if (check_card_ready(chip, lun))
577 eject_card(chip, lun);
578 return TRANSPORT_GOOD;
580 case MAKE_MEDIUM_READY:
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;
590 return TRANSPORT_ERROR;
593 static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip)
597 prevent = srb->cmnd[4] & 0x1;
599 scsi_set_resid(srb, 0);
602 set_sense_type(chip, SCSI_LUN(srb),
603 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
604 return TRANSPORT_FAILED;
607 return TRANSPORT_GOOD;
610 static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
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;
617 sense = &chip->sense_buffer[lun];
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));
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;
636 rtsx_set_stat(chip, RTSX_STAT_RUN);
639 buf = vmalloc(scsi_bufflen(srb));
641 return TRANSPORT_ERROR;
644 tmp = (unsigned char *)sense;
645 memcpy(buf, tmp, scsi_bufflen(srb));
647 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
650 scsi_set_resid(srb, 0);
651 /* Reset Sense Data */
652 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
653 return TRANSPORT_GOOD;
656 static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd,
657 int lun, u8 *buf, int buf_len)
659 struct ms_info *ms_card = &chip->ms_card;
661 int data_size = buf_len;
662 bool support_format = false;
665 if (cmd == MODE_SENSE) {
667 if (data_size > 0x68)
670 buf[i++] = 0x67; /* Mode Data Length */
672 sys_info_offset = 12;
673 if (data_size > 0x6C)
676 buf[i++] = 0x00; /* Mode Data Length (MSB) */
677 buf[i++] = 0x6A; /* Mode Data Length (LSB) */
680 /* Medium Type Code */
681 if (check_card_ready(chip, lun)) {
682 if (CHK_MSXC(ms_card)) {
683 support_format = true;
685 } else if (CHK_MSPRO(ms_card)) {
686 support_format = true;
693 if (check_card_wp(chip, lun))
699 buf[i++] = 0x00; /* MediaType */
700 buf[i++] = 0x00; /* WP */
703 buf[i++] = 0x00; /* Reserved */
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) */
710 /* The Following Data is the content of "Page 0x20" */
712 buf[i++] = 0x20; /* Page Code */
714 buf[i++] = 0x62; /* Page Length */
716 buf[i++] = 0x00; /* No Access Control */
717 if (data_size >= 12) {
719 buf[i++] = 0xC0; /* SF, SGM */
724 /* The Following Data is the content of "Page 0x20" */
726 buf[i++] = 0x20; /* Page Code */
728 buf[i++] = 0x62; /* Page Length */
730 buf[i++] = 0x00; /* No Access Control */
731 if (data_size >= 8) {
733 buf[i++] = 0xC0; /* SF, SGM */
739 if (data_size > sys_info_offset) {
740 /* 96 Bytes Attribute Data */
741 int len = data_size - sys_info_offset;
743 len = (len < 96) ? len : 96;
745 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len);
749 static int mode_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
751 unsigned int lun = SCSI_LUN(srb);
752 unsigned int data_size;
754 bool pro_formatter_flag;
755 unsigned char page_code, *buf;
756 u8 card = get_lun_card(chip, lun);
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;
766 pro_formatter_flag = false;
768 #ifdef SUPPORT_MAGIC_GATE
769 if ((chip->lun2card[lun] & MS_CARD)) {
770 if (!card || (card == MS_CARD)) {
772 if (chip->mspro_formatter_enable)
773 pro_formatter_flag = true;
777 if (card == MS_CARD) {
778 if (chip->mspro_formatter_enable) {
779 pro_formatter_flag = true;
785 buf = kmalloc(data_size, GFP_KERNEL);
787 return TRANSPORT_ERROR;
790 page_code = srb->cmnd[2] & 0x3f;
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);
803 if (check_card_wp(chip, lun))
811 if ((page_code == 0x3F) || (page_code == 0x20)) {
812 ms_mode_sense(chip, srb->cmnd[0],
813 lun, buf, data_size);
819 if (check_card_wp(chip, lun))
829 status = TRANSPORT_GOOD;
831 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
832 scsi_set_resid(srb, scsi_bufflen(srb));
833 status = TRANSPORT_FAILED;
836 if (status == TRANSPORT_GOOD) {
837 unsigned int len = min_t(unsigned int, scsi_bufflen(srb),
839 rtsx_stor_set_xfer_buf(buf, len, srb);
840 scsi_set_resid(srb, scsi_bufflen(srb) - len);
847 static int read_write(struct scsi_cmnd *srb, struct rtsx_chip *chip)
849 #ifdef SUPPORT_SD_LOCK
850 struct sd_info *sd_card = &chip->sd_card;
852 unsigned int lun = SCSI_LUN(srb);
857 rtsx_disable_aspm(chip);
859 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
863 rtsx_set_stat(chip, RTSX_STAT_RUN);
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;
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;
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
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;
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;
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];
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];
915 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
916 return TRANSPORT_FAILED;
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
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;
930 scsi_set_resid(srb, 0);
931 return TRANSPORT_GOOD;
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);
940 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
942 return TRANSPORT_FAILED;
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;
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);
960 chip->rw_fail_cnt[lun]++;
961 if (srb->sc_data_direction == DMA_FROM_DEVICE)
964 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
966 set_sense_type(chip, lun,
967 SENSE_TYPE_MEDIA_WRITE_ERR);
969 retval = TRANSPORT_FAILED;
972 chip->rw_fail_cnt[lun] = 0;
973 retval = TRANSPORT_GOOD;
976 scsi_set_resid(srb, 0);
982 static int read_format_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
985 unsigned int lun = SCSI_LUN(srb);
986 unsigned int buf_len;
987 u8 card = get_lun_card(chip, lun);
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;
999 buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12;
1001 buf = kmalloc(buf_len, GFP_KERNEL);
1003 return TRANSPORT_ERROR;
1010 /* Capacity List Length */
1011 if ((buf_len > 12) && chip->mspro_formatter_enable &&
1012 (chip->lun2card[lun] & MS_CARD) &&
1013 (!card || (card == MS_CARD))) {
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;
1052 buf_len = min_t(unsigned int, scsi_bufflen(srb), buf_len);
1053 rtsx_stor_set_xfer_buf(buf, buf_len, srb);
1056 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1058 return TRANSPORT_GOOD;
1061 static int read_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1064 unsigned int lun = SCSI_LUN(srb);
1067 if (!check_card_ready(chip, lun)) {
1068 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1069 return TRANSPORT_FAILED;
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;
1078 buf = kmalloc(8, GFP_KERNEL);
1080 return TRANSPORT_ERROR;
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);
1094 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1097 scsi_set_resid(srb, 0);
1099 return TRANSPORT_GOOD;
1102 static int read_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1104 unsigned short len, i;
1108 rtsx_disable_aspm(chip);
1110 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1114 rtsx_set_stat(chip, RTSX_STAT_RUN);
1116 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1120 return TRANSPORT_ERROR;
1123 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1124 if (retval != STATUS_SUCCESS) {
1126 set_sense_type(chip, SCSI_LUN(srb),
1127 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1128 return TRANSPORT_FAILED;
1131 for (i = 0; i < len; i++) {
1132 retval = spi_read_eeprom(chip, i, buf + i);
1133 if (retval != STATUS_SUCCESS) {
1135 set_sense_type(chip, SCSI_LUN(srb),
1136 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1137 return TRANSPORT_FAILED;
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);
1147 return TRANSPORT_GOOD;
1150 static int write_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1152 unsigned short len, i;
1156 rtsx_disable_aspm(chip);
1158 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1162 rtsx_set_stat(chip, RTSX_STAT_RUN);
1164 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
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;
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;
1180 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1184 return TRANSPORT_ERROR;
1187 rtsx_stor_get_xfer_buf(buf, len, srb);
1188 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1190 for (i = 0; i < len; i++) {
1191 retval = spi_write_eeprom(chip, i, buf[i]);
1192 if (retval != STATUS_SUCCESS) {
1194 set_sense_type(chip, SCSI_LUN(srb),
1195 SENSE_TYPE_MEDIA_WRITE_ERR);
1196 return TRANSPORT_FAILED;
1203 return TRANSPORT_GOOD;
1206 static int read_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1208 unsigned short addr, len, i;
1212 rtsx_disable_aspm(chip);
1214 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1218 rtsx_set_stat(chip, RTSX_STAT_RUN);
1220 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1221 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1223 if (addr < 0xFC00) {
1224 set_sense_type(chip, SCSI_LUN(srb),
1225 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1226 return TRANSPORT_FAILED;
1231 return TRANSPORT_ERROR;
1234 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1235 if (retval != STATUS_SUCCESS) {
1237 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1238 return TRANSPORT_FAILED;
1241 for (i = 0; i < len; i++) {
1242 retval = rtsx_read_register(chip, addr + i, buf + i);
1243 if (retval != STATUS_SUCCESS) {
1245 set_sense_type(chip, SCSI_LUN(srb),
1246 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1247 return TRANSPORT_FAILED;
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);
1257 return TRANSPORT_GOOD;
1260 static int write_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1262 unsigned short addr, len, i;
1266 rtsx_disable_aspm(chip);
1268 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1272 rtsx_set_stat(chip, RTSX_STAT_RUN);
1274 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1275 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1277 if (addr < 0xFC00) {
1278 set_sense_type(chip, SCSI_LUN(srb),
1279 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1280 return TRANSPORT_FAILED;
1283 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1286 return TRANSPORT_ERROR;
1289 rtsx_stor_get_xfer_buf(buf, len, srb);
1290 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1292 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1293 if (retval != STATUS_SUCCESS) {
1295 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1296 return TRANSPORT_FAILED;
1299 for (i = 0; i < len; i++) {
1300 retval = rtsx_write_register(chip, addr + i, 0xFF, buf[i]);
1301 if (retval != STATUS_SUCCESS) {
1303 set_sense_type(chip, SCSI_LUN(srb),
1304 SENSE_TYPE_MEDIA_WRITE_ERR);
1305 return TRANSPORT_FAILED;
1311 return TRANSPORT_GOOD;
1314 static int get_sd_csd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1316 struct sd_info *sd_card = &chip->sd_card;
1317 unsigned int lun = SCSI_LUN(srb);
1319 if (!check_card_ready(chip, lun)) {
1320 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1321 return TRANSPORT_FAILED;
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;
1329 scsi_set_resid(srb, 0);
1330 rtsx_stor_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb);
1332 return TRANSPORT_GOOD;
1335 static int toggle_gpio_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1337 u8 gpio = srb->cmnd[2];
1339 rtsx_disable_aspm(chip);
1341 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1345 rtsx_set_stat(chip, RTSX_STAT_RUN);
1349 toggle_gpio(chip, gpio);
1351 return TRANSPORT_GOOD;
1354 static int read_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1360 rtsx_disable_aspm(chip);
1362 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1366 rtsx_set_stat(chip, RTSX_STAT_RUN);
1368 addr = srb->cmnd[4];
1370 val = rtsx_readl(chip, addr);
1371 dev_dbg(rtsx_dev(chip), "Host register (0x%x): 0x%x\n", addr, val);
1373 buf[0] = (u8)(val >> 24);
1374 buf[1] = (u8)(val >> 16);
1375 buf[2] = (u8)(val >> 8);
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);
1382 return TRANSPORT_GOOD;
1385 static int write_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1391 rtsx_disable_aspm(chip);
1393 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1397 rtsx_set_stat(chip, RTSX_STAT_RUN);
1399 addr = srb->cmnd[4];
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);
1405 val = ((u32)buf[0] << 24) | ((u32)buf[1] << 16) | ((u32)buf[2]
1408 rtsx_writel(chip, addr, val);
1410 return TRANSPORT_GOOD;
1413 static int set_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1415 unsigned int lun = SCSI_LUN(srb);
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;
1423 switch (srb->cmnd[4]) {
1425 xd_card->xd_clock = srb->cmnd[5];
1429 sd_card->sd_clock = srb->cmnd[5];
1433 ms_card->ms_clock = srb->cmnd[5];
1437 set_sense_type(chip, lun,
1438 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1439 return TRANSPORT_FAILED;
1441 } else if (srb->cmnd[3] == 2) {
1443 chip->blink_led = 1;
1447 chip->blink_led = 0;
1449 rtsx_disable_aspm(chip);
1452 (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1456 rtsx_set_stat(chip, RTSX_STAT_RUN);
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;
1465 turn_off_led(chip, LED_GPIO);
1468 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1469 return TRANSPORT_FAILED;
1472 return TRANSPORT_GOOD;
1475 static int get_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1477 unsigned int lun = SCSI_LUN(srb);
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;
1485 switch (srb->cmnd[4]) {
1487 tmp = (u8)(xd_card->xd_clock);
1491 tmp = (u8)(sd_card->sd_clock);
1495 tmp = (u8)(ms_card->ms_clock);
1499 set_sense_type(chip, lun,
1500 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1501 return TRANSPORT_FAILED;
1504 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1505 } else if (srb->cmnd[3] == 2) {
1506 u8 tmp = chip->blink_led;
1508 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1510 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1511 return TRANSPORT_FAILED;
1514 return TRANSPORT_GOOD;
1517 static int dma_access_ring_buffer(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1520 unsigned int lun = SCSI_LUN(srb);
1523 rtsx_disable_aspm(chip);
1525 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1529 rtsx_set_stat(chip, RTSX_STAT_RUN);
1531 len = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
1532 len = min_t(u16, len, scsi_bufflen(srb));
1534 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1535 dev_dbg(rtsx_dev(chip), "Read from device\n");
1537 dev_dbg(rtsx_dev(chip), "Write to device\n");
1539 retval = rtsx_transfer_data(chip, 0, scsi_sglist(srb), len,
1540 scsi_sg_count(srb), srb->sc_data_direction,
1543 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1544 set_sense_type(chip, lun,
1545 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1547 set_sense_type(chip, lun,
1548 SENSE_TYPE_MEDIA_WRITE_ERR);
1550 return TRANSPORT_FAILED;
1552 scsi_set_resid(srb, 0);
1554 return TRANSPORT_GOOD;
1557 static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1559 struct sd_info *sd_card = &chip->sd_card;
1560 struct ms_info *ms_card = &chip->ms_card;
1562 unsigned int lun = SCSI_LUN(srb);
1563 u8 card = get_lun_card(chip, lun);
1566 u8 oc_now_mask = 0, oc_ever_mask = 0;
1569 memset(status, 0, 32);
1571 status[0] = (u8)(chip->product_id);
1572 status[1] = chip->ic_version;
1574 if (chip->auto_delink_en)
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;
1596 oc_now_mask = SD_OC_NOW;
1597 oc_ever_mask = SD_OC_EVER;
1600 if (chip->ocp_stat & oc_now_mask)
1603 if (chip->ocp_stat & oc_ever_mask)
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;
1613 status[0x0E] = 0x01;
1615 status[0x0E] = 0x00;
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;
1627 status[0x0F] = 0x00;
1629 if (CHK_MMC_SECTOR_MODE(sd_card))
1630 status[0x0E] = 0x01;
1632 status[0x0E] = 0x00;
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;
1641 status[0x0F] = 0x00;
1643 } else if (card == MS_CARD) {
1644 if (CHK_MSPRO(ms_card)) {
1645 if (CHK_MSXC(ms_card))
1646 status[0x0E] = 0x01;
1648 status[0x0E] = 0x00;
1650 if (CHK_HG8BIT(ms_card))
1651 status[0x0F] = 0x01;
1653 status[0x0F] = 0x00;
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;
1666 if (sd_card->sd_lock_status & SD_PWD_EXIST)
1667 status[0x17] |= 0x04;
1669 status[0x17] = 0x00;
1672 dev_dbg(rtsx_dev(chip), "status[0x17] = 0x%x\n", status[0x17]);
1675 status[0x18] = 0x8A;
1676 status[0x1A] = 0x28;
1677 #ifdef SUPPORT_SD_LOCK
1678 status[0x1F] = 0x01;
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);
1685 return TRANSPORT_GOOD;
1688 static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
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;
1700 phy_debug_mode = (int)(srb->cmnd[3]);
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;
1709 rtsx_disable_bus_int(chip);
1711 retval = rtsx_read_phy_register(chip, 0x1C, ®);
1712 if (retval != STATUS_SUCCESS) {
1713 return TRANSPORT_FAILED;
1717 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1718 if (retval != STATUS_SUCCESS) {
1719 return TRANSPORT_FAILED;
1722 chip->phy_debug_mode = 0;
1723 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77);
1724 if (retval != STATUS_SUCCESS) {
1725 return TRANSPORT_FAILED;
1728 rtsx_enable_bus_int(chip);
1730 retval = rtsx_read_phy_register(chip, 0x1C, ®);
1731 if (retval != STATUS_SUCCESS) {
1732 return TRANSPORT_FAILED;
1736 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1737 if (retval != STATUS_SUCCESS) {
1738 return TRANSPORT_FAILED;
1742 return TRANSPORT_GOOD;
1745 static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1747 int retval = STATUS_SUCCESS;
1748 unsigned int lun = SCSI_LUN(srb);
1749 u8 cmd_type, mask, value, idx;
1752 rtsx_disable_aspm(chip);
1754 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1758 rtsx_set_stat(chip, RTSX_STAT_RUN);
1760 switch (srb->cmnd[3]) {
1762 rtsx_init_cmd(chip);
1766 cmd_type = srb->cmnd[4];
1768 set_sense_type(chip, lun,
1769 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1770 return TRANSPORT_FAILED;
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);
1779 retval = rtsx_send_cmd(chip, 0, 1000);
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;
1790 rtsx_stor_set_xfer_buf(&value, 1, srb);
1791 scsi_set_resid(srb, 0);
1795 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1796 return TRANSPORT_FAILED;
1799 if (retval != STATUS_SUCCESS) {
1800 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1801 return TRANSPORT_FAILED;
1804 return TRANSPORT_GOOD;
1807 static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1809 switch (srb->cmnd[3]) {
1814 return rw_mem_cmd_buf(srb, chip);
1816 return TRANSPORT_ERROR;
1820 static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1822 unsigned short addr, len, i;
1827 rtsx_disable_aspm(chip);
1829 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1833 rtsx_set_stat(chip, RTSX_STAT_RUN);
1835 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1836 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1844 return TRANSPORT_ERROR;
1847 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1848 if (retval != STATUS_SUCCESS) {
1850 set_sense_type(chip, SCSI_LUN(srb),
1851 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1852 return TRANSPORT_FAILED;
1855 for (i = 0; i < len / 2; i++) {
1856 retval = rtsx_read_phy_register(chip, addr + i, &val);
1857 if (retval != STATUS_SUCCESS) {
1860 (chip, SCSI_LUN(srb),
1861 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1862 return TRANSPORT_FAILED;
1865 buf[2 * i] = (u8)(val >> 8);
1866 buf[2 * i + 1] = (u8)val;
1869 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1871 rtsx_stor_set_xfer_buf(buf, len, srb);
1872 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1877 return TRANSPORT_GOOD;
1880 static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1882 unsigned short addr, len, i;
1887 rtsx_disable_aspm(chip);
1889 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1893 rtsx_set_stat(chip, RTSX_STAT_RUN);
1895 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1896 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1902 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1907 return TRANSPORT_ERROR;
1910 rtsx_stor_get_xfer_buf(buf, len, srb);
1911 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1913 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1914 if (retval != STATUS_SUCCESS) {
1916 set_sense_type(chip, SCSI_LUN(srb),
1917 SENSE_TYPE_MEDIA_WRITE_ERR);
1918 return TRANSPORT_FAILED;
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) {
1926 set_sense_type(chip, SCSI_LUN(srb),
1927 SENSE_TYPE_MEDIA_WRITE_ERR);
1928 return TRANSPORT_FAILED;
1935 return TRANSPORT_GOOD;
1938 static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1940 unsigned short addr;
1944 rtsx_disable_aspm(chip);
1946 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1950 rtsx_set_stat(chip, RTSX_STAT_RUN);
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;
1958 mode = srb->cmnd[3];
1959 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
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;
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;
1976 set_sense_type(chip, SCSI_LUN(srb),
1977 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1978 return TRANSPORT_FAILED;
1981 return TRANSPORT_GOOD;
1984 static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1986 unsigned short addr, len, i;
1990 rtsx_disable_aspm(chip);
1992 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1996 rtsx_set_stat(chip, RTSX_STAT_RUN);
1998 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1999 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2003 return TRANSPORT_ERROR;
2006 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2007 if (retval != STATUS_SUCCESS) {
2009 set_sense_type(chip, SCSI_LUN(srb),
2010 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2011 return TRANSPORT_FAILED;
2014 for (i = 0; i < len; i++) {
2015 retval = spi_read_eeprom(chip, addr + i, buf + i);
2016 if (retval != STATUS_SUCCESS) {
2018 set_sense_type(chip, SCSI_LUN(srb),
2019 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2020 return TRANSPORT_FAILED;
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);
2030 return TRANSPORT_GOOD;
2033 static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2035 unsigned short addr, len, i;
2039 rtsx_disable_aspm(chip);
2041 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2045 rtsx_set_stat(chip, RTSX_STAT_RUN);
2047 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2048 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2050 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2053 return TRANSPORT_ERROR;
2056 rtsx_stor_get_xfer_buf(buf, len, srb);
2057 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2059 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2060 if (retval != STATUS_SUCCESS) {
2062 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2063 return TRANSPORT_FAILED;
2066 for (i = 0; i < len; i++) {
2067 retval = spi_write_eeprom(chip, addr + i, buf[i]);
2068 if (retval != STATUS_SUCCESS) {
2070 set_sense_type(chip, SCSI_LUN(srb),
2071 SENSE_TYPE_MEDIA_WRITE_ERR);
2072 return TRANSPORT_FAILED;
2078 return TRANSPORT_GOOD;
2081 static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2087 rtsx_disable_aspm(chip);
2089 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2093 rtsx_set_stat(chip, RTSX_STAT_RUN);
2095 addr = srb->cmnd[4];
2100 return TRANSPORT_ERROR;
2103 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2104 if (retval != STATUS_SUCCESS) {
2106 set_sense_type(chip, SCSI_LUN(srb),
2107 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2108 return TRANSPORT_FAILED;
2111 for (i = 0; i < len; i++) {
2112 retval = rtsx_read_efuse(chip, addr + i, buf + i);
2113 if (retval != STATUS_SUCCESS) {
2115 set_sense_type(chip, SCSI_LUN(srb),
2116 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2117 return TRANSPORT_FAILED;
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);
2127 return TRANSPORT_GOOD;
2130 static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2132 int retval, result = TRANSPORT_GOOD;
2137 rtsx_disable_aspm(chip);
2139 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2143 rtsx_set_stat(chip, RTSX_STAT_RUN);
2145 addr = srb->cmnd[4];
2148 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2151 return TRANSPORT_ERROR;
2154 rtsx_stor_get_xfer_buf(buf, len, srb);
2155 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2157 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2158 if (retval != STATUS_SUCCESS) {
2160 return TRANSPORT_ERROR;
2163 if (chip->asic_code) {
2164 retval = rtsx_read_phy_register(chip, 0x08, &val);
2165 if (retval != STATUS_SUCCESS) {
2167 return TRANSPORT_ERROR;
2170 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2171 LDO3318_PWR_MASK, LDO_OFF);
2172 if (retval != STATUS_SUCCESS) {
2174 return TRANSPORT_ERROR;
2179 retval = rtsx_write_phy_register(chip, 0x08,
2180 0x4C00 | chip->phy_voltage);
2181 if (retval != STATUS_SUCCESS) {
2183 return TRANSPORT_ERROR;
2186 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2187 LDO3318_PWR_MASK, LDO_ON);
2188 if (retval != STATUS_SUCCESS) {
2190 return TRANSPORT_ERROR;
2196 retval = card_power_on(chip, SPI_CARD);
2197 if (retval != STATUS_SUCCESS) {
2199 return TRANSPORT_ERROR;
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;
2217 retval = card_power_off(chip, SPI_CARD);
2218 if (retval != STATUS_SUCCESS) {
2219 return TRANSPORT_ERROR;
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;
2231 retval = rtsx_write_phy_register(chip, 0x08, val);
2232 if (retval != STATUS_SUCCESS) {
2233 return TRANSPORT_ERROR;
2236 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2237 LDO3318_PWR_MASK, LDO_ON);
2238 if (retval != STATUS_SUCCESS) {
2239 return TRANSPORT_ERROR;
2246 static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2254 rtsx_disable_aspm(chip);
2256 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2260 rtsx_set_stat(chip, RTSX_STAT_RUN);
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];
2266 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x, len = %d\n",
2267 __func__, func, addr, len);
2269 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2274 if (func > func_max) {
2275 set_sense_type(chip, SCSI_LUN(srb),
2276 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2277 return TRANSPORT_FAILED;
2282 return TRANSPORT_ERROR;
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);
2290 return TRANSPORT_FAILED;
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);
2299 return TRANSPORT_GOOD;
2302 static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2310 rtsx_disable_aspm(chip);
2312 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2316 rtsx_set_stat(chip, RTSX_STAT_RUN);
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];
2322 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x\n",
2323 __func__, func, addr);
2325 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2330 if (func > func_max) {
2331 set_sense_type(chip, SCSI_LUN(srb),
2332 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2333 return TRANSPORT_FAILED;
2336 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2339 return TRANSPORT_ERROR;
2342 rtsx_stor_get_xfer_buf(buf, len, srb);
2343 scsi_set_resid(srb, scsi_bufflen(srb) - len);
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);
2349 return TRANSPORT_FAILED;
2354 return TRANSPORT_GOOD;
2357 static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2361 switch (srb->cmnd[2]) {
2364 result = read_write(srb, chip);
2368 result = read_host_reg(srb, chip);
2371 case WRITE_HOST_REG:
2372 result = write_host_reg(srb, chip);
2376 result = get_variable(srb, chip);
2380 result = set_variable(srb, chip);
2385 result = dma_access_ring_buffer(srb, chip);
2389 result = read_phy_register(srb, chip);
2393 result = write_phy_register(srb, chip);
2397 result = erase_eeprom2(srb, chip);
2401 result = read_eeprom2(srb, chip);
2405 result = write_eeprom2(srb, chip);
2409 result = read_efuse(srb, chip);
2413 result = write_efuse(srb, chip);
2417 result = read_cfg_byte(srb, chip);
2421 result = write_cfg_byte(srb, chip);
2425 result = set_chip_mode(srb, chip);
2429 result = suit_cmd(srb, chip);
2432 case GET_DEV_STATUS:
2433 result = get_dev_status(srb, chip);
2437 set_sense_type(chip, SCSI_LUN(srb),
2438 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2439 return TRANSPORT_FAILED;
2445 static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2449 unsigned int lun = SCSI_LUN(srb);
2451 rtsx_status[0] = (u8)(chip->vendor_id >> 8);
2452 rtsx_status[1] = (u8)(chip->vendor_id);
2454 rtsx_status[2] = (u8)(chip->product_id >> 8);
2455 rtsx_status[3] = (u8)(chip->product_id);
2457 rtsx_status[4] = (u8)lun;
2459 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2460 if (chip->lun2card[lun] == SD_CARD)
2465 if (chip->card_exist) {
2466 if (chip->card_exist & XD_CARD)
2468 else if (chip->card_exist & SD_CARD)
2470 else if (chip->card_exist & MS_CARD)
2479 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2484 rtsx_status[7] = (u8)(chip->product_id);
2485 rtsx_status[8] = chip->ic_version;
2487 if (check_card_exist(chip, lun))
2492 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2493 rtsx_status[10] = 0;
2495 rtsx_status[10] = 1;
2497 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2498 if (chip->lun2card[lun] == SD_CARD)
2499 rtsx_status[11] = SD_CARD;
2501 rtsx_status[11] = MS_CARD;
2503 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD;
2506 if (check_card_ready(chip, lun))
2507 rtsx_status[12] = 1;
2509 rtsx_status[12] = 0;
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;
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;
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;
2529 } else if (get_lun_card(chip, lun) == MS_CARD) {
2530 struct ms_info *ms_card = &chip->ms_card;
2532 if (CHK_MSPRO(ms_card)) {
2533 rtsx_status[13] = 0x38;
2534 if (CHK_HG8BIT(ms_card))
2535 rtsx_status[13] |= 0x04;
2537 if (CHK_MSXC(ms_card))
2538 rtsx_status[13] |= 0x01;
2541 rtsx_status[13] = 0x30;
2544 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) {
2546 if (chip->sd_io && chip->sd_int)
2547 rtsx_status[13] = 0x60;
2549 rtsx_status[13] = 0x70;
2551 rtsx_status[13] = 0x70;
2554 if (chip->lun2card[lun] == SD_CARD)
2555 rtsx_status[13] = 0x20;
2557 rtsx_status[13] = 0x30;
2561 rtsx_status[14] = 0x78;
2562 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2563 rtsx_status[15] = 0x83;
2565 rtsx_status[15] = 0x82;
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);
2571 return TRANSPORT_GOOD;
2574 static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2576 unsigned int lun = SCSI_LUN(srb);
2579 if (!check_card_ready(chip, lun)) {
2580 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2581 return TRANSPORT_FAILED;
2584 card = get_lun_card(chip, lun);
2585 if ((card == SD_CARD) || (card == MS_CARD)) {
2586 bus_width = chip->card_bus_width[lun];
2588 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2589 return TRANSPORT_FAILED;
2592 scsi_set_resid(srb, 0);
2593 rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
2595 return TRANSPORT_GOOD;
2598 static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2601 unsigned int lun = SCSI_LUN(srb);
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;
2609 rtsx_disable_aspm(chip);
2611 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2615 rtsx_set_stat(chip, RTSX_STAT_RUN);
2617 rtsx_force_power_on(chip, SSC_PDCTL);
2619 rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir);
2620 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06);
2622 switch (srb->cmnd[2]) {
2623 case SCSI_SPI_GETSTATUS:
2624 result = spi_get_status(srb, chip);
2627 case SCSI_SPI_SETPARAMETER:
2628 result = spi_set_parameter(srb, chip);
2631 case SCSI_SPI_READFALSHID:
2632 result = spi_read_flash_id(srb, chip);
2635 case SCSI_SPI_READFLASH:
2636 result = spi_read_flash(srb, chip);
2639 case SCSI_SPI_WRITEFLASH:
2640 result = spi_write_flash(srb, chip);
2643 case SCSI_SPI_WRITEFLASHSTATUS:
2644 result = spi_write_flash_status(srb, chip);
2647 case SCSI_SPI_ERASEFLASH:
2648 result = spi_erase_flash(srb, chip);
2652 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2654 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2655 return TRANSPORT_FAILED;
2658 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2660 if (result != STATUS_SUCCESS) {
2661 return TRANSPORT_FAILED;
2664 return TRANSPORT_GOOD;
2667 static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2671 switch (srb->cmnd[1]) {
2673 result = read_status(srb, chip);
2677 result = read_mem(srb, chip);
2681 result = write_mem(srb, chip);
2685 result = read_eeprom(srb, chip);
2689 result = write_eeprom(srb, chip);
2693 result = toggle_gpio_cmd(srb, chip);
2697 result = get_sd_csd(srb, chip);
2701 result = get_card_bus_width(srb, chip);
2705 result = app_cmd(srb, chip);
2708 case SPI_VENDOR_COMMAND:
2709 result = spi_vendor_cmd(srb, chip);
2713 set_sense_type(chip, SCSI_LUN(srb),
2714 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2715 return TRANSPORT_FAILED;
2721 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
2722 void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2724 unsigned int lun = SCSI_LUN(srb);
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];
2737 if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) {
2738 toggle_gpio(chip, LED_GPIO);
2739 chip->rw_cap[lun] = 0;
2741 chip->rw_cap[lun] += sec_cnt;
2746 static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2748 struct ms_info *ms_card = &chip->ms_card;
2749 unsigned int lun = SCSI_LUN(srb);
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;
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;
2765 rtsx_disable_aspm(chip);
2767 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
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;
2777 rtsx_set_stat(chip, RTSX_STAT_RUN);
2779 if (srb->cmnd[8] & 0x01)
2780 quick_format = false;
2782 quick_format = true;
2784 if (!(chip->card_ready & MS_CARD)) {
2785 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2786 return TRANSPORT_FAILED;
2789 if (chip->card_wp & MS_CARD) {
2790 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2791 return TRANSPORT_FAILED;
2794 if (!CHK_MSPRO(ms_card)) {
2795 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2796 return TRANSPORT_FAILED;
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;
2805 scsi_set_resid(srb, 0);
2806 return TRANSPORT_GOOD;
2809 #ifdef SUPPORT_PCGL_1P18
2810 static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2812 struct ms_info *ms_card = &chip->ms_card;
2813 unsigned int lun = SCSI_LUN(srb);
2814 u8 dev_info_id, data_len;
2816 unsigned int buf_len;
2819 if (!check_card_ready(chip, lun)) {
2820 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2821 return TRANSPORT_FAILED;
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;
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;
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;
2843 if (dev_info_id == 0x15) {
2851 buf = kmalloc(buf_len, GFP_KERNEL);
2853 return TRANSPORT_ERROR;
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))
2872 /* Number of Device Information */
2875 /* Device Information Body */
2877 /* Device Information ID Number */
2878 buf[i++] = dev_info_id;
2879 /* Device Information Length */
2880 if (dev_info_id == 0x15)
2885 buf[i++] = 0x00; /* Data length MSB */
2886 buf[i++] = data_len; /* Data length LSB */
2889 if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
2890 /* System Information */
2891 memcpy(buf + i, ms_card->raw_sys_info, 96);
2894 memcpy(buf + i, ms_card->raw_model_name, 48);
2897 rtsx_stor_set_xfer_buf(buf, buf_len, srb);
2899 if (dev_info_id == 0x15)
2900 scsi_set_resid(srb, scsi_bufflen(srb) - 0x3C);
2902 scsi_set_resid(srb, scsi_bufflen(srb) - 0x6C);
2905 return STATUS_SUCCESS;
2909 static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2911 int retval = TRANSPORT_ERROR;
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);
2924 static int sd_extension_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2926 unsigned int lun = SCSI_LUN(srb);
2929 rtsx_disable_aspm(chip);
2931 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2935 rtsx_set_stat(chip, RTSX_STAT_RUN);
2937 sd_cleanup_work(chip);
2939 if (!check_card_ready(chip, lun)) {
2940 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2941 return TRANSPORT_FAILED;
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;
2948 switch (srb->cmnd[0]) {
2949 case SD_PASS_THRU_MODE:
2950 result = sd_pass_thru_mode(srb, chip);
2953 case SD_EXECUTE_NO_DATA:
2954 result = sd_execute_no_data(srb, chip);
2957 case SD_EXECUTE_READ:
2958 result = sd_execute_read_data(srb, chip);
2961 case SD_EXECUTE_WRITE:
2962 result = sd_execute_write_data(srb, chip);
2966 result = sd_get_cmd_rsp(srb, chip);
2970 result = sd_hw_rst(srb, chip);
2974 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2975 return TRANSPORT_FAILED;
2982 #ifdef SUPPORT_MAGIC_GATE
2983 static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2985 struct ms_info *ms_card = &chip->ms_card;
2986 unsigned int lun = SCSI_LUN(srb);
2990 rtsx_disable_aspm(chip);
2992 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2996 rtsx_set_stat(chip, RTSX_STAT_RUN);
2998 ms_cleanup_work(chip);
3000 if (!check_card_ready(chip, lun)) {
3001 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3002 return TRANSPORT_FAILED;
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;
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;
3014 if (!CHK_MSPRO(ms_card)) {
3015 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3016 return TRANSPORT_FAILED;
3019 key_format = srb->cmnd[10] & 0x3F;
3020 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
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;
3033 set_sense_type(chip, lun,
3034 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3035 return TRANSPORT_FAILED;
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;
3049 set_sense_type(chip, lun,
3050 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3051 return TRANSPORT_FAILED;
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;
3070 set_sense_type(chip, lun,
3071 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3072 return TRANSPORT_FAILED;
3077 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3078 return TRANSPORT_FAILED;
3081 scsi_set_resid(srb, 0);
3082 return TRANSPORT_GOOD;
3085 static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3087 struct ms_info *ms_card = &chip->ms_card;
3088 unsigned int lun = SCSI_LUN(srb);
3092 rtsx_disable_aspm(chip);
3094 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3098 rtsx_set_stat(chip, RTSX_STAT_RUN);
3100 ms_cleanup_work(chip);
3102 if (!check_card_ready(chip, lun)) {
3103 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3104 return TRANSPORT_FAILED;
3106 if (check_card_wp(chip, lun)) {
3107 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
3108 return TRANSPORT_FAILED;
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;
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;
3120 if (!CHK_MSPRO(ms_card)) {
3121 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3122 return TRANSPORT_FAILED;
3125 key_format = srb->cmnd[10] & 0x3F;
3126 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
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;
3139 set_sense_type(chip, lun,
3140 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3141 return TRANSPORT_FAILED;
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;
3155 set_sense_type(chip, lun,
3156 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3157 return TRANSPORT_FAILED;
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;
3171 set_sense_type(chip, lun,
3172 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3173 return TRANSPORT_FAILED;
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;
3192 set_sense_type(chip, lun,
3193 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3194 return TRANSPORT_FAILED;
3199 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3200 return TRANSPORT_FAILED;
3203 scsi_set_resid(srb, 0);
3204 return TRANSPORT_GOOD;
3208 int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3210 #ifdef SUPPORT_SD_LOCK
3211 struct sd_info *sd_card = &chip->sd_card;
3213 struct ms_info *ms_card = &chip->ms_card;
3214 unsigned int lun = SCSI_LUN(srb);
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
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;
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;
3245 switch (srb->cmnd[0]) {
3250 result = read_write(srb, chip);
3251 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
3252 led_shine(srb, chip);
3256 case TEST_UNIT_READY:
3257 result = test_unit_ready(srb, chip);
3261 result = inquiry(srb, chip);
3265 result = read_capacity(srb, chip);
3269 result = start_stop_unit(srb, chip);
3272 case ALLOW_MEDIUM_REMOVAL:
3273 result = allow_medium_removal(srb, chip);
3277 result = request_sense(srb, chip);
3282 result = mode_sense(srb, chip);
3286 result = read_format_capacity(srb, chip);
3290 result = vendor_cmnd(srb, chip);
3294 result = ms_sp_cmnd(srb, chip);
3298 case SD_PASS_THRU_MODE:
3299 case SD_EXECUTE_NO_DATA:
3300 case SD_EXECUTE_READ:
3301 case SD_EXECUTE_WRITE:
3304 result = sd_extension_cmnd(srb, chip);
3308 #ifdef SUPPORT_MAGIC_GATE
3309 case CMD_MSPRO_MG_RKEY:
3310 result = mg_report_key(srb, chip);
3313 case CMD_MSPRO_MG_SKEY:
3314 result = mg_send_key(srb, chip);
3321 result = TRANSPORT_GOOD;
3325 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3326 result = TRANSPORT_FAILED;