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 strncpy(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
;
561 static int start_stop_unit(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
563 unsigned int lun
= SCSI_LUN(srb
);
565 scsi_set_resid(srb
, scsi_bufflen(srb
));
567 if (srb
->cmnd
[1] == 1)
568 return TRANSPORT_GOOD
;
570 switch (srb
->cmnd
[0x4]) {
573 return TRANSPORT_GOOD
;
576 /* Media shall be unload */
577 if (check_card_ready(chip
, lun
))
578 eject_card(chip
, lun
);
579 return TRANSPORT_GOOD
;
581 case MAKE_MEDIUM_READY
:
583 if (check_card_ready(chip
, lun
))
584 return TRANSPORT_GOOD
;
585 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_NOT_PRESENT
);
587 return TRANSPORT_FAILED
;
593 return TRANSPORT_ERROR
;
596 static int allow_medium_removal(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
600 prevent
= srb
->cmnd
[4] & 0x1;
602 scsi_set_resid(srb
, 0);
605 set_sense_type(chip
, SCSI_LUN(srb
),
606 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
608 return TRANSPORT_FAILED
;
611 return TRANSPORT_GOOD
;
614 static int request_sense(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
616 struct sense_data_t
*sense
;
617 unsigned int lun
= SCSI_LUN(srb
);
618 struct ms_info
*ms_card
= &chip
->ms_card
;
619 unsigned char *tmp
, *buf
;
621 sense
= &chip
->sense_buffer
[lun
];
623 if ((get_lun_card(chip
, lun
) == MS_CARD
) &&
624 ms_card
->pro_under_formatting
) {
625 if (ms_card
->format_status
== FORMAT_SUCCESS
) {
626 set_sense_type(chip
, lun
, SENSE_TYPE_NO_SENSE
);
627 ms_card
->pro_under_formatting
= 0;
628 ms_card
->progress
= 0;
629 } else if (ms_card
->format_status
== FORMAT_IN_PROGRESS
) {
630 /* Logical Unit Not Ready Format in Progress */
631 set_sense_data(chip
, lun
, CUR_ERR
, 0x02, 0, 0x04, 0x04,
632 0, (u16
)(ms_card
->progress
));
634 /* Format Command Failed */
635 set_sense_type(chip
, lun
, SENSE_TYPE_FORMAT_CMD_FAILED
);
636 ms_card
->pro_under_formatting
= 0;
637 ms_card
->progress
= 0;
640 rtsx_set_stat(chip
, RTSX_STAT_RUN
);
643 buf
= vmalloc(scsi_bufflen(srb
));
646 return TRANSPORT_ERROR
;
649 tmp
= (unsigned char *)sense
;
650 memcpy(buf
, tmp
, scsi_bufflen(srb
));
652 rtsx_stor_set_xfer_buf(buf
, scsi_bufflen(srb
), srb
);
655 scsi_set_resid(srb
, 0);
656 /* Reset Sense Data */
657 set_sense_type(chip
, lun
, SENSE_TYPE_NO_SENSE
);
658 return TRANSPORT_GOOD
;
661 static void ms_mode_sense(struct rtsx_chip
*chip
, u8 cmd
,
662 int lun
, u8
*buf
, int buf_len
)
664 struct ms_info
*ms_card
= &chip
->ms_card
;
666 int data_size
= buf_len
;
667 bool support_format
= false;
670 if (cmd
== MODE_SENSE
) {
672 if (data_size
> 0x68)
675 buf
[i
++] = 0x67; /* Mode Data Length */
677 sys_info_offset
= 12;
678 if (data_size
> 0x6C)
681 buf
[i
++] = 0x00; /* Mode Data Length (MSB) */
682 buf
[i
++] = 0x6A; /* Mode Data Length (LSB) */
685 /* Medium Type Code */
686 if (check_card_ready(chip
, lun
)) {
687 if (CHK_MSXC(ms_card
)) {
688 support_format
= true;
690 } else if (CHK_MSPRO(ms_card
)) {
691 support_format
= true;
698 if (check_card_wp(chip
, lun
))
704 buf
[i
++] = 0x00; /* MediaType */
705 buf
[i
++] = 0x00; /* WP */
708 buf
[i
++] = 0x00; /* Reserved */
710 if (cmd
== MODE_SENSE_10
) {
711 buf
[i
++] = 0x00; /* Reserved */
712 buf
[i
++] = 0x00; /* Block descriptor length(MSB) */
713 buf
[i
++] = 0x00; /* Block descriptor length(LSB) */
715 /* The Following Data is the content of "Page 0x20" */
717 buf
[i
++] = 0x20; /* Page Code */
719 buf
[i
++] = 0x62; /* Page Length */
721 buf
[i
++] = 0x00; /* No Access Control */
722 if (data_size
>= 12) {
724 buf
[i
++] = 0xC0; /* SF, SGM */
729 /* The Following Data is the content of "Page 0x20" */
731 buf
[i
++] = 0x20; /* Page Code */
733 buf
[i
++] = 0x62; /* Page Length */
735 buf
[i
++] = 0x00; /* No Access Control */
736 if (data_size
>= 8) {
738 buf
[i
++] = 0xC0; /* SF, SGM */
744 if (data_size
> sys_info_offset
) {
745 /* 96 Bytes Attribute Data */
746 int len
= data_size
- sys_info_offset
;
748 len
= (len
< 96) ? len
: 96;
750 memcpy(buf
+ sys_info_offset
, ms_card
->raw_sys_info
, len
);
754 static int mode_sense(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
756 unsigned int lun
= SCSI_LUN(srb
);
757 unsigned int data_size
;
759 bool pro_formatter_flag
;
760 unsigned char page_code
, *buf
;
761 u8 card
= get_lun_card(chip
, lun
);
763 #ifndef SUPPORT_MAGIC_GATE
764 if (!check_card_ready(chip
, lun
)) {
765 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_NOT_PRESENT
);
766 scsi_set_resid(srb
, scsi_bufflen(srb
));
768 return TRANSPORT_FAILED
;
772 pro_formatter_flag
= false;
774 #ifdef SUPPORT_MAGIC_GATE
775 if ((chip
->lun2card
[lun
] & MS_CARD
)) {
776 if (!card
|| (card
== MS_CARD
)) {
778 if (chip
->mspro_formatter_enable
)
779 pro_formatter_flag
= true;
783 if (card
== MS_CARD
) {
784 if (chip
->mspro_formatter_enable
) {
785 pro_formatter_flag
= true;
791 buf
= kmalloc(data_size
, GFP_KERNEL
);
794 return TRANSPORT_ERROR
;
797 page_code
= srb
->cmnd
[2] & 0x3f;
799 if ((page_code
== 0x3F) || (page_code
== 0x1C) ||
800 (page_code
== 0x00) ||
801 (pro_formatter_flag
&& (page_code
== 0x20))) {
802 if (srb
->cmnd
[0] == MODE_SENSE
) {
803 if ((page_code
== 0x3F) || (page_code
== 0x20)) {
804 ms_mode_sense(chip
, srb
->cmnd
[0],
805 lun
, buf
, data_size
);
810 if (check_card_wp(chip
, lun
))
818 if ((page_code
== 0x3F) || (page_code
== 0x20)) {
819 ms_mode_sense(chip
, srb
->cmnd
[0],
820 lun
, buf
, data_size
);
826 if (check_card_wp(chip
, lun
))
836 status
= TRANSPORT_GOOD
;
838 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
839 scsi_set_resid(srb
, scsi_bufflen(srb
));
840 status
= TRANSPORT_FAILED
;
843 if (status
== TRANSPORT_GOOD
) {
844 unsigned int len
= min_t(unsigned int, scsi_bufflen(srb
),
846 rtsx_stor_set_xfer_buf(buf
, len
, srb
);
847 scsi_set_resid(srb
, scsi_bufflen(srb
) - len
);
854 static int read_write(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
856 #ifdef SUPPORT_SD_LOCK
857 struct sd_info
*sd_card
= &chip
->sd_card
;
859 unsigned int lun
= SCSI_LUN(srb
);
864 rtsx_disable_aspm(chip
);
866 if (chip
->ss_en
&& (rtsx_get_stat(chip
) == RTSX_STAT_SS
)) {
870 rtsx_set_stat(chip
, RTSX_STAT_RUN
);
872 if (!check_card_ready(chip
, lun
) || (get_card_size(chip
, lun
) == 0)) {
873 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_NOT_PRESENT
);
875 return TRANSPORT_FAILED
;
878 if (!(CHK_BIT(chip
->lun_mc
, lun
))) {
879 SET_BIT(chip
->lun_mc
, lun
);
880 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_CHANGE
);
881 return TRANSPORT_FAILED
;
884 #ifdef SUPPORT_SD_LOCK
885 if (sd_card
->sd_erase_status
) {
886 /* Accessing to any card is forbidden
887 * until the erase procedure of SD is completed
889 dev_dbg(rtsx_dev(chip
), "SD card being erased!\n");
890 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_READ_FORBIDDEN
);
892 return TRANSPORT_FAILED
;
895 if (get_lun_card(chip
, lun
) == SD_CARD
) {
896 if (sd_card
->sd_lock_status
& SD_LOCKED
) {
897 dev_dbg(rtsx_dev(chip
), "SD card locked!\n");
898 set_sense_type(chip
, lun
,
899 SENSE_TYPE_MEDIA_READ_FORBIDDEN
);
901 return TRANSPORT_FAILED
;
906 if ((srb
->cmnd
[0] == READ_10
) || (srb
->cmnd
[0] == WRITE_10
)) {
907 start_sec
= ((u32
)srb
->cmnd
[2] << 24) |
908 ((u32
)srb
->cmnd
[3] << 16) |
909 ((u32
)srb
->cmnd
[4] << 8) | ((u32
)srb
->cmnd
[5]);
910 sec_cnt
= ((u16
)(srb
->cmnd
[7]) << 8) | srb
->cmnd
[8];
911 } else if ((srb
->cmnd
[0] == READ_6
) || (srb
->cmnd
[0] == WRITE_6
)) {
912 start_sec
= ((u32
)(srb
->cmnd
[1] & 0x1F) << 16) |
913 ((u32
)srb
->cmnd
[2] << 8) | ((u32
)srb
->cmnd
[3]);
914 sec_cnt
= srb
->cmnd
[4];
917 } else if ((srb
->cmnd
[0] == VENDOR_CMND
) &&
918 (srb
->cmnd
[1] == SCSI_APP_CMD
) &&
919 ((srb
->cmnd
[2] == PP_READ10
) || (srb
->cmnd
[2] == PP_WRITE10
))) {
920 start_sec
= ((u32
)srb
->cmnd
[4] << 24) |
921 ((u32
)srb
->cmnd
[5] << 16) |
922 ((u32
)srb
->cmnd
[6] << 8) | ((u32
)srb
->cmnd
[7]);
923 sec_cnt
= ((u16
)(srb
->cmnd
[9]) << 8) | srb
->cmnd
[10];
925 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
927 return TRANSPORT_FAILED
;
930 /* In some test, we will receive a start_sec like 0xFFFFFFFF.
931 * In this situation, start_sec + sec_cnt will overflow, so we
932 * need to judge start_sec at first
934 if ((start_sec
> get_card_size(chip
, lun
)) ||
935 ((start_sec
+ sec_cnt
) > get_card_size(chip
, lun
))) {
936 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_LBA_OVER_RANGE
);
938 return TRANSPORT_FAILED
;
942 scsi_set_resid(srb
, 0);
943 return TRANSPORT_GOOD
;
946 if (chip
->rw_fail_cnt
[lun
] == 3) {
947 dev_dbg(rtsx_dev(chip
), "read/write fail three times in succession\n");
948 if (srb
->sc_data_direction
== DMA_FROM_DEVICE
)
949 set_sense_type(chip
, lun
,
950 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR
);
952 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_WRITE_ERR
);
955 return TRANSPORT_FAILED
;
958 if (srb
->sc_data_direction
== DMA_TO_DEVICE
) {
959 if (check_card_wp(chip
, lun
)) {
960 dev_dbg(rtsx_dev(chip
), "Write protected card!\n");
961 set_sense_type(chip
, lun
,
962 SENSE_TYPE_MEDIA_WRITE_PROTECT
);
964 return TRANSPORT_FAILED
;
968 retval
= card_rw(srb
, chip
, start_sec
, sec_cnt
);
969 if (retval
!= STATUS_SUCCESS
) {
970 if (chip
->need_release
& chip
->lun2card
[lun
]) {
971 chip
->rw_fail_cnt
[lun
] = 0;
972 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_NOT_PRESENT
);
974 chip
->rw_fail_cnt
[lun
]++;
975 if (srb
->sc_data_direction
== DMA_FROM_DEVICE
)
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
)) {
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 int 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
,
1655 if (srb
->sc_data_direction
== DMA_FROM_DEVICE
)
1656 set_sense_type(chip
, lun
,
1657 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR
);
1659 set_sense_type(chip
, lun
,
1660 SENSE_TYPE_MEDIA_WRITE_ERR
);
1663 return TRANSPORT_FAILED
;
1665 scsi_set_resid(srb
, 0);
1667 return TRANSPORT_GOOD
;
1670 static int get_dev_status(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
1672 struct sd_info
*sd_card
= &chip
->sd_card
;
1673 struct ms_info
*ms_card
= &chip
->ms_card
;
1675 unsigned int lun
= SCSI_LUN(srb
);
1676 u8 card
= get_lun_card(chip
, lun
);
1679 u8 oc_now_mask
= 0, oc_ever_mask
= 0;
1682 memset(status
, 0, 32);
1684 status
[0] = (u8
)(chip
->product_id
);
1685 status
[1] = chip
->ic_version
;
1687 if (chip
->auto_delink_en
)
1704 if (CHECK_LUN_MODE(chip
, SD_MS_2LUN
) &&
1705 (chip
->lun2card
[lun
] == MS_CARD
)) {
1706 oc_now_mask
= MS_OC_NOW
;
1707 oc_ever_mask
= MS_OC_EVER
;
1709 oc_now_mask
= SD_OC_NOW
;
1710 oc_ever_mask
= SD_OC_EVER
;
1713 if (chip
->ocp_stat
& oc_now_mask
)
1716 if (chip
->ocp_stat
& oc_ever_mask
)
1720 if (card
== SD_CARD
) {
1721 if (CHK_SD(sd_card
)) {
1722 if (CHK_SD_HCXC(sd_card
)) {
1723 if (sd_card
->capacity
> 0x4000000)
1724 status
[0x0E] = 0x02;
1726 status
[0x0E] = 0x01;
1728 status
[0x0E] = 0x00;
1731 if (CHK_SD_SDR104(sd_card
))
1732 status
[0x0F] = 0x03;
1733 else if (CHK_SD_DDR50(sd_card
))
1734 status
[0x0F] = 0x04;
1735 else if (CHK_SD_SDR50(sd_card
))
1736 status
[0x0F] = 0x02;
1737 else if (CHK_SD_HS(sd_card
))
1738 status
[0x0F] = 0x01;
1740 status
[0x0F] = 0x00;
1742 if (CHK_MMC_SECTOR_MODE(sd_card
))
1743 status
[0x0E] = 0x01;
1745 status
[0x0E] = 0x00;
1747 if (CHK_MMC_DDR52(sd_card
))
1748 status
[0x0F] = 0x03;
1749 else if (CHK_MMC_52M(sd_card
))
1750 status
[0x0F] = 0x02;
1751 else if (CHK_MMC_26M(sd_card
))
1752 status
[0x0F] = 0x01;
1754 status
[0x0F] = 0x00;
1756 } else if (card
== MS_CARD
) {
1757 if (CHK_MSPRO(ms_card
)) {
1758 if (CHK_MSXC(ms_card
))
1759 status
[0x0E] = 0x01;
1761 status
[0x0E] = 0x00;
1763 if (CHK_HG8BIT(ms_card
))
1764 status
[0x0F] = 0x01;
1766 status
[0x0F] = 0x00;
1770 #ifdef SUPPORT_SD_LOCK
1771 if (card
== SD_CARD
) {
1772 status
[0x17] = 0x80;
1773 if (sd_card
->sd_erase_status
)
1774 status
[0x17] |= 0x01;
1775 if (sd_card
->sd_lock_status
& SD_LOCKED
) {
1776 status
[0x17] |= 0x02;
1777 status
[0x07] |= 0x40;
1779 if (sd_card
->sd_lock_status
& SD_PWD_EXIST
)
1780 status
[0x17] |= 0x04;
1782 status
[0x17] = 0x00;
1785 dev_dbg(rtsx_dev(chip
), "status[0x17] = 0x%x\n", status
[0x17]);
1788 status
[0x18] = 0x8A;
1789 status
[0x1A] = 0x28;
1790 #ifdef SUPPORT_SD_LOCK
1791 status
[0x1F] = 0x01;
1794 buf_len
= min_t(unsigned int, scsi_bufflen(srb
), sizeof(status
));
1795 rtsx_stor_set_xfer_buf(status
, buf_len
, srb
);
1796 scsi_set_resid(srb
, scsi_bufflen(srb
) - buf_len
);
1798 return TRANSPORT_GOOD
;
1801 static int set_chip_mode(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
1807 if (!CHECK_PID(chip
, 0x5208)) {
1808 set_sense_type(chip
, SCSI_LUN(srb
),
1809 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
1811 return TRANSPORT_FAILED
;
1814 phy_debug_mode
= (int)(srb
->cmnd
[3]);
1816 if (phy_debug_mode
) {
1817 chip
->phy_debug_mode
= 1;
1818 retval
= rtsx_write_register(chip
, CDRESUMECTL
, 0x77, 0);
1819 if (retval
!= STATUS_SUCCESS
) {
1821 return TRANSPORT_FAILED
;
1824 rtsx_disable_bus_int(chip
);
1826 retval
= rtsx_read_phy_register(chip
, 0x1C, ®
);
1827 if (retval
!= STATUS_SUCCESS
) {
1829 return TRANSPORT_FAILED
;
1833 retval
= rtsx_write_phy_register(chip
, 0x1C, reg
);
1834 if (retval
!= STATUS_SUCCESS
) {
1836 return TRANSPORT_FAILED
;
1839 chip
->phy_debug_mode
= 0;
1840 retval
= rtsx_write_register(chip
, CDRESUMECTL
, 0x77, 0x77);
1841 if (retval
!= STATUS_SUCCESS
) {
1843 return TRANSPORT_FAILED
;
1846 rtsx_enable_bus_int(chip
);
1848 retval
= rtsx_read_phy_register(chip
, 0x1C, ®
);
1849 if (retval
!= STATUS_SUCCESS
) {
1851 return TRANSPORT_FAILED
;
1855 retval
= rtsx_write_phy_register(chip
, 0x1C, reg
);
1856 if (retval
!= STATUS_SUCCESS
) {
1858 return TRANSPORT_FAILED
;
1862 return TRANSPORT_GOOD
;
1865 static int rw_mem_cmd_buf(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
1867 int retval
= STATUS_SUCCESS
;
1868 unsigned int lun
= SCSI_LUN(srb
);
1869 u8 cmd_type
, mask
, value
, idx
;
1872 rtsx_disable_aspm(chip
);
1874 if (chip
->ss_en
&& (rtsx_get_stat(chip
) == RTSX_STAT_SS
)) {
1878 rtsx_set_stat(chip
, RTSX_STAT_RUN
);
1880 switch (srb
->cmnd
[3]) {
1882 rtsx_init_cmd(chip
);
1886 cmd_type
= srb
->cmnd
[4];
1888 set_sense_type(chip
, lun
,
1889 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
1891 return TRANSPORT_FAILED
;
1893 addr
= (srb
->cmnd
[5] << 8) | srb
->cmnd
[6];
1894 mask
= srb
->cmnd
[7];
1895 value
= srb
->cmnd
[8];
1896 rtsx_add_cmd(chip
, cmd_type
, addr
, mask
, value
);
1900 retval
= rtsx_send_cmd(chip
, 0, 1000);
1905 value
= *(rtsx_get_cmd_data(chip
) + idx
);
1906 if (scsi_bufflen(srb
) < 1) {
1907 set_sense_type(chip
, lun
,
1908 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
1910 return TRANSPORT_FAILED
;
1912 rtsx_stor_set_xfer_buf(&value
, 1, srb
);
1913 scsi_set_resid(srb
, 0);
1917 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
1919 return TRANSPORT_FAILED
;
1922 if (retval
!= STATUS_SUCCESS
) {
1923 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_WRITE_ERR
);
1925 return TRANSPORT_FAILED
;
1928 return TRANSPORT_GOOD
;
1931 static int suit_cmd(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
1933 switch (srb
->cmnd
[3]) {
1938 return rw_mem_cmd_buf(srb
, chip
);
1940 return TRANSPORT_ERROR
;
1944 static int read_phy_register(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
1946 unsigned short addr
, len
, i
;
1951 rtsx_disable_aspm(chip
);
1953 if (chip
->ss_en
&& (rtsx_get_stat(chip
) == RTSX_STAT_SS
)) {
1957 rtsx_set_stat(chip
, RTSX_STAT_RUN
);
1959 addr
= ((u16
)srb
->cmnd
[4] << 8) | srb
->cmnd
[5];
1960 len
= ((u16
)srb
->cmnd
[6] << 8) | srb
->cmnd
[7];
1969 return TRANSPORT_ERROR
;
1972 retval
= rtsx_force_power_on(chip
, SSC_PDCTL
);
1973 if (retval
!= STATUS_SUCCESS
) {
1975 set_sense_type(chip
, SCSI_LUN(srb
),
1976 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR
);
1978 return TRANSPORT_FAILED
;
1981 for (i
= 0; i
< len
/ 2; i
++) {
1982 retval
= rtsx_read_phy_register(chip
, addr
+ i
, &val
);
1983 if (retval
!= STATUS_SUCCESS
) {
1986 (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
;
2607 static int read_status(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
2611 unsigned int lun
= SCSI_LUN(srb
);
2613 rtsx_status
[0] = (u8
)(chip
->vendor_id
>> 8);
2614 rtsx_status
[1] = (u8
)(chip
->vendor_id
);
2616 rtsx_status
[2] = (u8
)(chip
->product_id
>> 8);
2617 rtsx_status
[3] = (u8
)(chip
->product_id
);
2619 rtsx_status
[4] = (u8
)lun
;
2621 if (CHECK_LUN_MODE(chip
, SD_MS_2LUN
)) {
2622 if (chip
->lun2card
[lun
] == SD_CARD
)
2627 if (chip
->card_exist
) {
2628 if (chip
->card_exist
& XD_CARD
)
2630 else if (chip
->card_exist
& SD_CARD
)
2632 else if (chip
->card_exist
& MS_CARD
)
2641 if (CHECK_LUN_MODE(chip
, SD_MS_2LUN
))
2646 rtsx_status
[7] = (u8
)(chip
->product_id
);
2647 rtsx_status
[8] = chip
->ic_version
;
2649 if (check_card_exist(chip
, lun
))
2654 if (CHECK_LUN_MODE(chip
, SD_MS_2LUN
))
2655 rtsx_status
[10] = 0;
2657 rtsx_status
[10] = 1;
2659 if (CHECK_LUN_MODE(chip
, SD_MS_2LUN
)) {
2660 if (chip
->lun2card
[lun
] == SD_CARD
)
2661 rtsx_status
[11] = SD_CARD
;
2663 rtsx_status
[11] = MS_CARD
;
2665 rtsx_status
[11] = XD_CARD
| SD_CARD
| MS_CARD
;
2668 if (check_card_ready(chip
, lun
))
2669 rtsx_status
[12] = 1;
2671 rtsx_status
[12] = 0;
2673 if (get_lun_card(chip
, lun
) == XD_CARD
) {
2674 rtsx_status
[13] = 0x40;
2675 } else if (get_lun_card(chip
, lun
) == SD_CARD
) {
2676 struct sd_info
*sd_card
= &chip
->sd_card
;
2678 rtsx_status
[13] = 0x20;
2679 if (CHK_SD(sd_card
)) {
2680 if (CHK_SD_HCXC(sd_card
))
2681 rtsx_status
[13] |= 0x04;
2682 if (CHK_SD_HS(sd_card
))
2683 rtsx_status
[13] |= 0x02;
2685 rtsx_status
[13] |= 0x08;
2686 if (CHK_MMC_52M(sd_card
))
2687 rtsx_status
[13] |= 0x02;
2688 if (CHK_MMC_SECTOR_MODE(sd_card
))
2689 rtsx_status
[13] |= 0x04;
2691 } else if (get_lun_card(chip
, lun
) == MS_CARD
) {
2692 struct ms_info
*ms_card
= &chip
->ms_card
;
2694 if (CHK_MSPRO(ms_card
)) {
2695 rtsx_status
[13] = 0x38;
2696 if (CHK_HG8BIT(ms_card
))
2697 rtsx_status
[13] |= 0x04;
2699 if (CHK_MSXC(ms_card
))
2700 rtsx_status
[13] |= 0x01;
2703 rtsx_status
[13] = 0x30;
2706 if (CHECK_LUN_MODE(chip
, DEFAULT_SINGLE
)) {
2708 if (chip
->sd_io
&& chip
->sd_int
)
2709 rtsx_status
[13] = 0x60;
2711 rtsx_status
[13] = 0x70;
2713 rtsx_status
[13] = 0x70;
2716 if (chip
->lun2card
[lun
] == SD_CARD
)
2717 rtsx_status
[13] = 0x20;
2719 rtsx_status
[13] = 0x30;
2723 rtsx_status
[14] = 0x78;
2724 if (CHK_SDIO_EXIST(chip
) && !CHK_SDIO_IGNORED(chip
))
2725 rtsx_status
[15] = 0x83;
2727 rtsx_status
[15] = 0x82;
2729 buf_len
= min_t(unsigned int, scsi_bufflen(srb
), sizeof(rtsx_status
));
2730 rtsx_stor_set_xfer_buf(rtsx_status
, buf_len
, srb
);
2731 scsi_set_resid(srb
, scsi_bufflen(srb
) - buf_len
);
2733 return TRANSPORT_GOOD
;
2736 static int get_card_bus_width(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
2738 unsigned int lun
= SCSI_LUN(srb
);
2741 if (!check_card_ready(chip
, lun
)) {
2742 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_NOT_PRESENT
);
2744 return TRANSPORT_FAILED
;
2747 card
= get_lun_card(chip
, lun
);
2748 if ((card
== SD_CARD
) || (card
== MS_CARD
)) {
2749 bus_width
= chip
->card_bus_width
[lun
];
2751 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR
);
2753 return TRANSPORT_FAILED
;
2756 scsi_set_resid(srb
, 0);
2757 rtsx_stor_set_xfer_buf(&bus_width
, scsi_bufflen(srb
), srb
);
2759 return TRANSPORT_GOOD
;
2762 static int spi_vendor_cmd(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
2765 unsigned int lun
= SCSI_LUN(srb
);
2768 if (CHECK_PID(chip
, 0x5208) || CHECK_PID(chip
, 0x5288)) {
2769 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
2771 return TRANSPORT_FAILED
;
2774 rtsx_disable_aspm(chip
);
2776 if (chip
->ss_en
&& (rtsx_get_stat(chip
) == RTSX_STAT_SS
)) {
2780 rtsx_set_stat(chip
, RTSX_STAT_RUN
);
2782 rtsx_force_power_on(chip
, SSC_PDCTL
);
2784 rtsx_read_register(chip
, CARD_GPIO_DIR
, &gpio_dir
);
2785 rtsx_write_register(chip
, CARD_GPIO_DIR
, 0x07, gpio_dir
& 0x06);
2787 switch (srb
->cmnd
[2]) {
2788 case SCSI_SPI_GETSTATUS
:
2789 result
= spi_get_status(srb
, chip
);
2792 case SCSI_SPI_SETPARAMETER
:
2793 result
= spi_set_parameter(srb
, chip
);
2796 case SCSI_SPI_READFALSHID
:
2797 result
= spi_read_flash_id(srb
, chip
);
2800 case SCSI_SPI_READFLASH
:
2801 result
= spi_read_flash(srb
, chip
);
2804 case SCSI_SPI_WRITEFLASH
:
2805 result
= spi_write_flash(srb
, chip
);
2808 case SCSI_SPI_WRITEFLASHSTATUS
:
2809 result
= spi_write_flash_status(srb
, chip
);
2812 case SCSI_SPI_ERASEFLASH
:
2813 result
= spi_erase_flash(srb
, chip
);
2817 rtsx_write_register(chip
, CARD_GPIO_DIR
, 0x07, gpio_dir
);
2819 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
2821 return TRANSPORT_FAILED
;
2824 rtsx_write_register(chip
, CARD_GPIO_DIR
, 0x07, gpio_dir
);
2826 if (result
!= STATUS_SUCCESS
) {
2828 return TRANSPORT_FAILED
;
2831 return TRANSPORT_GOOD
;
2834 static int vendor_cmnd(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
2838 switch (srb
->cmnd
[1]) {
2840 result
= read_status(srb
, chip
);
2844 result
= read_mem(srb
, chip
);
2848 result
= write_mem(srb
, chip
);
2852 result
= read_eeprom(srb
, chip
);
2856 result
= write_eeprom(srb
, chip
);
2860 result
= toggle_gpio_cmd(srb
, chip
);
2864 result
= get_sd_csd(srb
, chip
);
2868 result
= get_card_bus_width(srb
, chip
);
2873 result
= trace_msg_cmd(srb
, chip
);
2878 result
= app_cmd(srb
, chip
);
2881 case SPI_VENDOR_COMMAND
:
2882 result
= spi_vendor_cmd(srb
, chip
);
2886 set_sense_type(chip
, SCSI_LUN(srb
),
2887 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
2889 return TRANSPORT_FAILED
;
2895 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
2896 void led_shine(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
2898 unsigned int lun
= SCSI_LUN(srb
);
2901 if ((srb
->cmnd
[0] == READ_10
) || (srb
->cmnd
[0] == WRITE_10
)) {
2902 sec_cnt
= ((u16
)(srb
->cmnd
[7]) << 8) | srb
->cmnd
[8];
2903 } else if ((srb
->cmnd
[0] == READ_6
) || (srb
->cmnd
[0] == WRITE_6
)) {
2904 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) {
3036 buf
= kmalloc(buf_len
, GFP_KERNEL
);
3039 return TRANSPORT_ERROR
;
3043 /* GET Memory Stick Media Information Response Header */
3044 buf
[i
++] = 0x00; /* Data length MSB */
3045 buf
[i
++] = data_len
; /* Data length LSB */
3046 /* Device Information Type Code */
3047 if (CHK_MSXC(ms_card
))
3058 /* Number of Device Information */
3061 /* Device Information Body */
3063 /* Device Information ID Number */
3064 buf
[i
++] = dev_info_id
;
3065 /* Device Information Length */
3066 if (dev_info_id
== 0x15)
3071 buf
[i
++] = 0x00; /* Data length MSB */
3072 buf
[i
++] = data_len
; /* Data length LSB */
3075 if ((dev_info_id
== 0x10) || (dev_info_id
== 0x13)) {
3076 /* System Information */
3077 memcpy(buf
+ i
, ms_card
->raw_sys_info
, 96);
3080 memcpy(buf
+ i
, ms_card
->raw_model_name
, 48);
3083 rtsx_stor_set_xfer_buf(buf
, buf_len
, srb
);
3085 if (dev_info_id
== 0x15)
3086 scsi_set_resid(srb
, scsi_bufflen(srb
) - 0x3C);
3088 scsi_set_resid(srb
, scsi_bufflen(srb
) - 0x6C);
3091 return STATUS_SUCCESS
;
3095 static int ms_sp_cmnd(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
3097 int retval
= TRANSPORT_ERROR
;
3099 if (srb
->cmnd
[2] == MS_FORMAT
)
3100 retval
= ms_format_cmnd(srb
, chip
);
3101 #ifdef SUPPORT_PCGL_1P18
3102 else if (srb
->cmnd
[2] == GET_MS_INFORMATION
)
3103 retval
= get_ms_information(srb
, chip
);
3110 static int sd_extension_cmnd(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
3112 unsigned int lun
= SCSI_LUN(srb
);
3115 rtsx_disable_aspm(chip
);
3117 if (chip
->ss_en
&& (rtsx_get_stat(chip
) == RTSX_STAT_SS
)) {
3121 rtsx_set_stat(chip
, RTSX_STAT_RUN
);
3123 sd_cleanup_work(chip
);
3125 if (!check_card_ready(chip
, lun
)) {
3126 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_NOT_PRESENT
);
3128 return TRANSPORT_FAILED
;
3130 if (get_lun_card(chip
, lun
) != SD_CARD
) {
3131 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT
);
3133 return TRANSPORT_FAILED
;
3136 switch (srb
->cmnd
[0]) {
3137 case SD_PASS_THRU_MODE
:
3138 result
= sd_pass_thru_mode(srb
, chip
);
3141 case SD_EXECUTE_NO_DATA
:
3142 result
= sd_execute_no_data(srb
, chip
);
3145 case SD_EXECUTE_READ
:
3146 result
= sd_execute_read_data(srb
, chip
);
3149 case SD_EXECUTE_WRITE
:
3150 result
= sd_execute_write_data(srb
, chip
);
3154 result
= sd_get_cmd_rsp(srb
, chip
);
3158 result
= sd_hw_rst(srb
, chip
);
3162 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
3164 return TRANSPORT_FAILED
;
3171 #ifdef SUPPORT_MAGIC_GATE
3172 static int mg_report_key(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
3174 struct ms_info
*ms_card
= &chip
->ms_card
;
3175 unsigned int lun
= SCSI_LUN(srb
);
3179 rtsx_disable_aspm(chip
);
3181 if (chip
->ss_en
&& (rtsx_get_stat(chip
) == RTSX_STAT_SS
)) {
3185 rtsx_set_stat(chip
, RTSX_STAT_RUN
);
3187 ms_cleanup_work(chip
);
3189 if (!check_card_ready(chip
, lun
)) {
3190 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_NOT_PRESENT
);
3192 return TRANSPORT_FAILED
;
3194 if (get_lun_card(chip
, lun
) != MS_CARD
) {
3195 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT
);
3197 return TRANSPORT_FAILED
;
3200 if (srb
->cmnd
[7] != KC_MG_R_PRO
) {
3201 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
3203 return TRANSPORT_FAILED
;
3206 if (!CHK_MSPRO(ms_card
)) {
3207 set_sense_type(chip
, lun
, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM
);
3209 return TRANSPORT_FAILED
;
3212 key_format
= srb
->cmnd
[10] & 0x3F;
3213 dev_dbg(rtsx_dev(chip
), "key_format = 0x%x\n", key_format
);
3215 switch (key_format
) {
3216 case KF_GET_LOC_EKB
:
3217 if ((scsi_bufflen(srb
) == 0x41C) &&
3218 (srb
->cmnd
[8] == 0x04) &&
3219 (srb
->cmnd
[9] == 0x1C)) {
3220 retval
= mg_get_local_EKB(srb
, chip
);
3221 if (retval
!= STATUS_SUCCESS
) {
3223 return TRANSPORT_FAILED
;
3227 set_sense_type(chip
, lun
,
3228 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
3230 return TRANSPORT_FAILED
;
3235 if ((scsi_bufflen(srb
) == 0x24) &&
3236 (srb
->cmnd
[8] == 0x00) &&
3237 (srb
->cmnd
[9] == 0x24)) {
3238 retval
= mg_get_rsp_chg(srb
, chip
);
3239 if (retval
!= STATUS_SUCCESS
) {
3241 return TRANSPORT_FAILED
;
3245 set_sense_type(chip
, lun
,
3246 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
3248 return TRANSPORT_FAILED
;
3253 ms_card
->mg_entry_num
= srb
->cmnd
[5];
3254 if ((scsi_bufflen(srb
) == 0x404) &&
3255 (srb
->cmnd
[8] == 0x04) &&
3256 (srb
->cmnd
[9] == 0x04) &&
3257 (srb
->cmnd
[2] == 0x00) &&
3258 (srb
->cmnd
[3] == 0x00) &&
3259 (srb
->cmnd
[4] == 0x00) &&
3260 (srb
->cmnd
[5] < 32)) {
3261 retval
= mg_get_ICV(srb
, chip
);
3262 if (retval
!= STATUS_SUCCESS
) {
3264 return TRANSPORT_FAILED
;
3268 set_sense_type(chip
, lun
,
3269 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
3271 return TRANSPORT_FAILED
;
3276 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
3278 return TRANSPORT_FAILED
;
3281 scsi_set_resid(srb
, 0);
3282 return TRANSPORT_GOOD
;
3285 static int mg_send_key(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
3287 struct ms_info
*ms_card
= &chip
->ms_card
;
3288 unsigned int lun
= SCSI_LUN(srb
);
3292 rtsx_disable_aspm(chip
);
3294 if (chip
->ss_en
&& (rtsx_get_stat(chip
) == RTSX_STAT_SS
)) {
3298 rtsx_set_stat(chip
, RTSX_STAT_RUN
);
3300 ms_cleanup_work(chip
);
3302 if (!check_card_ready(chip
, lun
)) {
3303 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_NOT_PRESENT
);
3305 return TRANSPORT_FAILED
;
3307 if (check_card_wp(chip
, lun
)) {
3308 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_WRITE_PROTECT
);
3310 return TRANSPORT_FAILED
;
3312 if (get_lun_card(chip
, lun
) != MS_CARD
) {
3313 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT
);
3315 return TRANSPORT_FAILED
;
3318 if (srb
->cmnd
[7] != KC_MG_R_PRO
) {
3319 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
3321 return TRANSPORT_FAILED
;
3324 if (!CHK_MSPRO(ms_card
)) {
3325 set_sense_type(chip
, lun
, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM
);
3327 return TRANSPORT_FAILED
;
3330 key_format
= srb
->cmnd
[10] & 0x3F;
3331 dev_dbg(rtsx_dev(chip
), "key_format = 0x%x\n", key_format
);
3333 switch (key_format
) {
3334 case KF_SET_LEAF_ID
:
3335 if ((scsi_bufflen(srb
) == 0x0C) &&
3336 (srb
->cmnd
[8] == 0x00) &&
3337 (srb
->cmnd
[9] == 0x0C)) {
3338 retval
= mg_set_leaf_id(srb
, chip
);
3339 if (retval
!= STATUS_SUCCESS
) {
3341 return TRANSPORT_FAILED
;
3345 set_sense_type(chip
, lun
,
3346 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
3348 return TRANSPORT_FAILED
;
3353 if ((scsi_bufflen(srb
) == 0x0C) &&
3354 (srb
->cmnd
[8] == 0x00) &&
3355 (srb
->cmnd
[9] == 0x0C)) {
3356 retval
= mg_chg(srb
, chip
);
3357 if (retval
!= STATUS_SUCCESS
) {
3359 return TRANSPORT_FAILED
;
3363 set_sense_type(chip
, lun
,
3364 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
3366 return TRANSPORT_FAILED
;
3371 if ((scsi_bufflen(srb
) == 0x0C) &&
3372 (srb
->cmnd
[8] == 0x00) &&
3373 (srb
->cmnd
[9] == 0x0C)) {
3374 retval
= mg_rsp(srb
, chip
);
3375 if (retval
!= STATUS_SUCCESS
) {
3377 return TRANSPORT_FAILED
;
3381 set_sense_type(chip
, lun
,
3382 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
3384 return TRANSPORT_FAILED
;
3389 ms_card
->mg_entry_num
= srb
->cmnd
[5];
3390 if ((scsi_bufflen(srb
) == 0x404) &&
3391 (srb
->cmnd
[8] == 0x04) &&
3392 (srb
->cmnd
[9] == 0x04) &&
3393 (srb
->cmnd
[2] == 0x00) &&
3394 (srb
->cmnd
[3] == 0x00) &&
3395 (srb
->cmnd
[4] == 0x00) &&
3396 (srb
->cmnd
[5] < 32)) {
3397 retval
= mg_set_ICV(srb
, chip
);
3398 if (retval
!= STATUS_SUCCESS
) {
3400 return TRANSPORT_FAILED
;
3404 set_sense_type(chip
, lun
,
3405 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
3407 return TRANSPORT_FAILED
;
3412 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
3414 return TRANSPORT_FAILED
;
3417 scsi_set_resid(srb
, 0);
3418 return TRANSPORT_GOOD
;
3422 int rtsx_scsi_handler(struct scsi_cmnd
*srb
, struct rtsx_chip
*chip
)
3424 #ifdef SUPPORT_SD_LOCK
3425 struct sd_info
*sd_card
= &chip
->sd_card
;
3427 struct ms_info
*ms_card
= &chip
->ms_card
;
3428 unsigned int lun
= SCSI_LUN(srb
);
3431 #ifdef SUPPORT_SD_LOCK
3432 if (sd_card
->sd_erase_status
) {
3433 /* Block all SCSI command except for
3434 * REQUEST_SENSE and rs_ppstatus
3436 if (!((srb
->cmnd
[0] == VENDOR_CMND
) &&
3437 (srb
->cmnd
[1] == SCSI_APP_CMD
) &&
3438 (srb
->cmnd
[2] == GET_DEV_STATUS
)) &&
3439 (srb
->cmnd
[0] != REQUEST_SENSE
)) {
3440 /* Logical Unit Not Ready Format in Progress */
3441 set_sense_data(chip
, lun
, CUR_ERR
,
3442 0x02, 0, 0x04, 0x04, 0, 0);
3444 return TRANSPORT_FAILED
;
3449 if ((get_lun_card(chip
, lun
) == MS_CARD
) &&
3450 (ms_card
->format_status
== FORMAT_IN_PROGRESS
)) {
3451 if ((srb
->cmnd
[0] != REQUEST_SENSE
) &&
3452 (srb
->cmnd
[0] != INQUIRY
)) {
3453 /* Logical Unit Not Ready Format in Progress */
3454 set_sense_data(chip
, lun
, CUR_ERR
, 0x02, 0, 0x04, 0x04,
3455 0, (u16
)(ms_card
->progress
));
3457 return TRANSPORT_FAILED
;
3461 switch (srb
->cmnd
[0]) {
3466 result
= read_write(srb
, chip
);
3467 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
3468 led_shine(srb
, chip
);
3472 case TEST_UNIT_READY
:
3473 result
= test_unit_ready(srb
, chip
);
3477 result
= inquiry(srb
, chip
);
3481 result
= read_capacity(srb
, chip
);
3485 result
= start_stop_unit(srb
, chip
);
3488 case ALLOW_MEDIUM_REMOVAL
:
3489 result
= allow_medium_removal(srb
, chip
);
3493 result
= request_sense(srb
, chip
);
3498 result
= mode_sense(srb
, chip
);
3502 result
= read_format_capacity(srb
, chip
);
3506 result
= vendor_cmnd(srb
, chip
);
3510 result
= ms_sp_cmnd(srb
, chip
);
3514 case SD_PASS_THRU_MODE
:
3515 case SD_EXECUTE_NO_DATA
:
3516 case SD_EXECUTE_READ
:
3517 case SD_EXECUTE_WRITE
:
3520 result
= sd_extension_cmnd(srb
, chip
);
3524 #ifdef SUPPORT_MAGIC_GATE
3525 case CMD_MSPRO_MG_RKEY
:
3526 result
= mg_report_key(srb
, chip
);
3529 case CMD_MSPRO_MG_SKEY
:
3530 result
= mg_send_key(srb
, chip
);
3537 result
= TRANSPORT_GOOD
;
3541 set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
3542 result
= TRANSPORT_FAILED
;