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];
918 } else if ((srb->cmnd[0] == VENDOR_CMND) &&
919 (srb->cmnd[1] == SCSI_APP_CMD) &&
920 ((srb->cmnd[2] == PP_READ10) || (srb->cmnd[2] == PP_WRITE10))) {
921 start_sec = ((u32)srb->cmnd[4] << 24) |
922 ((u32)srb->cmnd[5] << 16) |
923 ((u32)srb->cmnd[6] << 8) | ((u32)srb->cmnd[7]);
924 sec_cnt = ((u16)(srb->cmnd[9]) << 8) | srb->cmnd[10];
926 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
928 return TRANSPORT_FAILED;
931 /* In some test, we will receive a start_sec like 0xFFFFFFFF.
932 * In this situation, start_sec + sec_cnt will overflow, so we
933 * need to judge start_sec at first
935 if ((start_sec > get_card_size(chip, lun)) ||
936 ((start_sec + sec_cnt) > get_card_size(chip, lun))) {
937 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE);
939 return TRANSPORT_FAILED;
943 scsi_set_resid(srb, 0);
944 return TRANSPORT_GOOD;
947 if (chip->rw_fail_cnt[lun] == 3) {
948 dev_dbg(rtsx_dev(chip), "read/write fail three times in succession\n");
949 if (srb->sc_data_direction == DMA_FROM_DEVICE)
950 set_sense_type(chip, lun,
951 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
953 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
956 return TRANSPORT_FAILED;
959 if (srb->sc_data_direction == DMA_TO_DEVICE) {
960 if (check_card_wp(chip, lun)) {
961 dev_dbg(rtsx_dev(chip), "Write protected card!\n");
962 set_sense_type(chip, lun,
963 SENSE_TYPE_MEDIA_WRITE_PROTECT);
965 return TRANSPORT_FAILED;
969 retval = card_rw(srb, chip, start_sec, sec_cnt);
970 if (retval != STATUS_SUCCESS) {
971 if (chip->need_release & chip->lun2card[lun]) {
972 chip->rw_fail_cnt[lun] = 0;
973 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
975 chip->rw_fail_cnt[lun]++;
976 if (srb->sc_data_direction == DMA_FROM_DEVICE)
977 set_sense_type(chip, lun,
978 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
980 set_sense_type(chip, lun,
981 SENSE_TYPE_MEDIA_WRITE_ERR);
983 retval = TRANSPORT_FAILED;
987 chip->rw_fail_cnt[lun] = 0;
988 retval = TRANSPORT_GOOD;
991 scsi_set_resid(srb, 0);
997 static int read_format_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1000 unsigned int lun = SCSI_LUN(srb);
1001 unsigned int buf_len;
1002 u8 card = get_lun_card(chip, lun);
1007 if (!check_card_ready(chip, lun)) {
1008 if (!chip->mspro_formatter_enable) {
1009 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1011 return TRANSPORT_FAILED;
1015 buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12;
1017 buf = kmalloc(buf_len, GFP_KERNEL);
1020 return TRANSPORT_ERROR;
1027 /* Capacity List Length */
1028 if ((buf_len > 12) && chip->mspro_formatter_enable &&
1029 (chip->lun2card[lun] & MS_CARD) &&
1030 (!card || (card == MS_CARD))) {
1039 if (check_card_ready(chip, lun)) {
1040 card_size = get_card_size(chip, lun);
1041 buf[i++] = (unsigned char)(card_size >> 24);
1042 buf[i++] = (unsigned char)(card_size >> 16);
1043 buf[i++] = (unsigned char)(card_size >> 8);
1044 buf[i++] = (unsigned char)card_size;
1069 buf_len = min_t(unsigned int, scsi_bufflen(srb), buf_len);
1070 rtsx_stor_set_xfer_buf(buf, buf_len, srb);
1073 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1075 return TRANSPORT_GOOD;
1078 static int read_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1081 unsigned int lun = SCSI_LUN(srb);
1084 if (!check_card_ready(chip, lun)) {
1085 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1087 return TRANSPORT_FAILED;
1090 if (!(CHK_BIT(chip->lun_mc, lun))) {
1091 SET_BIT(chip->lun_mc, lun);
1092 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
1093 return TRANSPORT_FAILED;
1096 buf = kmalloc(8, GFP_KERNEL);
1099 return TRANSPORT_ERROR;
1102 card_size = get_card_size(chip, lun);
1103 buf[0] = (unsigned char)((card_size - 1) >> 24);
1104 buf[1] = (unsigned char)((card_size - 1) >> 16);
1105 buf[2] = (unsigned char)((card_size - 1) >> 8);
1106 buf[3] = (unsigned char)(card_size - 1);
1113 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1116 scsi_set_resid(srb, 0);
1118 return TRANSPORT_GOOD;
1121 static int read_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1123 unsigned short len, i;
1127 rtsx_disable_aspm(chip);
1129 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1133 rtsx_set_stat(chip, RTSX_STAT_RUN);
1135 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1140 return TRANSPORT_ERROR;
1143 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1144 if (retval != STATUS_SUCCESS) {
1146 set_sense_type(chip, SCSI_LUN(srb),
1147 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1149 return TRANSPORT_FAILED;
1152 for (i = 0; i < len; i++) {
1153 retval = spi_read_eeprom(chip, i, buf + i);
1154 if (retval != STATUS_SUCCESS) {
1156 set_sense_type(chip, SCSI_LUN(srb),
1157 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1159 return TRANSPORT_FAILED;
1163 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1164 rtsx_stor_set_xfer_buf(buf, len, srb);
1165 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1169 return TRANSPORT_GOOD;
1172 static int write_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1174 unsigned short len, i;
1178 rtsx_disable_aspm(chip);
1180 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1184 rtsx_set_stat(chip, RTSX_STAT_RUN);
1186 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1188 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1189 if (retval != STATUS_SUCCESS) {
1190 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1192 return TRANSPORT_FAILED;
1196 retval = spi_erase_eeprom_chip(chip);
1197 if (retval != STATUS_SUCCESS) {
1198 set_sense_type(chip, SCSI_LUN(srb),
1199 SENSE_TYPE_MEDIA_WRITE_ERR);
1201 return TRANSPORT_FAILED;
1204 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1209 return TRANSPORT_ERROR;
1212 rtsx_stor_get_xfer_buf(buf, len, srb);
1213 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1215 for (i = 0; i < len; i++) {
1216 retval = spi_write_eeprom(chip, i, buf[i]);
1217 if (retval != STATUS_SUCCESS) {
1219 set_sense_type(chip, SCSI_LUN(srb),
1220 SENSE_TYPE_MEDIA_WRITE_ERR);
1222 return TRANSPORT_FAILED;
1229 return TRANSPORT_GOOD;
1232 static int read_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1234 unsigned short addr, len, i;
1238 rtsx_disable_aspm(chip);
1240 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1244 rtsx_set_stat(chip, RTSX_STAT_RUN);
1246 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1247 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1249 if (addr < 0xFC00) {
1250 set_sense_type(chip, SCSI_LUN(srb),
1251 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1253 return TRANSPORT_FAILED;
1259 return TRANSPORT_ERROR;
1262 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1263 if (retval != STATUS_SUCCESS) {
1265 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1267 return TRANSPORT_FAILED;
1270 for (i = 0; i < len; i++) {
1271 retval = rtsx_read_register(chip, addr + i, buf + i);
1272 if (retval != STATUS_SUCCESS) {
1274 set_sense_type(chip, SCSI_LUN(srb),
1275 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1277 return TRANSPORT_FAILED;
1281 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1282 rtsx_stor_set_xfer_buf(buf, len, srb);
1283 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1287 return TRANSPORT_GOOD;
1290 static int write_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1292 unsigned short addr, len, i;
1296 rtsx_disable_aspm(chip);
1298 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1302 rtsx_set_stat(chip, RTSX_STAT_RUN);
1304 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1305 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1307 if (addr < 0xFC00) {
1308 set_sense_type(chip, SCSI_LUN(srb),
1309 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1311 return TRANSPORT_FAILED;
1314 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1318 return TRANSPORT_ERROR;
1321 rtsx_stor_get_xfer_buf(buf, len, srb);
1322 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1324 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1325 if (retval != STATUS_SUCCESS) {
1327 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1329 return TRANSPORT_FAILED;
1332 for (i = 0; i < len; i++) {
1333 retval = rtsx_write_register(chip, addr + i, 0xFF, buf[i]);
1334 if (retval != STATUS_SUCCESS) {
1336 set_sense_type(chip, SCSI_LUN(srb),
1337 SENSE_TYPE_MEDIA_WRITE_ERR);
1339 return TRANSPORT_FAILED;
1345 return TRANSPORT_GOOD;
1348 static int get_sd_csd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1350 struct sd_info *sd_card = &(chip->sd_card);
1351 unsigned int lun = SCSI_LUN(srb);
1353 if (!check_card_ready(chip, lun)) {
1354 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1356 return TRANSPORT_FAILED;
1359 if (get_lun_card(chip, lun) != SD_CARD) {
1360 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1362 return TRANSPORT_FAILED;
1365 scsi_set_resid(srb, 0);
1366 rtsx_stor_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb);
1368 return TRANSPORT_GOOD;
1371 static int toggle_gpio_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1373 u8 gpio = srb->cmnd[2];
1375 rtsx_disable_aspm(chip);
1377 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1381 rtsx_set_stat(chip, RTSX_STAT_RUN);
1385 toggle_gpio(chip, gpio);
1387 return TRANSPORT_GOOD;
1391 static int trace_msg_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1393 unsigned char *ptr, *buf = NULL;
1396 unsigned int buf_len;
1398 buf_len = 4 + ((2 + MSG_FUNC_LEN + MSG_FILE_LEN + TIME_VAL_LEN) *
1401 if ((scsi_bufflen(srb) < buf_len) || (scsi_sglist(srb) == NULL)) {
1402 set_sense_type(chip, SCSI_LUN(srb),
1403 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1405 return TRANSPORT_FAILED;
1408 clear = srb->cmnd[2];
1410 buf = vmalloc(scsi_bufflen(srb));
1413 return TRANSPORT_ERROR;
1417 if (chip->trace_msg[chip->msg_idx].valid)
1418 msg_cnt = TRACE_ITEM_CNT;
1420 msg_cnt = chip->msg_idx;
1422 *(ptr++) = (u8)(msg_cnt >> 24);
1423 *(ptr++) = (u8)(msg_cnt >> 16);
1424 *(ptr++) = (u8)(msg_cnt >> 8);
1425 *(ptr++) = (u8)msg_cnt;
1426 dev_dbg(rtsx_dev(chip), "Trace message count is %d\n", msg_cnt);
1428 for (i = 1; i <= msg_cnt; i++) {
1431 idx = chip->msg_idx - i;
1433 idx += TRACE_ITEM_CNT;
1435 *(ptr++) = (u8)(chip->trace_msg[idx].line >> 8);
1436 *(ptr++) = (u8)(chip->trace_msg[idx].line);
1437 for (j = 0; j < MSG_FUNC_LEN; j++)
1438 *(ptr++) = chip->trace_msg[idx].func[j];
1440 for (j = 0; j < MSG_FILE_LEN; j++)
1441 *(ptr++) = chip->trace_msg[idx].file[j];
1443 for (j = 0; j < TIME_VAL_LEN; j++)
1444 *(ptr++) = chip->trace_msg[idx].timeval_buf[j];
1447 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1452 for (i = 0; i < TRACE_ITEM_CNT; i++)
1453 chip->trace_msg[i].valid = 0;
1456 scsi_set_resid(srb, 0);
1457 return TRANSPORT_GOOD;
1461 static int read_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1467 rtsx_disable_aspm(chip);
1469 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1473 rtsx_set_stat(chip, RTSX_STAT_RUN);
1475 addr = srb->cmnd[4];
1477 val = rtsx_readl(chip, addr);
1478 dev_dbg(rtsx_dev(chip), "Host register (0x%x): 0x%x\n", addr, val);
1480 buf[0] = (u8)(val >> 24);
1481 buf[1] = (u8)(val >> 16);
1482 buf[2] = (u8)(val >> 8);
1485 len = min_t(unsigned int, scsi_bufflen(srb), 4);
1486 rtsx_stor_set_xfer_buf(buf, len, srb);
1487 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1489 return TRANSPORT_GOOD;
1492 static int write_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1498 rtsx_disable_aspm(chip);
1500 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1504 rtsx_set_stat(chip, RTSX_STAT_RUN);
1506 addr = srb->cmnd[4];
1508 len = min_t(unsigned int, scsi_bufflen(srb), 4);
1509 rtsx_stor_get_xfer_buf(buf, len, srb);
1510 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1512 val = ((u32)buf[0] << 24) | ((u32)buf[1] << 16) | ((u32)buf[2]
1515 rtsx_writel(chip, addr, val);
1517 return TRANSPORT_GOOD;
1520 static int set_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1522 unsigned lun = SCSI_LUN(srb);
1524 if (srb->cmnd[3] == 1) {
1525 /* Variable Clock */
1526 struct xd_info *xd_card = &(chip->xd_card);
1527 struct sd_info *sd_card = &(chip->sd_card);
1528 struct ms_info *ms_card = &(chip->ms_card);
1530 switch (srb->cmnd[4]) {
1532 xd_card->xd_clock = srb->cmnd[5];
1536 sd_card->sd_clock = srb->cmnd[5];
1540 ms_card->ms_clock = srb->cmnd[5];
1544 set_sense_type(chip, lun,
1545 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1547 return TRANSPORT_FAILED;
1549 } else if (srb->cmnd[3] == 2) {
1551 chip->blink_led = 1;
1555 chip->blink_led = 0;
1557 rtsx_disable_aspm(chip);
1560 (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1564 rtsx_set_stat(chip, RTSX_STAT_RUN);
1566 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1567 if (retval != STATUS_SUCCESS) {
1568 set_sense_type(chip, SCSI_LUN(srb),
1569 SENSE_TYPE_MEDIA_WRITE_ERR);
1571 return TRANSPORT_FAILED;
1574 turn_off_led(chip, LED_GPIO);
1577 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1579 return TRANSPORT_FAILED;
1582 return TRANSPORT_GOOD;
1585 static int get_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1587 unsigned int lun = SCSI_LUN(srb);
1589 if (srb->cmnd[3] == 1) {
1590 struct xd_info *xd_card = &(chip->xd_card);
1591 struct sd_info *sd_card = &(chip->sd_card);
1592 struct ms_info *ms_card = &(chip->ms_card);
1595 switch (srb->cmnd[4]) {
1597 tmp = (u8)(xd_card->xd_clock);
1601 tmp = (u8)(sd_card->sd_clock);
1605 tmp = (u8)(ms_card->ms_clock);
1609 set_sense_type(chip, lun,
1610 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1612 return TRANSPORT_FAILED;
1615 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1616 } else if (srb->cmnd[3] == 2) {
1617 u8 tmp = chip->blink_led;
1619 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1621 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1623 return TRANSPORT_FAILED;
1626 return TRANSPORT_GOOD;
1629 static int dma_access_ring_buffer(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1632 unsigned int lun = SCSI_LUN(srb);
1635 rtsx_disable_aspm(chip);
1637 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1641 rtsx_set_stat(chip, RTSX_STAT_RUN);
1643 len = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
1644 len = min_t(u16, len, scsi_bufflen(srb));
1646 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1647 dev_dbg(rtsx_dev(chip), "Read from device\n");
1649 dev_dbg(rtsx_dev(chip), "Write to device\n");
1651 retval = rtsx_transfer_data(chip, 0, scsi_sglist(srb), len,
1652 scsi_sg_count(srb), srb->sc_data_direction, 1000);
1654 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1655 set_sense_type(chip, lun,
1656 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1658 set_sense_type(chip, lun,
1659 SENSE_TYPE_MEDIA_WRITE_ERR);
1662 return TRANSPORT_FAILED;
1664 scsi_set_resid(srb, 0);
1666 return TRANSPORT_GOOD;
1669 static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1671 struct sd_info *sd_card = &(chip->sd_card);
1672 struct ms_info *ms_card = &(chip->ms_card);
1674 unsigned int lun = SCSI_LUN(srb);
1675 u8 card = get_lun_card(chip, lun);
1678 u8 oc_now_mask = 0, oc_ever_mask = 0;
1681 memset(status, 0, 32);
1683 status[0] = (u8)(chip->product_id);
1684 status[1] = chip->ic_version;
1686 if (chip->auto_delink_en)
1703 if (CHECK_LUN_MODE(chip,
1704 SD_MS_2LUN) && (chip->lun2card[lun] == MS_CARD)) {
1705 oc_now_mask = MS_OC_NOW;
1706 oc_ever_mask = MS_OC_EVER;
1708 oc_now_mask = SD_OC_NOW;
1709 oc_ever_mask = SD_OC_EVER;
1712 if (chip->ocp_stat & oc_now_mask)
1715 if (chip->ocp_stat & oc_ever_mask)
1719 if (card == SD_CARD) {
1720 if (CHK_SD(sd_card)) {
1721 if (CHK_SD_HCXC(sd_card)) {
1722 if (sd_card->capacity > 0x4000000)
1723 status[0x0E] = 0x02;
1725 status[0x0E] = 0x01;
1727 status[0x0E] = 0x00;
1730 if (CHK_SD_SDR104(sd_card))
1731 status[0x0F] = 0x03;
1732 else if (CHK_SD_DDR50(sd_card))
1733 status[0x0F] = 0x04;
1734 else if (CHK_SD_SDR50(sd_card))
1735 status[0x0F] = 0x02;
1736 else if (CHK_SD_HS(sd_card))
1737 status[0x0F] = 0x01;
1739 status[0x0F] = 0x00;
1741 if (CHK_MMC_SECTOR_MODE(sd_card))
1742 status[0x0E] = 0x01;
1744 status[0x0E] = 0x00;
1746 if (CHK_MMC_DDR52(sd_card))
1747 status[0x0F] = 0x03;
1748 else if (CHK_MMC_52M(sd_card))
1749 status[0x0F] = 0x02;
1750 else if (CHK_MMC_26M(sd_card))
1751 status[0x0F] = 0x01;
1753 status[0x0F] = 0x00;
1755 } else if (card == MS_CARD) {
1756 if (CHK_MSPRO(ms_card)) {
1757 if (CHK_MSXC(ms_card))
1758 status[0x0E] = 0x01;
1760 status[0x0E] = 0x00;
1762 if (CHK_HG8BIT(ms_card))
1763 status[0x0F] = 0x01;
1765 status[0x0F] = 0x00;
1769 #ifdef SUPPORT_SD_LOCK
1770 if (card == SD_CARD) {
1771 status[0x17] = 0x80;
1772 if (sd_card->sd_erase_status)
1773 status[0x17] |= 0x01;
1774 if (sd_card->sd_lock_status & SD_LOCKED) {
1775 status[0x17] |= 0x02;
1776 status[0x07] |= 0x40;
1778 if (sd_card->sd_lock_status & SD_PWD_EXIST)
1779 status[0x17] |= 0x04;
1781 status[0x17] = 0x00;
1784 dev_dbg(rtsx_dev(chip), "status[0x17] = 0x%x\n", status[0x17]);
1787 status[0x18] = 0x8A;
1788 status[0x1A] = 0x28;
1789 #ifdef SUPPORT_SD_LOCK
1790 status[0x1F] = 0x01;
1793 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(status));
1794 rtsx_stor_set_xfer_buf(status, buf_len, srb);
1795 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1797 return TRANSPORT_GOOD;
1800 static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1806 if (!CHECK_PID(chip, 0x5208)) {
1807 set_sense_type(chip, SCSI_LUN(srb),
1808 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1810 return TRANSPORT_FAILED;
1813 phy_debug_mode = (int)(srb->cmnd[3]);
1815 if (phy_debug_mode) {
1816 chip->phy_debug_mode = 1;
1817 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0);
1818 if (retval != STATUS_SUCCESS) {
1820 return TRANSPORT_FAILED;
1823 rtsx_disable_bus_int(chip);
1825 retval = rtsx_read_phy_register(chip, 0x1C, ®);
1826 if (retval != STATUS_SUCCESS) {
1828 return TRANSPORT_FAILED;
1832 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1833 if (retval != STATUS_SUCCESS) {
1835 return TRANSPORT_FAILED;
1838 chip->phy_debug_mode = 0;
1839 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77);
1840 if (retval != STATUS_SUCCESS) {
1842 return TRANSPORT_FAILED;
1845 rtsx_enable_bus_int(chip);
1847 retval = rtsx_read_phy_register(chip, 0x1C, ®);
1848 if (retval != STATUS_SUCCESS) {
1850 return TRANSPORT_FAILED;
1854 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1855 if (retval != STATUS_SUCCESS) {
1857 return TRANSPORT_FAILED;
1861 return TRANSPORT_GOOD;
1864 static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1866 int retval = STATUS_SUCCESS;
1867 unsigned int lun = SCSI_LUN(srb);
1868 u8 cmd_type, mask, value, idx;
1871 rtsx_disable_aspm(chip);
1873 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1877 rtsx_set_stat(chip, RTSX_STAT_RUN);
1879 switch (srb->cmnd[3]) {
1881 rtsx_init_cmd(chip);
1885 cmd_type = srb->cmnd[4];
1887 set_sense_type(chip, lun,
1888 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1890 return TRANSPORT_FAILED;
1892 addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1893 mask = srb->cmnd[7];
1894 value = srb->cmnd[8];
1895 rtsx_add_cmd(chip, cmd_type, addr, mask, value);
1899 retval = rtsx_send_cmd(chip, 0, 1000);
1904 value = *(rtsx_get_cmd_data(chip) + idx);
1905 if (scsi_bufflen(srb) < 1) {
1906 set_sense_type(chip, lun,
1907 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1909 return TRANSPORT_FAILED;
1911 rtsx_stor_set_xfer_buf(&value, 1, srb);
1912 scsi_set_resid(srb, 0);
1916 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1918 return TRANSPORT_FAILED;
1921 if (retval != STATUS_SUCCESS) {
1922 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1924 return TRANSPORT_FAILED;
1927 return TRANSPORT_GOOD;
1930 static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1934 switch (srb->cmnd[3]) {
1939 result = rw_mem_cmd_buf(srb, chip);
1942 result = TRANSPORT_ERROR;
1948 static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1950 unsigned short addr, len, i;
1955 rtsx_disable_aspm(chip);
1957 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1961 rtsx_set_stat(chip, RTSX_STAT_RUN);
1963 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1964 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1973 return TRANSPORT_ERROR;
1976 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1977 if (retval != STATUS_SUCCESS) {
1979 set_sense_type(chip, SCSI_LUN(srb),
1980 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1982 return TRANSPORT_FAILED;
1985 for (i = 0; i < len / 2; i++) {
1986 retval = rtsx_read_phy_register(chip, addr + i, &val);
1987 if (retval != STATUS_SUCCESS) {
1989 set_sense_type(chip, SCSI_LUN(srb),
1990 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1992 return TRANSPORT_FAILED;
1995 buf[2*i] = (u8)(val >> 8);
1996 buf[2*i+1] = (u8)val;
1999 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
2001 rtsx_stor_set_xfer_buf(buf, len, srb);
2002 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2007 return TRANSPORT_GOOD;
2010 static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2012 unsigned short addr, len, i;
2017 rtsx_disable_aspm(chip);
2019 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2023 rtsx_set_stat(chip, RTSX_STAT_RUN);
2025 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2026 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2032 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
2038 return TRANSPORT_ERROR;
2041 rtsx_stor_get_xfer_buf(buf, len, srb);
2042 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2044 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2045 if (retval != STATUS_SUCCESS) {
2047 set_sense_type(chip, SCSI_LUN(srb),
2048 SENSE_TYPE_MEDIA_WRITE_ERR);
2050 return TRANSPORT_FAILED;
2053 for (i = 0; i < len / 2; i++) {
2054 val = ((u16)buf[2*i] << 8) | buf[2*i+1];
2055 retval = rtsx_write_phy_register(chip, addr + i, val);
2056 if (retval != STATUS_SUCCESS) {
2058 set_sense_type(chip, SCSI_LUN(srb),
2059 SENSE_TYPE_MEDIA_WRITE_ERR);
2061 return TRANSPORT_FAILED;
2068 return TRANSPORT_GOOD;
2071 static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2073 unsigned short addr;
2077 rtsx_disable_aspm(chip);
2079 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2083 rtsx_set_stat(chip, RTSX_STAT_RUN);
2085 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2086 if (retval != STATUS_SUCCESS) {
2087 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2089 return TRANSPORT_FAILED;
2092 mode = srb->cmnd[3];
2093 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2096 retval = spi_erase_eeprom_chip(chip);
2097 if (retval != STATUS_SUCCESS) {
2098 set_sense_type(chip, SCSI_LUN(srb),
2099 SENSE_TYPE_MEDIA_WRITE_ERR);
2101 return TRANSPORT_FAILED;
2103 } else if (mode == 1) {
2104 retval = spi_erase_eeprom_byte(chip, addr);
2105 if (retval != STATUS_SUCCESS) {
2106 set_sense_type(chip, SCSI_LUN(srb),
2107 SENSE_TYPE_MEDIA_WRITE_ERR);
2109 return TRANSPORT_FAILED;
2112 set_sense_type(chip, SCSI_LUN(srb),
2113 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2115 return TRANSPORT_FAILED;
2118 return TRANSPORT_GOOD;
2121 static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2123 unsigned short addr, len, i;
2127 rtsx_disable_aspm(chip);
2129 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2133 rtsx_set_stat(chip, RTSX_STAT_RUN);
2135 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2136 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2141 return TRANSPORT_ERROR;
2144 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2145 if (retval != STATUS_SUCCESS) {
2147 set_sense_type(chip, SCSI_LUN(srb),
2148 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2150 return TRANSPORT_FAILED;
2153 for (i = 0; i < len; i++) {
2154 retval = spi_read_eeprom(chip, addr + i, buf + i);
2155 if (retval != STATUS_SUCCESS) {
2157 set_sense_type(chip, SCSI_LUN(srb),
2158 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2160 return TRANSPORT_FAILED;
2164 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2165 rtsx_stor_set_xfer_buf(buf, len, srb);
2166 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2170 return TRANSPORT_GOOD;
2173 static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2175 unsigned short addr, len, i;
2179 rtsx_disable_aspm(chip);
2181 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2185 rtsx_set_stat(chip, RTSX_STAT_RUN);
2187 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2188 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2190 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2194 return TRANSPORT_ERROR;
2197 rtsx_stor_get_xfer_buf(buf, len, srb);
2198 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2200 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2201 if (retval != STATUS_SUCCESS) {
2203 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2205 return TRANSPORT_FAILED;
2208 for (i = 0; i < len; i++) {
2209 retval = spi_write_eeprom(chip, addr + i, buf[i]);
2210 if (retval != STATUS_SUCCESS) {
2212 set_sense_type(chip, SCSI_LUN(srb),
2213 SENSE_TYPE_MEDIA_WRITE_ERR);
2215 return TRANSPORT_FAILED;
2221 return TRANSPORT_GOOD;
2224 static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2230 rtsx_disable_aspm(chip);
2232 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2236 rtsx_set_stat(chip, RTSX_STAT_RUN);
2238 addr = srb->cmnd[4];
2244 return TRANSPORT_ERROR;
2247 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2248 if (retval != STATUS_SUCCESS) {
2250 set_sense_type(chip, SCSI_LUN(srb),
2251 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2253 return TRANSPORT_FAILED;
2256 for (i = 0; i < len; i++) {
2257 retval = rtsx_read_efuse(chip, addr + i, buf + i);
2258 if (retval != STATUS_SUCCESS) {
2260 set_sense_type(chip, SCSI_LUN(srb),
2261 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2263 return TRANSPORT_FAILED;
2267 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2268 rtsx_stor_set_xfer_buf(buf, len, srb);
2269 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2273 return TRANSPORT_GOOD;
2276 static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2278 int retval, result = TRANSPORT_GOOD;
2283 rtsx_disable_aspm(chip);
2285 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2289 rtsx_set_stat(chip, RTSX_STAT_RUN);
2291 addr = srb->cmnd[4];
2294 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2298 return TRANSPORT_ERROR;
2301 rtsx_stor_get_xfer_buf(buf, len, srb);
2302 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2304 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2305 if (retval != STATUS_SUCCESS) {
2308 return TRANSPORT_ERROR;
2311 if (chip->asic_code) {
2312 retval = rtsx_read_phy_register(chip, 0x08, &val);
2313 if (retval != STATUS_SUCCESS) {
2316 return TRANSPORT_ERROR;
2319 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2320 LDO3318_PWR_MASK, LDO_OFF);
2321 if (retval != STATUS_SUCCESS) {
2324 return TRANSPORT_ERROR;
2329 retval = rtsx_write_phy_register(chip, 0x08,
2330 0x4C00 | chip->phy_voltage);
2331 if (retval != STATUS_SUCCESS) {
2334 return TRANSPORT_ERROR;
2337 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2338 LDO3318_PWR_MASK, LDO_ON);
2339 if (retval != STATUS_SUCCESS) {
2342 return TRANSPORT_ERROR;
2348 retval = card_power_on(chip, SPI_CARD);
2349 if (retval != STATUS_SUCCESS) {
2352 return TRANSPORT_ERROR;
2357 for (i = 0; i < len; i++) {
2358 retval = rtsx_write_efuse(chip, addr + i, buf[i]);
2359 if (retval != STATUS_SUCCESS) {
2360 set_sense_type(chip, SCSI_LUN(srb),
2361 SENSE_TYPE_MEDIA_WRITE_ERR);
2362 result = TRANSPORT_FAILED;
2371 retval = card_power_off(chip, SPI_CARD);
2372 if (retval != STATUS_SUCCESS) {
2374 return TRANSPORT_ERROR;
2377 if (chip->asic_code) {
2378 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2379 LDO3318_PWR_MASK, LDO_OFF);
2380 if (retval != STATUS_SUCCESS) {
2382 return TRANSPORT_ERROR;
2387 retval = rtsx_write_phy_register(chip, 0x08, val);
2388 if (retval != STATUS_SUCCESS) {
2390 return TRANSPORT_ERROR;
2393 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2394 LDO3318_PWR_MASK, LDO_ON);
2395 if (retval != STATUS_SUCCESS) {
2397 return TRANSPORT_ERROR;
2404 static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2412 rtsx_disable_aspm(chip);
2414 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2418 rtsx_set_stat(chip, RTSX_STAT_RUN);
2420 func = srb->cmnd[3];
2421 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2422 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2424 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x, len = %d\n",
2425 __func__, func, addr, len);
2427 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2432 if (func > func_max) {
2433 set_sense_type(chip, SCSI_LUN(srb),
2434 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2436 return TRANSPORT_FAILED;
2442 return TRANSPORT_ERROR;
2445 retval = rtsx_read_cfg_seq(chip, func, addr, buf, len);
2446 if (retval != STATUS_SUCCESS) {
2447 set_sense_type(chip, SCSI_LUN(srb),
2448 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2451 return TRANSPORT_FAILED;
2454 len = (u16)min_t(unsigned int, scsi_bufflen(srb), len);
2455 rtsx_stor_set_xfer_buf(buf, len, srb);
2456 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2460 return TRANSPORT_GOOD;
2463 static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2471 rtsx_disable_aspm(chip);
2473 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2477 rtsx_set_stat(chip, RTSX_STAT_RUN);
2479 func = srb->cmnd[3];
2480 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2481 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2483 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x\n",
2484 __func__, func, addr);
2486 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2491 if (func > func_max) {
2492 set_sense_type(chip, SCSI_LUN(srb),
2493 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2495 return TRANSPORT_FAILED;
2498 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2502 return TRANSPORT_ERROR;
2505 rtsx_stor_get_xfer_buf(buf, len, srb);
2506 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2508 retval = rtsx_write_cfg_seq(chip, func, addr, buf, len);
2509 if (retval != STATUS_SUCCESS) {
2510 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2513 return TRANSPORT_FAILED;
2518 return TRANSPORT_GOOD;
2521 static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2525 switch (srb->cmnd[2]) {
2528 result = read_write(srb, chip);
2532 result = read_host_reg(srb, chip);
2535 case WRITE_HOST_REG:
2536 result = write_host_reg(srb, chip);
2540 result = get_variable(srb, chip);
2544 result = set_variable(srb, chip);
2549 result = dma_access_ring_buffer(srb, chip);
2553 result = read_phy_register(srb, chip);
2557 result = write_phy_register(srb, chip);
2561 result = erase_eeprom2(srb, chip);
2565 result = read_eeprom2(srb, chip);
2569 result = write_eeprom2(srb, chip);
2573 result = read_efuse(srb, chip);
2577 result = write_efuse(srb, chip);
2581 result = read_cfg_byte(srb, chip);
2585 result = write_cfg_byte(srb, chip);
2589 result = set_chip_mode(srb, chip);
2593 result = suit_cmd(srb, chip);
2596 case GET_DEV_STATUS:
2597 result = get_dev_status(srb, chip);
2601 set_sense_type(chip, SCSI_LUN(srb),
2602 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2604 return TRANSPORT_FAILED;
2611 static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2615 unsigned int lun = SCSI_LUN(srb);
2617 rtsx_status[0] = (u8)(chip->vendor_id >> 8);
2618 rtsx_status[1] = (u8)(chip->vendor_id);
2620 rtsx_status[2] = (u8)(chip->product_id >> 8);
2621 rtsx_status[3] = (u8)(chip->product_id);
2623 rtsx_status[4] = (u8)lun;
2625 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2626 if (chip->lun2card[lun] == SD_CARD)
2631 if (chip->card_exist) {
2632 if (chip->card_exist & XD_CARD)
2634 else if (chip->card_exist & SD_CARD)
2636 else if (chip->card_exist & MS_CARD)
2645 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2650 rtsx_status[7] = (u8)(chip->product_id);
2651 rtsx_status[8] = chip->ic_version;
2653 if (check_card_exist(chip, lun))
2658 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2659 rtsx_status[10] = 0;
2661 rtsx_status[10] = 1;
2663 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2664 if (chip->lun2card[lun] == SD_CARD)
2665 rtsx_status[11] = SD_CARD;
2667 rtsx_status[11] = MS_CARD;
2669 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD;
2672 if (check_card_ready(chip, lun))
2673 rtsx_status[12] = 1;
2675 rtsx_status[12] = 0;
2677 if (get_lun_card(chip, lun) == XD_CARD) {
2678 rtsx_status[13] = 0x40;
2679 } else if (get_lun_card(chip, lun) == SD_CARD) {
2680 struct sd_info *sd_card = &(chip->sd_card);
2682 rtsx_status[13] = 0x20;
2683 if (CHK_SD(sd_card)) {
2684 if (CHK_SD_HCXC(sd_card))
2685 rtsx_status[13] |= 0x04;
2686 if (CHK_SD_HS(sd_card))
2687 rtsx_status[13] |= 0x02;
2689 rtsx_status[13] |= 0x08;
2690 if (CHK_MMC_52M(sd_card))
2691 rtsx_status[13] |= 0x02;
2692 if (CHK_MMC_SECTOR_MODE(sd_card))
2693 rtsx_status[13] |= 0x04;
2695 } else if (get_lun_card(chip, lun) == MS_CARD) {
2696 struct ms_info *ms_card = &(chip->ms_card);
2698 if (CHK_MSPRO(ms_card)) {
2699 rtsx_status[13] = 0x38;
2700 if (CHK_HG8BIT(ms_card))
2701 rtsx_status[13] |= 0x04;
2703 if (CHK_MSXC(ms_card))
2704 rtsx_status[13] |= 0x01;
2707 rtsx_status[13] = 0x30;
2710 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) {
2712 if (chip->sd_io && chip->sd_int)
2713 rtsx_status[13] = 0x60;
2715 rtsx_status[13] = 0x70;
2717 rtsx_status[13] = 0x70;
2720 if (chip->lun2card[lun] == SD_CARD)
2721 rtsx_status[13] = 0x20;
2723 rtsx_status[13] = 0x30;
2727 rtsx_status[14] = 0x78;
2728 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2729 rtsx_status[15] = 0x83;
2731 rtsx_status[15] = 0x82;
2733 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(rtsx_status));
2734 rtsx_stor_set_xfer_buf(rtsx_status, buf_len, srb);
2735 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
2737 return TRANSPORT_GOOD;
2740 static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2742 unsigned int lun = SCSI_LUN(srb);
2745 if (!check_card_ready(chip, lun)) {
2746 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2748 return TRANSPORT_FAILED;
2751 card = get_lun_card(chip, lun);
2752 if ((card == SD_CARD) || (card == MS_CARD)) {
2753 bus_width = chip->card_bus_width[lun];
2755 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2757 return TRANSPORT_FAILED;
2760 scsi_set_resid(srb, 0);
2761 rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
2763 return TRANSPORT_GOOD;
2766 static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2769 unsigned int lun = SCSI_LUN(srb);
2772 if (CHECK_PID(chip, 0x5208) || CHECK_PID(chip, 0x5288)) {
2773 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2775 return TRANSPORT_FAILED;
2778 rtsx_disable_aspm(chip);
2780 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2784 rtsx_set_stat(chip, RTSX_STAT_RUN);
2786 rtsx_force_power_on(chip, SSC_PDCTL);
2788 rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir);
2789 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06);
2791 switch (srb->cmnd[2]) {
2792 case SCSI_SPI_GETSTATUS:
2793 result = spi_get_status(srb, chip);
2796 case SCSI_SPI_SETPARAMETER:
2797 result = spi_set_parameter(srb, chip);
2800 case SCSI_SPI_READFALSHID:
2801 result = spi_read_flash_id(srb, chip);
2804 case SCSI_SPI_READFLASH:
2805 result = spi_read_flash(srb, chip);
2808 case SCSI_SPI_WRITEFLASH:
2809 result = spi_write_flash(srb, chip);
2812 case SCSI_SPI_WRITEFLASHSTATUS:
2813 result = spi_write_flash_status(srb, chip);
2816 case SCSI_SPI_ERASEFLASH:
2817 result = spi_erase_flash(srb, chip);
2821 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2823 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2825 return TRANSPORT_FAILED;
2828 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2830 if (result != STATUS_SUCCESS) {
2832 return TRANSPORT_FAILED;
2835 return TRANSPORT_GOOD;
2838 static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2842 switch (srb->cmnd[1]) {
2844 result = read_status(srb, chip);
2848 result = read_mem(srb, chip);
2852 result = write_mem(srb, chip);
2856 result = read_eeprom(srb, chip);
2860 result = write_eeprom(srb, chip);
2864 result = toggle_gpio_cmd(srb, chip);
2868 result = get_sd_csd(srb, chip);
2872 result = get_card_bus_width(srb, chip);
2877 result = trace_msg_cmd(srb, chip);
2882 result = app_cmd(srb, chip);
2885 case SPI_VENDOR_COMMAND:
2886 result = spi_vendor_cmd(srb, chip);
2890 set_sense_type(chip, SCSI_LUN(srb),
2891 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2893 return TRANSPORT_FAILED;
2899 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
2900 void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2902 unsigned int lun = SCSI_LUN(srb);
2905 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10))
2906 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
2907 else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6))
2908 sec_cnt = srb->cmnd[4];
2912 if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) {
2913 toggle_gpio(chip, LED_GPIO);
2914 chip->rw_cap[lun] = 0;
2916 chip->rw_cap[lun] += sec_cnt;
2921 static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2923 struct ms_info *ms_card = &(chip->ms_card);
2924 unsigned int lun = SCSI_LUN(srb);
2928 if (get_lun_card(chip, lun) != MS_CARD) {
2929 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2931 return TRANSPORT_FAILED;
2934 if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47) ||
2935 (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D) ||
2936 (srb->cmnd[7] != 0x74)) {
2937 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2939 return TRANSPORT_FAILED;
2942 rtsx_disable_aspm(chip);
2944 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2948 if (!check_card_ready(chip, lun) ||
2949 (get_card_size(chip, lun) == 0)) {
2950 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2952 return TRANSPORT_FAILED;
2955 rtsx_set_stat(chip, RTSX_STAT_RUN);
2957 if (srb->cmnd[8] & 0x01)
2958 quick_format = false;
2960 quick_format = true;
2962 if (!(chip->card_ready & MS_CARD)) {
2963 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2965 return TRANSPORT_FAILED;
2968 if (chip->card_wp & MS_CARD) {
2969 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2971 return TRANSPORT_FAILED;
2974 if (!CHK_MSPRO(ms_card)) {
2975 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2977 return TRANSPORT_FAILED;
2980 retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
2981 if (retval != STATUS_SUCCESS) {
2982 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
2984 return TRANSPORT_FAILED;
2987 scsi_set_resid(srb, 0);
2988 return TRANSPORT_GOOD;
2991 #ifdef SUPPORT_PCGL_1P18
2992 static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2994 struct ms_info *ms_card = &(chip->ms_card);
2995 unsigned int lun = SCSI_LUN(srb);
2996 u8 dev_info_id, data_len;
2998 unsigned int buf_len;
3001 if (!check_card_ready(chip, lun)) {
3002 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3004 return TRANSPORT_FAILED;
3006 if (get_lun_card(chip, lun) != MS_CARD) {
3007 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3009 return TRANSPORT_FAILED;
3012 if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) ||
3013 (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) ||
3014 (srb->cmnd[7] != 0x44)) {
3015 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3017 return TRANSPORT_FAILED;
3020 dev_info_id = srb->cmnd[3];
3021 if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) ||
3022 (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) ||
3023 !CHK_MSPRO(ms_card)) {
3024 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3026 return TRANSPORT_FAILED;
3029 if (dev_info_id == 0x15)
3030 buf_len = data_len = 0x3A;
3032 buf_len = data_len = 0x6A;
3034 buf = kmalloc(buf_len, GFP_KERNEL);
3037 return TRANSPORT_ERROR;
3041 /* GET Memory Stick Media Information Response Header */
3042 buf[i++] = 0x00; /* Data length MSB */
3043 buf[i++] = data_len; /* Data length LSB */
3044 /* Device Information Type Code */
3045 if (CHK_MSXC(ms_card))
3056 /* Number of Device Information */
3059 /* Device Information Body */
3061 /* Device Information ID Number */
3062 buf[i++] = dev_info_id;
3063 /* Device Information Length */
3064 if (dev_info_id == 0x15)
3069 buf[i++] = 0x00; /* Data length MSB */
3070 buf[i++] = data_len; /* Data length LSB */
3073 if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
3074 /* System Information */
3075 memcpy(buf+i, ms_card->raw_sys_info, 96);
3078 memcpy(buf+i, ms_card->raw_model_name, 48);
3081 rtsx_stor_set_xfer_buf(buf, buf_len, srb);
3083 if (dev_info_id == 0x15)
3084 scsi_set_resid(srb, scsi_bufflen(srb)-0x3C);
3086 scsi_set_resid(srb, scsi_bufflen(srb)-0x6C);
3089 return STATUS_SUCCESS;
3093 static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3095 int retval = TRANSPORT_ERROR;
3097 if (srb->cmnd[2] == MS_FORMAT)
3098 retval = ms_format_cmnd(srb, chip);
3099 #ifdef SUPPORT_PCGL_1P18
3100 else if (srb->cmnd[2] == GET_MS_INFORMATION)
3101 retval = get_ms_information(srb, chip);
3108 static int sd_extention_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3110 unsigned int lun = SCSI_LUN(srb);
3113 rtsx_disable_aspm(chip);
3115 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3119 rtsx_set_stat(chip, RTSX_STAT_RUN);
3121 sd_cleanup_work(chip);
3123 if (!check_card_ready(chip, lun)) {
3124 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3126 return TRANSPORT_FAILED;
3128 if (get_lun_card(chip, lun) != SD_CARD) {
3129 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3131 return TRANSPORT_FAILED;
3134 switch (srb->cmnd[0]) {
3135 case SD_PASS_THRU_MODE:
3136 result = sd_pass_thru_mode(srb, chip);
3139 case SD_EXECUTE_NO_DATA:
3140 result = sd_execute_no_data(srb, chip);
3143 case SD_EXECUTE_READ:
3144 result = sd_execute_read_data(srb, chip);
3147 case SD_EXECUTE_WRITE:
3148 result = sd_execute_write_data(srb, chip);
3152 result = sd_get_cmd_rsp(srb, chip);
3156 result = sd_hw_rst(srb, chip);
3160 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3162 return TRANSPORT_FAILED;
3169 #ifdef SUPPORT_MAGIC_GATE
3170 static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3172 struct ms_info *ms_card = &(chip->ms_card);
3173 unsigned int lun = SCSI_LUN(srb);
3177 rtsx_disable_aspm(chip);
3179 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3183 rtsx_set_stat(chip, RTSX_STAT_RUN);
3185 ms_cleanup_work(chip);
3187 if (!check_card_ready(chip, lun)) {
3188 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3190 return TRANSPORT_FAILED;
3192 if (get_lun_card(chip, lun) != MS_CARD) {
3193 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3195 return TRANSPORT_FAILED;
3198 if (srb->cmnd[7] != KC_MG_R_PRO) {
3199 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3201 return TRANSPORT_FAILED;
3204 if (!CHK_MSPRO(ms_card)) {
3205 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3207 return TRANSPORT_FAILED;
3210 key_format = srb->cmnd[10] & 0x3F;
3211 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3213 switch (key_format) {
3214 case KF_GET_LOC_EKB:
3215 if ((scsi_bufflen(srb) == 0x41C) &&
3216 (srb->cmnd[8] == 0x04) &&
3217 (srb->cmnd[9] == 0x1C)) {
3218 retval = mg_get_local_EKB(srb, chip);
3219 if (retval != STATUS_SUCCESS) {
3221 return TRANSPORT_FAILED;
3225 set_sense_type(chip, lun,
3226 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3228 return TRANSPORT_FAILED;
3233 if ((scsi_bufflen(srb) == 0x24) &&
3234 (srb->cmnd[8] == 0x00) &&
3235 (srb->cmnd[9] == 0x24)) {
3236 retval = mg_get_rsp_chg(srb, chip);
3237 if (retval != STATUS_SUCCESS) {
3239 return TRANSPORT_FAILED;
3243 set_sense_type(chip, lun,
3244 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3246 return TRANSPORT_FAILED;
3251 ms_card->mg_entry_num = srb->cmnd[5];
3252 if ((scsi_bufflen(srb) == 0x404) &&
3253 (srb->cmnd[8] == 0x04) &&
3254 (srb->cmnd[9] == 0x04) &&
3255 (srb->cmnd[2] == 0x00) &&
3256 (srb->cmnd[3] == 0x00) &&
3257 (srb->cmnd[4] == 0x00) &&
3258 (srb->cmnd[5] < 32)) {
3259 retval = mg_get_ICV(srb, chip);
3260 if (retval != STATUS_SUCCESS) {
3262 return TRANSPORT_FAILED;
3266 set_sense_type(chip, lun,
3267 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3269 return TRANSPORT_FAILED;
3274 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3276 return TRANSPORT_FAILED;
3279 scsi_set_resid(srb, 0);
3280 return TRANSPORT_GOOD;
3283 static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3285 struct ms_info *ms_card = &(chip->ms_card);
3286 unsigned int lun = SCSI_LUN(srb);
3290 rtsx_disable_aspm(chip);
3292 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3296 rtsx_set_stat(chip, RTSX_STAT_RUN);
3298 ms_cleanup_work(chip);
3300 if (!check_card_ready(chip, lun)) {
3301 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3303 return TRANSPORT_FAILED;
3305 if (check_card_wp(chip, lun)) {
3306 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
3308 return TRANSPORT_FAILED;
3310 if (get_lun_card(chip, lun) != MS_CARD) {
3311 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3313 return TRANSPORT_FAILED;
3316 if (srb->cmnd[7] != KC_MG_R_PRO) {
3317 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3319 return TRANSPORT_FAILED;
3322 if (!CHK_MSPRO(ms_card)) {
3323 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3325 return TRANSPORT_FAILED;
3328 key_format = srb->cmnd[10] & 0x3F;
3329 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3331 switch (key_format) {
3332 case KF_SET_LEAF_ID:
3333 if ((scsi_bufflen(srb) == 0x0C) &&
3334 (srb->cmnd[8] == 0x00) &&
3335 (srb->cmnd[9] == 0x0C)) {
3336 retval = mg_set_leaf_id(srb, chip);
3337 if (retval != STATUS_SUCCESS) {
3339 return TRANSPORT_FAILED;
3343 set_sense_type(chip, lun,
3344 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3346 return TRANSPORT_FAILED;
3351 if ((scsi_bufflen(srb) == 0x0C) &&
3352 (srb->cmnd[8] == 0x00) &&
3353 (srb->cmnd[9] == 0x0C)) {
3354 retval = mg_chg(srb, chip);
3355 if (retval != STATUS_SUCCESS) {
3357 return TRANSPORT_FAILED;
3361 set_sense_type(chip, lun,
3362 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3364 return TRANSPORT_FAILED;
3369 if ((scsi_bufflen(srb) == 0x0C) &&
3370 (srb->cmnd[8] == 0x00) &&
3371 (srb->cmnd[9] == 0x0C)) {
3372 retval = mg_rsp(srb, chip);
3373 if (retval != STATUS_SUCCESS) {
3375 return TRANSPORT_FAILED;
3379 set_sense_type(chip, lun,
3380 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3382 return TRANSPORT_FAILED;
3387 ms_card->mg_entry_num = srb->cmnd[5];
3388 if ((scsi_bufflen(srb) == 0x404) &&
3389 (srb->cmnd[8] == 0x04) &&
3390 (srb->cmnd[9] == 0x04) &&
3391 (srb->cmnd[2] == 0x00) &&
3392 (srb->cmnd[3] == 0x00) &&
3393 (srb->cmnd[4] == 0x00) &&
3394 (srb->cmnd[5] < 32)) {
3395 retval = mg_set_ICV(srb, chip);
3396 if (retval != STATUS_SUCCESS) {
3398 return TRANSPORT_FAILED;
3402 set_sense_type(chip, lun,
3403 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3405 return TRANSPORT_FAILED;
3410 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3412 return TRANSPORT_FAILED;
3415 scsi_set_resid(srb, 0);
3416 return TRANSPORT_GOOD;
3420 int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3422 #ifdef SUPPORT_SD_LOCK
3423 struct sd_info *sd_card = &(chip->sd_card);
3425 struct ms_info *ms_card = &(chip->ms_card);
3426 unsigned int lun = SCSI_LUN(srb);
3429 #ifdef SUPPORT_SD_LOCK
3430 if (sd_card->sd_erase_status) {
3431 /* Block all SCSI command except for
3432 * REQUEST_SENSE and rs_ppstatus
3434 if (!((srb->cmnd[0] == VENDOR_CMND) &&
3435 (srb->cmnd[1] == SCSI_APP_CMD) &&
3436 (srb->cmnd[2] == GET_DEV_STATUS)) &&
3437 (srb->cmnd[0] != REQUEST_SENSE)) {
3438 /* Logical Unit Not Ready Format in Progress */
3439 set_sense_data(chip, lun, CUR_ERR,
3440 0x02, 0, 0x04, 0x04, 0, 0);
3442 return TRANSPORT_FAILED;
3447 if ((get_lun_card(chip, lun) == MS_CARD) &&
3448 (ms_card->format_status == FORMAT_IN_PROGRESS)) {
3449 if ((srb->cmnd[0] != REQUEST_SENSE) &&
3450 (srb->cmnd[0] != INQUIRY)) {
3451 /* Logical Unit Not Ready Format in Progress */
3452 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
3453 0, (u16)(ms_card->progress));
3455 return TRANSPORT_FAILED;
3459 switch (srb->cmnd[0]) {
3464 result = read_write(srb, chip);
3465 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
3466 led_shine(srb, chip);
3470 case TEST_UNIT_READY:
3471 result = test_unit_ready(srb, chip);
3475 result = inquiry(srb, chip);
3479 result = read_capacity(srb, chip);
3483 result = start_stop_unit(srb, chip);
3486 case ALLOW_MEDIUM_REMOVAL:
3487 result = allow_medium_removal(srb, chip);
3491 result = request_sense(srb, chip);
3496 result = mode_sense(srb, chip);
3500 result = read_format_capacity(srb, chip);
3504 result = vendor_cmnd(srb, chip);
3508 result = ms_sp_cmnd(srb, chip);
3512 case SD_PASS_THRU_MODE:
3513 case SD_EXECUTE_NO_DATA:
3514 case SD_EXECUTE_READ:
3515 case SD_EXECUTE_WRITE:
3518 result = sd_extention_cmnd(srb, chip);
3522 #ifdef SUPPORT_MAGIC_GATE
3523 case CMD_MSPRO_MG_RKEY:
3524 result = mg_report_key(srb, chip);
3527 case CMD_MSPRO_MG_SKEY:
3528 result = mg_send_key(srb, chip);
3535 result = TRANSPORT_GOOD;
3539 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3540 result = TRANSPORT_FAILED;