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>
26 #include <linux/vmalloc.h>
29 #include "rtsx_transport.h"
31 #include "rtsx_card.h"
32 #include "rtsx_chip.h"
33 #include "rtsx_scsi.h"
38 void scsi_show_command(struct scsi_cmnd *srb)
41 int i, unknown_cmd = 0;
43 switch (srb->cmnd[0]) {
44 case TEST_UNIT_READY: what = "TEST_UNIT_READY"; break;
45 case REZERO_UNIT: what = "REZERO_UNIT"; break;
46 case REQUEST_SENSE: what = "REQUEST_SENSE"; break;
47 case FORMAT_UNIT: what = "FORMAT_UNIT"; break;
48 case READ_BLOCK_LIMITS: what = "READ_BLOCK_LIMITS"; break;
49 case REASSIGN_BLOCKS: what = "REASSIGN_BLOCKS"; break;
50 case READ_6: what = "READ_6"; break;
51 case WRITE_6: what = "WRITE_6"; break;
52 case SEEK_6: what = "SEEK_6"; break;
53 case READ_REVERSE: what = "READ_REVERSE"; break;
54 case WRITE_FILEMARKS: what = "WRITE_FILEMARKS"; break;
55 case SPACE: what = "SPACE"; break;
56 case INQUIRY: what = "INQUIRY"; break;
57 case RECOVER_BUFFERED_DATA: what = "RECOVER_BUFFERED_DATA"; break;
58 case MODE_SELECT: what = "MODE_SELECT"; break;
59 case RESERVE: what = "RESERVE"; break;
60 case RELEASE: what = "RELEASE"; break;
61 case COPY: what = "COPY"; break;
62 case ERASE: what = "ERASE"; break;
63 case MODE_SENSE: what = "MODE_SENSE"; break;
64 case START_STOP: what = "START_STOP"; break;
65 case RECEIVE_DIAGNOSTIC: what = "RECEIVE_DIAGNOSTIC"; break;
66 case SEND_DIAGNOSTIC: what = "SEND_DIAGNOSTIC"; break;
67 case ALLOW_MEDIUM_REMOVAL: what = "ALLOW_MEDIUM_REMOVAL"; break;
68 case SET_WINDOW: what = "SET_WINDOW"; break;
69 case READ_CAPACITY: what = "READ_CAPACITY"; break;
70 case READ_10: what = "READ_10"; break;
71 case WRITE_10: what = "WRITE_10"; break;
72 case SEEK_10: what = "SEEK_10"; break;
73 case WRITE_VERIFY: what = "WRITE_VERIFY"; break;
74 case VERIFY: what = "VERIFY"; break;
75 case SEARCH_HIGH: what = "SEARCH_HIGH"; break;
76 case SEARCH_EQUAL: what = "SEARCH_EQUAL"; break;
77 case SEARCH_LOW: what = "SEARCH_LOW"; break;
78 case SET_LIMITS: what = "SET_LIMITS"; break;
79 case READ_POSITION: what = "READ_POSITION"; break;
80 case SYNCHRONIZE_CACHE: what = "SYNCHRONIZE_CACHE"; break;
81 case LOCK_UNLOCK_CACHE: what = "LOCK_UNLOCK_CACHE"; break;
82 case READ_DEFECT_DATA: what = "READ_DEFECT_DATA"; break;
83 case MEDIUM_SCAN: what = "MEDIUM_SCAN"; break;
84 case COMPARE: what = "COMPARE"; break;
85 case COPY_VERIFY: what = "COPY_VERIFY"; break;
86 case WRITE_BUFFER: what = "WRITE_BUFFER"; break;
87 case READ_BUFFER: what = "READ_BUFFER"; break;
88 case UPDATE_BLOCK: what = "UPDATE_BLOCK"; break;
89 case READ_LONG: what = "READ_LONG"; break;
90 case WRITE_LONG: what = "WRITE_LONG"; break;
91 case CHANGE_DEFINITION: what = "CHANGE_DEFINITION"; break;
92 case WRITE_SAME: what = "WRITE_SAME"; break;
93 case GPCMD_READ_SUBCHANNEL: what = "READ SUBCHANNEL"; break;
94 case READ_TOC: what = "READ_TOC"; break;
95 case GPCMD_READ_HEADER: what = "READ HEADER"; break;
96 case GPCMD_PLAY_AUDIO_10: what = "PLAY AUDIO (10)"; break;
97 case GPCMD_PLAY_AUDIO_MSF: what = "PLAY AUDIO MSF"; break;
98 case GPCMD_GET_EVENT_STATUS_NOTIFICATION:
99 what = "GET EVENT/STATUS NOTIFICATION"; break;
100 case GPCMD_PAUSE_RESUME: what = "PAUSE/RESUME"; break;
101 case LOG_SELECT: what = "LOG_SELECT"; break;
102 case LOG_SENSE: what = "LOG_SENSE"; break;
103 case GPCMD_STOP_PLAY_SCAN: what = "STOP PLAY/SCAN"; break;
104 case GPCMD_READ_DISC_INFO: what = "READ DISC INFORMATION"; break;
105 case GPCMD_READ_TRACK_RZONE_INFO:
106 what = "READ TRACK INFORMATION"; break;
107 case GPCMD_RESERVE_RZONE_TRACK: what = "RESERVE TRACK"; break;
108 case GPCMD_SEND_OPC: what = "SEND OPC"; break;
109 case MODE_SELECT_10: what = "MODE_SELECT_10"; break;
110 case GPCMD_REPAIR_RZONE_TRACK: what = "REPAIR TRACK"; break;
111 case 0x59: what = "READ MASTER CUE"; break;
112 case MODE_SENSE_10: what = "MODE_SENSE_10"; break;
113 case GPCMD_CLOSE_TRACK: what = "CLOSE TRACK/SESSION"; break;
114 case 0x5C: what = "READ BUFFER CAPACITY"; break;
115 case 0x5D: what = "SEND CUE SHEET"; break;
116 case GPCMD_BLANK: what = "BLANK"; break;
117 case REPORT_LUNS: what = "REPORT LUNS"; break;
118 case MOVE_MEDIUM: what = "MOVE_MEDIUM or PLAY AUDIO (12)"; break;
119 case READ_12: what = "READ_12"; break;
120 case WRITE_12: what = "WRITE_12"; break;
121 case WRITE_VERIFY_12: what = "WRITE_VERIFY_12"; break;
122 case SEARCH_HIGH_12: what = "SEARCH_HIGH_12"; break;
123 case SEARCH_EQUAL_12: what = "SEARCH_EQUAL_12"; break;
124 case SEARCH_LOW_12: what = "SEARCH_LOW_12"; break;
125 case SEND_VOLUME_TAG: what = "SEND_VOLUME_TAG"; break;
126 case READ_ELEMENT_STATUS: what = "READ_ELEMENT_STATUS"; break;
127 case GPCMD_READ_CD_MSF: what = "READ CD MSF"; break;
128 case GPCMD_SCAN: what = "SCAN"; break;
129 case GPCMD_SET_SPEED: what = "SET CD SPEED"; break;
130 case GPCMD_MECHANISM_STATUS: what = "MECHANISM STATUS"; break;
131 case GPCMD_READ_CD: what = "READ CD"; break;
132 case 0xE1: what = "WRITE CONTINUE"; break;
133 case WRITE_LONG_2: what = "WRITE_LONG_2"; break;
134 case VENDOR_CMND: what = "Realtek's vendor command"; break;
135 default: what = "(unknown command)"; unknown_cmd = 1; break;
138 if (srb->cmnd[0] != TEST_UNIT_READY) {
139 RTSX_DEBUGP("Command %s (%d bytes)\n", what, srb->cmd_len);
143 for (i = 0; i < srb->cmd_len && i < 16; i++)
144 RTSX_DEBUGPN(" %02x", srb->cmnd[i]);
149 void set_sense_type(struct rtsx_chip *chip, unsigned int lun, int sense_type)
151 switch (sense_type) {
152 case SENSE_TYPE_MEDIA_CHANGE:
153 set_sense_data(chip, lun, CUR_ERR, 0x06, 0, 0x28, 0, 0, 0);
156 case SENSE_TYPE_MEDIA_NOT_PRESENT:
157 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x3A, 0, 0, 0);
160 case SENSE_TYPE_MEDIA_LBA_OVER_RANGE:
161 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x21, 0, 0, 0);
164 case SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT:
165 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x25, 0, 0, 0);
168 case SENSE_TYPE_MEDIA_WRITE_PROTECT:
169 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x27, 0, 0, 0);
172 case SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR:
173 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x11, 0, 0, 0);
176 case SENSE_TYPE_MEDIA_WRITE_ERR:
177 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x02, 0, 0);
180 case SENSE_TYPE_MEDIA_INVALID_CMD_FIELD:
181 set_sense_data(chip, lun, CUR_ERR, ILGAL_REQ, 0,
182 ASC_INVLD_CDB, ASCQ_INVLD_CDB, CDB_ILLEGAL, 1);
185 case SENSE_TYPE_FORMAT_IN_PROGRESS:
186 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 0, 0);
189 case SENSE_TYPE_FORMAT_CMD_FAILED:
190 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x31, 0x01, 0, 0);
193 #ifdef SUPPORT_MAGIC_GATE
194 case SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB:
195 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x02, 0, 0);
198 case SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN:
199 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x00, 0, 0);
202 case SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM:
203 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x30, 0x00, 0, 0);
206 case SENSE_TYPE_MG_WRITE_ERR:
207 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x00, 0, 0);
211 #ifdef SUPPORT_SD_LOCK
212 case SENSE_TYPE_MEDIA_READ_FORBIDDEN:
213 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x11, 0x13, 0, 0);
217 case SENSE_TYPE_NO_SENSE:
219 set_sense_data(chip, lun, CUR_ERR, 0, 0, 0, 0, 0, 0);
224 void set_sense_data(struct rtsx_chip *chip, unsigned int lun, u8 err_code, u8 sense_key,
225 u32 info, u8 asc, u8 ascq, u8 sns_key_info0, u16 sns_key_info1)
227 struct sense_data_t *sense = &(chip->sense_buffer[lun]);
229 sense->err_code = err_code;
230 sense->sense_key = sense_key;
231 sense->info[0] = (u8)(info >> 24);
232 sense->info[1] = (u8)(info >> 16);
233 sense->info[2] = (u8)(info >> 8);
234 sense->info[3] = (u8)info;
236 sense->ad_sense_len = sizeof(struct sense_data_t) - 8;
239 if (sns_key_info0 != 0) {
240 sense->sns_key_info[0] = SKSV | sns_key_info0;
241 sense->sns_key_info[1] = (sns_key_info1 & 0xf0) >> 8;
242 sense->sns_key_info[2] = sns_key_info1 & 0x0f;
246 static int test_unit_ready(struct scsi_cmnd *srb, struct rtsx_chip *chip)
248 unsigned int lun = SCSI_LUN(srb);
250 if (!check_card_ready(chip, lun)) {
251 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
252 return TRANSPORT_FAILED;
255 if (!(CHK_BIT(chip->lun_mc, lun))) {
256 SET_BIT(chip->lun_mc, lun);
257 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
258 return TRANSPORT_FAILED;
261 #ifdef SUPPORT_SD_LOCK
262 if (get_lun_card(chip, SCSI_LUN(srb)) == SD_CARD) {
263 struct sd_info *sd_card = &(chip->sd_card);
264 if (sd_card->sd_lock_notify) {
265 sd_card->sd_lock_notify = 0;
266 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
267 return TRANSPORT_FAILED;
268 } else if (sd_card->sd_lock_status & SD_LOCKED) {
269 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
270 return TRANSPORT_FAILED;
275 return TRANSPORT_GOOD;
278 static unsigned char formatter_inquiry_str[20] = {
279 'M', 'E', 'M', 'O', 'R', 'Y', 'S', 'T', 'I', 'C', 'K',
280 #ifdef SUPPORT_MAGIC_GATE
281 '-', 'M', 'G', /* Byte[47:49] */
283 0x20, 0x20, 0x20, /* Byte[47:49] */
286 #ifdef SUPPORT_MAGIC_GATE
287 0x0B, /* Byte[50]: MG, MS, MSPro, MSXC */
289 0x09, /* Byte[50]: MS, MSPro, MSXC */
291 0x00, /* Byte[51]: Category Specific Commands */
292 0x00, /* Byte[52]: Access Control and feature */
293 0x20, 0x20, 0x20, /* Byte[53:55] */
296 static int inquiry(struct scsi_cmnd *srb, struct rtsx_chip *chip)
298 unsigned int lun = SCSI_LUN(srb);
299 char *inquiry_default = (char *)"Generic-xD/SD/M.S. 1.00 ";
300 char *inquiry_sdms = (char *)"Generic-SD/MemoryStick 1.00 ";
301 char *inquiry_sd = (char *)"Generic-SD/MMC 1.00 ";
302 char *inquiry_ms = (char *)"Generic-MemoryStick 1.00 ";
303 char *inquiry_string;
304 unsigned char sendbytes;
306 u8 card = get_lun_card(chip, lun);
307 int pro_formatter_flag = 0;
308 unsigned char inquiry_buf[] = {
309 QULIFIRE|DRCT_ACCESS_DEV,
316 REL_ADR|WBUS_32|WBUS_16|SYNC|LINKED|CMD_QUE|SFT_RE,
319 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
320 if (chip->lun2card[lun] == SD_CARD) {
321 inquiry_string = inquiry_sd;
323 inquiry_string = inquiry_ms;
325 } else if (CHECK_LUN_MODE(chip, SD_MS_1LUN)) {
326 inquiry_string = inquiry_sdms;
328 inquiry_string = inquiry_default;
331 buf = vmalloc(scsi_bufflen(srb));
333 TRACE_RET(chip, TRANSPORT_ERROR);
336 #ifdef SUPPORT_MAGIC_GATE
337 if ((chip->mspro_formatter_enable) &&
338 (chip->lun2card[lun] & MS_CARD))
340 if (chip->mspro_formatter_enable)
343 if (!card || (card == MS_CARD)) {
344 pro_formatter_flag = 1;
348 if (pro_formatter_flag) {
349 if (scsi_bufflen(srb) < 56) {
350 sendbytes = (unsigned char)(scsi_bufflen(srb));
355 if (scsi_bufflen(srb) < 36) {
356 sendbytes = (unsigned char)(scsi_bufflen(srb));
363 memcpy(buf, inquiry_buf, 8);
364 memcpy(buf + 8, inquiry_string, sendbytes - 8);
365 if (pro_formatter_flag) {
366 /* Additional Length */
370 memcpy(buf, inquiry_buf, sendbytes);
373 if (pro_formatter_flag) {
374 if (sendbytes > 36) {
375 memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36);
379 scsi_set_resid(srb, 0);
381 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
384 return TRANSPORT_GOOD;
388 static int start_stop_unit(struct scsi_cmnd *srb, struct rtsx_chip *chip)
390 unsigned int lun = SCSI_LUN(srb);
392 scsi_set_resid(srb, scsi_bufflen(srb));
394 if (srb->cmnd[1] == 1)
395 return TRANSPORT_GOOD;
397 switch (srb->cmnd[0x4]) {
400 return TRANSPORT_GOOD;
403 /* Media shall be unload */
404 if (check_card_ready(chip, lun))
405 eject_card(chip, lun);
406 return TRANSPORT_GOOD;
408 case MAKE_MEDIUM_READY:
410 if (check_card_ready(chip, lun)) {
411 return TRANSPORT_GOOD;
413 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
414 TRACE_RET(chip, TRANSPORT_FAILED);
420 TRACE_RET(chip, TRANSPORT_ERROR);
424 static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip)
428 prevent = srb->cmnd[4] & 0x1;
430 scsi_set_resid(srb, 0);
433 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
434 TRACE_RET(chip, TRANSPORT_FAILED);
437 return TRANSPORT_GOOD;
441 static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
443 struct sense_data_t *sense;
444 unsigned int lun = SCSI_LUN(srb);
445 struct ms_info *ms_card = &(chip->ms_card);
446 unsigned char *tmp, *buf;
448 sense = &(chip->sense_buffer[lun]);
450 if ((get_lun_card(chip, lun) == MS_CARD) && ms_card->pro_under_formatting) {
451 if (ms_card->format_status == FORMAT_SUCCESS) {
452 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
453 ms_card->pro_under_formatting = 0;
454 ms_card->progress = 0;
455 } else if (ms_card->format_status == FORMAT_IN_PROGRESS) {
456 /* Logical Unit Not Ready Format in Progress */
457 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
458 0, (u16)(ms_card->progress));
460 /* Format Command Failed */
461 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
462 ms_card->pro_under_formatting = 0;
463 ms_card->progress = 0;
466 rtsx_set_stat(chip, RTSX_STAT_RUN);
469 buf = vmalloc(scsi_bufflen(srb));
471 TRACE_RET(chip, TRANSPORT_ERROR);
474 tmp = (unsigned char *)sense;
475 memcpy(buf, tmp, scsi_bufflen(srb));
477 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
480 scsi_set_resid(srb, 0);
481 /* Reset Sense Data */
482 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
483 return TRANSPORT_GOOD;
486 static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd,
487 int lun, u8 *buf, int buf_len)
489 struct ms_info *ms_card = &(chip->ms_card);
491 int data_size = buf_len;
492 int support_format = 0;
495 if (cmd == MODE_SENSE) {
497 if (data_size > 0x68) {
500 buf[i++] = 0x67; /* Mode Data Length */
502 sys_info_offset = 12;
503 if (data_size > 0x6C) {
506 buf[i++] = 0x00; /* Mode Data Length (MSB) */
507 buf[i++] = 0x6A; /* Mode Data Length (LSB) */
510 /* Medium Type Code */
511 if (check_card_ready(chip, lun)) {
512 if (CHK_MSXC(ms_card)) {
515 } else if (CHK_MSPRO(ms_card)) {
523 if (check_card_wp(chip, lun)) {
529 buf[i++] = 0x00; /* MediaType */
530 buf[i++] = 0x00; /* WP */
533 buf[i++] = 0x00; /* Reserved */
535 if (cmd == MODE_SENSE_10) {
536 buf[i++] = 0x00; /* Reserved */
537 buf[i++] = 0x00; /* Block descriptor length(MSB) */
538 buf[i++] = 0x00; /* Block descriptor length(LSB) */
540 /* The Following Data is the content of "Page 0x20" */
542 buf[i++] = 0x20; /* Page Code */
544 buf[i++] = 0x62; /* Page Length */
546 buf[i++] = 0x00; /* No Access Control */
547 if (data_size >= 12) {
548 if (support_format) {
549 buf[i++] = 0xC0; /* SF, SGM */
555 /* The Following Data is the content of "Page 0x20" */
557 buf[i++] = 0x20; /* Page Code */
559 buf[i++] = 0x62; /* Page Length */
561 buf[i++] = 0x00; /* No Access Control */
562 if (data_size >= 8) {
563 if (support_format) {
564 buf[i++] = 0xC0; /* SF, SGM */
571 if (data_size > sys_info_offset) {
572 /* 96 Bytes Attribute Data */
573 int len = data_size - sys_info_offset;
574 len = (len < 96) ? len : 96;
576 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len);
580 static int mode_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
582 unsigned int lun = SCSI_LUN(srb);
583 unsigned int dataSize;
585 int pro_formatter_flag;
586 unsigned char pageCode, *buf;
587 u8 card = get_lun_card(chip, lun);
589 #ifndef SUPPORT_MAGIC_GATE
590 if (!check_card_ready(chip, lun)) {
591 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
592 scsi_set_resid(srb, scsi_bufflen(srb));
593 TRACE_RET(chip, TRANSPORT_FAILED);
597 pro_formatter_flag = 0;
599 #ifdef SUPPORT_MAGIC_GATE
600 if ((chip->lun2card[lun] & MS_CARD)) {
601 if (!card || (card == MS_CARD)) {
603 if (chip->mspro_formatter_enable) {
604 pro_formatter_flag = 1;
609 if (card == MS_CARD) {
610 if (chip->mspro_formatter_enable) {
611 pro_formatter_flag = 1;
617 buf = kmalloc(dataSize, GFP_KERNEL);
619 TRACE_RET(chip, TRANSPORT_ERROR);
622 pageCode = srb->cmnd[2] & 0x3f;
624 if ((pageCode == 0x3F) || (pageCode == 0x1C) ||
625 (pageCode == 0x00) ||
626 (pro_formatter_flag && (pageCode == 0x20))) {
627 if (srb->cmnd[0] == MODE_SENSE) {
628 if ((pageCode == 0x3F) || (pageCode == 0x20)) {
629 ms_mode_sense(chip, srb->cmnd[0],
635 if (check_card_wp(chip, lun)) {
643 if ((pageCode == 0x3F) || (pageCode == 0x20)) {
644 ms_mode_sense(chip, srb->cmnd[0],
651 if (check_card_wp(chip, lun)) {
662 status = TRANSPORT_GOOD;
664 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
665 scsi_set_resid(srb, scsi_bufflen(srb));
666 status = TRANSPORT_FAILED;
669 if (status == TRANSPORT_GOOD) {
670 unsigned int len = min(scsi_bufflen(srb), dataSize);
671 rtsx_stor_set_xfer_buf(buf, len, srb);
672 scsi_set_resid(srb, scsi_bufflen(srb) - len);
679 static int read_write(struct scsi_cmnd *srb, struct rtsx_chip *chip)
681 #ifdef SUPPORT_SD_LOCK
682 struct sd_info *sd_card = &(chip->sd_card);
684 unsigned int lun = SCSI_LUN(srb);
689 rtsx_disable_aspm(chip);
691 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
695 rtsx_set_stat(chip, RTSX_STAT_RUN);
697 if (!check_card_ready(chip, lun) || (get_card_size(chip, lun) == 0)) {
698 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
699 TRACE_RET(chip, TRANSPORT_FAILED);
702 if (!(CHK_BIT(chip->lun_mc, lun))) {
703 SET_BIT(chip->lun_mc, lun);
704 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
705 return TRANSPORT_FAILED;
708 #ifdef SUPPORT_SD_LOCK
709 if (sd_card->sd_erase_status) {
710 /* Accessing to any card is forbidden
711 * until the erase procedure of SD is completed
713 RTSX_DEBUGP("SD card being erased!\n");
714 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
715 TRACE_RET(chip, TRANSPORT_FAILED);
718 if (get_lun_card(chip, lun) == SD_CARD) {
719 if (sd_card->sd_lock_status & SD_LOCKED) {
720 RTSX_DEBUGP("SD card locked!\n");
721 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
722 TRACE_RET(chip, TRANSPORT_FAILED);
727 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
728 start_sec = ((u32)srb->cmnd[2] << 24) | ((u32)srb->cmnd[3] << 16) |
729 ((u32)srb->cmnd[4] << 8) | ((u32)srb->cmnd[5]);
730 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
731 } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
732 start_sec = ((u32)(srb->cmnd[1] & 0x1F) << 16) |
733 ((u32)srb->cmnd[2] << 8) | ((u32)srb->cmnd[3]);
734 sec_cnt = srb->cmnd[4];
735 } else if ((srb->cmnd[0] == VENDOR_CMND) && (srb->cmnd[1] == SCSI_APP_CMD) &&
736 ((srb->cmnd[2] == PP_READ10) || (srb->cmnd[2] == PP_WRITE10))) {
737 start_sec = ((u32)srb->cmnd[4] << 24) | ((u32)srb->cmnd[5] << 16) |
738 ((u32)srb->cmnd[6] << 8) | ((u32)srb->cmnd[7]);
739 sec_cnt = ((u16)(srb->cmnd[9]) << 8) | srb->cmnd[10];
741 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
742 TRACE_RET(chip, TRANSPORT_FAILED);
745 /* In some test, we will receive a start_sec like 0xFFFFFFFF.
746 * In this situation, start_sec + sec_cnt will overflow, so we
747 * need to judge start_sec at first
749 if ((start_sec > get_card_size(chip, lun)) ||
750 ((start_sec + sec_cnt) > get_card_size(chip, lun))) {
751 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE);
752 TRACE_RET(chip, TRANSPORT_FAILED);
756 scsi_set_resid(srb, 0);
757 return TRANSPORT_GOOD;
760 if (chip->rw_fail_cnt[lun] == 3) {
761 RTSX_DEBUGP("read/write fail three times in succession\n");
762 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
763 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
765 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
767 TRACE_RET(chip, TRANSPORT_FAILED);
770 if (srb->sc_data_direction == DMA_TO_DEVICE) {
771 if (check_card_wp(chip, lun)) {
772 RTSX_DEBUGP("Write protected card!\n");
773 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
774 TRACE_RET(chip, TRANSPORT_FAILED);
776 if (CHECK_PID(chip, 0x5209) && chip->max_payload) {
777 u8 val = 0x10 | (chip->max_payload << 5);
778 retval = rtsx_write_cfg_dw(chip, 0, 0x78, 0xFF, val);
779 if (retval != STATUS_SUCCESS) {
780 TRACE_RET(chip, TRANSPORT_ERROR);
785 retval = card_rw(srb, chip, start_sec, sec_cnt);
786 if (retval != STATUS_SUCCESS) {
787 if (chip->need_release & chip->lun2card[lun]) {
788 chip->rw_fail_cnt[lun] = 0;
789 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
791 chip->rw_fail_cnt[lun]++;
792 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
793 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
795 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
798 retval = TRANSPORT_FAILED;
799 TRACE_GOTO(chip, Exit);
801 chip->rw_fail_cnt[lun] = 0;
802 retval = TRANSPORT_GOOD;
805 scsi_set_resid(srb, 0);
808 if (srb->sc_data_direction == DMA_TO_DEVICE) {
809 if (CHECK_PID(chip, 0x5209) && chip->max_payload) {
810 retval = rtsx_write_cfg_dw(chip, 0, 0x78, 0xFF, 0x10);
811 if (retval != STATUS_SUCCESS) {
812 TRACE_RET(chip, TRANSPORT_ERROR);
820 static int read_format_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
823 unsigned int lun = SCSI_LUN(srb);
824 unsigned int buf_len;
825 u8 card = get_lun_card(chip, lun);
830 if (!check_card_ready(chip, lun)) {
831 if (!chip->mspro_formatter_enable) {
832 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
833 TRACE_RET(chip, TRANSPORT_FAILED);
837 buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12;
839 buf = kmalloc(buf_len, GFP_KERNEL);
841 TRACE_RET(chip, TRANSPORT_ERROR);
848 /* Capacity List Length */
849 if ((buf_len > 12) && chip->mspro_formatter_enable &&
850 (chip->lun2card[lun] & MS_CARD) &&
851 (!card || (card == MS_CARD))) {
860 if (check_card_ready(chip, lun)) {
861 card_size = get_card_size(chip, lun);
862 buf[i++] = (unsigned char)(card_size >> 24);
863 buf[i++] = (unsigned char)(card_size >> 16);
864 buf[i++] = (unsigned char)(card_size >> 8);
865 buf[i++] = (unsigned char)card_size;
892 buf_len = min(scsi_bufflen(srb), buf_len);
893 rtsx_stor_set_xfer_buf(buf, buf_len, srb);
896 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
898 return TRANSPORT_GOOD;
901 static int read_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
904 unsigned int lun = SCSI_LUN(srb);
907 if (!check_card_ready(chip, lun)) {
908 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
909 TRACE_RET(chip, TRANSPORT_FAILED);
912 if (!(CHK_BIT(chip->lun_mc, lun))) {
913 SET_BIT(chip->lun_mc, lun);
914 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
915 return TRANSPORT_FAILED;
918 buf = kmalloc(8, GFP_KERNEL);
920 TRACE_RET(chip, TRANSPORT_ERROR);
923 card_size = get_card_size(chip, lun);
924 buf[0] = (unsigned char)((card_size - 1) >> 24);
925 buf[1] = (unsigned char)((card_size - 1) >> 16);
926 buf[2] = (unsigned char)((card_size - 1) >> 8);
927 buf[3] = (unsigned char)(card_size - 1);
934 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
937 scsi_set_resid(srb, 0);
939 return TRANSPORT_GOOD;
942 static int read_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
944 unsigned short len, i;
948 rtsx_disable_aspm(chip);
950 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
954 rtsx_set_stat(chip, RTSX_STAT_RUN);
956 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
958 buf = (u8 *)vmalloc(len);
960 TRACE_RET(chip, TRANSPORT_ERROR);
963 retval = rtsx_force_power_on(chip, SSC_PDCTL);
964 if (retval != STATUS_SUCCESS) {
966 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
967 TRACE_RET(chip, TRANSPORT_FAILED);
970 for (i = 0; i < len; i++) {
971 retval = spi_read_eeprom(chip, i, buf + i);
972 if (retval != STATUS_SUCCESS) {
974 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
975 TRACE_RET(chip, TRANSPORT_FAILED);
979 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
980 rtsx_stor_set_xfer_buf(buf, len, srb);
981 scsi_set_resid(srb, scsi_bufflen(srb) - len);
985 return TRANSPORT_GOOD;
988 static int write_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
990 unsigned short len, i;
994 rtsx_disable_aspm(chip);
996 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1000 rtsx_set_stat(chip, RTSX_STAT_RUN);
1002 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1004 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1005 if (retval != STATUS_SUCCESS) {
1006 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1007 TRACE_RET(chip, TRANSPORT_FAILED);
1011 retval = spi_erase_eeprom_chip(chip);
1012 if (retval != STATUS_SUCCESS) {
1013 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1014 TRACE_RET(chip, TRANSPORT_FAILED);
1017 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1018 buf = (u8 *)vmalloc(len);
1020 TRACE_RET(chip, TRANSPORT_ERROR);
1023 rtsx_stor_get_xfer_buf(buf, len, srb);
1024 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1026 for (i = 0; i < len; i++) {
1027 retval = spi_write_eeprom(chip, i, buf[i]);
1028 if (retval != STATUS_SUCCESS) {
1030 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1031 TRACE_RET(chip, TRANSPORT_FAILED);
1038 return TRANSPORT_GOOD;
1041 static int read_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1043 unsigned short addr, len, i;
1047 rtsx_disable_aspm(chip);
1049 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1053 rtsx_set_stat(chip, RTSX_STAT_RUN);
1055 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1056 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1058 if (addr < 0xFC00) {
1059 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1060 TRACE_RET(chip, TRANSPORT_FAILED);
1063 buf = (u8 *)vmalloc(len);
1065 TRACE_RET(chip, TRANSPORT_ERROR);
1068 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1069 if (retval != STATUS_SUCCESS) {
1071 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1072 TRACE_RET(chip, TRANSPORT_FAILED);
1075 for (i = 0; i < len; i++) {
1076 retval = rtsx_read_register(chip, addr + i, buf + i);
1077 if (retval != STATUS_SUCCESS) {
1079 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1080 TRACE_RET(chip, TRANSPORT_FAILED);
1084 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1085 rtsx_stor_set_xfer_buf(buf, len, srb);
1086 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1090 return TRANSPORT_GOOD;
1093 static int write_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1095 unsigned short addr, len, i;
1099 rtsx_disable_aspm(chip);
1101 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1105 rtsx_set_stat(chip, RTSX_STAT_RUN);
1107 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1108 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1110 if (addr < 0xFC00) {
1111 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1112 TRACE_RET(chip, TRANSPORT_FAILED);
1115 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1116 buf = (u8 *)vmalloc(len);
1118 TRACE_RET(chip, TRANSPORT_ERROR);
1121 rtsx_stor_get_xfer_buf(buf, len, srb);
1122 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1124 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1125 if (retval != STATUS_SUCCESS) {
1127 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1128 TRACE_RET(chip, TRANSPORT_FAILED);
1131 for (i = 0; i < len; i++) {
1132 retval = rtsx_write_register(chip, addr + i, 0xFF, buf[i]);
1133 if (retval != STATUS_SUCCESS) {
1135 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1136 TRACE_RET(chip, TRANSPORT_FAILED);
1142 return TRANSPORT_GOOD;
1145 static int get_sd_csd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1147 struct sd_info *sd_card = &(chip->sd_card);
1148 unsigned int lun = SCSI_LUN(srb);
1150 if (!check_card_ready(chip, lun)) {
1151 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1152 TRACE_RET(chip, TRANSPORT_FAILED);
1155 if (get_lun_card(chip, lun) != SD_CARD) {
1156 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1157 TRACE_RET(chip, TRANSPORT_FAILED);
1160 scsi_set_resid(srb, 0);
1161 rtsx_stor_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb);
1163 return TRANSPORT_GOOD;
1166 static int toggle_gpio_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1168 u8 gpio = srb->cmnd[2];
1170 rtsx_disable_aspm(chip);
1172 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1176 rtsx_set_stat(chip, RTSX_STAT_RUN);
1180 toggle_gpio(chip, gpio);
1182 return TRANSPORT_GOOD;
1186 static int trace_msg_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1188 unsigned char *ptr, *buf = NULL;
1191 unsigned int buf_len;
1193 buf_len = 4 + ((2 + MSG_FUNC_LEN + MSG_FILE_LEN + TIME_VAL_LEN) * TRACE_ITEM_CNT);
1195 if ((scsi_bufflen(srb) < buf_len) || (scsi_sglist(srb) == NULL)) {
1196 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1197 TRACE_RET(chip, TRANSPORT_FAILED);
1200 clear = srb->cmnd[2];
1202 buf = (unsigned char *)vmalloc(scsi_bufflen(srb));
1204 TRACE_RET(chip, TRANSPORT_ERROR);
1208 if (chip->trace_msg[chip->msg_idx].valid) {
1209 msg_cnt = TRACE_ITEM_CNT;
1211 msg_cnt = chip->msg_idx;
1213 *(ptr++) = (u8)(msg_cnt >> 24);
1214 *(ptr++) = (u8)(msg_cnt >> 16);
1215 *(ptr++) = (u8)(msg_cnt >> 8);
1216 *(ptr++) = (u8)msg_cnt;
1217 RTSX_DEBUGP("Trace message count is %d\n", msg_cnt);
1219 for (i = 1; i <= msg_cnt; i++) {
1222 idx = chip->msg_idx - i;
1224 idx += TRACE_ITEM_CNT;
1226 *(ptr++) = (u8)(chip->trace_msg[idx].line >> 8);
1227 *(ptr++) = (u8)(chip->trace_msg[idx].line);
1228 for (j = 0; j < MSG_FUNC_LEN; j++) {
1229 *(ptr++) = chip->trace_msg[idx].func[j];
1231 for (j = 0; j < MSG_FILE_LEN; j++) {
1232 *(ptr++) = chip->trace_msg[idx].file[j];
1234 for (j = 0; j < TIME_VAL_LEN; j++) {
1235 *(ptr++) = chip->trace_msg[idx].timeval_buf[j];
1239 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1244 for (i = 0; i < TRACE_ITEM_CNT; i++)
1245 chip->trace_msg[i].valid = 0;
1248 scsi_set_resid(srb, 0);
1249 return TRANSPORT_GOOD;
1253 static int read_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1259 rtsx_disable_aspm(chip);
1261 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1265 rtsx_set_stat(chip, RTSX_STAT_RUN);
1267 addr = srb->cmnd[4];
1269 val = rtsx_readl(chip, addr);
1270 RTSX_DEBUGP("Host register (0x%x): 0x%x\n", addr, val);
1272 buf[0] = (u8)(val >> 24);
1273 buf[1] = (u8)(val >> 16);
1274 buf[2] = (u8)(val >> 8);
1277 len = min(scsi_bufflen(srb), (unsigned int)4);
1278 rtsx_stor_set_xfer_buf(buf, len, srb);
1279 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1281 return TRANSPORT_GOOD;
1284 static int write_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1290 rtsx_disable_aspm(chip);
1292 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1296 rtsx_set_stat(chip, RTSX_STAT_RUN);
1298 addr = srb->cmnd[4];
1300 len = min(scsi_bufflen(srb), (unsigned int)4);
1301 rtsx_stor_get_xfer_buf(buf, len, srb);
1302 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1304 val = ((u32)buf[0] << 24) | ((u32)buf[1] << 16) | ((u32)buf[2] << 8) | buf[3];
1306 rtsx_writel(chip, addr, val);
1308 return TRANSPORT_GOOD;
1311 static int set_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1313 unsigned lun = SCSI_LUN(srb);
1315 if (srb->cmnd[3] == 1) {
1316 /* Variable Clock */
1317 struct xd_info *xd_card = &(chip->xd_card);
1318 struct sd_info *sd_card = &(chip->sd_card);
1319 struct ms_info *ms_card = &(chip->ms_card);
1321 switch (srb->cmnd[4]) {
1323 xd_card->xd_clock = srb->cmnd[5];
1327 sd_card->sd_clock = srb->cmnd[5];
1331 ms_card->ms_clock = srb->cmnd[5];
1335 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1336 TRACE_RET(chip, TRANSPORT_FAILED);
1338 } else if (srb->cmnd[3] == 2) {
1340 chip->blink_led = 1;
1344 chip->blink_led = 0;
1346 rtsx_disable_aspm(chip);
1348 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1352 rtsx_set_stat(chip, RTSX_STAT_RUN);
1354 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1355 if (retval != STATUS_SUCCESS) {
1356 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1357 TRACE_RET(chip, TRANSPORT_FAILED);
1360 turn_off_led(chip, LED_GPIO);
1363 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1364 TRACE_RET(chip, TRANSPORT_FAILED);
1367 return TRANSPORT_GOOD;
1370 static int get_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1372 unsigned int lun = SCSI_LUN(srb);
1374 if (srb->cmnd[3] == 1) {
1375 struct xd_info *xd_card = &(chip->xd_card);
1376 struct sd_info *sd_card = &(chip->sd_card);
1377 struct ms_info *ms_card = &(chip->ms_card);
1380 switch (srb->cmnd[4]) {
1382 tmp = (u8)(xd_card->xd_clock);
1386 tmp = (u8)(sd_card->sd_clock);
1390 tmp = (u8)(ms_card->ms_clock);
1394 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1395 TRACE_RET(chip, TRANSPORT_FAILED);
1398 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1399 } else if (srb->cmnd[3] == 2) {
1400 u8 tmp = chip->blink_led;
1401 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1403 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1404 TRACE_RET(chip, TRANSPORT_FAILED);
1407 return TRANSPORT_GOOD;
1410 static int dma_access_ring_buffer(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1413 unsigned int lun = SCSI_LUN(srb);
1416 rtsx_disable_aspm(chip);
1418 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1422 rtsx_set_stat(chip, RTSX_STAT_RUN);
1424 len = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
1425 len = min(len, (u16)scsi_bufflen(srb));
1427 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
1428 RTSX_DEBUGP("Read from device\n");
1430 RTSX_DEBUGP("Write to device\n");
1433 retval = rtsx_transfer_data(chip, 0, scsi_sglist(srb), len,
1434 scsi_sg_count(srb), srb->sc_data_direction, 1000);
1436 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
1437 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1439 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1441 TRACE_RET(chip, TRANSPORT_FAILED);
1443 scsi_set_resid(srb, 0);
1445 return TRANSPORT_GOOD;
1448 static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1450 struct sd_info *sd_card = &(chip->sd_card);
1451 struct ms_info *ms_card = &(chip->ms_card);
1453 unsigned int lun = SCSI_LUN(srb);
1454 u8 card = get_lun_card(chip, lun);
1457 u8 oc_now_mask = 0, oc_ever_mask = 0;
1460 memset(status, 0, 32);
1462 status[0] = (u8)(chip->product_id);
1463 status[1] = chip->ic_version;
1465 if (chip->auto_delink_en) {
1476 if (chip->card_wp) {
1484 if (CHECK_LUN_MODE(chip, SD_MS_2LUN) && (chip->lun2card[lun] == MS_CARD)) {
1485 oc_now_mask = MS_OC_NOW;
1486 oc_ever_mask = MS_OC_EVER;
1488 oc_now_mask = SD_OC_NOW;
1489 oc_ever_mask = SD_OC_EVER;
1492 if (chip->ocp_stat & oc_now_mask) {
1495 if (chip->ocp_stat & oc_ever_mask) {
1500 if (card == SD_CARD) {
1501 if (CHK_SD(sd_card)) {
1502 if (CHK_SD_HCXC(sd_card)) {
1503 if (sd_card->capacity > 0x4000000) {
1504 status[0x0E] = 0x02;
1506 status[0x0E] = 0x01;
1509 status[0x0E] = 0x00;
1512 if (CHK_SD_SDR104(sd_card)) {
1513 status[0x0F] = 0x03;
1514 } else if (CHK_SD_DDR50(sd_card)) {
1515 status[0x0F] = 0x04;
1516 } else if (CHK_SD_SDR50(sd_card)) {
1517 status[0x0F] = 0x02;
1518 } else if (CHK_SD_HS(sd_card)) {
1519 status[0x0F] = 0x01;
1521 status[0x0F] = 0x00;
1524 if (CHK_MMC_SECTOR_MODE(sd_card)) {
1525 status[0x0E] = 0x01;
1527 status[0x0E] = 0x00;
1530 if (CHK_MMC_DDR52(sd_card)) {
1531 status[0x0F] = 0x03;
1532 } else if (CHK_MMC_52M(sd_card)) {
1533 status[0x0F] = 0x02;
1534 } else if (CHK_MMC_26M(sd_card)) {
1535 status[0x0F] = 0x01;
1537 status[0x0F] = 0x00;
1540 } else if (card == MS_CARD) {
1541 if (CHK_MSPRO(ms_card)) {
1542 if (CHK_MSXC(ms_card)) {
1543 status[0x0E] = 0x01;
1545 status[0x0E] = 0x00;
1548 if (CHK_HG8BIT(ms_card)) {
1549 status[0x0F] = 0x01;
1551 status[0x0F] = 0x00;
1556 #ifdef SUPPORT_SD_LOCK
1557 if (card == SD_CARD) {
1558 status[0x17] = 0x80;
1559 if (sd_card->sd_erase_status)
1560 status[0x17] |= 0x01;
1561 if (sd_card->sd_lock_status & SD_LOCKED) {
1562 status[0x17] |= 0x02;
1563 status[0x07] |= 0x40;
1565 if (sd_card->sd_lock_status & SD_PWD_EXIST)
1566 status[0x17] |= 0x04;
1568 status[0x17] = 0x00;
1571 RTSX_DEBUGP("status[0x17] = 0x%x\n", status[0x17]);
1574 status[0x18] = 0x8A;
1575 status[0x1A] = 0x28;
1576 #ifdef SUPPORT_SD_LOCK
1577 status[0x1F] = 0x01;
1580 buf_len = min(scsi_bufflen(srb), (unsigned int)sizeof(status));
1581 rtsx_stor_set_xfer_buf(status, buf_len, srb);
1582 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1584 return TRANSPORT_GOOD;
1587 static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1593 if (!CHECK_PID(chip, 0x5208)) {
1594 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1595 TRACE_RET(chip, TRANSPORT_FAILED);
1598 phy_debug_mode = (int)(srb->cmnd[3]);
1600 if (phy_debug_mode) {
1601 chip->phy_debug_mode = 1;
1602 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0);
1603 if (retval != STATUS_SUCCESS) {
1604 TRACE_RET(chip, TRANSPORT_FAILED);
1606 rtsx_disable_bus_int(chip);
1608 retval = rtsx_read_phy_register(chip, 0x1C, ®);
1609 if (retval != STATUS_SUCCESS) {
1610 TRACE_RET(chip, TRANSPORT_FAILED);
1613 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1614 if (retval != STATUS_SUCCESS) {
1615 TRACE_RET(chip, TRANSPORT_FAILED);
1618 chip->phy_debug_mode = 0;
1619 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77);
1620 if (retval != STATUS_SUCCESS) {
1621 TRACE_RET(chip, TRANSPORT_FAILED);
1623 rtsx_enable_bus_int(chip);
1625 retval = rtsx_read_phy_register(chip, 0x1C, ®);
1626 if (retval != STATUS_SUCCESS) {
1627 TRACE_RET(chip, TRANSPORT_FAILED);
1630 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1631 if (retval != STATUS_SUCCESS) {
1632 TRACE_RET(chip, TRANSPORT_FAILED);
1636 return TRANSPORT_GOOD;
1639 static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1641 int retval = STATUS_SUCCESS;
1642 unsigned int lun = SCSI_LUN(srb);
1643 u8 cmd_type, mask, value, idx;
1646 rtsx_disable_aspm(chip);
1648 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1652 rtsx_set_stat(chip, RTSX_STAT_RUN);
1654 switch (srb->cmnd[3]) {
1656 rtsx_init_cmd(chip);
1660 cmd_type = srb->cmnd[4];
1662 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1663 TRACE_RET(chip, TRANSPORT_FAILED);
1665 addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1666 mask = srb->cmnd[7];
1667 value = srb->cmnd[8];
1668 rtsx_add_cmd(chip, cmd_type, addr, mask, value);
1672 retval = rtsx_send_cmd(chip, 0, 1000);
1677 value = *(rtsx_get_cmd_data(chip) + idx);
1678 if (scsi_bufflen(srb) < 1) {
1679 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1680 TRACE_RET(chip, TRANSPORT_FAILED);
1682 rtsx_stor_set_xfer_buf(&value, 1, srb);
1683 scsi_set_resid(srb, 0);
1687 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1688 TRACE_RET(chip, TRANSPORT_FAILED);
1691 if (retval != STATUS_SUCCESS) {
1692 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1693 TRACE_RET(chip, TRANSPORT_FAILED);
1696 return TRANSPORT_GOOD;
1699 static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1703 switch (srb->cmnd[3]) {
1708 result = rw_mem_cmd_buf(srb, chip);
1711 result = TRANSPORT_ERROR;
1717 static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1719 unsigned short addr, len, i;
1724 rtsx_disable_aspm(chip);
1726 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1730 rtsx_set_stat(chip, RTSX_STAT_RUN);
1732 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1733 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1739 buf = (u8 *)vmalloc(len);
1741 TRACE_RET(chip, TRANSPORT_ERROR);
1744 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1745 if (retval != STATUS_SUCCESS) {
1747 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1748 TRACE_RET(chip, TRANSPORT_FAILED);
1751 for (i = 0; i < len / 2; i++) {
1752 retval = rtsx_read_phy_register(chip, addr + i, &val);
1753 if (retval != STATUS_SUCCESS) {
1755 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1756 TRACE_RET(chip, TRANSPORT_FAILED);
1759 buf[2*i] = (u8)(val >> 8);
1760 buf[2*i+1] = (u8)val;
1763 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1764 rtsx_stor_set_xfer_buf(buf, len, srb);
1765 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1770 return TRANSPORT_GOOD;
1773 static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1775 unsigned short addr, len, i;
1780 rtsx_disable_aspm(chip);
1782 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1786 rtsx_set_stat(chip, RTSX_STAT_RUN);
1788 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1789 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1795 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1797 buf = (u8 *)vmalloc(len);
1799 TRACE_RET(chip, TRANSPORT_ERROR);
1802 rtsx_stor_get_xfer_buf(buf, len, srb);
1803 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1805 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1806 if (retval != STATUS_SUCCESS) {
1808 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1809 TRACE_RET(chip, TRANSPORT_FAILED);
1812 for (i = 0; i < len / 2; i++) {
1813 val = ((u16)buf[2*i] << 8) | buf[2*i+1];
1814 retval = rtsx_write_phy_register(chip, addr + i, val);
1815 if (retval != STATUS_SUCCESS) {
1817 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1818 TRACE_RET(chip, TRANSPORT_FAILED);
1825 return TRANSPORT_GOOD;
1828 static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1830 unsigned short addr;
1834 rtsx_disable_aspm(chip);
1836 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1840 rtsx_set_stat(chip, RTSX_STAT_RUN);
1842 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1843 if (retval != STATUS_SUCCESS) {
1844 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1845 TRACE_RET(chip, TRANSPORT_FAILED);
1848 mode = srb->cmnd[3];
1849 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1852 retval = spi_erase_eeprom_chip(chip);
1853 if (retval != STATUS_SUCCESS) {
1854 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1855 TRACE_RET(chip, TRANSPORT_FAILED);
1857 } else if (mode == 1) {
1858 retval = spi_erase_eeprom_byte(chip, addr);
1859 if (retval != STATUS_SUCCESS) {
1860 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1861 TRACE_RET(chip, TRANSPORT_FAILED);
1864 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1865 TRACE_RET(chip, TRANSPORT_FAILED);
1868 return TRANSPORT_GOOD;
1871 static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1873 unsigned short addr, len, i;
1877 rtsx_disable_aspm(chip);
1879 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1883 rtsx_set_stat(chip, RTSX_STAT_RUN);
1885 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1886 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1888 buf = (u8 *)vmalloc(len);
1890 TRACE_RET(chip, TRANSPORT_ERROR);
1893 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1894 if (retval != STATUS_SUCCESS) {
1896 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1897 TRACE_RET(chip, TRANSPORT_FAILED);
1900 for (i = 0; i < len; i++) {
1901 retval = spi_read_eeprom(chip, addr + i, buf + i);
1902 if (retval != STATUS_SUCCESS) {
1904 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1905 TRACE_RET(chip, TRANSPORT_FAILED);
1909 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1910 rtsx_stor_set_xfer_buf(buf, len, srb);
1911 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1915 return TRANSPORT_GOOD;
1918 static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1920 unsigned short addr, len, i;
1924 rtsx_disable_aspm(chip);
1926 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1930 rtsx_set_stat(chip, RTSX_STAT_RUN);
1932 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1933 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1935 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1936 buf = (u8 *)vmalloc(len);
1938 TRACE_RET(chip, TRANSPORT_ERROR);
1941 rtsx_stor_get_xfer_buf(buf, len, srb);
1942 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1944 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1945 if (retval != STATUS_SUCCESS) {
1947 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1948 TRACE_RET(chip, TRANSPORT_FAILED);
1951 for (i = 0; i < len; i++) {
1952 retval = spi_write_eeprom(chip, addr + i, buf[i]);
1953 if (retval != STATUS_SUCCESS) {
1955 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1956 TRACE_RET(chip, TRANSPORT_FAILED);
1962 return TRANSPORT_GOOD;
1965 static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1971 rtsx_disable_aspm(chip);
1973 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1977 rtsx_set_stat(chip, RTSX_STAT_RUN);
1979 addr = srb->cmnd[4];
1982 buf = (u8 *)vmalloc(len);
1984 TRACE_RET(chip, TRANSPORT_ERROR);
1987 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1988 if (retval != STATUS_SUCCESS) {
1990 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1991 TRACE_RET(chip, TRANSPORT_FAILED);
1994 for (i = 0; i < len; i++) {
1995 retval = rtsx_read_efuse(chip, addr + i, buf + i);
1996 if (retval != STATUS_SUCCESS) {
1998 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1999 TRACE_RET(chip, TRANSPORT_FAILED);
2003 len = (u8)min(scsi_bufflen(srb), (unsigned int)len);
2004 rtsx_stor_set_xfer_buf(buf, len, srb);
2005 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2009 return TRANSPORT_GOOD;
2012 static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2014 int retval, result = TRANSPORT_GOOD;
2019 rtsx_disable_aspm(chip);
2021 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2025 rtsx_set_stat(chip, RTSX_STAT_RUN);
2027 addr = srb->cmnd[4];
2030 len = (u8)min(scsi_bufflen(srb), (unsigned int)len);
2031 buf = (u8 *)vmalloc(len);
2033 TRACE_RET(chip, TRANSPORT_ERROR);
2036 rtsx_stor_get_xfer_buf(buf, len, srb);
2037 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2039 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2040 if (retval != STATUS_SUCCESS) {
2042 TRACE_RET(chip, TRANSPORT_ERROR);
2045 if (chip->asic_code) {
2046 retval = rtsx_read_phy_register(chip, 0x08, &val);
2047 if (retval != STATUS_SUCCESS) {
2049 TRACE_RET(chip, TRANSPORT_ERROR);
2052 retval = rtsx_write_register(chip, PWR_GATE_CTRL, LDO3318_PWR_MASK, LDO_OFF);
2053 if (retval != STATUS_SUCCESS) {
2055 TRACE_RET(chip, TRANSPORT_ERROR);
2060 retval = rtsx_write_phy_register(chip, 0x08, 0x4C00 | chip->phy_voltage);
2061 if (retval != STATUS_SUCCESS) {
2063 TRACE_RET(chip, TRANSPORT_ERROR);
2066 retval = rtsx_write_register(chip, PWR_GATE_CTRL, LDO3318_PWR_MASK, LDO_ON);
2067 if (retval != STATUS_SUCCESS) {
2069 TRACE_RET(chip, TRANSPORT_ERROR);
2075 retval = card_power_on(chip, SPI_CARD);
2076 if (retval != STATUS_SUCCESS) {
2078 TRACE_RET(chip, TRANSPORT_ERROR);
2083 for (i = 0; i < len; i++) {
2084 retval = rtsx_write_efuse(chip, addr + i, buf[i]);
2085 if (retval != STATUS_SUCCESS) {
2086 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2087 result = TRANSPORT_FAILED;
2088 TRACE_GOTO(chip, Exit);
2095 retval = card_power_off(chip, SPI_CARD);
2096 if (retval != STATUS_SUCCESS) {
2097 TRACE_RET(chip, TRANSPORT_ERROR);
2100 if (chip->asic_code) {
2101 retval = rtsx_write_register(chip, PWR_GATE_CTRL, LDO3318_PWR_MASK, LDO_OFF);
2102 if (retval != STATUS_SUCCESS) {
2103 TRACE_RET(chip, TRANSPORT_ERROR);
2108 retval = rtsx_write_phy_register(chip, 0x08, val);
2109 if (retval != STATUS_SUCCESS) {
2110 TRACE_RET(chip, TRANSPORT_ERROR);
2113 retval = rtsx_write_register(chip, PWR_GATE_CTRL, LDO3318_PWR_MASK, LDO_ON);
2114 if (retval != STATUS_SUCCESS) {
2115 TRACE_RET(chip, TRANSPORT_ERROR);
2122 static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2129 rtsx_disable_aspm(chip);
2131 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2135 rtsx_set_stat(chip, RTSX_STAT_RUN);
2137 func = srb->cmnd[3];
2138 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2139 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2141 RTSX_DEBUGP("%s: func = %d, addr = 0x%x, len = %d\n", __func__, func, addr, len);
2143 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) {
2149 if (func > func_max) {
2150 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2151 TRACE_RET(chip, TRANSPORT_FAILED);
2154 buf = (u8 *)vmalloc(len);
2156 TRACE_RET(chip, TRANSPORT_ERROR);
2159 retval = rtsx_read_cfg_seq(chip, func, addr, buf, len);
2160 if (retval != STATUS_SUCCESS) {
2161 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2163 TRACE_RET(chip, TRANSPORT_FAILED);
2166 len = (u16)min(scsi_bufflen(srb), (unsigned int)len);
2167 rtsx_stor_set_xfer_buf(buf, len, srb);
2168 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2172 return TRANSPORT_GOOD;
2175 static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2182 rtsx_disable_aspm(chip);
2184 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2188 rtsx_set_stat(chip, RTSX_STAT_RUN);
2190 func = srb->cmnd[3];
2191 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2192 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2194 RTSX_DEBUGP("%s: func = %d, addr = 0x%x\n", __func__, func, addr);
2196 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) {
2202 if (func > func_max) {
2203 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2204 TRACE_RET(chip, TRANSPORT_FAILED);
2207 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
2208 buf = (u8 *)vmalloc(len);
2210 TRACE_RET(chip, TRANSPORT_ERROR);
2213 rtsx_stor_get_xfer_buf(buf, len, srb);
2214 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2216 retval = rtsx_write_cfg_seq(chip, func, addr, buf, len);
2217 if (retval != STATUS_SUCCESS) {
2218 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2220 TRACE_RET(chip, TRANSPORT_FAILED);
2225 return TRANSPORT_GOOD;
2228 static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2232 switch (srb->cmnd[2]) {
2235 result = read_write(srb, chip);
2239 result = read_host_reg(srb, chip);
2242 case WRITE_HOST_REG:
2243 result = write_host_reg(srb, chip);
2247 result = get_variable(srb, chip);
2251 result = set_variable(srb, chip);
2256 result = dma_access_ring_buffer(srb, chip);
2260 result = read_phy_register(srb, chip);
2264 result = write_phy_register(srb, chip);
2268 result = erase_eeprom2(srb, chip);
2272 result = read_eeprom2(srb, chip);
2276 result = write_eeprom2(srb, chip);
2280 result = read_efuse(srb, chip);
2284 result = write_efuse(srb, chip);
2288 result = read_cfg_byte(srb, chip);
2292 result = write_cfg_byte(srb, chip);
2296 result = set_chip_mode(srb, chip);
2300 result = suit_cmd(srb, chip);
2303 case GET_DEV_STATUS:
2304 result = get_dev_status(srb, chip);
2308 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2309 TRACE_RET(chip, TRANSPORT_FAILED);
2316 static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2320 unsigned int lun = SCSI_LUN(srb);
2322 rtsx_status[0] = (u8)(chip->vendor_id >> 8);
2323 rtsx_status[1] = (u8)(chip->vendor_id);
2325 rtsx_status[2] = (u8)(chip->product_id >> 8);
2326 rtsx_status[3] = (u8)(chip->product_id);
2328 rtsx_status[4] = (u8)lun;
2330 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2331 if (chip->lun2card[lun] == SD_CARD) {
2337 if (chip->card_exist) {
2338 if (chip->card_exist & XD_CARD) {
2340 } else if (chip->card_exist & SD_CARD) {
2342 } else if (chip->card_exist & MS_CARD) {
2352 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2358 rtsx_status[7] = (u8)(chip->product_id);
2359 rtsx_status[8] = chip->ic_version;
2361 if (check_card_exist(chip, lun)) {
2367 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2368 rtsx_status[10] = 0;
2370 rtsx_status[10] = 1;
2373 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2374 if (chip->lun2card[lun] == SD_CARD) {
2375 rtsx_status[11] = SD_CARD;
2377 rtsx_status[11] = MS_CARD;
2380 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD;
2383 if (check_card_ready(chip, lun)) {
2384 rtsx_status[12] = 1;
2386 rtsx_status[12] = 0;
2389 if (get_lun_card(chip, lun) == XD_CARD) {
2390 rtsx_status[13] = 0x40;
2391 } else if (get_lun_card(chip, lun) == SD_CARD) {
2392 struct sd_info *sd_card = &(chip->sd_card);
2394 rtsx_status[13] = 0x20;
2395 if (CHK_SD(sd_card)) {
2396 if (CHK_SD_HCXC(sd_card))
2397 rtsx_status[13] |= 0x04;
2398 if (CHK_SD_HS(sd_card))
2399 rtsx_status[13] |= 0x02;
2401 rtsx_status[13] |= 0x08;
2402 if (CHK_MMC_52M(sd_card))
2403 rtsx_status[13] |= 0x02;
2404 if (CHK_MMC_SECTOR_MODE(sd_card))
2405 rtsx_status[13] |= 0x04;
2407 } else if (get_lun_card(chip, lun) == MS_CARD) {
2408 struct ms_info *ms_card = &(chip->ms_card);
2410 if (CHK_MSPRO(ms_card)) {
2411 rtsx_status[13] = 0x38;
2412 if (CHK_HG8BIT(ms_card))
2413 rtsx_status[13] |= 0x04;
2415 if (CHK_MSXC(ms_card))
2416 rtsx_status[13] |= 0x01;
2419 rtsx_status[13] = 0x30;
2422 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) {
2424 if (chip->sd_io && chip->sd_int) {
2425 rtsx_status[13] = 0x60;
2427 rtsx_status[13] = 0x70;
2430 rtsx_status[13] = 0x70;
2433 if (chip->lun2card[lun] == SD_CARD) {
2434 rtsx_status[13] = 0x20;
2436 rtsx_status[13] = 0x30;
2441 rtsx_status[14] = 0x78;
2442 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) {
2443 rtsx_status[15] = 0x83;
2445 rtsx_status[15] = 0x82;
2448 buf_len = min(scsi_bufflen(srb), (unsigned int)sizeof(rtsx_status));
2449 rtsx_stor_set_xfer_buf(rtsx_status, buf_len, srb);
2450 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
2452 return TRANSPORT_GOOD;
2455 static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2457 unsigned int lun = SCSI_LUN(srb);
2460 if (!check_card_ready(chip, lun)) {
2461 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2462 TRACE_RET(chip, TRANSPORT_FAILED);
2465 card = get_lun_card(chip, lun);
2466 if ((card == SD_CARD) || (card == MS_CARD)) {
2467 bus_width = chip->card_bus_width[lun];
2469 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2470 TRACE_RET(chip, TRANSPORT_FAILED);
2473 scsi_set_resid(srb, 0);
2474 rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
2476 return TRANSPORT_GOOD;
2479 static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2482 unsigned int lun = SCSI_LUN(srb);
2485 if (CHECK_PID(chip, 0x5208) && CHECK_PID(chip, 0x5288)) {
2486 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2487 TRACE_RET(chip, TRANSPORT_FAILED);
2490 rtsx_disable_aspm(chip);
2492 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2496 rtsx_set_stat(chip, RTSX_STAT_RUN);
2498 rtsx_force_power_on(chip, SSC_PDCTL);
2500 rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir);
2501 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06);
2503 switch (srb->cmnd[2]) {
2504 case SCSI_SPI_GETSTATUS:
2505 result = spi_get_status(srb, chip);
2508 case SCSI_SPI_SETPARAMETER:
2509 result = spi_set_parameter(srb, chip);
2512 case SCSI_SPI_READFALSHID:
2513 result = spi_read_flash_id(srb, chip);
2516 case SCSI_SPI_READFLASH:
2517 result = spi_read_flash(srb, chip);
2520 case SCSI_SPI_WRITEFLASH:
2521 result = spi_write_flash(srb, chip);
2524 case SCSI_SPI_WRITEFLASHSTATUS:
2525 result = spi_write_flash_status(srb, chip);
2528 case SCSI_SPI_ERASEFLASH:
2529 result = spi_erase_flash(srb, chip);
2533 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2535 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2536 TRACE_RET(chip, TRANSPORT_FAILED);
2539 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2541 if (result != STATUS_SUCCESS) {
2542 TRACE_RET(chip, TRANSPORT_FAILED);
2545 return TRANSPORT_GOOD;
2548 static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2552 switch (srb->cmnd[1]) {
2554 result = read_status(srb, chip);
2558 result = read_mem(srb, chip);
2562 result = write_mem(srb, chip);
2566 result = read_eeprom(srb, chip);
2570 result = write_eeprom(srb, chip);
2574 result = toggle_gpio_cmd(srb, chip);
2578 result = get_sd_csd(srb, chip);
2582 result = get_card_bus_width(srb, chip);
2587 result = trace_msg_cmd(srb, chip);
2592 result = app_cmd(srb, chip);
2595 case SPI_VENDOR_COMMAND:
2596 result = spi_vendor_cmd(srb, chip);
2600 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2601 TRACE_RET(chip, TRANSPORT_FAILED);
2607 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
2608 void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2610 unsigned int lun = SCSI_LUN(srb);
2613 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
2614 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
2615 } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
2616 sec_cnt = srb->cmnd[4];
2621 if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) {
2622 toggle_gpio(chip, LED_GPIO);
2623 chip->rw_cap[lun] = 0;
2625 chip->rw_cap[lun] += sec_cnt;
2630 static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2632 struct ms_info *ms_card = &(chip->ms_card);
2633 unsigned int lun = SCSI_LUN(srb);
2634 int retval, quick_format;
2636 if (get_lun_card(chip, lun) != MS_CARD) {
2637 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2638 TRACE_RET(chip, TRANSPORT_FAILED);
2641 if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47) ||
2642 (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D) ||
2643 (srb->cmnd[7] != 0x74)) {
2644 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2645 TRACE_RET(chip, TRANSPORT_FAILED);
2648 rtsx_disable_aspm(chip);
2650 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2654 if (!check_card_ready(chip, lun) ||
2655 (get_card_size(chip, lun) == 0)) {
2656 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2657 TRACE_RET(chip, TRANSPORT_FAILED);
2660 rtsx_set_stat(chip, RTSX_STAT_RUN);
2662 if (srb->cmnd[8] & 0x01) {
2668 if (!(chip->card_ready & MS_CARD)) {
2669 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2670 TRACE_RET(chip, TRANSPORT_FAILED);
2673 if (chip->card_wp & MS_CARD) {
2674 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2675 TRACE_RET(chip, TRANSPORT_FAILED);
2678 if (!CHK_MSPRO(ms_card)) {
2679 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2680 TRACE_RET(chip, TRANSPORT_FAILED);
2683 retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
2684 if (retval != STATUS_SUCCESS) {
2685 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
2686 TRACE_RET(chip, TRANSPORT_FAILED);
2689 scsi_set_resid(srb, 0);
2690 return TRANSPORT_GOOD;
2693 #ifdef SUPPORT_PCGL_1P18
2694 static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2696 struct ms_info *ms_card = &(chip->ms_card);
2697 unsigned int lun = SCSI_LUN(srb);
2698 u8 dev_info_id, data_len;
2700 unsigned int buf_len;
2703 if (!check_card_ready(chip, lun)) {
2704 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2705 TRACE_RET(chip, TRANSPORT_FAILED);
2707 if ((get_lun_card(chip, lun) != MS_CARD)) {
2708 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2709 TRACE_RET(chip, TRANSPORT_FAILED);
2712 if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) ||
2713 (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) ||
2714 (srb->cmnd[7] != 0x44)) {
2715 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2716 TRACE_RET(chip, TRANSPORT_FAILED);
2719 dev_info_id = srb->cmnd[3];
2720 if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) ||
2721 (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) ||
2722 !CHK_MSPRO(ms_card)) {
2723 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2724 TRACE_RET(chip, TRANSPORT_FAILED);
2727 if (dev_info_id == 0x15) {
2728 buf_len = data_len = 0x3A;
2730 buf_len = data_len = 0x6A;
2733 buf = (u8 *)kmalloc(buf_len, GFP_KERNEL);
2735 TRACE_RET(chip, TRANSPORT_ERROR);
2739 /* GET Memory Stick Media Information Response Header */
2740 buf[i++] = 0x00; /* Data length MSB */
2741 buf[i++] = data_len; /* Data length LSB */
2742 /* Device Information Type Code */
2743 if (CHK_MSXC(ms_card)) {
2754 /* Number of Device Information */
2757 /* Device Information Body */
2759 /* Device Information ID Number */
2760 buf[i++] = dev_info_id;
2761 /* Device Information Length */
2762 if (dev_info_id == 0x15) {
2767 buf[i++] = 0x00; /* Data length MSB */
2768 buf[i++] = data_len; /* Data length LSB */
2771 if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
2772 /* System Information */
2773 memcpy(buf+i, ms_card->raw_sys_info, 96);
2776 memcpy(buf+i, ms_card->raw_model_name, 48);
2779 rtsx_stor_set_xfer_buf(buf, buf_len, srb);
2781 if (dev_info_id == 0x15) {
2782 scsi_set_resid(srb, scsi_bufflen(srb)-0x3C);
2784 scsi_set_resid(srb, scsi_bufflen(srb)-0x6C);
2788 return STATUS_SUCCESS;
2792 static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2794 int retval = TRANSPORT_ERROR;
2796 if (srb->cmnd[2] == MS_FORMAT) {
2797 retval = ms_format_cmnd(srb, chip);
2799 #ifdef SUPPORT_PCGL_1P18
2800 else if (srb->cmnd[2] == GET_MS_INFORMATION) {
2801 retval = get_ms_information(srb, chip);
2809 static int sd_extention_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2811 unsigned int lun = SCSI_LUN(srb);
2814 rtsx_disable_aspm(chip);
2816 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2820 rtsx_set_stat(chip, RTSX_STAT_RUN);
2822 sd_cleanup_work(chip);
2824 if (!check_card_ready(chip, lun)) {
2825 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2826 TRACE_RET(chip, TRANSPORT_FAILED);
2828 if ((get_lun_card(chip, lun) != SD_CARD)) {
2829 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2830 TRACE_RET(chip, TRANSPORT_FAILED);
2833 switch (srb->cmnd[0]) {
2834 case SD_PASS_THRU_MODE:
2835 result = sd_pass_thru_mode(srb, chip);
2838 case SD_EXECUTE_NO_DATA:
2839 result = sd_execute_no_data(srb, chip);
2842 case SD_EXECUTE_READ:
2843 result = sd_execute_read_data(srb, chip);
2846 case SD_EXECUTE_WRITE:
2847 result = sd_execute_write_data(srb, chip);
2851 result = sd_get_cmd_rsp(srb, chip);
2855 result = sd_hw_rst(srb, chip);
2859 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2860 TRACE_RET(chip, TRANSPORT_FAILED);
2867 #ifdef SUPPORT_MAGIC_GATE
2868 static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2870 struct ms_info *ms_card = &(chip->ms_card);
2871 unsigned int lun = SCSI_LUN(srb);
2875 RTSX_DEBUGP("--%s--\n", __func__);
2877 rtsx_disable_aspm(chip);
2879 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2883 rtsx_set_stat(chip, RTSX_STAT_RUN);
2885 ms_cleanup_work(chip);
2887 if (!check_card_ready(chip, lun)) {
2888 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2889 TRACE_RET(chip, TRANSPORT_FAILED);
2891 if ((get_lun_card(chip, lun) != MS_CARD)) {
2892 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2893 TRACE_RET(chip, TRANSPORT_FAILED);
2896 if (srb->cmnd[7] != KC_MG_R_PRO) {
2897 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2898 TRACE_RET(chip, TRANSPORT_FAILED);
2901 if (!CHK_MSPRO(ms_card)) {
2902 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
2903 TRACE_RET(chip, TRANSPORT_FAILED);
2906 key_format = srb->cmnd[10] & 0x3F;
2907 RTSX_DEBUGP("key_format = 0x%x\n", key_format);
2909 switch (key_format) {
2910 case KF_GET_LOC_EKB:
2911 if ((scsi_bufflen(srb) == 0x41C) &&
2912 (srb->cmnd[8] == 0x04) &&
2913 (srb->cmnd[9] == 0x1C)) {
2914 retval = mg_get_local_EKB(srb, chip);
2915 if (retval != STATUS_SUCCESS) {
2916 TRACE_RET(chip, TRANSPORT_FAILED);
2919 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2920 TRACE_RET(chip, TRANSPORT_FAILED);
2925 if ((scsi_bufflen(srb) == 0x24) &&
2926 (srb->cmnd[8] == 0x00) &&
2927 (srb->cmnd[9] == 0x24)) {
2928 retval = mg_get_rsp_chg(srb, chip);
2929 if (retval != STATUS_SUCCESS) {
2930 TRACE_RET(chip, TRANSPORT_FAILED);
2933 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2934 TRACE_RET(chip, TRANSPORT_FAILED);
2939 ms_card->mg_entry_num = srb->cmnd[5];
2940 if ((scsi_bufflen(srb) == 0x404) &&
2941 (srb->cmnd[8] == 0x04) &&
2942 (srb->cmnd[9] == 0x04) &&
2943 (srb->cmnd[2] == 0x00) &&
2944 (srb->cmnd[3] == 0x00) &&
2945 (srb->cmnd[4] == 0x00) &&
2946 (srb->cmnd[5] < 32)) {
2947 retval = mg_get_ICV(srb, chip);
2948 if (retval != STATUS_SUCCESS) {
2949 TRACE_RET(chip, TRANSPORT_FAILED);
2952 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2953 TRACE_RET(chip, TRANSPORT_FAILED);
2958 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2959 TRACE_RET(chip, TRANSPORT_FAILED);
2962 scsi_set_resid(srb, 0);
2963 return TRANSPORT_GOOD;
2966 static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2968 struct ms_info *ms_card = &(chip->ms_card);
2969 unsigned int lun = SCSI_LUN(srb);
2973 RTSX_DEBUGP("--%s--\n", __func__);
2975 rtsx_disable_aspm(chip);
2977 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2981 rtsx_set_stat(chip, RTSX_STAT_RUN);
2983 ms_cleanup_work(chip);
2985 if (!check_card_ready(chip, lun)) {
2986 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2987 TRACE_RET(chip, TRANSPORT_FAILED);
2989 if (check_card_wp(chip, lun)) {
2990 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2991 TRACE_RET(chip, TRANSPORT_FAILED);
2993 if ((get_lun_card(chip, lun) != MS_CARD)) {
2994 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2995 TRACE_RET(chip, TRANSPORT_FAILED);
2998 if (srb->cmnd[7] != KC_MG_R_PRO) {
2999 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3000 TRACE_RET(chip, TRANSPORT_FAILED);
3003 if (!CHK_MSPRO(ms_card)) {
3004 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3005 TRACE_RET(chip, TRANSPORT_FAILED);
3008 key_format = srb->cmnd[10] & 0x3F;
3009 RTSX_DEBUGP("key_format = 0x%x\n", key_format);
3011 switch (key_format) {
3012 case KF_SET_LEAF_ID:
3013 if ((scsi_bufflen(srb) == 0x0C) &&
3014 (srb->cmnd[8] == 0x00) &&
3015 (srb->cmnd[9] == 0x0C)) {
3016 retval = mg_set_leaf_id(srb, chip);
3017 if (retval != STATUS_SUCCESS) {
3018 TRACE_RET(chip, TRANSPORT_FAILED);
3021 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3022 TRACE_RET(chip, TRANSPORT_FAILED);
3027 if ((scsi_bufflen(srb) == 0x0C) &&
3028 (srb->cmnd[8] == 0x00) &&
3029 (srb->cmnd[9] == 0x0C)) {
3030 retval = mg_chg(srb, chip);
3031 if (retval != STATUS_SUCCESS) {
3032 TRACE_RET(chip, TRANSPORT_FAILED);
3035 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3036 TRACE_RET(chip, TRANSPORT_FAILED);
3041 if ((scsi_bufflen(srb) == 0x0C) &&
3042 (srb->cmnd[8] == 0x00) &&
3043 (srb->cmnd[9] == 0x0C)) {
3044 retval = mg_rsp(srb, chip);
3045 if (retval != STATUS_SUCCESS) {
3046 TRACE_RET(chip, TRANSPORT_FAILED);
3049 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3050 TRACE_RET(chip, TRANSPORT_FAILED);
3055 ms_card->mg_entry_num = srb->cmnd[5];
3056 if ((scsi_bufflen(srb) == 0x404) &&
3057 (srb->cmnd[8] == 0x04) &&
3058 (srb->cmnd[9] == 0x04) &&
3059 (srb->cmnd[2] == 0x00) &&
3060 (srb->cmnd[3] == 0x00) &&
3061 (srb->cmnd[4] == 0x00) &&
3062 (srb->cmnd[5] < 32)) {
3063 retval = mg_set_ICV(srb, chip);
3064 if (retval != STATUS_SUCCESS) {
3065 TRACE_RET(chip, TRANSPORT_FAILED);
3068 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3069 TRACE_RET(chip, TRANSPORT_FAILED);
3074 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3075 TRACE_RET(chip, TRANSPORT_FAILED);
3078 scsi_set_resid(srb, 0);
3079 return TRANSPORT_GOOD;
3083 int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3085 #ifdef SUPPORT_SD_LOCK
3086 struct sd_info *sd_card = &(chip->sd_card);
3088 struct ms_info *ms_card = &(chip->ms_card);
3089 unsigned int lun = SCSI_LUN(srb);
3092 #ifdef SUPPORT_SD_LOCK
3093 if (sd_card->sd_erase_status) {
3094 /* Block all SCSI command except for
3095 * REQUEST_SENSE and rs_ppstatus
3097 if (!((srb->cmnd[0] == VENDOR_CMND) &&
3098 (srb->cmnd[1] == SCSI_APP_CMD) &&
3099 (srb->cmnd[2] == GET_DEV_STATUS)) &&
3100 (srb->cmnd[0] != REQUEST_SENSE)) {
3101 /* Logical Unit Not Ready Format in Progress */
3102 set_sense_data(chip, lun, CUR_ERR,
3103 0x02, 0, 0x04, 0x04, 0, 0);
3104 TRACE_RET(chip, TRANSPORT_FAILED);
3109 if ((get_lun_card(chip, lun) == MS_CARD) &&
3110 (ms_card->format_status == FORMAT_IN_PROGRESS)) {
3111 if ((srb->cmnd[0] != REQUEST_SENSE) && (srb->cmnd[0] != INQUIRY)) {
3112 /* Logical Unit Not Ready Format in Progress */
3113 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
3114 0, (u16)(ms_card->progress));
3115 TRACE_RET(chip, TRANSPORT_FAILED);
3119 switch (srb->cmnd[0]) {
3124 result = read_write(srb, chip);
3125 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
3126 led_shine(srb, chip);
3130 case TEST_UNIT_READY:
3131 result = test_unit_ready(srb, chip);
3135 result = inquiry(srb, chip);
3139 result = read_capacity(srb, chip);
3143 result = start_stop_unit(srb, chip);
3146 case ALLOW_MEDIUM_REMOVAL:
3147 result = allow_medium_removal(srb, chip);
3151 result = request_sense(srb, chip);
3156 result = mode_sense(srb, chip);
3160 result = read_format_capacity(srb, chip);
3164 result = vendor_cmnd(srb, chip);
3168 result = ms_sp_cmnd(srb, chip);
3172 case SD_PASS_THRU_MODE:
3173 case SD_EXECUTE_NO_DATA:
3174 case SD_EXECUTE_READ:
3175 case SD_EXECUTE_WRITE:
3178 result = sd_extention_cmnd(srb, chip);
3182 #ifdef SUPPORT_MAGIC_GATE
3183 case CMD_MSPRO_MG_RKEY:
3184 result = mg_report_key(srb, chip);
3187 case CMD_MSPRO_MG_SKEY:
3188 result = mg_send_key(srb, chip);
3195 result = TRANSPORT_GOOD;
3199 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3200 result = TRANSPORT_FAILED;