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) >> 8;
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));
512 return TRANSPORT_ERROR;
515 #ifdef SUPPORT_MAGIC_GATE
516 if ((chip->mspro_formatter_enable) &&
517 (chip->lun2card[lun] & MS_CARD))
519 if (chip->mspro_formatter_enable)
521 if (!card || (card == MS_CARD))
522 pro_formatter_flag = true;
524 if (pro_formatter_flag) {
525 if (scsi_bufflen(srb) < 56)
526 sendbytes = (unsigned char)(scsi_bufflen(srb));
531 if (scsi_bufflen(srb) < 36)
532 sendbytes = (unsigned char)(scsi_bufflen(srb));
538 memcpy(buf, inquiry_buf, 8);
539 memcpy(buf + 8, inquiry_string, sendbytes - 8);
540 if (pro_formatter_flag) {
541 /* Additional Length */
545 memcpy(buf, inquiry_buf, sendbytes);
548 if (pro_formatter_flag) {
550 memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36);
553 scsi_set_resid(srb, 0);
555 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
558 return TRANSPORT_GOOD;
562 static int start_stop_unit(struct scsi_cmnd *srb, struct rtsx_chip *chip)
564 unsigned int lun = SCSI_LUN(srb);
566 scsi_set_resid(srb, scsi_bufflen(srb));
568 if (srb->cmnd[1] == 1)
569 return TRANSPORT_GOOD;
571 switch (srb->cmnd[0x4]) {
574 return TRANSPORT_GOOD;
577 /* Media shall be unload */
578 if (check_card_ready(chip, lun))
579 eject_card(chip, lun);
580 return TRANSPORT_GOOD;
582 case MAKE_MEDIUM_READY:
584 if (check_card_ready(chip, lun))
585 return TRANSPORT_GOOD;
586 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
588 return TRANSPORT_FAILED;
594 return TRANSPORT_ERROR;
598 static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip)
602 prevent = srb->cmnd[4] & 0x1;
604 scsi_set_resid(srb, 0);
607 set_sense_type(chip, SCSI_LUN(srb),
608 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
610 return TRANSPORT_FAILED;
613 return TRANSPORT_GOOD;
617 static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
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;
624 sense = &(chip->sense_buffer[lun]);
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));
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;
643 rtsx_set_stat(chip, RTSX_STAT_RUN);
646 buf = vmalloc(scsi_bufflen(srb));
649 return TRANSPORT_ERROR;
652 tmp = (unsigned char *)sense;
653 memcpy(buf, tmp, scsi_bufflen(srb));
655 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
658 scsi_set_resid(srb, 0);
659 /* Reset Sense Data */
660 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
661 return TRANSPORT_GOOD;
664 static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd,
665 int lun, u8 *buf, int buf_len)
667 struct ms_info *ms_card = &(chip->ms_card);
669 int data_size = buf_len;
670 bool support_format = false;
673 if (cmd == MODE_SENSE) {
675 if (data_size > 0x68)
678 buf[i++] = 0x67; /* Mode Data Length */
680 sys_info_offset = 12;
681 if (data_size > 0x6C)
684 buf[i++] = 0x00; /* Mode Data Length (MSB) */
685 buf[i++] = 0x6A; /* Mode Data Length (LSB) */
688 /* Medium Type Code */
689 if (check_card_ready(chip, lun)) {
690 if (CHK_MSXC(ms_card)) {
691 support_format = true;
693 } else if (CHK_MSPRO(ms_card)) {
694 support_format = true;
701 if (check_card_wp(chip, lun))
707 buf[i++] = 0x00; /* MediaType */
708 buf[i++] = 0x00; /* WP */
711 buf[i++] = 0x00; /* Reserved */
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) */
718 /* The Following Data is the content of "Page 0x20" */
720 buf[i++] = 0x20; /* Page Code */
722 buf[i++] = 0x62; /* Page Length */
724 buf[i++] = 0x00; /* No Access Control */
725 if (data_size >= 12) {
727 buf[i++] = 0xC0; /* SF, SGM */
732 /* The Following Data is the content of "Page 0x20" */
734 buf[i++] = 0x20; /* Page Code */
736 buf[i++] = 0x62; /* Page Length */
738 buf[i++] = 0x00; /* No Access Control */
739 if (data_size >= 8) {
741 buf[i++] = 0xC0; /* SF, SGM */
747 if (data_size > sys_info_offset) {
748 /* 96 Bytes Attribute Data */
749 int len = data_size - sys_info_offset;
751 len = (len < 96) ? len : 96;
753 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len);
757 static int mode_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
759 unsigned int lun = SCSI_LUN(srb);
760 unsigned int dataSize;
762 bool pro_formatter_flag;
763 unsigned char pageCode, *buf;
764 u8 card = get_lun_card(chip, lun);
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));
771 return TRANSPORT_FAILED;
775 pro_formatter_flag = false;
777 #ifdef SUPPORT_MAGIC_GATE
778 if ((chip->lun2card[lun] & MS_CARD)) {
779 if (!card || (card == MS_CARD)) {
781 if (chip->mspro_formatter_enable)
782 pro_formatter_flag = true;
786 if (card == MS_CARD) {
787 if (chip->mspro_formatter_enable) {
788 pro_formatter_flag = true;
794 buf = kmalloc(dataSize, GFP_KERNEL);
797 return TRANSPORT_ERROR;
800 pageCode = srb->cmnd[2] & 0x3f;
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],
813 if (check_card_wp(chip, lun))
821 if ((pageCode == 0x3F) || (pageCode == 0x20)) {
822 ms_mode_sense(chip, srb->cmnd[0],
829 if (check_card_wp(chip, lun))
839 status = TRANSPORT_GOOD;
841 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
842 scsi_set_resid(srb, scsi_bufflen(srb));
843 status = TRANSPORT_FAILED;
846 if (status == TRANSPORT_GOOD) {
847 unsigned int len = min_t(unsigned int, scsi_bufflen(srb),
849 rtsx_stor_set_xfer_buf(buf, len, srb);
850 scsi_set_resid(srb, scsi_bufflen(srb) - len);
857 static int read_write(struct scsi_cmnd *srb, struct rtsx_chip *chip)
859 #ifdef SUPPORT_SD_LOCK
860 struct sd_info *sd_card = &(chip->sd_card);
862 unsigned int lun = SCSI_LUN(srb);
867 rtsx_disable_aspm(chip);
869 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
873 rtsx_set_stat(chip, RTSX_STAT_RUN);
875 if (!check_card_ready(chip, lun) || (get_card_size(chip, lun) == 0)) {
876 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
878 return TRANSPORT_FAILED;
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;
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
892 dev_dbg(rtsx_dev(chip), "SD card being erased!\n");
893 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
895 return TRANSPORT_FAILED;
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);
904 return TRANSPORT_FAILED;
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];
920 } else if ((srb->cmnd[0] == VENDOR_CMND) &&
921 (srb->cmnd[1] == SCSI_APP_CMD) &&
922 ((srb->cmnd[2] == PP_READ10) || (srb->cmnd[2] == PP_WRITE10))) {
923 start_sec = ((u32)srb->cmnd[4] << 24) |
924 ((u32)srb->cmnd[5] << 16) |
925 ((u32)srb->cmnd[6] << 8) | ((u32)srb->cmnd[7]);
926 sec_cnt = ((u16)(srb->cmnd[9]) << 8) | srb->cmnd[10];
928 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
930 return TRANSPORT_FAILED;
933 /* In some test, we will receive a start_sec like 0xFFFFFFFF.
934 * In this situation, start_sec + sec_cnt will overflow, so we
935 * need to judge start_sec at first
937 if ((start_sec > get_card_size(chip, lun)) ||
938 ((start_sec + sec_cnt) > get_card_size(chip, lun))) {
939 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE);
941 return TRANSPORT_FAILED;
945 scsi_set_resid(srb, 0);
946 return TRANSPORT_GOOD;
949 if (chip->rw_fail_cnt[lun] == 3) {
950 dev_dbg(rtsx_dev(chip), "read/write fail three times in succession\n");
951 if (srb->sc_data_direction == DMA_FROM_DEVICE)
952 set_sense_type(chip, lun,
953 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
955 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
958 return TRANSPORT_FAILED;
961 if (srb->sc_data_direction == DMA_TO_DEVICE) {
962 if (check_card_wp(chip, lun)) {
963 dev_dbg(rtsx_dev(chip), "Write protected card!\n");
964 set_sense_type(chip, lun,
965 SENSE_TYPE_MEDIA_WRITE_PROTECT);
967 return TRANSPORT_FAILED;
971 retval = card_rw(srb, chip, start_sec, sec_cnt);
972 if (retval != STATUS_SUCCESS) {
973 if (chip->need_release & chip->lun2card[lun]) {
974 chip->rw_fail_cnt[lun] = 0;
975 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
977 chip->rw_fail_cnt[lun]++;
978 if (srb->sc_data_direction == DMA_FROM_DEVICE)
979 set_sense_type(chip, lun,
980 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
982 set_sense_type(chip, lun,
983 SENSE_TYPE_MEDIA_WRITE_ERR);
985 retval = TRANSPORT_FAILED;
989 chip->rw_fail_cnt[lun] = 0;
990 retval = TRANSPORT_GOOD;
993 scsi_set_resid(srb, 0);
999 static int read_format_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1002 unsigned int lun = SCSI_LUN(srb);
1003 unsigned int buf_len;
1004 u8 card = get_lun_card(chip, lun);
1009 if (!check_card_ready(chip, lun)) {
1010 if (!chip->mspro_formatter_enable) {
1011 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1013 return TRANSPORT_FAILED;
1017 buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12;
1019 buf = kmalloc(buf_len, GFP_KERNEL);
1022 return TRANSPORT_ERROR;
1029 /* Capacity List Length */
1030 if ((buf_len > 12) && chip->mspro_formatter_enable &&
1031 (chip->lun2card[lun] & MS_CARD) &&
1032 (!card || (card == MS_CARD))) {
1041 if (check_card_ready(chip, lun)) {
1042 card_size = get_card_size(chip, lun);
1043 buf[i++] = (unsigned char)(card_size >> 24);
1044 buf[i++] = (unsigned char)(card_size >> 16);
1045 buf[i++] = (unsigned char)(card_size >> 8);
1046 buf[i++] = (unsigned char)card_size;
1071 buf_len = min_t(unsigned int, scsi_bufflen(srb), buf_len);
1072 rtsx_stor_set_xfer_buf(buf, buf_len, srb);
1075 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1077 return TRANSPORT_GOOD;
1080 static int read_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1083 unsigned int lun = SCSI_LUN(srb);
1086 if (!check_card_ready(chip, lun)) {
1087 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1089 return TRANSPORT_FAILED;
1092 if (!(CHK_BIT(chip->lun_mc, lun))) {
1093 SET_BIT(chip->lun_mc, lun);
1094 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
1095 return TRANSPORT_FAILED;
1098 buf = kmalloc(8, GFP_KERNEL);
1101 return TRANSPORT_ERROR;
1104 card_size = get_card_size(chip, lun);
1105 buf[0] = (unsigned char)((card_size - 1) >> 24);
1106 buf[1] = (unsigned char)((card_size - 1) >> 16);
1107 buf[2] = (unsigned char)((card_size - 1) >> 8);
1108 buf[3] = (unsigned char)(card_size - 1);
1115 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1118 scsi_set_resid(srb, 0);
1120 return TRANSPORT_GOOD;
1123 static int read_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1125 unsigned short len, i;
1129 rtsx_disable_aspm(chip);
1131 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1135 rtsx_set_stat(chip, RTSX_STAT_RUN);
1137 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1142 return TRANSPORT_ERROR;
1145 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1146 if (retval != STATUS_SUCCESS) {
1148 set_sense_type(chip, SCSI_LUN(srb),
1149 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1151 return TRANSPORT_FAILED;
1154 for (i = 0; i < len; i++) {
1155 retval = spi_read_eeprom(chip, i, buf + i);
1156 if (retval != STATUS_SUCCESS) {
1158 set_sense_type(chip, SCSI_LUN(srb),
1159 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1161 return TRANSPORT_FAILED;
1165 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1166 rtsx_stor_set_xfer_buf(buf, len, srb);
1167 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1171 return TRANSPORT_GOOD;
1174 static int write_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1176 unsigned short len, i;
1180 rtsx_disable_aspm(chip);
1182 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1186 rtsx_set_stat(chip, RTSX_STAT_RUN);
1188 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1190 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1191 if (retval != STATUS_SUCCESS) {
1192 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1194 return TRANSPORT_FAILED;
1198 retval = spi_erase_eeprom_chip(chip);
1199 if (retval != STATUS_SUCCESS) {
1200 set_sense_type(chip, SCSI_LUN(srb),
1201 SENSE_TYPE_MEDIA_WRITE_ERR);
1203 return TRANSPORT_FAILED;
1206 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1211 return TRANSPORT_ERROR;
1214 rtsx_stor_get_xfer_buf(buf, len, srb);
1215 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1217 for (i = 0; i < len; i++) {
1218 retval = spi_write_eeprom(chip, i, buf[i]);
1219 if (retval != STATUS_SUCCESS) {
1221 set_sense_type(chip, SCSI_LUN(srb),
1222 SENSE_TYPE_MEDIA_WRITE_ERR);
1224 return TRANSPORT_FAILED;
1231 return TRANSPORT_GOOD;
1234 static int read_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1236 unsigned short addr, len, i;
1240 rtsx_disable_aspm(chip);
1242 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1246 rtsx_set_stat(chip, RTSX_STAT_RUN);
1248 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1249 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1251 if (addr < 0xFC00) {
1252 set_sense_type(chip, SCSI_LUN(srb),
1253 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1255 return TRANSPORT_FAILED;
1261 return TRANSPORT_ERROR;
1264 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1265 if (retval != STATUS_SUCCESS) {
1267 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1269 return TRANSPORT_FAILED;
1272 for (i = 0; i < len; i++) {
1273 retval = rtsx_read_register(chip, addr + i, buf + i);
1274 if (retval != STATUS_SUCCESS) {
1276 set_sense_type(chip, SCSI_LUN(srb),
1277 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1279 return TRANSPORT_FAILED;
1283 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1284 rtsx_stor_set_xfer_buf(buf, len, srb);
1285 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1289 return TRANSPORT_GOOD;
1292 static int write_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1294 unsigned short addr, len, i;
1298 rtsx_disable_aspm(chip);
1300 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1304 rtsx_set_stat(chip, RTSX_STAT_RUN);
1306 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1307 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1309 if (addr < 0xFC00) {
1310 set_sense_type(chip, SCSI_LUN(srb),
1311 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1313 return TRANSPORT_FAILED;
1316 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1320 return TRANSPORT_ERROR;
1323 rtsx_stor_get_xfer_buf(buf, len, srb);
1324 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1326 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1327 if (retval != STATUS_SUCCESS) {
1329 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1331 return TRANSPORT_FAILED;
1334 for (i = 0; i < len; i++) {
1335 retval = rtsx_write_register(chip, addr + i, 0xFF, buf[i]);
1336 if (retval != STATUS_SUCCESS) {
1338 set_sense_type(chip, SCSI_LUN(srb),
1339 SENSE_TYPE_MEDIA_WRITE_ERR);
1341 return TRANSPORT_FAILED;
1347 return TRANSPORT_GOOD;
1350 static int get_sd_csd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1352 struct sd_info *sd_card = &(chip->sd_card);
1353 unsigned int lun = SCSI_LUN(srb);
1355 if (!check_card_ready(chip, lun)) {
1356 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1358 return TRANSPORT_FAILED;
1361 if (get_lun_card(chip, lun) != SD_CARD) {
1362 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1364 return TRANSPORT_FAILED;
1367 scsi_set_resid(srb, 0);
1368 rtsx_stor_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb);
1370 return TRANSPORT_GOOD;
1373 static int toggle_gpio_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1375 u8 gpio = srb->cmnd[2];
1377 rtsx_disable_aspm(chip);
1379 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1383 rtsx_set_stat(chip, RTSX_STAT_RUN);
1387 toggle_gpio(chip, gpio);
1389 return TRANSPORT_GOOD;
1393 static int trace_msg_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1395 unsigned char *ptr, *buf = NULL;
1398 unsigned int buf_len;
1400 buf_len = 4 + ((2 + MSG_FUNC_LEN + MSG_FILE_LEN + TIME_VAL_LEN) *
1403 if ((scsi_bufflen(srb) < buf_len) || (scsi_sglist(srb) == NULL)) {
1404 set_sense_type(chip, SCSI_LUN(srb),
1405 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1407 return TRANSPORT_FAILED;
1410 clear = srb->cmnd[2];
1412 buf = vmalloc(scsi_bufflen(srb));
1415 return TRANSPORT_ERROR;
1419 if (chip->trace_msg[chip->msg_idx].valid)
1420 msg_cnt = TRACE_ITEM_CNT;
1422 msg_cnt = chip->msg_idx;
1424 *(ptr++) = (u8)(msg_cnt >> 24);
1425 *(ptr++) = (u8)(msg_cnt >> 16);
1426 *(ptr++) = (u8)(msg_cnt >> 8);
1427 *(ptr++) = (u8)msg_cnt;
1428 dev_dbg(rtsx_dev(chip), "Trace message count is %d\n", msg_cnt);
1430 for (i = 1; i <= msg_cnt; i++) {
1433 idx = chip->msg_idx - i;
1435 idx += TRACE_ITEM_CNT;
1437 *(ptr++) = (u8)(chip->trace_msg[idx].line >> 8);
1438 *(ptr++) = (u8)(chip->trace_msg[idx].line);
1439 for (j = 0; j < MSG_FUNC_LEN; j++)
1440 *(ptr++) = chip->trace_msg[idx].func[j];
1442 for (j = 0; j < MSG_FILE_LEN; j++)
1443 *(ptr++) = chip->trace_msg[idx].file[j];
1445 for (j = 0; j < TIME_VAL_LEN; j++)
1446 *(ptr++) = chip->trace_msg[idx].timeval_buf[j];
1449 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1454 for (i = 0; i < TRACE_ITEM_CNT; i++)
1455 chip->trace_msg[i].valid = 0;
1458 scsi_set_resid(srb, 0);
1459 return TRANSPORT_GOOD;
1463 static int read_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1469 rtsx_disable_aspm(chip);
1471 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1475 rtsx_set_stat(chip, RTSX_STAT_RUN);
1477 addr = srb->cmnd[4];
1479 val = rtsx_readl(chip, addr);
1480 dev_dbg(rtsx_dev(chip), "Host register (0x%x): 0x%x\n", addr, val);
1482 buf[0] = (u8)(val >> 24);
1483 buf[1] = (u8)(val >> 16);
1484 buf[2] = (u8)(val >> 8);
1487 len = min_t(unsigned int, scsi_bufflen(srb), 4);
1488 rtsx_stor_set_xfer_buf(buf, len, srb);
1489 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1491 return TRANSPORT_GOOD;
1494 static int write_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1500 rtsx_disable_aspm(chip);
1502 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1506 rtsx_set_stat(chip, RTSX_STAT_RUN);
1508 addr = srb->cmnd[4];
1510 len = min_t(unsigned int, scsi_bufflen(srb), 4);
1511 rtsx_stor_get_xfer_buf(buf, len, srb);
1512 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1514 val = ((u32)buf[0] << 24) | ((u32)buf[1] << 16) | ((u32)buf[2]
1517 rtsx_writel(chip, addr, val);
1519 return TRANSPORT_GOOD;
1522 static int set_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1524 unsigned lun = SCSI_LUN(srb);
1526 if (srb->cmnd[3] == 1) {
1527 /* Variable Clock */
1528 struct xd_info *xd_card = &(chip->xd_card);
1529 struct sd_info *sd_card = &(chip->sd_card);
1530 struct ms_info *ms_card = &(chip->ms_card);
1532 switch (srb->cmnd[4]) {
1534 xd_card->xd_clock = srb->cmnd[5];
1538 sd_card->sd_clock = srb->cmnd[5];
1542 ms_card->ms_clock = srb->cmnd[5];
1546 set_sense_type(chip, lun,
1547 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1549 return TRANSPORT_FAILED;
1551 } else if (srb->cmnd[3] == 2) {
1553 chip->blink_led = 1;
1557 chip->blink_led = 0;
1559 rtsx_disable_aspm(chip);
1562 (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1566 rtsx_set_stat(chip, RTSX_STAT_RUN);
1568 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1569 if (retval != STATUS_SUCCESS) {
1570 set_sense_type(chip, SCSI_LUN(srb),
1571 SENSE_TYPE_MEDIA_WRITE_ERR);
1573 return TRANSPORT_FAILED;
1576 turn_off_led(chip, LED_GPIO);
1579 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1581 return TRANSPORT_FAILED;
1584 return TRANSPORT_GOOD;
1587 static int get_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1589 unsigned int lun = SCSI_LUN(srb);
1591 if (srb->cmnd[3] == 1) {
1592 struct xd_info *xd_card = &(chip->xd_card);
1593 struct sd_info *sd_card = &(chip->sd_card);
1594 struct ms_info *ms_card = &(chip->ms_card);
1597 switch (srb->cmnd[4]) {
1599 tmp = (u8)(xd_card->xd_clock);
1603 tmp = (u8)(sd_card->sd_clock);
1607 tmp = (u8)(ms_card->ms_clock);
1611 set_sense_type(chip, lun,
1612 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1614 return TRANSPORT_FAILED;
1617 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1618 } else if (srb->cmnd[3] == 2) {
1619 u8 tmp = chip->blink_led;
1621 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1623 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1625 return TRANSPORT_FAILED;
1628 return TRANSPORT_GOOD;
1631 static int dma_access_ring_buffer(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1634 unsigned int lun = SCSI_LUN(srb);
1637 rtsx_disable_aspm(chip);
1639 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1643 rtsx_set_stat(chip, RTSX_STAT_RUN);
1645 len = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
1646 len = min_t(u16, len, scsi_bufflen(srb));
1648 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1649 dev_dbg(rtsx_dev(chip), "Read from device\n");
1651 dev_dbg(rtsx_dev(chip), "Write to device\n");
1653 retval = rtsx_transfer_data(chip, 0, scsi_sglist(srb), len,
1654 scsi_sg_count(srb), srb->sc_data_direction, 1000);
1656 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1657 set_sense_type(chip, lun,
1658 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1660 set_sense_type(chip, lun,
1661 SENSE_TYPE_MEDIA_WRITE_ERR);
1664 return TRANSPORT_FAILED;
1666 scsi_set_resid(srb, 0);
1668 return TRANSPORT_GOOD;
1671 static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1673 struct sd_info *sd_card = &(chip->sd_card);
1674 struct ms_info *ms_card = &(chip->ms_card);
1676 unsigned int lun = SCSI_LUN(srb);
1677 u8 card = get_lun_card(chip, lun);
1680 u8 oc_now_mask = 0, oc_ever_mask = 0;
1683 memset(status, 0, 32);
1685 status[0] = (u8)(chip->product_id);
1686 status[1] = chip->ic_version;
1688 if (chip->auto_delink_en)
1705 if (CHECK_LUN_MODE(chip,
1706 SD_MS_2LUN) && (chip->lun2card[lun] == MS_CARD)) {
1707 oc_now_mask = MS_OC_NOW;
1708 oc_ever_mask = MS_OC_EVER;
1710 oc_now_mask = SD_OC_NOW;
1711 oc_ever_mask = SD_OC_EVER;
1714 if (chip->ocp_stat & oc_now_mask)
1717 if (chip->ocp_stat & oc_ever_mask)
1721 if (card == SD_CARD) {
1722 if (CHK_SD(sd_card)) {
1723 if (CHK_SD_HCXC(sd_card)) {
1724 if (sd_card->capacity > 0x4000000)
1725 status[0x0E] = 0x02;
1727 status[0x0E] = 0x01;
1729 status[0x0E] = 0x00;
1732 if (CHK_SD_SDR104(sd_card))
1733 status[0x0F] = 0x03;
1734 else if (CHK_SD_DDR50(sd_card))
1735 status[0x0F] = 0x04;
1736 else if (CHK_SD_SDR50(sd_card))
1737 status[0x0F] = 0x02;
1738 else if (CHK_SD_HS(sd_card))
1739 status[0x0F] = 0x01;
1741 status[0x0F] = 0x00;
1743 if (CHK_MMC_SECTOR_MODE(sd_card))
1744 status[0x0E] = 0x01;
1746 status[0x0E] = 0x00;
1748 if (CHK_MMC_DDR52(sd_card))
1749 status[0x0F] = 0x03;
1750 else if (CHK_MMC_52M(sd_card))
1751 status[0x0F] = 0x02;
1752 else if (CHK_MMC_26M(sd_card))
1753 status[0x0F] = 0x01;
1755 status[0x0F] = 0x00;
1757 } else if (card == MS_CARD) {
1758 if (CHK_MSPRO(ms_card)) {
1759 if (CHK_MSXC(ms_card))
1760 status[0x0E] = 0x01;
1762 status[0x0E] = 0x00;
1764 if (CHK_HG8BIT(ms_card))
1765 status[0x0F] = 0x01;
1767 status[0x0F] = 0x00;
1771 #ifdef SUPPORT_SD_LOCK
1772 if (card == SD_CARD) {
1773 status[0x17] = 0x80;
1774 if (sd_card->sd_erase_status)
1775 status[0x17] |= 0x01;
1776 if (sd_card->sd_lock_status & SD_LOCKED) {
1777 status[0x17] |= 0x02;
1778 status[0x07] |= 0x40;
1780 if (sd_card->sd_lock_status & SD_PWD_EXIST)
1781 status[0x17] |= 0x04;
1783 status[0x17] = 0x00;
1786 dev_dbg(rtsx_dev(chip), "status[0x17] = 0x%x\n", status[0x17]);
1789 status[0x18] = 0x8A;
1790 status[0x1A] = 0x28;
1791 #ifdef SUPPORT_SD_LOCK
1792 status[0x1F] = 0x01;
1795 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(status));
1796 rtsx_stor_set_xfer_buf(status, buf_len, srb);
1797 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1799 return TRANSPORT_GOOD;
1802 static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1808 if (!CHECK_PID(chip, 0x5208)) {
1809 set_sense_type(chip, SCSI_LUN(srb),
1810 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1812 return TRANSPORT_FAILED;
1815 phy_debug_mode = (int)(srb->cmnd[3]);
1817 if (phy_debug_mode) {
1818 chip->phy_debug_mode = 1;
1819 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0);
1820 if (retval != STATUS_SUCCESS) {
1822 return TRANSPORT_FAILED;
1825 rtsx_disable_bus_int(chip);
1827 retval = rtsx_read_phy_register(chip, 0x1C, ®);
1828 if (retval != STATUS_SUCCESS) {
1830 return TRANSPORT_FAILED;
1834 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1835 if (retval != STATUS_SUCCESS) {
1837 return TRANSPORT_FAILED;
1840 chip->phy_debug_mode = 0;
1841 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77);
1842 if (retval != STATUS_SUCCESS) {
1844 return TRANSPORT_FAILED;
1847 rtsx_enable_bus_int(chip);
1849 retval = rtsx_read_phy_register(chip, 0x1C, ®);
1850 if (retval != STATUS_SUCCESS) {
1852 return TRANSPORT_FAILED;
1856 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1857 if (retval != STATUS_SUCCESS) {
1859 return TRANSPORT_FAILED;
1863 return TRANSPORT_GOOD;
1866 static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1868 int retval = STATUS_SUCCESS;
1869 unsigned int lun = SCSI_LUN(srb);
1870 u8 cmd_type, mask, value, idx;
1873 rtsx_disable_aspm(chip);
1875 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1879 rtsx_set_stat(chip, RTSX_STAT_RUN);
1881 switch (srb->cmnd[3]) {
1883 rtsx_init_cmd(chip);
1887 cmd_type = srb->cmnd[4];
1889 set_sense_type(chip, lun,
1890 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1892 return TRANSPORT_FAILED;
1894 addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1895 mask = srb->cmnd[7];
1896 value = srb->cmnd[8];
1897 rtsx_add_cmd(chip, cmd_type, addr, mask, value);
1901 retval = rtsx_send_cmd(chip, 0, 1000);
1906 value = *(rtsx_get_cmd_data(chip) + idx);
1907 if (scsi_bufflen(srb) < 1) {
1908 set_sense_type(chip, lun,
1909 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1911 return TRANSPORT_FAILED;
1913 rtsx_stor_set_xfer_buf(&value, 1, srb);
1914 scsi_set_resid(srb, 0);
1918 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1920 return TRANSPORT_FAILED;
1923 if (retval != STATUS_SUCCESS) {
1924 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1926 return TRANSPORT_FAILED;
1929 return TRANSPORT_GOOD;
1932 static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1934 switch (srb->cmnd[3]) {
1939 return rw_mem_cmd_buf(srb, chip);
1941 return TRANSPORT_ERROR;
1945 static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1947 unsigned short addr, len, i;
1952 rtsx_disable_aspm(chip);
1954 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1958 rtsx_set_stat(chip, RTSX_STAT_RUN);
1960 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1961 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1970 return TRANSPORT_ERROR;
1973 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1974 if (retval != STATUS_SUCCESS) {
1976 set_sense_type(chip, SCSI_LUN(srb),
1977 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1979 return TRANSPORT_FAILED;
1982 for (i = 0; i < len / 2; i++) {
1983 retval = rtsx_read_phy_register(chip, addr + i, &val);
1984 if (retval != STATUS_SUCCESS) {
1986 set_sense_type(chip, SCSI_LUN(srb),
1987 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1989 return TRANSPORT_FAILED;
1992 buf[2*i] = (u8)(val >> 8);
1993 buf[2*i+1] = (u8)val;
1996 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1998 rtsx_stor_set_xfer_buf(buf, len, srb);
1999 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2004 return TRANSPORT_GOOD;
2007 static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2009 unsigned short addr, len, i;
2014 rtsx_disable_aspm(chip);
2016 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2020 rtsx_set_stat(chip, RTSX_STAT_RUN);
2022 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2023 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2029 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
2035 return TRANSPORT_ERROR;
2038 rtsx_stor_get_xfer_buf(buf, len, srb);
2039 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2041 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2042 if (retval != STATUS_SUCCESS) {
2044 set_sense_type(chip, SCSI_LUN(srb),
2045 SENSE_TYPE_MEDIA_WRITE_ERR);
2047 return TRANSPORT_FAILED;
2050 for (i = 0; i < len / 2; i++) {
2051 val = ((u16)buf[2*i] << 8) | buf[2*i+1];
2052 retval = rtsx_write_phy_register(chip, addr + i, val);
2053 if (retval != STATUS_SUCCESS) {
2055 set_sense_type(chip, SCSI_LUN(srb),
2056 SENSE_TYPE_MEDIA_WRITE_ERR);
2058 return TRANSPORT_FAILED;
2065 return TRANSPORT_GOOD;
2068 static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2070 unsigned short addr;
2074 rtsx_disable_aspm(chip);
2076 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2080 rtsx_set_stat(chip, RTSX_STAT_RUN);
2082 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2083 if (retval != STATUS_SUCCESS) {
2084 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2086 return TRANSPORT_FAILED;
2089 mode = srb->cmnd[3];
2090 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2093 retval = spi_erase_eeprom_chip(chip);
2094 if (retval != STATUS_SUCCESS) {
2095 set_sense_type(chip, SCSI_LUN(srb),
2096 SENSE_TYPE_MEDIA_WRITE_ERR);
2098 return TRANSPORT_FAILED;
2100 } else if (mode == 1) {
2101 retval = spi_erase_eeprom_byte(chip, addr);
2102 if (retval != STATUS_SUCCESS) {
2103 set_sense_type(chip, SCSI_LUN(srb),
2104 SENSE_TYPE_MEDIA_WRITE_ERR);
2106 return TRANSPORT_FAILED;
2109 set_sense_type(chip, SCSI_LUN(srb),
2110 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2112 return TRANSPORT_FAILED;
2115 return TRANSPORT_GOOD;
2118 static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2120 unsigned short addr, len, i;
2124 rtsx_disable_aspm(chip);
2126 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2130 rtsx_set_stat(chip, RTSX_STAT_RUN);
2132 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2133 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2138 return TRANSPORT_ERROR;
2141 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2142 if (retval != STATUS_SUCCESS) {
2144 set_sense_type(chip, SCSI_LUN(srb),
2145 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2147 return TRANSPORT_FAILED;
2150 for (i = 0; i < len; i++) {
2151 retval = spi_read_eeprom(chip, addr + i, buf + i);
2152 if (retval != STATUS_SUCCESS) {
2154 set_sense_type(chip, SCSI_LUN(srb),
2155 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2157 return TRANSPORT_FAILED;
2161 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2162 rtsx_stor_set_xfer_buf(buf, len, srb);
2163 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2167 return TRANSPORT_GOOD;
2170 static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2172 unsigned short addr, len, i;
2176 rtsx_disable_aspm(chip);
2178 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2182 rtsx_set_stat(chip, RTSX_STAT_RUN);
2184 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2185 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2187 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2191 return TRANSPORT_ERROR;
2194 rtsx_stor_get_xfer_buf(buf, len, srb);
2195 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2197 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2198 if (retval != STATUS_SUCCESS) {
2200 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2202 return TRANSPORT_FAILED;
2205 for (i = 0; i < len; i++) {
2206 retval = spi_write_eeprom(chip, addr + i, buf[i]);
2207 if (retval != STATUS_SUCCESS) {
2209 set_sense_type(chip, SCSI_LUN(srb),
2210 SENSE_TYPE_MEDIA_WRITE_ERR);
2212 return TRANSPORT_FAILED;
2218 return TRANSPORT_GOOD;
2221 static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2227 rtsx_disable_aspm(chip);
2229 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2233 rtsx_set_stat(chip, RTSX_STAT_RUN);
2235 addr = srb->cmnd[4];
2241 return TRANSPORT_ERROR;
2244 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2245 if (retval != STATUS_SUCCESS) {
2247 set_sense_type(chip, SCSI_LUN(srb),
2248 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2250 return TRANSPORT_FAILED;
2253 for (i = 0; i < len; i++) {
2254 retval = rtsx_read_efuse(chip, addr + i, buf + i);
2255 if (retval != STATUS_SUCCESS) {
2257 set_sense_type(chip, SCSI_LUN(srb),
2258 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2260 return TRANSPORT_FAILED;
2264 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2265 rtsx_stor_set_xfer_buf(buf, len, srb);
2266 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2270 return TRANSPORT_GOOD;
2273 static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2275 int retval, result = TRANSPORT_GOOD;
2280 rtsx_disable_aspm(chip);
2282 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2286 rtsx_set_stat(chip, RTSX_STAT_RUN);
2288 addr = srb->cmnd[4];
2291 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2295 return TRANSPORT_ERROR;
2298 rtsx_stor_get_xfer_buf(buf, len, srb);
2299 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2301 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2302 if (retval != STATUS_SUCCESS) {
2305 return TRANSPORT_ERROR;
2308 if (chip->asic_code) {
2309 retval = rtsx_read_phy_register(chip, 0x08, &val);
2310 if (retval != STATUS_SUCCESS) {
2313 return TRANSPORT_ERROR;
2316 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2317 LDO3318_PWR_MASK, LDO_OFF);
2318 if (retval != STATUS_SUCCESS) {
2321 return TRANSPORT_ERROR;
2326 retval = rtsx_write_phy_register(chip, 0x08,
2327 0x4C00 | chip->phy_voltage);
2328 if (retval != STATUS_SUCCESS) {
2331 return TRANSPORT_ERROR;
2334 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2335 LDO3318_PWR_MASK, LDO_ON);
2336 if (retval != STATUS_SUCCESS) {
2339 return TRANSPORT_ERROR;
2345 retval = card_power_on(chip, SPI_CARD);
2346 if (retval != STATUS_SUCCESS) {
2349 return TRANSPORT_ERROR;
2354 for (i = 0; i < len; i++) {
2355 retval = rtsx_write_efuse(chip, addr + i, buf[i]);
2356 if (retval != STATUS_SUCCESS) {
2357 set_sense_type(chip, SCSI_LUN(srb),
2358 SENSE_TYPE_MEDIA_WRITE_ERR);
2359 result = TRANSPORT_FAILED;
2368 retval = card_power_off(chip, SPI_CARD);
2369 if (retval != STATUS_SUCCESS) {
2371 return TRANSPORT_ERROR;
2374 if (chip->asic_code) {
2375 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2376 LDO3318_PWR_MASK, LDO_OFF);
2377 if (retval != STATUS_SUCCESS) {
2379 return TRANSPORT_ERROR;
2384 retval = rtsx_write_phy_register(chip, 0x08, val);
2385 if (retval != STATUS_SUCCESS) {
2387 return TRANSPORT_ERROR;
2390 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2391 LDO3318_PWR_MASK, LDO_ON);
2392 if (retval != STATUS_SUCCESS) {
2394 return TRANSPORT_ERROR;
2401 static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2409 rtsx_disable_aspm(chip);
2411 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2415 rtsx_set_stat(chip, RTSX_STAT_RUN);
2417 func = srb->cmnd[3];
2418 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2419 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2421 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x, len = %d\n",
2422 __func__, func, addr, len);
2424 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2429 if (func > func_max) {
2430 set_sense_type(chip, SCSI_LUN(srb),
2431 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2433 return TRANSPORT_FAILED;
2439 return TRANSPORT_ERROR;
2442 retval = rtsx_read_cfg_seq(chip, func, addr, buf, len);
2443 if (retval != STATUS_SUCCESS) {
2444 set_sense_type(chip, SCSI_LUN(srb),
2445 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2448 return TRANSPORT_FAILED;
2451 len = (u16)min_t(unsigned int, scsi_bufflen(srb), len);
2452 rtsx_stor_set_xfer_buf(buf, len, srb);
2453 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2457 return TRANSPORT_GOOD;
2460 static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2468 rtsx_disable_aspm(chip);
2470 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2474 rtsx_set_stat(chip, RTSX_STAT_RUN);
2476 func = srb->cmnd[3];
2477 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2478 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2480 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x\n",
2481 __func__, func, addr);
2483 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2488 if (func > func_max) {
2489 set_sense_type(chip, SCSI_LUN(srb),
2490 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2492 return TRANSPORT_FAILED;
2495 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2499 return TRANSPORT_ERROR;
2502 rtsx_stor_get_xfer_buf(buf, len, srb);
2503 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2505 retval = rtsx_write_cfg_seq(chip, func, addr, buf, len);
2506 if (retval != STATUS_SUCCESS) {
2507 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2510 return TRANSPORT_FAILED;
2515 return TRANSPORT_GOOD;
2518 static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2522 switch (srb->cmnd[2]) {
2525 result = read_write(srb, chip);
2529 result = read_host_reg(srb, chip);
2532 case WRITE_HOST_REG:
2533 result = write_host_reg(srb, chip);
2537 result = get_variable(srb, chip);
2541 result = set_variable(srb, chip);
2546 result = dma_access_ring_buffer(srb, chip);
2550 result = read_phy_register(srb, chip);
2554 result = write_phy_register(srb, chip);
2558 result = erase_eeprom2(srb, chip);
2562 result = read_eeprom2(srb, chip);
2566 result = write_eeprom2(srb, chip);
2570 result = read_efuse(srb, chip);
2574 result = write_efuse(srb, chip);
2578 result = read_cfg_byte(srb, chip);
2582 result = write_cfg_byte(srb, chip);
2586 result = set_chip_mode(srb, chip);
2590 result = suit_cmd(srb, chip);
2593 case GET_DEV_STATUS:
2594 result = get_dev_status(srb, chip);
2598 set_sense_type(chip, SCSI_LUN(srb),
2599 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2601 return TRANSPORT_FAILED;
2608 static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2612 unsigned int lun = SCSI_LUN(srb);
2614 rtsx_status[0] = (u8)(chip->vendor_id >> 8);
2615 rtsx_status[1] = (u8)(chip->vendor_id);
2617 rtsx_status[2] = (u8)(chip->product_id >> 8);
2618 rtsx_status[3] = (u8)(chip->product_id);
2620 rtsx_status[4] = (u8)lun;
2622 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2623 if (chip->lun2card[lun] == SD_CARD)
2628 if (chip->card_exist) {
2629 if (chip->card_exist & XD_CARD)
2631 else if (chip->card_exist & SD_CARD)
2633 else if (chip->card_exist & MS_CARD)
2642 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2647 rtsx_status[7] = (u8)(chip->product_id);
2648 rtsx_status[8] = chip->ic_version;
2650 if (check_card_exist(chip, lun))
2655 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2656 rtsx_status[10] = 0;
2658 rtsx_status[10] = 1;
2660 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2661 if (chip->lun2card[lun] == SD_CARD)
2662 rtsx_status[11] = SD_CARD;
2664 rtsx_status[11] = MS_CARD;
2666 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD;
2669 if (check_card_ready(chip, lun))
2670 rtsx_status[12] = 1;
2672 rtsx_status[12] = 0;
2674 if (get_lun_card(chip, lun) == XD_CARD) {
2675 rtsx_status[13] = 0x40;
2676 } else if (get_lun_card(chip, lun) == SD_CARD) {
2677 struct sd_info *sd_card = &(chip->sd_card);
2679 rtsx_status[13] = 0x20;
2680 if (CHK_SD(sd_card)) {
2681 if (CHK_SD_HCXC(sd_card))
2682 rtsx_status[13] |= 0x04;
2683 if (CHK_SD_HS(sd_card))
2684 rtsx_status[13] |= 0x02;
2686 rtsx_status[13] |= 0x08;
2687 if (CHK_MMC_52M(sd_card))
2688 rtsx_status[13] |= 0x02;
2689 if (CHK_MMC_SECTOR_MODE(sd_card))
2690 rtsx_status[13] |= 0x04;
2692 } else if (get_lun_card(chip, lun) == MS_CARD) {
2693 struct ms_info *ms_card = &(chip->ms_card);
2695 if (CHK_MSPRO(ms_card)) {
2696 rtsx_status[13] = 0x38;
2697 if (CHK_HG8BIT(ms_card))
2698 rtsx_status[13] |= 0x04;
2700 if (CHK_MSXC(ms_card))
2701 rtsx_status[13] |= 0x01;
2704 rtsx_status[13] = 0x30;
2707 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) {
2709 if (chip->sd_io && chip->sd_int)
2710 rtsx_status[13] = 0x60;
2712 rtsx_status[13] = 0x70;
2714 rtsx_status[13] = 0x70;
2717 if (chip->lun2card[lun] == SD_CARD)
2718 rtsx_status[13] = 0x20;
2720 rtsx_status[13] = 0x30;
2724 rtsx_status[14] = 0x78;
2725 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2726 rtsx_status[15] = 0x83;
2728 rtsx_status[15] = 0x82;
2730 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(rtsx_status));
2731 rtsx_stor_set_xfer_buf(rtsx_status, buf_len, srb);
2732 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
2734 return TRANSPORT_GOOD;
2737 static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2739 unsigned int lun = SCSI_LUN(srb);
2742 if (!check_card_ready(chip, lun)) {
2743 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2745 return TRANSPORT_FAILED;
2748 card = get_lun_card(chip, lun);
2749 if ((card == SD_CARD) || (card == MS_CARD)) {
2750 bus_width = chip->card_bus_width[lun];
2752 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2754 return TRANSPORT_FAILED;
2757 scsi_set_resid(srb, 0);
2758 rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
2760 return TRANSPORT_GOOD;
2763 static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2766 unsigned int lun = SCSI_LUN(srb);
2769 if (CHECK_PID(chip, 0x5208) || CHECK_PID(chip, 0x5288)) {
2770 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2772 return TRANSPORT_FAILED;
2775 rtsx_disable_aspm(chip);
2777 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2781 rtsx_set_stat(chip, RTSX_STAT_RUN);
2783 rtsx_force_power_on(chip, SSC_PDCTL);
2785 rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir);
2786 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06);
2788 switch (srb->cmnd[2]) {
2789 case SCSI_SPI_GETSTATUS:
2790 result = spi_get_status(srb, chip);
2793 case SCSI_SPI_SETPARAMETER:
2794 result = spi_set_parameter(srb, chip);
2797 case SCSI_SPI_READFALSHID:
2798 result = spi_read_flash_id(srb, chip);
2801 case SCSI_SPI_READFLASH:
2802 result = spi_read_flash(srb, chip);
2805 case SCSI_SPI_WRITEFLASH:
2806 result = spi_write_flash(srb, chip);
2809 case SCSI_SPI_WRITEFLASHSTATUS:
2810 result = spi_write_flash_status(srb, chip);
2813 case SCSI_SPI_ERASEFLASH:
2814 result = spi_erase_flash(srb, chip);
2818 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2820 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2822 return TRANSPORT_FAILED;
2825 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2827 if (result != STATUS_SUCCESS) {
2829 return TRANSPORT_FAILED;
2832 return TRANSPORT_GOOD;
2835 static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2839 switch (srb->cmnd[1]) {
2841 result = read_status(srb, chip);
2845 result = read_mem(srb, chip);
2849 result = write_mem(srb, chip);
2853 result = read_eeprom(srb, chip);
2857 result = write_eeprom(srb, chip);
2861 result = toggle_gpio_cmd(srb, chip);
2865 result = get_sd_csd(srb, chip);
2869 result = get_card_bus_width(srb, chip);
2874 result = trace_msg_cmd(srb, chip);
2879 result = app_cmd(srb, chip);
2882 case SPI_VENDOR_COMMAND:
2883 result = spi_vendor_cmd(srb, chip);
2887 set_sense_type(chip, SCSI_LUN(srb),
2888 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2890 return TRANSPORT_FAILED;
2896 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
2897 void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2899 unsigned int lun = SCSI_LUN(srb);
2902 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10))
2903 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
2904 else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
2905 sec_cnt = srb->cmnd[4];
2911 if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) {
2912 toggle_gpio(chip, LED_GPIO);
2913 chip->rw_cap[lun] = 0;
2915 chip->rw_cap[lun] += sec_cnt;
2920 static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2922 struct ms_info *ms_card = &(chip->ms_card);
2923 unsigned int lun = SCSI_LUN(srb);
2927 if (get_lun_card(chip, lun) != MS_CARD) {
2928 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2930 return TRANSPORT_FAILED;
2933 if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47) ||
2934 (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D) ||
2935 (srb->cmnd[7] != 0x74)) {
2936 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2938 return TRANSPORT_FAILED;
2941 rtsx_disable_aspm(chip);
2943 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2947 if (!check_card_ready(chip, lun) ||
2948 (get_card_size(chip, lun) == 0)) {
2949 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2951 return TRANSPORT_FAILED;
2954 rtsx_set_stat(chip, RTSX_STAT_RUN);
2956 if (srb->cmnd[8] & 0x01)
2957 quick_format = false;
2959 quick_format = true;
2961 if (!(chip->card_ready & MS_CARD)) {
2962 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2964 return TRANSPORT_FAILED;
2967 if (chip->card_wp & MS_CARD) {
2968 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2970 return TRANSPORT_FAILED;
2973 if (!CHK_MSPRO(ms_card)) {
2974 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2976 return TRANSPORT_FAILED;
2979 retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
2980 if (retval != STATUS_SUCCESS) {
2981 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
2983 return TRANSPORT_FAILED;
2986 scsi_set_resid(srb, 0);
2987 return TRANSPORT_GOOD;
2990 #ifdef SUPPORT_PCGL_1P18
2991 static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2993 struct ms_info *ms_card = &(chip->ms_card);
2994 unsigned int lun = SCSI_LUN(srb);
2995 u8 dev_info_id, data_len;
2997 unsigned int buf_len;
3000 if (!check_card_ready(chip, lun)) {
3001 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3003 return TRANSPORT_FAILED;
3005 if (get_lun_card(chip, lun) != MS_CARD) {
3006 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3008 return TRANSPORT_FAILED;
3011 if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) ||
3012 (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) ||
3013 (srb->cmnd[7] != 0x44)) {
3014 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3016 return TRANSPORT_FAILED;
3019 dev_info_id = srb->cmnd[3];
3020 if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) ||
3021 (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) ||
3022 !CHK_MSPRO(ms_card)) {
3023 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3025 return TRANSPORT_FAILED;
3028 if (dev_info_id == 0x15)
3029 buf_len = data_len = 0x3A;
3031 buf_len = data_len = 0x6A;
3033 buf = kmalloc(buf_len, GFP_KERNEL);
3036 return TRANSPORT_ERROR;
3040 /* GET Memory Stick Media Information Response Header */
3041 buf[i++] = 0x00; /* Data length MSB */
3042 buf[i++] = data_len; /* Data length LSB */
3043 /* Device Information Type Code */
3044 if (CHK_MSXC(ms_card))
3055 /* Number of Device Information */
3058 /* Device Information Body */
3060 /* Device Information ID Number */
3061 buf[i++] = dev_info_id;
3062 /* Device Information Length */
3063 if (dev_info_id == 0x15)
3068 buf[i++] = 0x00; /* Data length MSB */
3069 buf[i++] = data_len; /* Data length LSB */
3072 if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
3073 /* System Information */
3074 memcpy(buf+i, ms_card->raw_sys_info, 96);
3077 memcpy(buf+i, ms_card->raw_model_name, 48);
3080 rtsx_stor_set_xfer_buf(buf, buf_len, srb);
3082 if (dev_info_id == 0x15)
3083 scsi_set_resid(srb, scsi_bufflen(srb)-0x3C);
3085 scsi_set_resid(srb, scsi_bufflen(srb)-0x6C);
3088 return STATUS_SUCCESS;
3092 static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3094 int retval = TRANSPORT_ERROR;
3096 if (srb->cmnd[2] == MS_FORMAT)
3097 retval = ms_format_cmnd(srb, chip);
3098 #ifdef SUPPORT_PCGL_1P18
3099 else if (srb->cmnd[2] == GET_MS_INFORMATION)
3100 retval = get_ms_information(srb, chip);
3107 static int sd_extention_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3109 unsigned int lun = SCSI_LUN(srb);
3112 rtsx_disable_aspm(chip);
3114 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3118 rtsx_set_stat(chip, RTSX_STAT_RUN);
3120 sd_cleanup_work(chip);
3122 if (!check_card_ready(chip, lun)) {
3123 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3125 return TRANSPORT_FAILED;
3127 if (get_lun_card(chip, lun) != SD_CARD) {
3128 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3130 return TRANSPORT_FAILED;
3133 switch (srb->cmnd[0]) {
3134 case SD_PASS_THRU_MODE:
3135 result = sd_pass_thru_mode(srb, chip);
3138 case SD_EXECUTE_NO_DATA:
3139 result = sd_execute_no_data(srb, chip);
3142 case SD_EXECUTE_READ:
3143 result = sd_execute_read_data(srb, chip);
3146 case SD_EXECUTE_WRITE:
3147 result = sd_execute_write_data(srb, chip);
3151 result = sd_get_cmd_rsp(srb, chip);
3155 result = sd_hw_rst(srb, chip);
3159 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3161 return TRANSPORT_FAILED;
3168 #ifdef SUPPORT_MAGIC_GATE
3169 static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3171 struct ms_info *ms_card = &(chip->ms_card);
3172 unsigned int lun = SCSI_LUN(srb);
3176 rtsx_disable_aspm(chip);
3178 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3182 rtsx_set_stat(chip, RTSX_STAT_RUN);
3184 ms_cleanup_work(chip);
3186 if (!check_card_ready(chip, lun)) {
3187 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3189 return TRANSPORT_FAILED;
3191 if (get_lun_card(chip, lun) != MS_CARD) {
3192 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3194 return TRANSPORT_FAILED;
3197 if (srb->cmnd[7] != KC_MG_R_PRO) {
3198 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3200 return TRANSPORT_FAILED;
3203 if (!CHK_MSPRO(ms_card)) {
3204 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3206 return TRANSPORT_FAILED;
3209 key_format = srb->cmnd[10] & 0x3F;
3210 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3212 switch (key_format) {
3213 case KF_GET_LOC_EKB:
3214 if ((scsi_bufflen(srb) == 0x41C) &&
3215 (srb->cmnd[8] == 0x04) &&
3216 (srb->cmnd[9] == 0x1C)) {
3217 retval = mg_get_local_EKB(srb, chip);
3218 if (retval != STATUS_SUCCESS) {
3220 return TRANSPORT_FAILED;
3224 set_sense_type(chip, lun,
3225 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3227 return TRANSPORT_FAILED;
3232 if ((scsi_bufflen(srb) == 0x24) &&
3233 (srb->cmnd[8] == 0x00) &&
3234 (srb->cmnd[9] == 0x24)) {
3235 retval = mg_get_rsp_chg(srb, chip);
3236 if (retval != STATUS_SUCCESS) {
3238 return TRANSPORT_FAILED;
3242 set_sense_type(chip, lun,
3243 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3245 return TRANSPORT_FAILED;
3250 ms_card->mg_entry_num = srb->cmnd[5];
3251 if ((scsi_bufflen(srb) == 0x404) &&
3252 (srb->cmnd[8] == 0x04) &&
3253 (srb->cmnd[9] == 0x04) &&
3254 (srb->cmnd[2] == 0x00) &&
3255 (srb->cmnd[3] == 0x00) &&
3256 (srb->cmnd[4] == 0x00) &&
3257 (srb->cmnd[5] < 32)) {
3258 retval = mg_get_ICV(srb, chip);
3259 if (retval != STATUS_SUCCESS) {
3261 return TRANSPORT_FAILED;
3265 set_sense_type(chip, lun,
3266 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3268 return TRANSPORT_FAILED;
3273 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3275 return TRANSPORT_FAILED;
3278 scsi_set_resid(srb, 0);
3279 return TRANSPORT_GOOD;
3282 static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3284 struct ms_info *ms_card = &(chip->ms_card);
3285 unsigned int lun = SCSI_LUN(srb);
3289 rtsx_disable_aspm(chip);
3291 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3295 rtsx_set_stat(chip, RTSX_STAT_RUN);
3297 ms_cleanup_work(chip);
3299 if (!check_card_ready(chip, lun)) {
3300 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3302 return TRANSPORT_FAILED;
3304 if (check_card_wp(chip, lun)) {
3305 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
3307 return TRANSPORT_FAILED;
3309 if (get_lun_card(chip, lun) != MS_CARD) {
3310 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3312 return TRANSPORT_FAILED;
3315 if (srb->cmnd[7] != KC_MG_R_PRO) {
3316 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3318 return TRANSPORT_FAILED;
3321 if (!CHK_MSPRO(ms_card)) {
3322 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3324 return TRANSPORT_FAILED;
3327 key_format = srb->cmnd[10] & 0x3F;
3328 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3330 switch (key_format) {
3331 case KF_SET_LEAF_ID:
3332 if ((scsi_bufflen(srb) == 0x0C) &&
3333 (srb->cmnd[8] == 0x00) &&
3334 (srb->cmnd[9] == 0x0C)) {
3335 retval = mg_set_leaf_id(srb, chip);
3336 if (retval != STATUS_SUCCESS) {
3338 return TRANSPORT_FAILED;
3342 set_sense_type(chip, lun,
3343 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3345 return TRANSPORT_FAILED;
3350 if ((scsi_bufflen(srb) == 0x0C) &&
3351 (srb->cmnd[8] == 0x00) &&
3352 (srb->cmnd[9] == 0x0C)) {
3353 retval = mg_chg(srb, chip);
3354 if (retval != STATUS_SUCCESS) {
3356 return TRANSPORT_FAILED;
3360 set_sense_type(chip, lun,
3361 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3363 return TRANSPORT_FAILED;
3368 if ((scsi_bufflen(srb) == 0x0C) &&
3369 (srb->cmnd[8] == 0x00) &&
3370 (srb->cmnd[9] == 0x0C)) {
3371 retval = mg_rsp(srb, chip);
3372 if (retval != STATUS_SUCCESS) {
3374 return TRANSPORT_FAILED;
3378 set_sense_type(chip, lun,
3379 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3381 return TRANSPORT_FAILED;
3386 ms_card->mg_entry_num = srb->cmnd[5];
3387 if ((scsi_bufflen(srb) == 0x404) &&
3388 (srb->cmnd[8] == 0x04) &&
3389 (srb->cmnd[9] == 0x04) &&
3390 (srb->cmnd[2] == 0x00) &&
3391 (srb->cmnd[3] == 0x00) &&
3392 (srb->cmnd[4] == 0x00) &&
3393 (srb->cmnd[5] < 32)) {
3394 retval = mg_set_ICV(srb, chip);
3395 if (retval != STATUS_SUCCESS) {
3397 return TRANSPORT_FAILED;
3401 set_sense_type(chip, lun,
3402 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3404 return TRANSPORT_FAILED;
3409 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3411 return TRANSPORT_FAILED;
3414 scsi_set_resid(srb, 0);
3415 return TRANSPORT_GOOD;
3419 int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3421 #ifdef SUPPORT_SD_LOCK
3422 struct sd_info *sd_card = &(chip->sd_card);
3424 struct ms_info *ms_card = &(chip->ms_card);
3425 unsigned int lun = SCSI_LUN(srb);
3428 #ifdef SUPPORT_SD_LOCK
3429 if (sd_card->sd_erase_status) {
3430 /* Block all SCSI command except for
3431 * REQUEST_SENSE and rs_ppstatus
3433 if (!((srb->cmnd[0] == VENDOR_CMND) &&
3434 (srb->cmnd[1] == SCSI_APP_CMD) &&
3435 (srb->cmnd[2] == GET_DEV_STATUS)) &&
3436 (srb->cmnd[0] != REQUEST_SENSE)) {
3437 /* Logical Unit Not Ready Format in Progress */
3438 set_sense_data(chip, lun, CUR_ERR,
3439 0x02, 0, 0x04, 0x04, 0, 0);
3441 return TRANSPORT_FAILED;
3446 if ((get_lun_card(chip, lun) == MS_CARD) &&
3447 (ms_card->format_status == FORMAT_IN_PROGRESS)) {
3448 if ((srb->cmnd[0] != REQUEST_SENSE) &&
3449 (srb->cmnd[0] != INQUIRY)) {
3450 /* Logical Unit Not Ready Format in Progress */
3451 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
3452 0, (u16)(ms_card->progress));
3454 return TRANSPORT_FAILED;
3458 switch (srb->cmnd[0]) {
3463 result = read_write(srb, chip);
3464 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
3465 led_shine(srb, chip);
3469 case TEST_UNIT_READY:
3470 result = test_unit_ready(srb, chip);
3474 result = inquiry(srb, chip);
3478 result = read_capacity(srb, chip);
3482 result = start_stop_unit(srb, chip);
3485 case ALLOW_MEDIUM_REMOVAL:
3486 result = allow_medium_removal(srb, chip);
3490 result = request_sense(srb, chip);
3495 result = mode_sense(srb, chip);
3499 result = read_format_capacity(srb, chip);
3503 result = vendor_cmnd(srb, chip);
3507 result = ms_sp_cmnd(srb, chip);
3511 case SD_PASS_THRU_MODE:
3512 case SD_EXECUTE_NO_DATA:
3513 case SD_EXECUTE_READ:
3514 case SD_EXECUTE_WRITE:
3517 result = sd_extention_cmnd(srb, chip);
3521 #ifdef SUPPORT_MAGIC_GATE
3522 case CMD_MSPRO_MG_RKEY:
3523 result = mg_report_key(srb, chip);
3526 case CMD_MSPRO_MG_SKEY:
3527 result = mg_send_key(srb, chip);
3534 result = TRANSPORT_GOOD;
3538 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3539 result = TRANSPORT_FAILED;