1 /* Driver for Realtek PCI-Express card reader
3 * Copyright(c) 2009 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 * wwang (wei_wang@realsil.com.cn)
20 * No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
23 #include <linux/blkdev.h>
24 #include <linux/kthread.h>
25 #include <linux/sched.h>
28 #include "rtsx_transport.h"
30 #include "rtsx_card.h"
31 #include "rtsx_chip.h"
32 #include "rtsx_scsi.h"
37 void scsi_show_command(struct scsi_cmnd *srb)
40 int i, unknown_cmd = 0;
42 switch (srb->cmnd[0]) {
43 case TEST_UNIT_READY: what = "TEST_UNIT_READY"; break;
44 case REZERO_UNIT: what = "REZERO_UNIT"; break;
45 case REQUEST_SENSE: what = "REQUEST_SENSE"; break;
46 case FORMAT_UNIT: what = "FORMAT_UNIT"; break;
47 case READ_BLOCK_LIMITS: what = "READ_BLOCK_LIMITS"; break;
48 case REASSIGN_BLOCKS: what = "REASSIGN_BLOCKS"; break;
49 case READ_6: what = "READ_6"; break;
50 case WRITE_6: what = "WRITE_6"; break;
51 case SEEK_6: what = "SEEK_6"; break;
52 case READ_REVERSE: what = "READ_REVERSE"; break;
53 case WRITE_FILEMARKS: what = "WRITE_FILEMARKS"; break;
54 case SPACE: what = "SPACE"; break;
55 case INQUIRY: what = "INQUIRY"; break;
56 case RECOVER_BUFFERED_DATA: what = "RECOVER_BUFFERED_DATA"; break;
57 case MODE_SELECT: what = "MODE_SELECT"; break;
58 case RESERVE: what = "RESERVE"; break;
59 case RELEASE: what = "RELEASE"; break;
60 case COPY: what = "COPY"; break;
61 case ERASE: what = "ERASE"; break;
62 case MODE_SENSE: what = "MODE_SENSE"; break;
63 case START_STOP: what = "START_STOP"; break;
64 case RECEIVE_DIAGNOSTIC: what = "RECEIVE_DIAGNOSTIC"; break;
65 case SEND_DIAGNOSTIC: what = "SEND_DIAGNOSTIC"; break;
66 case ALLOW_MEDIUM_REMOVAL: what = "ALLOW_MEDIUM_REMOVAL"; break;
67 case SET_WINDOW: what = "SET_WINDOW"; break;
68 case READ_CAPACITY: what = "READ_CAPACITY"; break;
69 case READ_10: what = "READ_10"; break;
70 case WRITE_10: what = "WRITE_10"; break;
71 case SEEK_10: what = "SEEK_10"; break;
72 case WRITE_VERIFY: what = "WRITE_VERIFY"; break;
73 case VERIFY: what = "VERIFY"; break;
74 case SEARCH_HIGH: what = "SEARCH_HIGH"; break;
75 case SEARCH_EQUAL: what = "SEARCH_EQUAL"; break;
76 case SEARCH_LOW: what = "SEARCH_LOW"; break;
77 case SET_LIMITS: what = "SET_LIMITS"; break;
78 case READ_POSITION: what = "READ_POSITION"; break;
79 case SYNCHRONIZE_CACHE: what = "SYNCHRONIZE_CACHE"; break;
80 case LOCK_UNLOCK_CACHE: what = "LOCK_UNLOCK_CACHE"; break;
81 case READ_DEFECT_DATA: what = "READ_DEFECT_DATA"; break;
82 case MEDIUM_SCAN: what = "MEDIUM_SCAN"; break;
83 case COMPARE: what = "COMPARE"; break;
84 case COPY_VERIFY: what = "COPY_VERIFY"; break;
85 case WRITE_BUFFER: what = "WRITE_BUFFER"; break;
86 case READ_BUFFER: what = "READ_BUFFER"; break;
87 case UPDATE_BLOCK: what = "UPDATE_BLOCK"; break;
88 case READ_LONG: what = "READ_LONG"; break;
89 case WRITE_LONG: what = "WRITE_LONG"; break;
90 case CHANGE_DEFINITION: what = "CHANGE_DEFINITION"; break;
91 case WRITE_SAME: what = "WRITE_SAME"; break;
92 case GPCMD_READ_SUBCHANNEL: what = "READ SUBCHANNEL"; break;
93 case READ_TOC: what = "READ_TOC"; break;
94 case GPCMD_READ_HEADER: what = "READ HEADER"; break;
95 case GPCMD_PLAY_AUDIO_10: what = "PLAY AUDIO (10)"; break;
96 case GPCMD_PLAY_AUDIO_MSF: what = "PLAY AUDIO MSF"; break;
97 case GPCMD_GET_EVENT_STATUS_NOTIFICATION:
98 what = "GET EVENT/STATUS NOTIFICATION"; break;
99 case GPCMD_PAUSE_RESUME: what = "PAUSE/RESUME"; break;
100 case LOG_SELECT: what = "LOG_SELECT"; break;
101 case LOG_SENSE: what = "LOG_SENSE"; break;
102 case GPCMD_STOP_PLAY_SCAN: what = "STOP PLAY/SCAN"; break;
103 case GPCMD_READ_DISC_INFO: what = "READ DISC INFORMATION"; break;
104 case GPCMD_READ_TRACK_RZONE_INFO:
105 what = "READ TRACK INFORMATION"; break;
106 case GPCMD_RESERVE_RZONE_TRACK: what = "RESERVE TRACK"; break;
107 case GPCMD_SEND_OPC: what = "SEND OPC"; break;
108 case MODE_SELECT_10: what = "MODE_SELECT_10"; break;
109 case GPCMD_REPAIR_RZONE_TRACK: what = "REPAIR TRACK"; break;
110 case 0x59: what = "READ MASTER CUE"; break;
111 case MODE_SENSE_10: what = "MODE_SENSE_10"; break;
112 case GPCMD_CLOSE_TRACK: what = "CLOSE TRACK/SESSION"; break;
113 case 0x5C: what = "READ BUFFER CAPACITY"; break;
114 case 0x5D: what = "SEND CUE SHEET"; break;
115 case GPCMD_BLANK: what = "BLANK"; break;
116 case REPORT_LUNS: what = "REPORT LUNS"; break;
117 case MOVE_MEDIUM: what = "MOVE_MEDIUM or PLAY AUDIO (12)"; break;
118 case READ_12: what = "READ_12"; break;
119 case WRITE_12: what = "WRITE_12"; break;
120 case WRITE_VERIFY_12: what = "WRITE_VERIFY_12"; break;
121 case SEARCH_HIGH_12: what = "SEARCH_HIGH_12"; break;
122 case SEARCH_EQUAL_12: what = "SEARCH_EQUAL_12"; break;
123 case SEARCH_LOW_12: what = "SEARCH_LOW_12"; break;
124 case SEND_VOLUME_TAG: what = "SEND_VOLUME_TAG"; break;
125 case READ_ELEMENT_STATUS: what = "READ_ELEMENT_STATUS"; break;
126 case GPCMD_READ_CD_MSF: what = "READ CD MSF"; break;
127 case GPCMD_SCAN: what = "SCAN"; break;
128 case GPCMD_SET_SPEED: what = "SET CD SPEED"; break;
129 case GPCMD_MECHANISM_STATUS: what = "MECHANISM STATUS"; break;
130 case GPCMD_READ_CD: what = "READ CD"; break;
131 case 0xE1: what = "WRITE CONTINUE"; break;
132 case WRITE_LONG_2: what = "WRITE_LONG_2"; break;
133 case VENDOR_CMND: what = "Realtek's vendor command"; break;
134 default: what = "(unknown command)"; unknown_cmd = 1; break;
137 if (srb->cmnd[0] != TEST_UNIT_READY) {
138 RTSX_DEBUGP("Command %s (%d bytes)\n", what, srb->cmd_len);
142 for (i = 0; i < srb->cmd_len && i < 16; i++)
143 RTSX_DEBUGPN(" %02x", srb->cmnd[i]);
148 void set_sense_type(struct rtsx_chip *chip, unsigned int lun, int sense_type)
150 switch (sense_type) {
151 case SENSE_TYPE_MEDIA_CHANGE:
152 set_sense_data(chip, lun, CUR_ERR, 0x06, 0, 0x28, 0, 0, 0);
155 case SENSE_TYPE_MEDIA_NOT_PRESENT:
156 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x3A, 0, 0, 0);
159 case SENSE_TYPE_MEDIA_LBA_OVER_RANGE:
160 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x21, 0, 0, 0);
163 case SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT:
164 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x25, 0, 0, 0);
167 case SENSE_TYPE_MEDIA_WRITE_PROTECT:
168 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x27, 0, 0, 0);
171 case SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR:
172 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x11, 0, 0, 0);
175 case SENSE_TYPE_MEDIA_WRITE_ERR:
176 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x02, 0, 0);
179 case SENSE_TYPE_MEDIA_INVALID_CMD_FIELD:
180 set_sense_data(chip, lun, CUR_ERR, ILGAL_REQ, 0,
181 ASC_INVLD_CDB, ASCQ_INVLD_CDB, CDB_ILLEGAL, 1);
184 case SENSE_TYPE_FORMAT_IN_PROGRESS:
185 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 0, 0);
188 case SENSE_TYPE_FORMAT_CMD_FAILED:
189 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x31, 0x01, 0, 0);
192 #ifdef SUPPORT_MAGIC_GATE
193 case SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB:
194 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x02, 0, 0);
197 case SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN:
198 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x00, 0, 0);
201 case SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM:
202 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x30, 0x00, 0, 0);
205 case SENSE_TYPE_MG_WRITE_ERR:
206 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x00, 0, 0);
210 #ifdef SUPPORT_SD_LOCK
211 case SENSE_TYPE_MEDIA_READ_FORBIDDEN:
212 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x11, 0x13, 0, 0);
216 case SENSE_TYPE_NO_SENSE:
218 set_sense_data(chip, lun, CUR_ERR, 0, 0, 0, 0, 0, 0);
223 void set_sense_data(struct rtsx_chip *chip, unsigned int lun, u8 err_code, u8 sense_key,
224 u32 info, u8 asc, u8 ascq, u8 sns_key_info0, u16 sns_key_info1)
226 struct sense_data_t *sense = &(chip->sense_buffer[lun]);
228 sense->err_code = err_code;
229 sense->sense_key = sense_key;
230 sense->info[0] = (u8)(info >> 24);
231 sense->info[1] = (u8)(info >> 16);
232 sense->info[2] = (u8)(info >> 8);
233 sense->info[3] = (u8)info;
235 sense->ad_sense_len = sizeof(struct sense_data_t) - 8;
238 if (sns_key_info0 != 0) {
239 sense->sns_key_info[0] = SKSV | sns_key_info0;
240 sense->sns_key_info[1] = (sns_key_info1 & 0xf0) >> 8;
241 sense->sns_key_info[2] = sns_key_info1 & 0x0f;
245 static int test_unit_ready(struct scsi_cmnd *srb, struct rtsx_chip *chip)
247 unsigned int lun = SCSI_LUN(srb);
249 if (!check_card_ready(chip, lun)) {
250 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
251 return TRANSPORT_FAILED;
254 if (!(CHK_BIT(chip->lun_mc, lun))) {
255 SET_BIT(chip->lun_mc, lun);
256 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
257 return TRANSPORT_FAILED;
260 #ifdef SUPPORT_SD_LOCK
261 if (get_lun_card(chip, SCSI_LUN(srb)) == SD_CARD) {
262 struct sd_info *sd_card = &(chip->sd_card);
263 if (sd_card->sd_lock_notify) {
264 sd_card->sd_lock_notify = 0;
265 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
266 return TRANSPORT_FAILED;
267 } else if (sd_card->sd_lock_status & SD_LOCKED) {
268 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
269 return TRANSPORT_FAILED;
274 return TRANSPORT_GOOD;
277 static unsigned char formatter_inquiry_str[20] = {
278 'M', 'E', 'M', 'O', 'R', 'Y', 'S', 'T', 'I', 'C', 'K',
279 #ifdef SUPPORT_MAGIC_GATE
280 '-', 'M', 'G', /* Byte[47:49] */
282 0x20, 0x20, 0x20, /* Byte[47:49] */
285 #ifdef SUPPORT_MAGIC_GATE
286 0x0B, /* Byte[50]: MG, MS, MSPro, MSXC */
288 0x09, /* Byte[50]: MS, MSPro, MSXC */
290 0x00, /* Byte[51]: Category Specific Commands */
291 0x00, /* Byte[52]: Access Control and feature */
292 0x20, 0x20, 0x20, /* Byte[53:55] */
295 static int inquiry(struct scsi_cmnd *srb, struct rtsx_chip *chip)
297 unsigned int lun = SCSI_LUN(srb);
298 char *inquiry_default = (char *)"Generic-xD/SD/M.S. 1.00 ";
299 char *inquiry_sdms = (char *)"Generic-SD/MemoryStick 1.00 ";
300 char *inquiry_sd = (char *)"Generic-SD/MMC 1.00 ";
301 char *inquiry_ms = (char *)"Generic-MemoryStick 1.00 ";
302 char *inquiry_string;
303 unsigned char sendbytes;
305 u8 card = get_lun_card(chip, lun);
306 int pro_formatter_flag = 0;
307 unsigned char inquiry_buf[] = {
308 QULIFIRE|DRCT_ACCESS_DEV,
315 REL_ADR|WBUS_32|WBUS_16|SYNC|LINKED|CMD_QUE|SFT_RE,
318 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
319 if (chip->lun2card[lun] == SD_CARD) {
320 inquiry_string = inquiry_sd;
322 inquiry_string = inquiry_ms;
324 } else if (CHECK_LUN_MODE(chip, SD_MS_1LUN)) {
325 inquiry_string = inquiry_sdms;
327 inquiry_string = inquiry_default;
330 buf = vmalloc(scsi_bufflen(srb));
332 TRACE_RET(chip, TRANSPORT_ERROR);
335 #ifdef SUPPORT_MAGIC_GATE
336 if ((chip->mspro_formatter_enable) &&
337 (chip->lun2card[lun] & MS_CARD))
339 if (chip->mspro_formatter_enable)
342 if (!card || (card == MS_CARD)) {
343 pro_formatter_flag = 1;
347 if (pro_formatter_flag) {
348 if (scsi_bufflen(srb) < 56) {
349 sendbytes = (unsigned char)(scsi_bufflen(srb));
354 if (scsi_bufflen(srb) < 36) {
355 sendbytes = (unsigned char)(scsi_bufflen(srb));
362 memcpy(buf, inquiry_buf, 8);
363 memcpy(buf + 8, inquiry_string, sendbytes - 8);
364 if (pro_formatter_flag) {
365 /* Additional Length */
369 memcpy(buf, inquiry_buf, sendbytes);
372 if (pro_formatter_flag) {
373 if (sendbytes > 36) {
374 memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36);
378 scsi_set_resid(srb, 0);
380 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
383 return TRANSPORT_GOOD;
387 static int start_stop_unit(struct scsi_cmnd *srb, struct rtsx_chip *chip)
389 unsigned int lun = SCSI_LUN(srb);
391 scsi_set_resid(srb, scsi_bufflen(srb));
393 if (srb->cmnd[1] == 1)
394 return TRANSPORT_GOOD;
396 switch (srb->cmnd[0x4]) {
399 return TRANSPORT_GOOD;
402 /* Media shall be unload */
403 if (check_card_ready(chip, lun))
404 eject_card(chip, lun);
405 return TRANSPORT_GOOD;
407 case MAKE_MEDIUM_READY:
409 if (check_card_ready(chip, lun)) {
410 return TRANSPORT_GOOD;
412 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
413 TRACE_RET(chip, TRANSPORT_FAILED);
419 TRACE_RET(chip, TRANSPORT_ERROR);
423 static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip)
427 prevent = srb->cmnd[4] & 0x1;
429 scsi_set_resid(srb, 0);
432 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
433 TRACE_RET(chip, TRANSPORT_FAILED);
436 return TRANSPORT_GOOD;
440 static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
442 struct sense_data_t *sense;
443 unsigned int lun = SCSI_LUN(srb);
444 struct ms_info *ms_card = &(chip->ms_card);
445 unsigned char *tmp, *buf;
447 sense = &(chip->sense_buffer[lun]);
449 if ((get_lun_card(chip, lun) == MS_CARD) && ms_card->pro_under_formatting) {
450 if (ms_card->format_status == FORMAT_SUCCESS) {
451 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
452 ms_card->pro_under_formatting = 0;
453 ms_card->progress = 0;
454 } else if (ms_card->format_status == FORMAT_IN_PROGRESS) {
455 /* Logical Unit Not Ready Format in Progress */
456 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
457 0, (u16)(ms_card->progress));
459 /* Format Command Failed */
460 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
461 ms_card->pro_under_formatting = 0;
462 ms_card->progress = 0;
465 rtsx_set_stat(chip, RTSX_STAT_RUN);
468 buf = vmalloc(scsi_bufflen(srb));
470 TRACE_RET(chip, TRANSPORT_ERROR);
473 tmp = (unsigned char *)sense;
474 memcpy(buf, tmp, scsi_bufflen(srb));
476 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
479 scsi_set_resid(srb, 0);
480 /* Reset Sense Data */
481 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
482 return TRANSPORT_GOOD;
485 static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd,
486 int lun, u8 *buf, int buf_len)
488 struct ms_info *ms_card = &(chip->ms_card);
490 int data_size = buf_len;
491 int support_format = 0;
494 if (cmd == MODE_SENSE) {
496 if (data_size > 0x68) {
499 buf[i++] = 0x67; /* Mode Data Length */
501 sys_info_offset = 12;
502 if (data_size > 0x6C) {
505 buf[i++] = 0x00; /* Mode Data Length (MSB) */
506 buf[i++] = 0x6A; /* Mode Data Length (LSB) */
509 /* Medium Type Code */
510 if (check_card_ready(chip, lun)) {
511 if (CHK_MSXC(ms_card)) {
514 } else if (CHK_MSPRO(ms_card)) {
522 if (check_card_wp(chip, lun)) {
528 buf[i++] = 0x00; /* MediaType */
529 buf[i++] = 0x00; /* WP */
532 buf[i++] = 0x00; /* Reserved */
534 if (cmd == MODE_SENSE_10) {
535 buf[i++] = 0x00; /* Reserved */
536 buf[i++] = 0x00; /* Block descriptor length(MSB) */
537 buf[i++] = 0x00; /* Block descriptor length(LSB) */
539 /* The Following Data is the content of "Page 0x20" */
541 buf[i++] = 0x20; /* Page Code */
543 buf[i++] = 0x62; /* Page Length */
545 buf[i++] = 0x00; /* No Access Control */
546 if (data_size >= 12) {
547 if (support_format) {
548 buf[i++] = 0xC0; /* SF, SGM */
554 /* The Following Data is the content of "Page 0x20" */
556 buf[i++] = 0x20; /* Page Code */
558 buf[i++] = 0x62; /* Page Length */
560 buf[i++] = 0x00; /* No Access Control */
561 if (data_size >= 8) {
562 if (support_format) {
563 buf[i++] = 0xC0; /* SF, SGM */
570 if (data_size > sys_info_offset) {
571 /* 96 Bytes Attribute Data */
572 int len = data_size - sys_info_offset;
573 len = (len < 96) ? len : 96;
575 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len);
579 static int mode_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
581 unsigned int lun = SCSI_LUN(srb);
582 unsigned int dataSize;
584 int pro_formatter_flag;
585 unsigned char pageCode, *buf;
586 u8 card = get_lun_card(chip, lun);
588 #ifndef SUPPORT_MAGIC_GATE
589 if (!check_card_ready(chip, lun)) {
590 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
591 scsi_set_resid(srb, scsi_bufflen(srb));
592 TRACE_RET(chip, TRANSPORT_FAILED);
596 pro_formatter_flag = 0;
598 #ifdef SUPPORT_MAGIC_GATE
599 if ((chip->lun2card[lun] & MS_CARD)) {
600 if (!card || (card == MS_CARD)) {
602 if (chip->mspro_formatter_enable) {
603 pro_formatter_flag = 1;
608 if (card == MS_CARD) {
609 if (chip->mspro_formatter_enable) {
610 pro_formatter_flag = 1;
616 buf = kmalloc(dataSize, GFP_KERNEL);
618 TRACE_RET(chip, TRANSPORT_ERROR);
621 pageCode = srb->cmnd[2] & 0x3f;
623 if ((pageCode == 0x3F) || (pageCode == 0x1C) ||
624 (pageCode == 0x00) ||
625 (pro_formatter_flag && (pageCode == 0x20))) {
626 if (srb->cmnd[0] == MODE_SENSE) {
627 if ((pageCode == 0x3F) || (pageCode == 0x20)) {
628 ms_mode_sense(chip, srb->cmnd[0],
634 if (check_card_wp(chip, lun)) {
642 if ((pageCode == 0x3F) || (pageCode == 0x20)) {
643 ms_mode_sense(chip, srb->cmnd[0],
650 if (check_card_wp(chip, lun)) {
661 status = TRANSPORT_GOOD;
663 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
664 scsi_set_resid(srb, scsi_bufflen(srb));
665 status = TRANSPORT_FAILED;
668 if (status == TRANSPORT_GOOD) {
669 unsigned int len = min(scsi_bufflen(srb), dataSize);
670 rtsx_stor_set_xfer_buf(buf, len, srb);
671 scsi_set_resid(srb, scsi_bufflen(srb) - len);
678 static int read_write(struct scsi_cmnd *srb, struct rtsx_chip *chip)
680 #ifdef SUPPORT_SD_LOCK
681 struct sd_info *sd_card = &(chip->sd_card);
683 unsigned int lun = SCSI_LUN(srb);
688 rtsx_disable_aspm(chip);
690 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
694 rtsx_set_stat(chip, RTSX_STAT_RUN);
696 if (!check_card_ready(chip, lun) || (get_card_size(chip, lun) == 0)) {
697 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
698 TRACE_RET(chip, TRANSPORT_FAILED);
701 if (!(CHK_BIT(chip->lun_mc, lun))) {
702 SET_BIT(chip->lun_mc, lun);
703 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
704 return TRANSPORT_FAILED;
707 #ifdef SUPPORT_SD_LOCK
708 if (sd_card->sd_erase_status) {
709 /* Accessing to any card is forbidden
710 * until the erase procedure of SD is completed
712 RTSX_DEBUGP("SD card being erased!\n");
713 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
714 TRACE_RET(chip, TRANSPORT_FAILED);
717 if (get_lun_card(chip, lun) == SD_CARD) {
718 if (sd_card->sd_lock_status & SD_LOCKED) {
719 RTSX_DEBUGP("SD card locked!\n");
720 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
721 TRACE_RET(chip, TRANSPORT_FAILED);
726 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
727 start_sec = ((u32)srb->cmnd[2] << 24) | ((u32)srb->cmnd[3] << 16) |
728 ((u32)srb->cmnd[4] << 8) | ((u32)srb->cmnd[5]);
729 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
730 } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
731 start_sec = ((u32)(srb->cmnd[1] & 0x1F) << 16) |
732 ((u32)srb->cmnd[2] << 8) | ((u32)srb->cmnd[3]);
733 sec_cnt = srb->cmnd[4];
734 } else if ((srb->cmnd[0] == VENDOR_CMND) && (srb->cmnd[1] == SCSI_APP_CMD) &&
735 ((srb->cmnd[2] == PP_READ10) || (srb->cmnd[2] == PP_WRITE10))) {
736 start_sec = ((u32)srb->cmnd[4] << 24) | ((u32)srb->cmnd[5] << 16) |
737 ((u32)srb->cmnd[6] << 8) | ((u32)srb->cmnd[7]);
738 sec_cnt = ((u16)(srb->cmnd[9]) << 8) | srb->cmnd[10];
740 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
741 TRACE_RET(chip, TRANSPORT_FAILED);
744 /* In some test, we will receive a start_sec like 0xFFFFFFFF.
745 * In this situation, start_sec + sec_cnt will overflow, so we
746 * need to judge start_sec at first
748 if ((start_sec > get_card_size(chip, lun)) ||
749 ((start_sec + sec_cnt) > get_card_size(chip, lun))) {
750 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE);
751 TRACE_RET(chip, TRANSPORT_FAILED);
755 scsi_set_resid(srb, 0);
756 return TRANSPORT_GOOD;
759 if (chip->rw_fail_cnt[lun] == 3) {
760 RTSX_DEBUGP("read/write fail three times in succession\n");
761 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
762 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
764 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
766 TRACE_RET(chip, TRANSPORT_FAILED);
769 if (srb->sc_data_direction == DMA_TO_DEVICE) {
770 if (check_card_wp(chip, lun)) {
771 RTSX_DEBUGP("Write protected card!\n");
772 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
773 TRACE_RET(chip, TRANSPORT_FAILED);
775 if (CHECK_PID(chip, 0x5209) && chip->max_payload) {
776 u8 val = 0x10 | (chip->max_payload << 5);
777 retval = rtsx_write_cfg_dw(chip, 0, 0x78, 0xFF, val);
778 if (retval != STATUS_SUCCESS) {
779 TRACE_RET(chip, TRANSPORT_ERROR);
784 retval = card_rw(srb, chip, start_sec, sec_cnt);
785 if (retval != STATUS_SUCCESS) {
786 if (chip->need_release & chip->lun2card[lun]) {
787 chip->rw_fail_cnt[lun] = 0;
788 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
790 chip->rw_fail_cnt[lun]++;
791 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
792 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
794 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
797 retval = TRANSPORT_FAILED;
798 TRACE_GOTO(chip, Exit);
800 chip->rw_fail_cnt[lun] = 0;
801 retval = TRANSPORT_GOOD;
804 scsi_set_resid(srb, 0);
807 if (srb->sc_data_direction == DMA_TO_DEVICE) {
808 if (CHECK_PID(chip, 0x5209) && chip->max_payload) {
809 retval = rtsx_write_cfg_dw(chip, 0, 0x78, 0xFF, 0x10);
810 if (retval != STATUS_SUCCESS) {
811 TRACE_RET(chip, TRANSPORT_ERROR);
819 static int read_format_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
822 unsigned int lun = SCSI_LUN(srb);
823 unsigned int buf_len;
824 u8 card = get_lun_card(chip, lun);
829 if (!check_card_ready(chip, lun)) {
830 if (!chip->mspro_formatter_enable) {
831 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
832 TRACE_RET(chip, TRANSPORT_FAILED);
836 buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12;
838 buf = kmalloc(buf_len, GFP_KERNEL);
840 TRACE_RET(chip, TRANSPORT_ERROR);
847 /* Capacity List Length */
848 if ((buf_len > 12) && chip->mspro_formatter_enable &&
849 (chip->lun2card[lun] & MS_CARD) &&
850 (!card || (card == MS_CARD))) {
859 if (check_card_ready(chip, lun)) {
860 card_size = get_card_size(chip, lun);
861 buf[i++] = (unsigned char)(card_size >> 24);
862 buf[i++] = (unsigned char)(card_size >> 16);
863 buf[i++] = (unsigned char)(card_size >> 8);
864 buf[i++] = (unsigned char)card_size;
891 buf_len = min(scsi_bufflen(srb), buf_len);
892 rtsx_stor_set_xfer_buf(buf, buf_len, srb);
895 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
897 return TRANSPORT_GOOD;
900 static int read_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
903 unsigned int lun = SCSI_LUN(srb);
906 if (!check_card_ready(chip, lun)) {
907 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
908 TRACE_RET(chip, TRANSPORT_FAILED);
911 if (!(CHK_BIT(chip->lun_mc, lun))) {
912 SET_BIT(chip->lun_mc, lun);
913 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
914 return TRANSPORT_FAILED;
917 buf = kmalloc(8, GFP_KERNEL);
919 TRACE_RET(chip, TRANSPORT_ERROR);
922 card_size = get_card_size(chip, lun);
923 buf[0] = (unsigned char)((card_size - 1) >> 24);
924 buf[1] = (unsigned char)((card_size - 1) >> 16);
925 buf[2] = (unsigned char)((card_size - 1) >> 8);
926 buf[3] = (unsigned char)(card_size - 1);
933 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
936 scsi_set_resid(srb, 0);
938 return TRANSPORT_GOOD;
941 static int read_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
943 unsigned short len, i;
947 rtsx_disable_aspm(chip);
949 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
953 rtsx_set_stat(chip, RTSX_STAT_RUN);
955 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
957 buf = (u8 *)vmalloc(len);
959 TRACE_RET(chip, TRANSPORT_ERROR);
962 retval = rtsx_force_power_on(chip, SSC_PDCTL);
963 if (retval != STATUS_SUCCESS) {
965 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
966 TRACE_RET(chip, TRANSPORT_FAILED);
969 for (i = 0; i < len; i++) {
970 retval = spi_read_eeprom(chip, i, buf + i);
971 if (retval != STATUS_SUCCESS) {
973 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
974 TRACE_RET(chip, TRANSPORT_FAILED);
978 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
979 rtsx_stor_set_xfer_buf(buf, len, srb);
980 scsi_set_resid(srb, scsi_bufflen(srb) - len);
984 return TRANSPORT_GOOD;
987 static int write_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
989 unsigned short len, i;
993 rtsx_disable_aspm(chip);
995 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
999 rtsx_set_stat(chip, RTSX_STAT_RUN);
1001 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1003 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1004 if (retval != STATUS_SUCCESS) {
1005 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1006 TRACE_RET(chip, TRANSPORT_FAILED);
1010 retval = spi_erase_eeprom_chip(chip);
1011 if (retval != STATUS_SUCCESS) {
1012 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1013 TRACE_RET(chip, TRANSPORT_FAILED);
1016 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1017 buf = (u8 *)vmalloc(len);
1019 TRACE_RET(chip, TRANSPORT_ERROR);
1022 rtsx_stor_get_xfer_buf(buf, len, srb);
1023 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1025 for (i = 0; i < len; i++) {
1026 retval = spi_write_eeprom(chip, i, buf[i]);
1027 if (retval != STATUS_SUCCESS) {
1029 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1030 TRACE_RET(chip, TRANSPORT_FAILED);
1037 return TRANSPORT_GOOD;
1040 static int read_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1042 unsigned short addr, len, i;
1046 rtsx_disable_aspm(chip);
1048 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1052 rtsx_set_stat(chip, RTSX_STAT_RUN);
1054 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1055 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1057 if (addr < 0xFC00) {
1058 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1059 TRACE_RET(chip, TRANSPORT_FAILED);
1062 buf = (u8 *)vmalloc(len);
1064 TRACE_RET(chip, TRANSPORT_ERROR);
1067 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1068 if (retval != STATUS_SUCCESS) {
1070 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1071 TRACE_RET(chip, TRANSPORT_FAILED);
1074 for (i = 0; i < len; i++) {
1075 retval = rtsx_read_register(chip, addr + i, buf + i);
1076 if (retval != STATUS_SUCCESS) {
1078 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1079 TRACE_RET(chip, TRANSPORT_FAILED);
1083 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1084 rtsx_stor_set_xfer_buf(buf, len, srb);
1085 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1089 return TRANSPORT_GOOD;
1092 static int write_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1094 unsigned short addr, len, i;
1098 rtsx_disable_aspm(chip);
1100 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1104 rtsx_set_stat(chip, RTSX_STAT_RUN);
1106 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1107 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1109 if (addr < 0xFC00) {
1110 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1111 TRACE_RET(chip, TRANSPORT_FAILED);
1114 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1115 buf = (u8 *)vmalloc(len);
1117 TRACE_RET(chip, TRANSPORT_ERROR);
1120 rtsx_stor_get_xfer_buf(buf, len, srb);
1121 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1123 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1124 if (retval != STATUS_SUCCESS) {
1126 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1127 TRACE_RET(chip, TRANSPORT_FAILED);
1130 for (i = 0; i < len; i++) {
1131 retval = rtsx_write_register(chip, addr + i, 0xFF, buf[i]);
1132 if (retval != STATUS_SUCCESS) {
1134 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1135 TRACE_RET(chip, TRANSPORT_FAILED);
1141 return TRANSPORT_GOOD;
1144 static int get_sd_csd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1146 struct sd_info *sd_card = &(chip->sd_card);
1147 unsigned int lun = SCSI_LUN(srb);
1149 if (!check_card_ready(chip, lun)) {
1150 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1151 TRACE_RET(chip, TRANSPORT_FAILED);
1154 if (get_lun_card(chip, lun) != SD_CARD) {
1155 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1156 TRACE_RET(chip, TRANSPORT_FAILED);
1159 scsi_set_resid(srb, 0);
1160 rtsx_stor_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb);
1162 return TRANSPORT_GOOD;
1165 static int toggle_gpio_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1167 u8 gpio = srb->cmnd[2];
1169 rtsx_disable_aspm(chip);
1171 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1175 rtsx_set_stat(chip, RTSX_STAT_RUN);
1179 toggle_gpio(chip, gpio);
1181 return TRANSPORT_GOOD;
1185 static int trace_msg_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1187 unsigned char *ptr, *buf = NULL;
1190 unsigned int buf_len;
1192 buf_len = 4 + ((2 + MSG_FUNC_LEN + MSG_FILE_LEN + TIME_VAL_LEN) * TRACE_ITEM_CNT);
1194 if ((scsi_bufflen(srb) < buf_len) || (scsi_sglist(srb) == NULL)) {
1195 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1196 TRACE_RET(chip, TRANSPORT_FAILED);
1199 clear = srb->cmnd[2];
1201 buf = (unsigned char *)vmalloc(scsi_bufflen(srb));
1203 TRACE_RET(chip, TRANSPORT_ERROR);
1207 if (chip->trace_msg[chip->msg_idx].valid) {
1208 msg_cnt = TRACE_ITEM_CNT;
1210 msg_cnt = chip->msg_idx;
1212 *(ptr++) = (u8)(msg_cnt >> 24);
1213 *(ptr++) = (u8)(msg_cnt >> 16);
1214 *(ptr++) = (u8)(msg_cnt >> 8);
1215 *(ptr++) = (u8)msg_cnt;
1216 RTSX_DEBUGP("Trace message count is %d\n", msg_cnt);
1218 for (i = 1; i <= msg_cnt; i++) {
1221 idx = chip->msg_idx - i;
1223 idx += TRACE_ITEM_CNT;
1225 *(ptr++) = (u8)(chip->trace_msg[idx].line >> 8);
1226 *(ptr++) = (u8)(chip->trace_msg[idx].line);
1227 for (j = 0; j < MSG_FUNC_LEN; j++) {
1228 *(ptr++) = chip->trace_msg[idx].func[j];
1230 for (j = 0; j < MSG_FILE_LEN; j++) {
1231 *(ptr++) = chip->trace_msg[idx].file[j];
1233 for (j = 0; j < TIME_VAL_LEN; j++) {
1234 *(ptr++) = chip->trace_msg[idx].timeval_buf[j];
1238 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1243 for (i = 0; i < TRACE_ITEM_CNT; i++)
1244 chip->trace_msg[i].valid = 0;
1247 scsi_set_resid(srb, 0);
1248 return TRANSPORT_GOOD;
1252 static int read_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1258 rtsx_disable_aspm(chip);
1260 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1264 rtsx_set_stat(chip, RTSX_STAT_RUN);
1266 addr = srb->cmnd[4];
1268 val = rtsx_readl(chip, addr);
1269 RTSX_DEBUGP("Host register (0x%x): 0x%x\n", addr, val);
1271 buf[0] = (u8)(val >> 24);
1272 buf[1] = (u8)(val >> 16);
1273 buf[2] = (u8)(val >> 8);
1276 len = min(scsi_bufflen(srb), (unsigned int)4);
1277 rtsx_stor_set_xfer_buf(buf, len, srb);
1278 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1280 return TRANSPORT_GOOD;
1283 static int write_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1289 rtsx_disable_aspm(chip);
1291 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1295 rtsx_set_stat(chip, RTSX_STAT_RUN);
1297 addr = srb->cmnd[4];
1299 len = min(scsi_bufflen(srb), (unsigned int)4);
1300 rtsx_stor_get_xfer_buf(buf, len, srb);
1301 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1303 val = ((u32)buf[0] << 24) | ((u32)buf[1] << 16) | ((u32)buf[2] << 8) | buf[3];
1305 rtsx_writel(chip, addr, val);
1307 return TRANSPORT_GOOD;
1310 static int set_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1312 unsigned lun = SCSI_LUN(srb);
1314 if (srb->cmnd[3] == 1) {
1315 /* Variable Clock */
1316 struct xd_info *xd_card = &(chip->xd_card);
1317 struct sd_info *sd_card = &(chip->sd_card);
1318 struct ms_info *ms_card = &(chip->ms_card);
1320 switch (srb->cmnd[4]) {
1322 xd_card->xd_clock = srb->cmnd[5];
1326 sd_card->sd_clock = srb->cmnd[5];
1330 ms_card->ms_clock = srb->cmnd[5];
1334 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1335 TRACE_RET(chip, TRANSPORT_FAILED);
1337 } else if (srb->cmnd[3] == 2) {
1339 chip->blink_led = 1;
1343 chip->blink_led = 0;
1345 rtsx_disable_aspm(chip);
1347 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1351 rtsx_set_stat(chip, RTSX_STAT_RUN);
1353 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1354 if (retval != STATUS_SUCCESS) {
1355 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1356 TRACE_RET(chip, TRANSPORT_FAILED);
1359 turn_off_led(chip, LED_GPIO);
1362 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1363 TRACE_RET(chip, TRANSPORT_FAILED);
1366 return TRANSPORT_GOOD;
1369 static int get_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1371 unsigned int lun = SCSI_LUN(srb);
1373 if (srb->cmnd[3] == 1) {
1374 struct xd_info *xd_card = &(chip->xd_card);
1375 struct sd_info *sd_card = &(chip->sd_card);
1376 struct ms_info *ms_card = &(chip->ms_card);
1379 switch (srb->cmnd[4]) {
1381 tmp = (u8)(xd_card->xd_clock);
1385 tmp = (u8)(sd_card->sd_clock);
1389 tmp = (u8)(ms_card->ms_clock);
1393 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1394 TRACE_RET(chip, TRANSPORT_FAILED);
1397 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1398 } else if (srb->cmnd[3] == 2) {
1399 u8 tmp = chip->blink_led;
1400 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1402 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1403 TRACE_RET(chip, TRANSPORT_FAILED);
1406 return TRANSPORT_GOOD;
1409 static int dma_access_ring_buffer(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1412 unsigned int lun = SCSI_LUN(srb);
1415 rtsx_disable_aspm(chip);
1417 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1421 rtsx_set_stat(chip, RTSX_STAT_RUN);
1423 len = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
1424 len = min(len, (u16)scsi_bufflen(srb));
1426 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
1427 RTSX_DEBUGP("Read from device\n");
1429 RTSX_DEBUGP("Write to device\n");
1432 retval = rtsx_transfer_data(chip, 0, scsi_sglist(srb), len,
1433 scsi_sg_count(srb), srb->sc_data_direction, 1000);
1435 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
1436 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1438 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1440 TRACE_RET(chip, TRANSPORT_FAILED);
1442 scsi_set_resid(srb, 0);
1444 return TRANSPORT_GOOD;
1447 static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1449 struct sd_info *sd_card = &(chip->sd_card);
1450 struct ms_info *ms_card = &(chip->ms_card);
1452 unsigned int lun = SCSI_LUN(srb);
1453 u8 card = get_lun_card(chip, lun);
1456 u8 oc_now_mask = 0, oc_ever_mask = 0;
1459 memset(status, 0, 32);
1461 status[0] = (u8)(chip->product_id);
1462 status[1] = chip->ic_version;
1464 if (chip->auto_delink_en) {
1475 if (chip->card_wp) {
1483 if (CHECK_LUN_MODE(chip, SD_MS_2LUN) && (chip->lun2card[lun] == MS_CARD)) {
1484 oc_now_mask = MS_OC_NOW;
1485 oc_ever_mask = MS_OC_EVER;
1487 oc_now_mask = SD_OC_NOW;
1488 oc_ever_mask = SD_OC_EVER;
1491 if (chip->ocp_stat & oc_now_mask) {
1494 if (chip->ocp_stat & oc_ever_mask) {
1499 if (card == SD_CARD) {
1500 if (CHK_SD(sd_card)) {
1501 if (CHK_SD_HCXC(sd_card)) {
1502 if (sd_card->capacity > 0x4000000) {
1503 status[0x0E] = 0x02;
1505 status[0x0E] = 0x01;
1508 status[0x0E] = 0x00;
1511 if (CHK_SD_SDR104(sd_card)) {
1512 status[0x0F] = 0x03;
1513 } else if (CHK_SD_DDR50(sd_card)) {
1514 status[0x0F] = 0x04;
1515 } else if (CHK_SD_SDR50(sd_card)) {
1516 status[0x0F] = 0x02;
1517 } else if (CHK_SD_HS(sd_card)) {
1518 status[0x0F] = 0x01;
1520 status[0x0F] = 0x00;
1523 if (CHK_MMC_SECTOR_MODE(sd_card)) {
1524 status[0x0E] = 0x01;
1526 status[0x0E] = 0x00;
1529 if (CHK_MMC_DDR52(sd_card)) {
1530 status[0x0F] = 0x03;
1531 } else if (CHK_MMC_52M(sd_card)) {
1532 status[0x0F] = 0x02;
1533 } else if (CHK_MMC_26M(sd_card)) {
1534 status[0x0F] = 0x01;
1536 status[0x0F] = 0x00;
1539 } else if (card == MS_CARD) {
1540 if (CHK_MSPRO(ms_card)) {
1541 if (CHK_MSXC(ms_card)) {
1542 status[0x0E] = 0x01;
1544 status[0x0E] = 0x00;
1547 if (CHK_HG8BIT(ms_card)) {
1548 status[0x0F] = 0x01;
1550 status[0x0F] = 0x00;
1555 #ifdef SUPPORT_SD_LOCK
1556 if (card == SD_CARD) {
1557 status[0x17] = 0x80;
1558 if (sd_card->sd_erase_status)
1559 status[0x17] |= 0x01;
1560 if (sd_card->sd_lock_status & SD_LOCKED) {
1561 status[0x17] |= 0x02;
1562 status[0x07] |= 0x40;
1564 if (sd_card->sd_lock_status & SD_PWD_EXIST)
1565 status[0x17] |= 0x04;
1567 status[0x17] = 0x00;
1570 RTSX_DEBUGP("status[0x17] = 0x%x\n", status[0x17]);
1573 status[0x18] = 0x8A;
1574 status[0x1A] = 0x28;
1575 #ifdef SUPPORT_SD_LOCK
1576 status[0x1F] = 0x01;
1579 buf_len = min(scsi_bufflen(srb), (unsigned int)sizeof(status));
1580 rtsx_stor_set_xfer_buf(status, buf_len, srb);
1581 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1583 return TRANSPORT_GOOD;
1586 static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1592 if (!CHECK_PID(chip, 0x5208)) {
1593 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1594 TRACE_RET(chip, TRANSPORT_FAILED);
1597 phy_debug_mode = (int)(srb->cmnd[3]);
1599 if (phy_debug_mode) {
1600 chip->phy_debug_mode = 1;
1601 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0);
1602 if (retval != STATUS_SUCCESS) {
1603 TRACE_RET(chip, TRANSPORT_FAILED);
1605 rtsx_disable_bus_int(chip);
1607 retval = rtsx_read_phy_register(chip, 0x1C, ®);
1608 if (retval != STATUS_SUCCESS) {
1609 TRACE_RET(chip, TRANSPORT_FAILED);
1612 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1613 if (retval != STATUS_SUCCESS) {
1614 TRACE_RET(chip, TRANSPORT_FAILED);
1617 chip->phy_debug_mode = 0;
1618 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77);
1619 if (retval != STATUS_SUCCESS) {
1620 TRACE_RET(chip, TRANSPORT_FAILED);
1622 rtsx_enable_bus_int(chip);
1624 retval = rtsx_read_phy_register(chip, 0x1C, ®);
1625 if (retval != STATUS_SUCCESS) {
1626 TRACE_RET(chip, TRANSPORT_FAILED);
1629 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1630 if (retval != STATUS_SUCCESS) {
1631 TRACE_RET(chip, TRANSPORT_FAILED);
1635 return TRANSPORT_GOOD;
1638 static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1640 int retval = STATUS_SUCCESS;
1641 unsigned int lun = SCSI_LUN(srb);
1642 u8 cmd_type, mask, value, idx;
1645 rtsx_disable_aspm(chip);
1647 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1651 rtsx_set_stat(chip, RTSX_STAT_RUN);
1653 switch (srb->cmnd[3]) {
1655 rtsx_init_cmd(chip);
1659 cmd_type = srb->cmnd[4];
1661 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1662 TRACE_RET(chip, TRANSPORT_FAILED);
1664 addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1665 mask = srb->cmnd[7];
1666 value = srb->cmnd[8];
1667 rtsx_add_cmd(chip, cmd_type, addr, mask, value);
1671 retval = rtsx_send_cmd(chip, 0, 1000);
1676 value = *(rtsx_get_cmd_data(chip) + idx);
1677 if (scsi_bufflen(srb) < 1) {
1678 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1679 TRACE_RET(chip, TRANSPORT_FAILED);
1681 rtsx_stor_set_xfer_buf(&value, 1, srb);
1682 scsi_set_resid(srb, 0);
1686 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1687 TRACE_RET(chip, TRANSPORT_FAILED);
1690 if (retval != STATUS_SUCCESS) {
1691 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1692 TRACE_RET(chip, TRANSPORT_FAILED);
1695 return TRANSPORT_GOOD;
1698 static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1702 switch (srb->cmnd[3]) {
1707 result = rw_mem_cmd_buf(srb, chip);
1710 result = TRANSPORT_ERROR;
1716 static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1718 unsigned short addr, len, i;
1723 rtsx_disable_aspm(chip);
1725 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1729 rtsx_set_stat(chip, RTSX_STAT_RUN);
1731 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1732 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1738 buf = (u8 *)vmalloc(len);
1740 TRACE_RET(chip, TRANSPORT_ERROR);
1743 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1744 if (retval != STATUS_SUCCESS) {
1746 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1747 TRACE_RET(chip, TRANSPORT_FAILED);
1750 for (i = 0; i < len / 2; i++) {
1751 retval = rtsx_read_phy_register(chip, addr + i, &val);
1752 if (retval != STATUS_SUCCESS) {
1754 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1755 TRACE_RET(chip, TRANSPORT_FAILED);
1758 buf[2*i] = (u8)(val >> 8);
1759 buf[2*i+1] = (u8)val;
1762 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1763 rtsx_stor_set_xfer_buf(buf, len, srb);
1764 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1769 return TRANSPORT_GOOD;
1772 static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1774 unsigned short addr, len, i;
1779 rtsx_disable_aspm(chip);
1781 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1785 rtsx_set_stat(chip, RTSX_STAT_RUN);
1787 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1788 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1794 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1796 buf = (u8 *)vmalloc(len);
1798 TRACE_RET(chip, TRANSPORT_ERROR);
1801 rtsx_stor_get_xfer_buf(buf, len, srb);
1802 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1804 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1805 if (retval != STATUS_SUCCESS) {
1807 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1808 TRACE_RET(chip, TRANSPORT_FAILED);
1811 for (i = 0; i < len / 2; i++) {
1812 val = ((u16)buf[2*i] << 8) | buf[2*i+1];
1813 retval = rtsx_write_phy_register(chip, addr + i, val);
1814 if (retval != STATUS_SUCCESS) {
1816 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1817 TRACE_RET(chip, TRANSPORT_FAILED);
1824 return TRANSPORT_GOOD;
1827 static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1829 unsigned short addr;
1833 rtsx_disable_aspm(chip);
1835 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1839 rtsx_set_stat(chip, RTSX_STAT_RUN);
1841 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1842 if (retval != STATUS_SUCCESS) {
1843 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1844 TRACE_RET(chip, TRANSPORT_FAILED);
1847 mode = srb->cmnd[3];
1848 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1851 retval = spi_erase_eeprom_chip(chip);
1852 if (retval != STATUS_SUCCESS) {
1853 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1854 TRACE_RET(chip, TRANSPORT_FAILED);
1856 } else if (mode == 1) {
1857 retval = spi_erase_eeprom_byte(chip, addr);
1858 if (retval != STATUS_SUCCESS) {
1859 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1860 TRACE_RET(chip, TRANSPORT_FAILED);
1863 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1864 TRACE_RET(chip, TRANSPORT_FAILED);
1867 return TRANSPORT_GOOD;
1870 static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1872 unsigned short addr, len, i;
1876 rtsx_disable_aspm(chip);
1878 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1882 rtsx_set_stat(chip, RTSX_STAT_RUN);
1884 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1885 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1887 buf = (u8 *)vmalloc(len);
1889 TRACE_RET(chip, TRANSPORT_ERROR);
1892 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1893 if (retval != STATUS_SUCCESS) {
1895 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1896 TRACE_RET(chip, TRANSPORT_FAILED);
1899 for (i = 0; i < len; i++) {
1900 retval = spi_read_eeprom(chip, addr + i, buf + i);
1901 if (retval != STATUS_SUCCESS) {
1903 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1904 TRACE_RET(chip, TRANSPORT_FAILED);
1908 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1909 rtsx_stor_set_xfer_buf(buf, len, srb);
1910 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1914 return TRANSPORT_GOOD;
1917 static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1919 unsigned short addr, len, i;
1923 rtsx_disable_aspm(chip);
1925 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1929 rtsx_set_stat(chip, RTSX_STAT_RUN);
1931 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1932 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1934 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1935 buf = (u8 *)vmalloc(len);
1937 TRACE_RET(chip, TRANSPORT_ERROR);
1940 rtsx_stor_get_xfer_buf(buf, len, srb);
1941 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1943 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1944 if (retval != STATUS_SUCCESS) {
1946 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1947 TRACE_RET(chip, TRANSPORT_FAILED);
1950 for (i = 0; i < len; i++) {
1951 retval = spi_write_eeprom(chip, addr + i, buf[i]);
1952 if (retval != STATUS_SUCCESS) {
1954 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1955 TRACE_RET(chip, TRANSPORT_FAILED);
1961 return TRANSPORT_GOOD;
1964 static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1970 rtsx_disable_aspm(chip);
1972 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1976 rtsx_set_stat(chip, RTSX_STAT_RUN);
1978 addr = srb->cmnd[4];
1981 buf = (u8 *)vmalloc(len);
1983 TRACE_RET(chip, TRANSPORT_ERROR);
1986 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1987 if (retval != STATUS_SUCCESS) {
1989 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1990 TRACE_RET(chip, TRANSPORT_FAILED);
1993 for (i = 0; i < len; i++) {
1994 retval = rtsx_read_efuse(chip, addr + i, buf + i);
1995 if (retval != STATUS_SUCCESS) {
1997 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1998 TRACE_RET(chip, TRANSPORT_FAILED);
2002 len = (u8)min(scsi_bufflen(srb), (unsigned int)len);
2003 rtsx_stor_set_xfer_buf(buf, len, srb);
2004 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2008 return TRANSPORT_GOOD;
2011 static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2013 int retval, result = TRANSPORT_GOOD;
2018 rtsx_disable_aspm(chip);
2020 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2024 rtsx_set_stat(chip, RTSX_STAT_RUN);
2026 addr = srb->cmnd[4];
2029 len = (u8)min(scsi_bufflen(srb), (unsigned int)len);
2030 buf = (u8 *)vmalloc(len);
2032 TRACE_RET(chip, TRANSPORT_ERROR);
2035 rtsx_stor_get_xfer_buf(buf, len, srb);
2036 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2038 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2039 if (retval != STATUS_SUCCESS) {
2041 TRACE_RET(chip, TRANSPORT_ERROR);
2044 if (chip->asic_code) {
2045 retval = rtsx_read_phy_register(chip, 0x08, &val);
2046 if (retval != STATUS_SUCCESS) {
2048 TRACE_RET(chip, TRANSPORT_ERROR);
2051 retval = rtsx_write_register(chip, PWR_GATE_CTRL, LDO3318_PWR_MASK, LDO_OFF);
2052 if (retval != STATUS_SUCCESS) {
2054 TRACE_RET(chip, TRANSPORT_ERROR);
2059 retval = rtsx_write_phy_register(chip, 0x08, 0x4C00 | chip->phy_voltage);
2060 if (retval != STATUS_SUCCESS) {
2062 TRACE_RET(chip, TRANSPORT_ERROR);
2065 retval = rtsx_write_register(chip, PWR_GATE_CTRL, LDO3318_PWR_MASK, LDO_ON);
2066 if (retval != STATUS_SUCCESS) {
2068 TRACE_RET(chip, TRANSPORT_ERROR);
2074 retval = card_power_on(chip, SPI_CARD);
2075 if (retval != STATUS_SUCCESS) {
2077 TRACE_RET(chip, TRANSPORT_ERROR);
2082 for (i = 0; i < len; i++) {
2083 retval = rtsx_write_efuse(chip, addr + i, buf[i]);
2084 if (retval != STATUS_SUCCESS) {
2085 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2086 result = TRANSPORT_FAILED;
2087 TRACE_GOTO(chip, Exit);
2094 retval = card_power_off(chip, SPI_CARD);
2095 if (retval != STATUS_SUCCESS) {
2096 TRACE_RET(chip, TRANSPORT_ERROR);
2099 if (chip->asic_code) {
2100 retval = rtsx_write_register(chip, PWR_GATE_CTRL, LDO3318_PWR_MASK, LDO_OFF);
2101 if (retval != STATUS_SUCCESS) {
2102 TRACE_RET(chip, TRANSPORT_ERROR);
2107 retval = rtsx_write_phy_register(chip, 0x08, val);
2108 if (retval != STATUS_SUCCESS) {
2109 TRACE_RET(chip, TRANSPORT_ERROR);
2112 retval = rtsx_write_register(chip, PWR_GATE_CTRL, LDO3318_PWR_MASK, LDO_ON);
2113 if (retval != STATUS_SUCCESS) {
2114 TRACE_RET(chip, TRANSPORT_ERROR);
2121 static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2128 rtsx_disable_aspm(chip);
2130 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2134 rtsx_set_stat(chip, RTSX_STAT_RUN);
2136 func = srb->cmnd[3];
2137 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2138 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2140 RTSX_DEBUGP("%s: func = %d, addr = 0x%x, len = %d\n", __func__, func, addr, len);
2142 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) {
2148 if (func > func_max) {
2149 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2150 TRACE_RET(chip, TRANSPORT_FAILED);
2153 buf = (u8 *)vmalloc(len);
2155 TRACE_RET(chip, TRANSPORT_ERROR);
2158 retval = rtsx_read_cfg_seq(chip, func, addr, buf, len);
2159 if (retval != STATUS_SUCCESS) {
2160 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2162 TRACE_RET(chip, TRANSPORT_FAILED);
2165 len = (u16)min(scsi_bufflen(srb), (unsigned int)len);
2166 rtsx_stor_set_xfer_buf(buf, len, srb);
2167 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2171 return TRANSPORT_GOOD;
2174 static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2181 rtsx_disable_aspm(chip);
2183 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2187 rtsx_set_stat(chip, RTSX_STAT_RUN);
2189 func = srb->cmnd[3];
2190 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2191 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2193 RTSX_DEBUGP("%s: func = %d, addr = 0x%x\n", __func__, func, addr);
2195 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) {
2201 if (func > func_max) {
2202 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2203 TRACE_RET(chip, TRANSPORT_FAILED);
2206 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
2207 buf = (u8 *)vmalloc(len);
2209 TRACE_RET(chip, TRANSPORT_ERROR);
2212 rtsx_stor_get_xfer_buf(buf, len, srb);
2213 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2215 retval = rtsx_write_cfg_seq(chip, func, addr, buf, len);
2216 if (retval != STATUS_SUCCESS) {
2217 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2219 TRACE_RET(chip, TRANSPORT_FAILED);
2224 return TRANSPORT_GOOD;
2227 static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2231 switch (srb->cmnd[2]) {
2234 result = read_write(srb, chip);
2238 result = read_host_reg(srb, chip);
2241 case WRITE_HOST_REG:
2242 result = write_host_reg(srb, chip);
2246 result = get_variable(srb, chip);
2250 result = set_variable(srb, chip);
2255 result = dma_access_ring_buffer(srb, chip);
2259 result = read_phy_register(srb, chip);
2263 result = write_phy_register(srb, chip);
2267 result = erase_eeprom2(srb, chip);
2271 result = read_eeprom2(srb, chip);
2275 result = write_eeprom2(srb, chip);
2279 result = read_efuse(srb, chip);
2283 result = write_efuse(srb, chip);
2287 result = read_cfg_byte(srb, chip);
2291 result = write_cfg_byte(srb, chip);
2295 result = set_chip_mode(srb, chip);
2299 result = suit_cmd(srb, chip);
2302 case GET_DEV_STATUS:
2303 result = get_dev_status(srb, chip);
2307 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2308 TRACE_RET(chip, TRANSPORT_FAILED);
2315 static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2319 unsigned int lun = SCSI_LUN(srb);
2321 rtsx_status[0] = (u8)(chip->vendor_id >> 8);
2322 rtsx_status[1] = (u8)(chip->vendor_id);
2324 rtsx_status[2] = (u8)(chip->product_id >> 8);
2325 rtsx_status[3] = (u8)(chip->product_id);
2327 rtsx_status[4] = (u8)lun;
2329 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2330 if (chip->lun2card[lun] == SD_CARD) {
2336 if (chip->card_exist) {
2337 if (chip->card_exist & XD_CARD) {
2339 } else if (chip->card_exist & SD_CARD) {
2341 } else if (chip->card_exist & MS_CARD) {
2351 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2357 rtsx_status[7] = (u8)(chip->product_id);
2358 rtsx_status[8] = chip->ic_version;
2360 if (check_card_exist(chip, lun)) {
2366 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2367 rtsx_status[10] = 0;
2369 rtsx_status[10] = 1;
2372 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2373 if (chip->lun2card[lun] == SD_CARD) {
2374 rtsx_status[11] = SD_CARD;
2376 rtsx_status[11] = MS_CARD;
2379 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD;
2382 if (check_card_ready(chip, lun)) {
2383 rtsx_status[12] = 1;
2385 rtsx_status[12] = 0;
2388 if (get_lun_card(chip, lun) == XD_CARD) {
2389 rtsx_status[13] = 0x40;
2390 } else if (get_lun_card(chip, lun) == SD_CARD) {
2391 struct sd_info *sd_card = &(chip->sd_card);
2393 rtsx_status[13] = 0x20;
2394 if (CHK_SD(sd_card)) {
2395 if (CHK_SD_HCXC(sd_card))
2396 rtsx_status[13] |= 0x04;
2397 if (CHK_SD_HS(sd_card))
2398 rtsx_status[13] |= 0x02;
2400 rtsx_status[13] |= 0x08;
2401 if (CHK_MMC_52M(sd_card))
2402 rtsx_status[13] |= 0x02;
2403 if (CHK_MMC_SECTOR_MODE(sd_card))
2404 rtsx_status[13] |= 0x04;
2406 } else if (get_lun_card(chip, lun) == MS_CARD) {
2407 struct ms_info *ms_card = &(chip->ms_card);
2409 if (CHK_MSPRO(ms_card)) {
2410 rtsx_status[13] = 0x38;
2411 if (CHK_HG8BIT(ms_card))
2412 rtsx_status[13] |= 0x04;
2414 if (CHK_MSXC(ms_card))
2415 rtsx_status[13] |= 0x01;
2418 rtsx_status[13] = 0x30;
2421 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) {
2423 if (chip->sd_io && chip->sd_int) {
2424 rtsx_status[13] = 0x60;
2426 rtsx_status[13] = 0x70;
2429 rtsx_status[13] = 0x70;
2432 if (chip->lun2card[lun] == SD_CARD) {
2433 rtsx_status[13] = 0x20;
2435 rtsx_status[13] = 0x30;
2440 rtsx_status[14] = 0x78;
2441 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) {
2442 rtsx_status[15] = 0x83;
2444 rtsx_status[15] = 0x82;
2447 buf_len = min(scsi_bufflen(srb), (unsigned int)sizeof(rtsx_status));
2448 rtsx_stor_set_xfer_buf(rtsx_status, buf_len, srb);
2449 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
2451 return TRANSPORT_GOOD;
2454 static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2456 unsigned int lun = SCSI_LUN(srb);
2459 if (!check_card_ready(chip, lun)) {
2460 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2461 TRACE_RET(chip, TRANSPORT_FAILED);
2464 card = get_lun_card(chip, lun);
2465 if ((card == SD_CARD) || (card == MS_CARD)) {
2466 bus_width = chip->card_bus_width[lun];
2468 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2469 TRACE_RET(chip, TRANSPORT_FAILED);
2472 scsi_set_resid(srb, 0);
2473 rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
2475 return TRANSPORT_GOOD;
2478 static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2481 unsigned int lun = SCSI_LUN(srb);
2484 if (CHECK_PID(chip, 0x5208) && CHECK_PID(chip, 0x5288)) {
2485 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2486 TRACE_RET(chip, TRANSPORT_FAILED);
2489 rtsx_disable_aspm(chip);
2491 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2495 rtsx_set_stat(chip, RTSX_STAT_RUN);
2497 rtsx_force_power_on(chip, SSC_PDCTL);
2499 rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir);
2500 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06);
2502 switch (srb->cmnd[2]) {
2503 case SCSI_SPI_GETSTATUS:
2504 result = spi_get_status(srb, chip);
2507 case SCSI_SPI_SETPARAMETER:
2508 result = spi_set_parameter(srb, chip);
2511 case SCSI_SPI_READFALSHID:
2512 result = spi_read_flash_id(srb, chip);
2515 case SCSI_SPI_READFLASH:
2516 result = spi_read_flash(srb, chip);
2519 case SCSI_SPI_WRITEFLASH:
2520 result = spi_write_flash(srb, chip);
2523 case SCSI_SPI_WRITEFLASHSTATUS:
2524 result = spi_write_flash_status(srb, chip);
2527 case SCSI_SPI_ERASEFLASH:
2528 result = spi_erase_flash(srb, chip);
2532 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2534 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2535 TRACE_RET(chip, TRANSPORT_FAILED);
2538 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2540 if (result != STATUS_SUCCESS) {
2541 TRACE_RET(chip, TRANSPORT_FAILED);
2544 return TRANSPORT_GOOD;
2547 static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2551 switch (srb->cmnd[1]) {
2553 result = read_status(srb, chip);
2557 result = read_mem(srb, chip);
2561 result = write_mem(srb, chip);
2565 result = read_eeprom(srb, chip);
2569 result = write_eeprom(srb, chip);
2573 result = toggle_gpio_cmd(srb, chip);
2577 result = get_sd_csd(srb, chip);
2581 result = get_card_bus_width(srb, chip);
2586 result = trace_msg_cmd(srb, chip);
2591 result = app_cmd(srb, chip);
2594 case SPI_VENDOR_COMMAND:
2595 result = spi_vendor_cmd(srb, chip);
2599 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2600 TRACE_RET(chip, TRANSPORT_FAILED);
2606 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
2607 void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2609 unsigned int lun = SCSI_LUN(srb);
2612 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
2613 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
2614 } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
2615 sec_cnt = srb->cmnd[4];
2620 if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) {
2621 toggle_gpio(chip, LED_GPIO);
2622 chip->rw_cap[lun] = 0;
2624 chip->rw_cap[lun] += sec_cnt;
2629 static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2631 struct ms_info *ms_card = &(chip->ms_card);
2632 unsigned int lun = SCSI_LUN(srb);
2633 int retval, quick_format;
2635 if (get_lun_card(chip, lun) != MS_CARD) {
2636 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2637 TRACE_RET(chip, TRANSPORT_FAILED);
2640 if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47) ||
2641 (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D) ||
2642 (srb->cmnd[7] != 0x74)) {
2643 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2644 TRACE_RET(chip, TRANSPORT_FAILED);
2647 rtsx_disable_aspm(chip);
2649 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2653 if (!check_card_ready(chip, lun) ||
2654 (get_card_size(chip, lun) == 0)) {
2655 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2656 TRACE_RET(chip, TRANSPORT_FAILED);
2659 rtsx_set_stat(chip, RTSX_STAT_RUN);
2661 if (srb->cmnd[8] & 0x01) {
2667 if (!(chip->card_ready & MS_CARD)) {
2668 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2669 TRACE_RET(chip, TRANSPORT_FAILED);
2672 if (chip->card_wp & MS_CARD) {
2673 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2674 TRACE_RET(chip, TRANSPORT_FAILED);
2677 if (!CHK_MSPRO(ms_card)) {
2678 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2679 TRACE_RET(chip, TRANSPORT_FAILED);
2682 retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
2683 if (retval != STATUS_SUCCESS) {
2684 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
2685 TRACE_RET(chip, TRANSPORT_FAILED);
2688 scsi_set_resid(srb, 0);
2689 return TRANSPORT_GOOD;
2692 #ifdef SUPPORT_PCGL_1P18
2693 static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2695 struct ms_info *ms_card = &(chip->ms_card);
2696 unsigned int lun = SCSI_LUN(srb);
2697 u8 dev_info_id, data_len;
2699 unsigned int buf_len;
2702 if (!check_card_ready(chip, lun)) {
2703 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2704 TRACE_RET(chip, TRANSPORT_FAILED);
2706 if ((get_lun_card(chip, lun) != MS_CARD)) {
2707 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2708 TRACE_RET(chip, TRANSPORT_FAILED);
2711 if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) ||
2712 (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) ||
2713 (srb->cmnd[7] != 0x44)) {
2714 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2715 TRACE_RET(chip, TRANSPORT_FAILED);
2718 dev_info_id = srb->cmnd[3];
2719 if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) ||
2720 (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) ||
2721 !CHK_MSPRO(ms_card)) {
2722 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2723 TRACE_RET(chip, TRANSPORT_FAILED);
2726 if (dev_info_id == 0x15) {
2727 buf_len = data_len = 0x3A;
2729 buf_len = data_len = 0x6A;
2732 buf = (u8 *)kmalloc(buf_len, GFP_KERNEL);
2734 TRACE_RET(chip, TRANSPORT_ERROR);
2738 /* GET Memory Stick Media Information Response Header */
2739 buf[i++] = 0x00; /* Data length MSB */
2740 buf[i++] = data_len; /* Data length LSB */
2741 /* Device Information Type Code */
2742 if (CHK_MSXC(ms_card)) {
2753 /* Number of Device Information */
2756 /* Device Information Body */
2758 /* Device Information ID Number */
2759 buf[i++] = dev_info_id;
2760 /* Device Information Length */
2761 if (dev_info_id == 0x15) {
2766 buf[i++] = 0x00; /* Data length MSB */
2767 buf[i++] = data_len; /* Data length LSB */
2770 if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
2771 /* System Information */
2772 memcpy(buf+i, ms_card->raw_sys_info, 96);
2775 memcpy(buf+i, ms_card->raw_model_name, 48);
2778 rtsx_stor_set_xfer_buf(buf, buf_len, srb);
2780 if (dev_info_id == 0x15) {
2781 scsi_set_resid(srb, scsi_bufflen(srb)-0x3C);
2783 scsi_set_resid(srb, scsi_bufflen(srb)-0x6C);
2787 return STATUS_SUCCESS;
2791 static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2793 int retval = TRANSPORT_ERROR;
2795 if (srb->cmnd[2] == MS_FORMAT) {
2796 retval = ms_format_cmnd(srb, chip);
2798 #ifdef SUPPORT_PCGL_1P18
2799 else if (srb->cmnd[2] == GET_MS_INFORMATION) {
2800 retval = get_ms_information(srb, chip);
2808 static int sd_extention_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2810 unsigned int lun = SCSI_LUN(srb);
2813 rtsx_disable_aspm(chip);
2815 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2819 rtsx_set_stat(chip, RTSX_STAT_RUN);
2821 sd_cleanup_work(chip);
2823 if (!check_card_ready(chip, lun)) {
2824 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2825 TRACE_RET(chip, TRANSPORT_FAILED);
2827 if ((get_lun_card(chip, lun) != SD_CARD)) {
2828 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2829 TRACE_RET(chip, TRANSPORT_FAILED);
2832 switch (srb->cmnd[0]) {
2833 case SD_PASS_THRU_MODE:
2834 result = sd_pass_thru_mode(srb, chip);
2837 case SD_EXECUTE_NO_DATA:
2838 result = sd_execute_no_data(srb, chip);
2841 case SD_EXECUTE_READ:
2842 result = sd_execute_read_data(srb, chip);
2845 case SD_EXECUTE_WRITE:
2846 result = sd_execute_write_data(srb, chip);
2850 result = sd_get_cmd_rsp(srb, chip);
2854 result = sd_hw_rst(srb, chip);
2858 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2859 TRACE_RET(chip, TRANSPORT_FAILED);
2866 #ifdef SUPPORT_MAGIC_GATE
2867 static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2869 struct ms_info *ms_card = &(chip->ms_card);
2870 unsigned int lun = SCSI_LUN(srb);
2874 RTSX_DEBUGP("--%s--\n", __func__);
2876 rtsx_disable_aspm(chip);
2878 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2882 rtsx_set_stat(chip, RTSX_STAT_RUN);
2884 ms_cleanup_work(chip);
2886 if (!check_card_ready(chip, lun)) {
2887 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2888 TRACE_RET(chip, TRANSPORT_FAILED);
2890 if ((get_lun_card(chip, lun) != MS_CARD)) {
2891 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2892 TRACE_RET(chip, TRANSPORT_FAILED);
2895 if (srb->cmnd[7] != KC_MG_R_PRO) {
2896 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2897 TRACE_RET(chip, TRANSPORT_FAILED);
2900 if (!CHK_MSPRO(ms_card)) {
2901 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
2902 TRACE_RET(chip, TRANSPORT_FAILED);
2905 key_format = srb->cmnd[10] & 0x3F;
2906 RTSX_DEBUGP("key_format = 0x%x\n", key_format);
2908 switch (key_format) {
2909 case KF_GET_LOC_EKB:
2910 if ((scsi_bufflen(srb) == 0x41C) &&
2911 (srb->cmnd[8] == 0x04) &&
2912 (srb->cmnd[9] == 0x1C)) {
2913 retval = mg_get_local_EKB(srb, chip);
2914 if (retval != STATUS_SUCCESS) {
2915 TRACE_RET(chip, TRANSPORT_FAILED);
2918 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2919 TRACE_RET(chip, TRANSPORT_FAILED);
2924 if ((scsi_bufflen(srb) == 0x24) &&
2925 (srb->cmnd[8] == 0x00) &&
2926 (srb->cmnd[9] == 0x24)) {
2927 retval = mg_get_rsp_chg(srb, chip);
2928 if (retval != STATUS_SUCCESS) {
2929 TRACE_RET(chip, TRANSPORT_FAILED);
2932 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2933 TRACE_RET(chip, TRANSPORT_FAILED);
2938 ms_card->mg_entry_num = srb->cmnd[5];
2939 if ((scsi_bufflen(srb) == 0x404) &&
2940 (srb->cmnd[8] == 0x04) &&
2941 (srb->cmnd[9] == 0x04) &&
2942 (srb->cmnd[2] == 0x00) &&
2943 (srb->cmnd[3] == 0x00) &&
2944 (srb->cmnd[4] == 0x00) &&
2945 (srb->cmnd[5] < 32)) {
2946 retval = mg_get_ICV(srb, chip);
2947 if (retval != STATUS_SUCCESS) {
2948 TRACE_RET(chip, TRANSPORT_FAILED);
2951 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2952 TRACE_RET(chip, TRANSPORT_FAILED);
2957 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2958 TRACE_RET(chip, TRANSPORT_FAILED);
2961 scsi_set_resid(srb, 0);
2962 return TRANSPORT_GOOD;
2965 static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2967 struct ms_info *ms_card = &(chip->ms_card);
2968 unsigned int lun = SCSI_LUN(srb);
2972 RTSX_DEBUGP("--%s--\n", __func__);
2974 rtsx_disable_aspm(chip);
2976 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2980 rtsx_set_stat(chip, RTSX_STAT_RUN);
2982 ms_cleanup_work(chip);
2984 if (!check_card_ready(chip, lun)) {
2985 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2986 TRACE_RET(chip, TRANSPORT_FAILED);
2988 if (check_card_wp(chip, lun)) {
2989 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2990 TRACE_RET(chip, TRANSPORT_FAILED);
2992 if ((get_lun_card(chip, lun) != MS_CARD)) {
2993 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2994 TRACE_RET(chip, TRANSPORT_FAILED);
2997 if (srb->cmnd[7] != KC_MG_R_PRO) {
2998 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2999 TRACE_RET(chip, TRANSPORT_FAILED);
3002 if (!CHK_MSPRO(ms_card)) {
3003 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3004 TRACE_RET(chip, TRANSPORT_FAILED);
3007 key_format = srb->cmnd[10] & 0x3F;
3008 RTSX_DEBUGP("key_format = 0x%x\n", key_format);
3010 switch (key_format) {
3011 case KF_SET_LEAF_ID:
3012 if ((scsi_bufflen(srb) == 0x0C) &&
3013 (srb->cmnd[8] == 0x00) &&
3014 (srb->cmnd[9] == 0x0C)) {
3015 retval = mg_set_leaf_id(srb, chip);
3016 if (retval != STATUS_SUCCESS) {
3017 TRACE_RET(chip, TRANSPORT_FAILED);
3020 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3021 TRACE_RET(chip, TRANSPORT_FAILED);
3026 if ((scsi_bufflen(srb) == 0x0C) &&
3027 (srb->cmnd[8] == 0x00) &&
3028 (srb->cmnd[9] == 0x0C)) {
3029 retval = mg_chg(srb, chip);
3030 if (retval != STATUS_SUCCESS) {
3031 TRACE_RET(chip, TRANSPORT_FAILED);
3034 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3035 TRACE_RET(chip, TRANSPORT_FAILED);
3040 if ((scsi_bufflen(srb) == 0x0C) &&
3041 (srb->cmnd[8] == 0x00) &&
3042 (srb->cmnd[9] == 0x0C)) {
3043 retval = mg_rsp(srb, chip);
3044 if (retval != STATUS_SUCCESS) {
3045 TRACE_RET(chip, TRANSPORT_FAILED);
3048 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3049 TRACE_RET(chip, TRANSPORT_FAILED);
3054 ms_card->mg_entry_num = srb->cmnd[5];
3055 if ((scsi_bufflen(srb) == 0x404) &&
3056 (srb->cmnd[8] == 0x04) &&
3057 (srb->cmnd[9] == 0x04) &&
3058 (srb->cmnd[2] == 0x00) &&
3059 (srb->cmnd[3] == 0x00) &&
3060 (srb->cmnd[4] == 0x00) &&
3061 (srb->cmnd[5] < 32)) {
3062 retval = mg_set_ICV(srb, chip);
3063 if (retval != STATUS_SUCCESS) {
3064 TRACE_RET(chip, TRANSPORT_FAILED);
3067 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3068 TRACE_RET(chip, TRANSPORT_FAILED);
3073 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3074 TRACE_RET(chip, TRANSPORT_FAILED);
3077 scsi_set_resid(srb, 0);
3078 return TRANSPORT_GOOD;
3082 int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3084 #ifdef SUPPORT_SD_LOCK
3085 struct sd_info *sd_card = &(chip->sd_card);
3087 struct ms_info *ms_card = &(chip->ms_card);
3088 unsigned int lun = SCSI_LUN(srb);
3091 #ifdef SUPPORT_SD_LOCK
3092 if (sd_card->sd_erase_status) {
3093 /* Block all SCSI command except for
3094 * REQUEST_SENSE and rs_ppstatus
3096 if (!((srb->cmnd[0] == VENDOR_CMND) &&
3097 (srb->cmnd[1] == SCSI_APP_CMD) &&
3098 (srb->cmnd[2] == GET_DEV_STATUS)) &&
3099 (srb->cmnd[0] != REQUEST_SENSE)) {
3100 /* Logical Unit Not Ready Format in Progress */
3101 set_sense_data(chip, lun, CUR_ERR,
3102 0x02, 0, 0x04, 0x04, 0, 0);
3103 TRACE_RET(chip, TRANSPORT_FAILED);
3108 if ((get_lun_card(chip, lun) == MS_CARD) &&
3109 (ms_card->format_status == FORMAT_IN_PROGRESS)) {
3110 if ((srb->cmnd[0] != REQUEST_SENSE) && (srb->cmnd[0] != INQUIRY)) {
3111 /* Logical Unit Not Ready Format in Progress */
3112 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
3113 0, (u16)(ms_card->progress));
3114 TRACE_RET(chip, TRANSPORT_FAILED);
3118 switch (srb->cmnd[0]) {
3123 result = read_write(srb, chip);
3124 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
3125 led_shine(srb, chip);
3129 case TEST_UNIT_READY:
3130 result = test_unit_ready(srb, chip);
3134 result = inquiry(srb, chip);
3138 result = read_capacity(srb, chip);
3142 result = start_stop_unit(srb, chip);
3145 case ALLOW_MEDIUM_REMOVAL:
3146 result = allow_medium_removal(srb, chip);
3150 result = request_sense(srb, chip);
3155 result = mode_sense(srb, chip);
3159 result = read_format_capacity(srb, chip);
3163 result = vendor_cmnd(srb, chip);
3167 result = ms_sp_cmnd(srb, chip);
3171 case SD_PASS_THRU_MODE:
3172 case SD_EXECUTE_NO_DATA:
3173 case SD_EXECUTE_READ:
3174 case SD_EXECUTE_WRITE:
3177 result = sd_extention_cmnd(srb, chip);
3181 #ifdef SUPPORT_MAGIC_GATE
3182 case CMD_MSPRO_MG_RKEY:
3183 result = mg_report_key(srb, chip);
3186 case CMD_MSPRO_MG_SKEY:
3187 result = mg_send_key(srb, chip);
3194 result = TRANSPORT_GOOD;
3198 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3199 result = TRANSPORT_FAILED;