1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/blkdev.h>
24#include <linux/kthread.h>
25#include <linux/sched.h>
26#include <linux/vmalloc.h>
27
28#include "rtsx.h"
29#include "sd.h"
30#include "ms.h"
31#include "spi.h"
32
33void scsi_show_command(struct rtsx_chip *chip)
34{
35 struct scsi_cmnd *srb = chip->srb;
36 char *what = NULL;
37 bool unknown_cmd = false;
38 int len;
39
40 switch (srb->cmnd[0]) {
41 case TEST_UNIT_READY:
42 what = "TEST_UNIT_READY";
43 break;
44 case REZERO_UNIT:
45 what = "REZERO_UNIT";
46 break;
47 case REQUEST_SENSE:
48 what = "REQUEST_SENSE";
49 break;
50 case FORMAT_UNIT:
51 what = "FORMAT_UNIT";
52 break;
53 case READ_BLOCK_LIMITS:
54 what = "READ_BLOCK_LIMITS";
55 break;
56 case REASSIGN_BLOCKS:
57 what = "REASSIGN_BLOCKS";
58 break;
59 case READ_6:
60 what = "READ_6";
61 break;
62 case WRITE_6:
63 what = "WRITE_6";
64 break;
65 case SEEK_6:
66 what = "SEEK_6";
67 break;
68 case READ_REVERSE:
69 what = "READ_REVERSE";
70 break;
71 case WRITE_FILEMARKS:
72 what = "WRITE_FILEMARKS";
73 break;
74 case SPACE:
75 what = "SPACE";
76 break;
77 case INQUIRY:
78 what = "INQUIRY";
79 break;
80 case RECOVER_BUFFERED_DATA:
81 what = "RECOVER_BUFFERED_DATA";
82 break;
83 case MODE_SELECT:
84 what = "MODE_SELECT";
85 break;
86 case RESERVE:
87 what = "RESERVE";
88 break;
89 case RELEASE:
90 what = "RELEASE";
91 break;
92 case COPY:
93 what = "COPY";
94 break;
95 case ERASE:
96 what = "ERASE";
97 break;
98 case MODE_SENSE:
99 what = "MODE_SENSE";
100 break;
101 case START_STOP:
102 what = "START_STOP";
103 break;
104 case RECEIVE_DIAGNOSTIC:
105 what = "RECEIVE_DIAGNOSTIC";
106 break;
107 case SEND_DIAGNOSTIC:
108 what = "SEND_DIAGNOSTIC";
109 break;
110 case ALLOW_MEDIUM_REMOVAL:
111 what = "ALLOW_MEDIUM_REMOVAL";
112 break;
113 case SET_WINDOW:
114 what = "SET_WINDOW";
115 break;
116 case READ_CAPACITY:
117 what = "READ_CAPACITY";
118 break;
119 case READ_10:
120 what = "READ_10";
121 break;
122 case WRITE_10:
123 what = "WRITE_10";
124 break;
125 case SEEK_10:
126 what = "SEEK_10";
127 break;
128 case WRITE_VERIFY:
129 what = "WRITE_VERIFY";
130 break;
131 case VERIFY:
132 what = "VERIFY";
133 break;
134 case SEARCH_HIGH:
135 what = "SEARCH_HIGH";
136 break;
137 case SEARCH_EQUAL:
138 what = "SEARCH_EQUAL";
139 break;
140 case SEARCH_LOW:
141 what = "SEARCH_LOW";
142 break;
143 case SET_LIMITS:
144 what = "SET_LIMITS";
145 break;
146 case READ_POSITION:
147 what = "READ_POSITION";
148 break;
149 case SYNCHRONIZE_CACHE:
150 what = "SYNCHRONIZE_CACHE";
151 break;
152 case LOCK_UNLOCK_CACHE:
153 what = "LOCK_UNLOCK_CACHE";
154 break;
155 case READ_DEFECT_DATA:
156 what = "READ_DEFECT_DATA";
157 break;
158 case MEDIUM_SCAN:
159 what = "MEDIUM_SCAN";
160 break;
161 case COMPARE:
162 what = "COMPARE";
163 break;
164 case COPY_VERIFY:
165 what = "COPY_VERIFY";
166 break;
167 case WRITE_BUFFER:
168 what = "WRITE_BUFFER";
169 break;
170 case READ_BUFFER:
171 what = "READ_BUFFER";
172 break;
173 case UPDATE_BLOCK:
174 what = "UPDATE_BLOCK";
175 break;
176 case READ_LONG:
177 what = "READ_LONG";
178 break;
179 case WRITE_LONG:
180 what = "WRITE_LONG";
181 break;
182 case CHANGE_DEFINITION:
183 what = "CHANGE_DEFINITION";
184 break;
185 case WRITE_SAME:
186 what = "WRITE_SAME";
187 break;
188 case GPCMD_READ_SUBCHANNEL:
189 what = "READ SUBCHANNEL";
190 break;
191 case READ_TOC:
192 what = "READ_TOC";
193 break;
194 case GPCMD_READ_HEADER:
195 what = "READ HEADER";
196 break;
197 case GPCMD_PLAY_AUDIO_10:
198 what = "PLAY AUDIO (10)";
199 break;
200 case GPCMD_PLAY_AUDIO_MSF:
201 what = "PLAY AUDIO MSF";
202 break;
203 case GPCMD_GET_EVENT_STATUS_NOTIFICATION:
204 what = "GET EVENT/STATUS NOTIFICATION";
205 break;
206 case GPCMD_PAUSE_RESUME:
207 what = "PAUSE/RESUME";
208 break;
209 case LOG_SELECT:
210 what = "LOG_SELECT";
211 break;
212 case LOG_SENSE:
213 what = "LOG_SENSE";
214 break;
215 case GPCMD_STOP_PLAY_SCAN:
216 what = "STOP PLAY/SCAN";
217 break;
218 case GPCMD_READ_DISC_INFO:
219 what = "READ DISC INFORMATION";
220 break;
221 case GPCMD_READ_TRACK_RZONE_INFO:
222 what = "READ TRACK INFORMATION";
223 break;
224 case GPCMD_RESERVE_RZONE_TRACK:
225 what = "RESERVE TRACK";
226 break;
227 case GPCMD_SEND_OPC:
228 what = "SEND OPC";
229 break;
230 case MODE_SELECT_10:
231 what = "MODE_SELECT_10";
232 break;
233 case GPCMD_REPAIR_RZONE_TRACK:
234 what = "REPAIR TRACK";
235 break;
236 case 0x59:
237 what = "READ MASTER CUE";
238 break;
239 case MODE_SENSE_10:
240 what = "MODE_SENSE_10";
241 break;
242 case GPCMD_CLOSE_TRACK:
243 what = "CLOSE TRACK/SESSION";
244 break;
245 case 0x5C:
246 what = "READ BUFFER CAPACITY";
247 break;
248 case 0x5D:
249 what = "SEND CUE SHEET";
250 break;
251 case GPCMD_BLANK:
252 what = "BLANK";
253 break;
254 case REPORT_LUNS:
255 what = "REPORT LUNS";
256 break;
257 case MOVE_MEDIUM:
258 what = "MOVE_MEDIUM or PLAY AUDIO (12)";
259 break;
260 case READ_12:
261 what = "READ_12";
262 break;
263 case WRITE_12:
264 what = "WRITE_12";
265 break;
266 case WRITE_VERIFY_12:
267 what = "WRITE_VERIFY_12";
268 break;
269 case SEARCH_HIGH_12:
270 what = "SEARCH_HIGH_12";
271 break;
272 case SEARCH_EQUAL_12:
273 what = "SEARCH_EQUAL_12";
274 break;
275 case SEARCH_LOW_12:
276 what = "SEARCH_LOW_12";
277 break;
278 case SEND_VOLUME_TAG:
279 what = "SEND_VOLUME_TAG";
280 break;
281 case READ_ELEMENT_STATUS:
282 what = "READ_ELEMENT_STATUS";
283 break;
284 case GPCMD_READ_CD_MSF:
285 what = "READ CD MSF";
286 break;
287 case GPCMD_SCAN:
288 what = "SCAN";
289 break;
290 case GPCMD_SET_SPEED:
291 what = "SET CD SPEED";
292 break;
293 case GPCMD_MECHANISM_STATUS:
294 what = "MECHANISM STATUS";
295 break;
296 case GPCMD_READ_CD:
297 what = "READ CD";
298 break;
299 case 0xE1:
300 what = "WRITE CONTINUE";
301 break;
302 case WRITE_LONG_2:
303 what = "WRITE_LONG_2";
304 break;
305 case VENDOR_CMND:
306 what = "Realtek's vendor command";
307 break;
308 default:
309 what = "(unknown command)";
310 unknown_cmd = true;
311 break;
312 }
313
314 if (srb->cmnd[0] != TEST_UNIT_READY)
315 dev_dbg(rtsx_dev(chip), "Command %s (%d bytes)\n",
316 what, srb->cmd_len);
317
318 if (unknown_cmd) {
319 len = min_t(unsigned short, srb->cmd_len, 16);
320 dev_dbg(rtsx_dev(chip), "%*ph\n", len, srb->cmnd);
321 }
322}
323
324void set_sense_type(struct rtsx_chip *chip, unsigned int lun, int sense_type)
325{
326 switch (sense_type) {
327 case SENSE_TYPE_MEDIA_CHANGE:
328 set_sense_data(chip, lun, CUR_ERR, 0x06, 0, 0x28, 0, 0, 0);
329 break;
330
331 case SENSE_TYPE_MEDIA_NOT_PRESENT:
332 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x3A, 0, 0, 0);
333 break;
334
335 case SENSE_TYPE_MEDIA_LBA_OVER_RANGE:
336 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x21, 0, 0, 0);
337 break;
338
339 case SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT:
340 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x25, 0, 0, 0);
341 break;
342
343 case SENSE_TYPE_MEDIA_WRITE_PROTECT:
344 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x27, 0, 0, 0);
345 break;
346
347 case SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR:
348 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x11, 0, 0, 0);
349 break;
350
351 case SENSE_TYPE_MEDIA_WRITE_ERR:
352 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x02, 0, 0);
353 break;
354
355 case SENSE_TYPE_MEDIA_INVALID_CMD_FIELD:
356 set_sense_data(chip, lun, CUR_ERR, ILGAL_REQ, 0,
357 ASC_INVLD_CDB, ASCQ_INVLD_CDB, CDB_ILLEGAL, 1);
358 break;
359
360 case SENSE_TYPE_FORMAT_IN_PROGRESS:
361 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 0, 0);
362 break;
363
364 case SENSE_TYPE_FORMAT_CMD_FAILED:
365 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x31, 0x01, 0, 0);
366 break;
367
368#ifdef SUPPORT_MAGIC_GATE
369 case SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB:
370 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x02, 0, 0);
371 break;
372
373 case SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN:
374 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x00, 0, 0);
375 break;
376
377 case SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM:
378 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x30, 0x00, 0, 0);
379 break;
380
381 case SENSE_TYPE_MG_WRITE_ERR:
382 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x00, 0, 0);
383 break;
384#endif
385
386#ifdef SUPPORT_SD_LOCK
387 case SENSE_TYPE_MEDIA_READ_FORBIDDEN:
388 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x11, 0x13, 0, 0);
389 break;
390#endif
391
392 case SENSE_TYPE_NO_SENSE:
393 default:
394 set_sense_data(chip, lun, CUR_ERR, 0, 0, 0, 0, 0, 0);
395 break;
396 }
397}
398
399void set_sense_data(struct rtsx_chip *chip, unsigned int lun, u8 err_code,
400 u8 sense_key, u32 info, u8 asc, u8 ascq, u8 sns_key_info0,
401 u16 sns_key_info1)
402{
403 struct sense_data_t *sense = &(chip->sense_buffer[lun]);
404
405 sense->err_code = err_code;
406 sense->sense_key = sense_key;
407 sense->info[0] = (u8)(info >> 24);
408 sense->info[1] = (u8)(info >> 16);
409 sense->info[2] = (u8)(info >> 8);
410 sense->info[3] = (u8)info;
411
412 sense->ad_sense_len = sizeof(struct sense_data_t) - 8;
413 sense->asc = asc;
414 sense->ascq = ascq;
415 if (sns_key_info0 != 0) {
416 sense->sns_key_info[0] = SKSV | sns_key_info0;
417 sense->sns_key_info[1] = (sns_key_info1 & 0xf0) >> 8;
418 sense->sns_key_info[2] = sns_key_info1 & 0x0f;
419 }
420}
421
422static int test_unit_ready(struct scsi_cmnd *srb, struct rtsx_chip *chip)
423{
424 unsigned int lun = SCSI_LUN(srb);
425
426 if (!check_card_ready(chip, lun)) {
427 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
428 return TRANSPORT_FAILED;
429 }
430
431 if (!(CHK_BIT(chip->lun_mc, lun))) {
432 SET_BIT(chip->lun_mc, lun);
433 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
434 return TRANSPORT_FAILED;
435 }
436
437#ifdef SUPPORT_SD_LOCK
438 if (get_lun_card(chip, SCSI_LUN(srb)) == SD_CARD) {
439 struct sd_info *sd_card = &(chip->sd_card);
440
441 if (sd_card->sd_lock_notify) {
442 sd_card->sd_lock_notify = 0;
443 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
444 return TRANSPORT_FAILED;
445 } else if (sd_card->sd_lock_status & SD_LOCKED) {
446 set_sense_type(chip, lun,
447 SENSE_TYPE_MEDIA_READ_FORBIDDEN);
448 return TRANSPORT_FAILED;
449 }
450 }
451#endif
452
453 return TRANSPORT_GOOD;
454}
455
456static unsigned char formatter_inquiry_str[20] = {
457 'M', 'E', 'M', 'O', 'R', 'Y', 'S', 'T', 'I', 'C', 'K',
458#ifdef SUPPORT_MAGIC_GATE
459 '-', 'M', 'G',
460#else
461 0x20, 0x20, 0x20,
462#endif
463
464#ifdef SUPPORT_MAGIC_GATE
465 0x0B,
466#else
467 0x09,
468#endif
469 0x00,
470 0x00,
471 0x20, 0x20, 0x20,
472};
473
474static int inquiry(struct scsi_cmnd *srb, struct rtsx_chip *chip)
475{
476 unsigned int lun = SCSI_LUN(srb);
477 char *inquiry_default = (char *)"Generic-xD/SD/M.S. 1.00 ";
478 char *inquiry_sdms = (char *)"Generic-SD/MemoryStick 1.00 ";
479 char *inquiry_sd = (char *)"Generic-SD/MMC 1.00 ";
480 char *inquiry_ms = (char *)"Generic-MemoryStick 1.00 ";
481 char *inquiry_string;
482 unsigned char sendbytes;
483 unsigned char *buf;
484 u8 card = get_lun_card(chip, lun);
485 bool pro_formatter_flag = false;
486 unsigned char inquiry_buf[] = {
487 QULIFIRE | DRCT_ACCESS_DEV,
488 RMB_DISC | 0x0D,
489 0x00,
490 0x01,
491 0x1f,
492 0x02,
493 0,
494 REL_ADR | WBUS_32 | WBUS_16 | SYNC | LINKED | CMD_QUE | SFT_RE,
495 };
496
497 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
498 if (chip->lun2card[lun] == SD_CARD)
499 inquiry_string = inquiry_sd;
500 else
501 inquiry_string = inquiry_ms;
502
503 } else if (CHECK_LUN_MODE(chip, SD_MS_1LUN)) {
504 inquiry_string = inquiry_sdms;
505 } else {
506 inquiry_string = inquiry_default;
507 }
508
509 buf = vmalloc(scsi_bufflen(srb));
510 if (!buf) {
511 rtsx_trace(chip);
512 return TRANSPORT_ERROR;
513 }
514
515#ifdef SUPPORT_MAGIC_GATE
516 if ((chip->mspro_formatter_enable) &&
517 (chip->lun2card[lun] & MS_CARD))
518#else
519 if (chip->mspro_formatter_enable)
520#endif
521 if (!card || (card == MS_CARD))
522 pro_formatter_flag = true;
523
524 if (pro_formatter_flag) {
525 if (scsi_bufflen(srb) < 56)
526 sendbytes = (unsigned char)(scsi_bufflen(srb));
527 else
528 sendbytes = 56;
529
530 } else {
531 if (scsi_bufflen(srb) < 36)
532 sendbytes = (unsigned char)(scsi_bufflen(srb));
533 else
534 sendbytes = 36;
535 }
536
537 if (sendbytes > 8) {
538 memcpy(buf, inquiry_buf, 8);
539 memcpy(buf + 8, inquiry_string, sendbytes - 8);
540 if (pro_formatter_flag) {
541
542 buf[4] = 0x33;
543 }
544 } else {
545 memcpy(buf, inquiry_buf, sendbytes);
546 }
547
548 if (pro_formatter_flag) {
549 if (sendbytes > 36)
550 memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36);
551 }
552
553 scsi_set_resid(srb, 0);
554
555 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
556 vfree(buf);
557
558 return TRANSPORT_GOOD;
559}
560
561static int start_stop_unit(struct scsi_cmnd *srb, struct rtsx_chip *chip)
562{
563 unsigned int lun = SCSI_LUN(srb);
564
565 scsi_set_resid(srb, scsi_bufflen(srb));
566
567 if (srb->cmnd[1] == 1)
568 return TRANSPORT_GOOD;
569
570 switch (srb->cmnd[0x4]) {
571 case STOP_MEDIUM:
572
573 return TRANSPORT_GOOD;
574
575 case UNLOAD_MEDIUM:
576
577 if (check_card_ready(chip, lun))
578 eject_card(chip, lun);
579 return TRANSPORT_GOOD;
580
581 case MAKE_MEDIUM_READY:
582 case LOAD_MEDIUM:
583 if (check_card_ready(chip, lun))
584 return TRANSPORT_GOOD;
585 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
586 rtsx_trace(chip);
587 return TRANSPORT_FAILED;
588
589 break;
590 }
591
592 rtsx_trace(chip);
593 return TRANSPORT_ERROR;
594}
595
596static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip)
597{
598 int prevent;
599
600 prevent = srb->cmnd[4] & 0x1;
601
602 scsi_set_resid(srb, 0);
603
604 if (prevent) {
605 set_sense_type(chip, SCSI_LUN(srb),
606 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
607 rtsx_trace(chip);
608 return TRANSPORT_FAILED;
609 }
610
611 return TRANSPORT_GOOD;
612}
613
614static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
615{
616 struct sense_data_t *sense;
617 unsigned int lun = SCSI_LUN(srb);
618 struct ms_info *ms_card = &(chip->ms_card);
619 unsigned char *tmp, *buf;
620
621 sense = &(chip->sense_buffer[lun]);
622
623 if ((get_lun_card(chip, lun) == MS_CARD) &&
624 ms_card->pro_under_formatting) {
625 if (ms_card->format_status == FORMAT_SUCCESS) {
626 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
627 ms_card->pro_under_formatting = 0;
628 ms_card->progress = 0;
629 } else if (ms_card->format_status == FORMAT_IN_PROGRESS) {
630
631 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
632 0, (u16)(ms_card->progress));
633 } else {
634
635 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
636 ms_card->pro_under_formatting = 0;
637 ms_card->progress = 0;
638 }
639
640 rtsx_set_stat(chip, RTSX_STAT_RUN);
641 }
642
643 buf = vmalloc(scsi_bufflen(srb));
644 if (!buf) {
645 rtsx_trace(chip);
646 return TRANSPORT_ERROR;
647 }
648
649 tmp = (unsigned char *)sense;
650 memcpy(buf, tmp, scsi_bufflen(srb));
651
652 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
653 vfree(buf);
654
655 scsi_set_resid(srb, 0);
656
657 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
658 return TRANSPORT_GOOD;
659}
660
661static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd,
662 int lun, u8 *buf, int buf_len)
663{
664 struct ms_info *ms_card = &(chip->ms_card);
665 int sys_info_offset;
666 int data_size = buf_len;
667 bool support_format = false;
668 int i = 0;
669
670 if (cmd == MODE_SENSE) {
671 sys_info_offset = 8;
672 if (data_size > 0x68)
673 data_size = 0x68;
674
675 buf[i++] = 0x67;
676 } else {
677 sys_info_offset = 12;
678 if (data_size > 0x6C)
679 data_size = 0x6C;
680
681 buf[i++] = 0x00;
682 buf[i++] = 0x6A;
683 }
684
685
686 if (check_card_ready(chip, lun)) {
687 if (CHK_MSXC(ms_card)) {
688 support_format = true;
689 buf[i++] = 0x40;
690 } else if (CHK_MSPRO(ms_card)) {
691 support_format = true;
692 buf[i++] = 0x20;
693 } else {
694 buf[i++] = 0x10;
695 }
696
697
698 if (check_card_wp(chip, lun))
699 buf[i++] = 0x80;
700 else
701 buf[i++] = 0x00;
702
703 } else {
704 buf[i++] = 0x00;
705 buf[i++] = 0x00;
706 }
707
708 buf[i++] = 0x00;
709
710 if (cmd == MODE_SENSE_10) {
711 buf[i++] = 0x00;
712 buf[i++] = 0x00;
713 buf[i++] = 0x00;
714
715
716 if (data_size >= 9)
717 buf[i++] = 0x20;
718 if (data_size >= 10)
719 buf[i++] = 0x62;
720 if (data_size >= 11)
721 buf[i++] = 0x00;
722 if (data_size >= 12) {
723 if (support_format)
724 buf[i++] = 0xC0;
725 else
726 buf[i++] = 0x00;
727 }
728 } else {
729
730 if (data_size >= 5)
731 buf[i++] = 0x20;
732 if (data_size >= 6)
733 buf[i++] = 0x62;
734 if (data_size >= 7)
735 buf[i++] = 0x00;
736 if (data_size >= 8) {
737 if (support_format)
738 buf[i++] = 0xC0;
739 else
740 buf[i++] = 0x00;
741 }
742 }
743
744 if (data_size > sys_info_offset) {
745
746 int len = data_size - sys_info_offset;
747
748 len = (len < 96) ? len : 96;
749
750 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len);
751 }
752}
753
754static int mode_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
755{
756 unsigned int lun = SCSI_LUN(srb);
757 unsigned int dataSize;
758 int status;
759 bool pro_formatter_flag;
760 unsigned char pageCode, *buf;
761 u8 card = get_lun_card(chip, lun);
762
763#ifndef SUPPORT_MAGIC_GATE
764 if (!check_card_ready(chip, lun)) {
765 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
766 scsi_set_resid(srb, scsi_bufflen(srb));
767 rtsx_trace(chip);
768 return TRANSPORT_FAILED;
769 }
770#endif
771
772 pro_formatter_flag = false;
773 dataSize = 8;
774#ifdef SUPPORT_MAGIC_GATE
775 if ((chip->lun2card[lun] & MS_CARD)) {
776 if (!card || (card == MS_CARD)) {
777 dataSize = 108;
778 if (chip->mspro_formatter_enable)
779 pro_formatter_flag = true;
780 }
781 }
782#else
783 if (card == MS_CARD) {
784 if (chip->mspro_formatter_enable) {
785 pro_formatter_flag = true;
786 dataSize = 108;
787 }
788 }
789#endif
790
791 buf = kmalloc(dataSize, GFP_KERNEL);
792 if (!buf) {
793 rtsx_trace(chip);
794 return TRANSPORT_ERROR;
795 }
796
797 pageCode = srb->cmnd[2] & 0x3f;
798
799 if ((pageCode == 0x3F) || (pageCode == 0x1C) ||
800 (pageCode == 0x00) ||
801 (pro_formatter_flag && (pageCode == 0x20))) {
802 if (srb->cmnd[0] == MODE_SENSE) {
803 if ((pageCode == 0x3F) || (pageCode == 0x20)) {
804 ms_mode_sense(chip, srb->cmnd[0],
805 lun, buf, dataSize);
806 } else {
807 dataSize = 4;
808 buf[0] = 0x03;
809 buf[1] = 0x00;
810 if (check_card_wp(chip, lun))
811 buf[2] = 0x80;
812 else
813 buf[2] = 0x00;
814
815 buf[3] = 0x00;
816 }
817 } else {
818 if ((pageCode == 0x3F) || (pageCode == 0x20)) {
819 ms_mode_sense(chip, srb->cmnd[0],
820 lun, buf, dataSize);
821 } else {
822 dataSize = 8;
823 buf[0] = 0x00;
824 buf[1] = 0x06;
825 buf[2] = 0x00;
826 if (check_card_wp(chip, lun))
827 buf[3] = 0x80;
828 else
829 buf[3] = 0x00;
830 buf[4] = 0x00;
831 buf[5] = 0x00;
832 buf[6] = 0x00;
833 buf[7] = 0x00;
834 }
835 }
836 status = TRANSPORT_GOOD;
837 } else {
838 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
839 scsi_set_resid(srb, scsi_bufflen(srb));
840 status = TRANSPORT_FAILED;
841 }
842
843 if (status == TRANSPORT_GOOD) {
844 unsigned int len = min_t(unsigned int, scsi_bufflen(srb),
845 dataSize);
846 rtsx_stor_set_xfer_buf(buf, len, srb);
847 scsi_set_resid(srb, scsi_bufflen(srb) - len);
848 }
849 kfree(buf);
850
851 return status;
852}
853
854static int read_write(struct scsi_cmnd *srb, struct rtsx_chip *chip)
855{
856#ifdef SUPPORT_SD_LOCK
857 struct sd_info *sd_card = &(chip->sd_card);
858#endif
859 unsigned int lun = SCSI_LUN(srb);
860 int retval;
861 u32 start_sec;
862 u16 sec_cnt;
863
864 rtsx_disable_aspm(chip);
865
866 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
867 rtsx_exit_ss(chip);
868 wait_timeout(100);
869 }
870 rtsx_set_stat(chip, RTSX_STAT_RUN);
871
872 if (!check_card_ready(chip, lun) || (get_card_size(chip, lun) == 0)) {
873 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
874 rtsx_trace(chip);
875 return TRANSPORT_FAILED;
876 }
877
878 if (!(CHK_BIT(chip->lun_mc, lun))) {
879 SET_BIT(chip->lun_mc, lun);
880 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
881 return TRANSPORT_FAILED;
882 }
883
884#ifdef SUPPORT_SD_LOCK
885 if (sd_card->sd_erase_status) {
886
887
888
889 dev_dbg(rtsx_dev(chip), "SD card being erased!\n");
890 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
891 rtsx_trace(chip);
892 return TRANSPORT_FAILED;
893 }
894
895 if (get_lun_card(chip, lun) == SD_CARD) {
896 if (sd_card->sd_lock_status & SD_LOCKED) {
897 dev_dbg(rtsx_dev(chip), "SD card locked!\n");
898 set_sense_type(chip, lun,
899 SENSE_TYPE_MEDIA_READ_FORBIDDEN);
900 rtsx_trace(chip);
901 return TRANSPORT_FAILED;
902 }
903 }
904#endif
905
906 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
907 start_sec = ((u32)srb->cmnd[2] << 24) |
908 ((u32)srb->cmnd[3] << 16) |
909 ((u32)srb->cmnd[4] << 8) | ((u32)srb->cmnd[5]);
910 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
911 } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
912 start_sec = ((u32)(srb->cmnd[1] & 0x1F) << 16) |
913 ((u32)srb->cmnd[2] << 8) | ((u32)srb->cmnd[3]);
914 sec_cnt = srb->cmnd[4];
915 if (sec_cnt == 0)
916 sec_cnt = 256;
917 } else if ((srb->cmnd[0] == VENDOR_CMND) &&
918 (srb->cmnd[1] == SCSI_APP_CMD) &&
919 ((srb->cmnd[2] == PP_READ10) || (srb->cmnd[2] == PP_WRITE10))) {
920 start_sec = ((u32)srb->cmnd[4] << 24) |
921 ((u32)srb->cmnd[5] << 16) |
922 ((u32)srb->cmnd[6] << 8) | ((u32)srb->cmnd[7]);
923 sec_cnt = ((u16)(srb->cmnd[9]) << 8) | srb->cmnd[10];
924 } else {
925 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
926 rtsx_trace(chip);
927 return TRANSPORT_FAILED;
928 }
929
930
931
932
933
934 if ((start_sec > get_card_size(chip, lun)) ||
935 ((start_sec + sec_cnt) > get_card_size(chip, lun))) {
936 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE);
937 rtsx_trace(chip);
938 return TRANSPORT_FAILED;
939 }
940
941 if (sec_cnt == 0) {
942 scsi_set_resid(srb, 0);
943 return TRANSPORT_GOOD;
944 }
945
946 if (chip->rw_fail_cnt[lun] == 3) {
947 dev_dbg(rtsx_dev(chip), "read/write fail three times in succession\n");
948 if (srb->sc_data_direction == DMA_FROM_DEVICE)
949 set_sense_type(chip, lun,
950 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
951 else
952 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
953
954 rtsx_trace(chip);
955 return TRANSPORT_FAILED;
956 }
957
958 if (srb->sc_data_direction == DMA_TO_DEVICE) {
959 if (check_card_wp(chip, lun)) {
960 dev_dbg(rtsx_dev(chip), "Write protected card!\n");
961 set_sense_type(chip, lun,
962 SENSE_TYPE_MEDIA_WRITE_PROTECT);
963 rtsx_trace(chip);
964 return TRANSPORT_FAILED;
965 }
966 }
967
968 retval = card_rw(srb, chip, start_sec, sec_cnt);
969 if (retval != STATUS_SUCCESS) {
970 if (chip->need_release & chip->lun2card[lun]) {
971 chip->rw_fail_cnt[lun] = 0;
972 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
973 } else {
974 chip->rw_fail_cnt[lun]++;
975 if (srb->sc_data_direction == DMA_FROM_DEVICE)
976 set_sense_type(chip, lun,
977 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
978 else
979 set_sense_type(chip, lun,
980 SENSE_TYPE_MEDIA_WRITE_ERR);
981 }
982 retval = TRANSPORT_FAILED;
983 rtsx_trace(chip);
984 goto Exit;
985 } else {
986 chip->rw_fail_cnt[lun] = 0;
987 retval = TRANSPORT_GOOD;
988 }
989
990 scsi_set_resid(srb, 0);
991
992Exit:
993 return retval;
994}
995
996static int read_format_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
997{
998 unsigned char *buf;
999 unsigned int lun = SCSI_LUN(srb);
1000 unsigned int buf_len;
1001 u8 card = get_lun_card(chip, lun);
1002 u32 card_size;
1003 int desc_cnt;
1004 int i = 0;
1005
1006 if (!check_card_ready(chip, lun)) {
1007 if (!chip->mspro_formatter_enable) {
1008 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1009 rtsx_trace(chip);
1010 return TRANSPORT_FAILED;
1011 }
1012 }
1013
1014 buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12;
1015
1016 buf = kmalloc(buf_len, GFP_KERNEL);
1017 if (!buf) {
1018 rtsx_trace(chip);
1019 return TRANSPORT_ERROR;
1020 }
1021
1022 buf[i++] = 0;
1023 buf[i++] = 0;
1024 buf[i++] = 0;
1025
1026
1027 if ((buf_len > 12) && chip->mspro_formatter_enable &&
1028 (chip->lun2card[lun] & MS_CARD) &&
1029 (!card || (card == MS_CARD))) {
1030 buf[i++] = 0x10;
1031 desc_cnt = 2;
1032 } else {
1033 buf[i++] = 0x08;
1034 desc_cnt = 1;
1035 }
1036
1037 while (desc_cnt) {
1038 if (check_card_ready(chip, lun)) {
1039 card_size = get_card_size(chip, lun);
1040 buf[i++] = (unsigned char)(card_size >> 24);
1041 buf[i++] = (unsigned char)(card_size >> 16);
1042 buf[i++] = (unsigned char)(card_size >> 8);
1043 buf[i++] = (unsigned char)card_size;
1044
1045 if (desc_cnt == 2)
1046 buf[i++] = 2;
1047 else
1048 buf[i++] = 0;
1049 } else {
1050 buf[i++] = 0xFF;
1051 buf[i++] = 0xFF;
1052 buf[i++] = 0xFF;
1053 buf[i++] = 0xFF;
1054
1055 if (desc_cnt == 2)
1056 buf[i++] = 3;
1057 else
1058 buf[i++] = 0;
1059 }
1060
1061 buf[i++] = 0x00;
1062 buf[i++] = 0x02;
1063 buf[i++] = 0x00;
1064
1065 desc_cnt--;
1066 }
1067
1068 buf_len = min_t(unsigned int, scsi_bufflen(srb), buf_len);
1069 rtsx_stor_set_xfer_buf(buf, buf_len, srb);
1070 kfree(buf);
1071
1072 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1073
1074 return TRANSPORT_GOOD;
1075}
1076
1077static int read_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1078{
1079 unsigned char *buf;
1080 unsigned int lun = SCSI_LUN(srb);
1081 u32 card_size;
1082
1083 if (!check_card_ready(chip, lun)) {
1084 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1085 rtsx_trace(chip);
1086 return TRANSPORT_FAILED;
1087 }
1088
1089 if (!(CHK_BIT(chip->lun_mc, lun))) {
1090 SET_BIT(chip->lun_mc, lun);
1091 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
1092 return TRANSPORT_FAILED;
1093 }
1094
1095 buf = kmalloc(8, GFP_KERNEL);
1096 if (!buf) {
1097 rtsx_trace(chip);
1098 return TRANSPORT_ERROR;
1099 }
1100
1101 card_size = get_card_size(chip, lun);
1102 buf[0] = (unsigned char)((card_size - 1) >> 24);
1103 buf[1] = (unsigned char)((card_size - 1) >> 16);
1104 buf[2] = (unsigned char)((card_size - 1) >> 8);
1105 buf[3] = (unsigned char)(card_size - 1);
1106
1107 buf[4] = 0x00;
1108 buf[5] = 0x00;
1109 buf[6] = 0x02;
1110 buf[7] = 0x00;
1111
1112 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1113 kfree(buf);
1114
1115 scsi_set_resid(srb, 0);
1116
1117 return TRANSPORT_GOOD;
1118}
1119
1120static int read_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1121{
1122 unsigned short len, i;
1123 int retval;
1124 u8 *buf;
1125
1126 rtsx_disable_aspm(chip);
1127
1128 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1129 rtsx_exit_ss(chip);
1130 wait_timeout(100);
1131 }
1132 rtsx_set_stat(chip, RTSX_STAT_RUN);
1133
1134 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1135
1136 buf = vmalloc(len);
1137 if (!buf) {
1138 rtsx_trace(chip);
1139 return TRANSPORT_ERROR;
1140 }
1141
1142 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1143 if (retval != STATUS_SUCCESS) {
1144 vfree(buf);
1145 set_sense_type(chip, SCSI_LUN(srb),
1146 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1147 rtsx_trace(chip);
1148 return TRANSPORT_FAILED;
1149 }
1150
1151 for (i = 0; i < len; i++) {
1152 retval = spi_read_eeprom(chip, i, buf + i);
1153 if (retval != STATUS_SUCCESS) {
1154 vfree(buf);
1155 set_sense_type(chip, SCSI_LUN(srb),
1156 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1157 rtsx_trace(chip);
1158 return TRANSPORT_FAILED;
1159 }
1160 }
1161
1162 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1163 rtsx_stor_set_xfer_buf(buf, len, srb);
1164 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1165
1166 vfree(buf);
1167
1168 return TRANSPORT_GOOD;
1169}
1170
1171static int write_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1172{
1173 unsigned short len, i;
1174 int retval;
1175 u8 *buf;
1176
1177 rtsx_disable_aspm(chip);
1178
1179 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1180 rtsx_exit_ss(chip);
1181 wait_timeout(100);
1182 }
1183 rtsx_set_stat(chip, RTSX_STAT_RUN);
1184
1185 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1186
1187 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1188 if (retval != STATUS_SUCCESS) {
1189 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1190 rtsx_trace(chip);
1191 return TRANSPORT_FAILED;
1192 }
1193
1194 if (len == 511) {
1195 retval = spi_erase_eeprom_chip(chip);
1196 if (retval != STATUS_SUCCESS) {
1197 set_sense_type(chip, SCSI_LUN(srb),
1198 SENSE_TYPE_MEDIA_WRITE_ERR);
1199 rtsx_trace(chip);
1200 return TRANSPORT_FAILED;
1201 }
1202 } else {
1203 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1204 len);
1205 buf = vmalloc(len);
1206 if (!buf) {
1207 rtsx_trace(chip);
1208 return TRANSPORT_ERROR;
1209 }
1210
1211 rtsx_stor_get_xfer_buf(buf, len, srb);
1212 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1213
1214 for (i = 0; i < len; i++) {
1215 retval = spi_write_eeprom(chip, i, buf[i]);
1216 if (retval != STATUS_SUCCESS) {
1217 vfree(buf);
1218 set_sense_type(chip, SCSI_LUN(srb),
1219 SENSE_TYPE_MEDIA_WRITE_ERR);
1220 rtsx_trace(chip);
1221 return TRANSPORT_FAILED;
1222 }
1223 }
1224
1225 vfree(buf);
1226 }
1227
1228 return TRANSPORT_GOOD;
1229}
1230
1231static int read_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1232{
1233 unsigned short addr, len, i;
1234 int retval;
1235 u8 *buf;
1236
1237 rtsx_disable_aspm(chip);
1238
1239 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1240 rtsx_exit_ss(chip);
1241 wait_timeout(100);
1242 }
1243 rtsx_set_stat(chip, RTSX_STAT_RUN);
1244
1245 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1246 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1247
1248 if (addr < 0xFC00) {
1249 set_sense_type(chip, SCSI_LUN(srb),
1250 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1251 rtsx_trace(chip);
1252 return TRANSPORT_FAILED;
1253 }
1254
1255 buf = vmalloc(len);
1256 if (!buf) {
1257 rtsx_trace(chip);
1258 return TRANSPORT_ERROR;
1259 }
1260
1261 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1262 if (retval != STATUS_SUCCESS) {
1263 vfree(buf);
1264 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1265 rtsx_trace(chip);
1266 return TRANSPORT_FAILED;
1267 }
1268
1269 for (i = 0; i < len; i++) {
1270 retval = rtsx_read_register(chip, addr + i, buf + i);
1271 if (retval != STATUS_SUCCESS) {
1272 vfree(buf);
1273 set_sense_type(chip, SCSI_LUN(srb),
1274 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1275 rtsx_trace(chip);
1276 return TRANSPORT_FAILED;
1277 }
1278 }
1279
1280 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1281 rtsx_stor_set_xfer_buf(buf, len, srb);
1282 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1283
1284 vfree(buf);
1285
1286 return TRANSPORT_GOOD;
1287}
1288
1289static int write_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1290{
1291 unsigned short addr, len, i;
1292 int retval;
1293 u8 *buf;
1294
1295 rtsx_disable_aspm(chip);
1296
1297 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1298 rtsx_exit_ss(chip);
1299 wait_timeout(100);
1300 }
1301 rtsx_set_stat(chip, RTSX_STAT_RUN);
1302
1303 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1304 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1305
1306 if (addr < 0xFC00) {
1307 set_sense_type(chip, SCSI_LUN(srb),
1308 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1309 rtsx_trace(chip);
1310 return TRANSPORT_FAILED;
1311 }
1312
1313 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1314 buf = vmalloc(len);
1315 if (!buf) {
1316 rtsx_trace(chip);
1317 return TRANSPORT_ERROR;
1318 }
1319
1320 rtsx_stor_get_xfer_buf(buf, len, srb);
1321 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1322
1323 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1324 if (retval != STATUS_SUCCESS) {
1325 vfree(buf);
1326 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1327 rtsx_trace(chip);
1328 return TRANSPORT_FAILED;
1329 }
1330
1331 for (i = 0; i < len; i++) {
1332 retval = rtsx_write_register(chip, addr + i, 0xFF, buf[i]);
1333 if (retval != STATUS_SUCCESS) {
1334 vfree(buf);
1335 set_sense_type(chip, SCSI_LUN(srb),
1336 SENSE_TYPE_MEDIA_WRITE_ERR);
1337 rtsx_trace(chip);
1338 return TRANSPORT_FAILED;
1339 }
1340 }
1341
1342 vfree(buf);
1343
1344 return TRANSPORT_GOOD;
1345}
1346
1347static int get_sd_csd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1348{
1349 struct sd_info *sd_card = &(chip->sd_card);
1350 unsigned int lun = SCSI_LUN(srb);
1351
1352 if (!check_card_ready(chip, lun)) {
1353 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1354 rtsx_trace(chip);
1355 return TRANSPORT_FAILED;
1356 }
1357
1358 if (get_lun_card(chip, lun) != SD_CARD) {
1359 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1360 rtsx_trace(chip);
1361 return TRANSPORT_FAILED;
1362 }
1363
1364 scsi_set_resid(srb, 0);
1365 rtsx_stor_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb);
1366
1367 return TRANSPORT_GOOD;
1368}
1369
1370static int toggle_gpio_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1371{
1372 u8 gpio = srb->cmnd[2];
1373
1374 rtsx_disable_aspm(chip);
1375
1376 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1377 rtsx_exit_ss(chip);
1378 wait_timeout(100);
1379 }
1380 rtsx_set_stat(chip, RTSX_STAT_RUN);
1381
1382 if (gpio > 3)
1383 gpio = 1;
1384 toggle_gpio(chip, gpio);
1385
1386 return TRANSPORT_GOOD;
1387}
1388
1389#ifdef _MSG_TRACE
1390static int trace_msg_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1391{
1392 unsigned char *ptr, *buf = NULL;
1393 int i, msg_cnt;
1394 u8 clear;
1395 unsigned int buf_len;
1396
1397 buf_len = 4 + ((2 + MSG_FUNC_LEN + MSG_FILE_LEN + TIME_VAL_LEN) *
1398 TRACE_ITEM_CNT);
1399
1400 if ((scsi_bufflen(srb) < buf_len) || !scsi_sglist(srb)) {
1401 set_sense_type(chip, SCSI_LUN(srb),
1402 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1403 rtsx_trace(chip);
1404 return TRANSPORT_FAILED;
1405 }
1406
1407 clear = srb->cmnd[2];
1408
1409 buf = vmalloc(scsi_bufflen(srb));
1410 if (!buf) {
1411 rtsx_trace(chip);
1412 return TRANSPORT_ERROR;
1413 }
1414 ptr = buf;
1415
1416 if (chip->trace_msg[chip->msg_idx].valid)
1417 msg_cnt = TRACE_ITEM_CNT;
1418 else
1419 msg_cnt = chip->msg_idx;
1420
1421 *(ptr++) = (u8)(msg_cnt >> 24);
1422 *(ptr++) = (u8)(msg_cnt >> 16);
1423 *(ptr++) = (u8)(msg_cnt >> 8);
1424 *(ptr++) = (u8)msg_cnt;
1425 dev_dbg(rtsx_dev(chip), "Trace message count is %d\n", msg_cnt);
1426
1427 for (i = 1; i <= msg_cnt; i++) {
1428 int j, idx;
1429
1430 idx = chip->msg_idx - i;
1431 if (idx < 0)
1432 idx += TRACE_ITEM_CNT;
1433
1434 *(ptr++) = (u8)(chip->trace_msg[idx].line >> 8);
1435 *(ptr++) = (u8)(chip->trace_msg[idx].line);
1436 for (j = 0; j < MSG_FUNC_LEN; j++)
1437 *(ptr++) = chip->trace_msg[idx].func[j];
1438
1439 for (j = 0; j < MSG_FILE_LEN; j++)
1440 *(ptr++) = chip->trace_msg[idx].file[j];
1441
1442 for (j = 0; j < TIME_VAL_LEN; j++)
1443 *(ptr++) = chip->trace_msg[idx].timeval_buf[j];
1444 }
1445
1446 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1447 vfree(buf);
1448
1449 if (clear) {
1450 chip->msg_idx = 0;
1451 for (i = 0; i < TRACE_ITEM_CNT; i++)
1452 chip->trace_msg[i].valid = 0;
1453 }
1454
1455 scsi_set_resid(srb, 0);
1456 return TRANSPORT_GOOD;
1457}
1458#endif
1459
1460static int read_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1461{
1462 u8 addr, buf[4];
1463 u32 val;
1464 unsigned int len;
1465
1466 rtsx_disable_aspm(chip);
1467
1468 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1469 rtsx_exit_ss(chip);
1470 wait_timeout(100);
1471 }
1472 rtsx_set_stat(chip, RTSX_STAT_RUN);
1473
1474 addr = srb->cmnd[4];
1475
1476 val = rtsx_readl(chip, addr);
1477 dev_dbg(rtsx_dev(chip), "Host register (0x%x): 0x%x\n", addr, val);
1478
1479 buf[0] = (u8)(val >> 24);
1480 buf[1] = (u8)(val >> 16);
1481 buf[2] = (u8)(val >> 8);
1482 buf[3] = (u8)val;
1483
1484 len = min_t(unsigned int, scsi_bufflen(srb), 4);
1485 rtsx_stor_set_xfer_buf(buf, len, srb);
1486 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1487
1488 return TRANSPORT_GOOD;
1489}
1490
1491static int write_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1492{
1493 u8 addr, buf[4];
1494 u32 val;
1495 unsigned int len;
1496
1497 rtsx_disable_aspm(chip);
1498
1499 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1500 rtsx_exit_ss(chip);
1501 wait_timeout(100);
1502 }
1503 rtsx_set_stat(chip, RTSX_STAT_RUN);
1504
1505 addr = srb->cmnd[4];
1506
1507 len = min_t(unsigned int, scsi_bufflen(srb), 4);
1508 rtsx_stor_get_xfer_buf(buf, len, srb);
1509 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1510
1511 val = ((u32)buf[0] << 24) | ((u32)buf[1] << 16) | ((u32)buf[2]
1512 << 8) | buf[3];
1513
1514 rtsx_writel(chip, addr, val);
1515
1516 return TRANSPORT_GOOD;
1517}
1518
1519static int set_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1520{
1521 unsigned int lun = SCSI_LUN(srb);
1522
1523 if (srb->cmnd[3] == 1) {
1524
1525 struct xd_info *xd_card = &(chip->xd_card);
1526 struct sd_info *sd_card = &(chip->sd_card);
1527 struct ms_info *ms_card = &(chip->ms_card);
1528
1529 switch (srb->cmnd[4]) {
1530 case XD_CARD:
1531 xd_card->xd_clock = srb->cmnd[5];
1532 break;
1533
1534 case SD_CARD:
1535 sd_card->sd_clock = srb->cmnd[5];
1536 break;
1537
1538 case MS_CARD:
1539 ms_card->ms_clock = srb->cmnd[5];
1540 break;
1541
1542 default:
1543 set_sense_type(chip, lun,
1544 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1545 rtsx_trace(chip);
1546 return TRANSPORT_FAILED;
1547 }
1548 } else if (srb->cmnd[3] == 2) {
1549 if (srb->cmnd[4]) {
1550 chip->blink_led = 1;
1551 } else {
1552 int retval;
1553
1554 chip->blink_led = 0;
1555
1556 rtsx_disable_aspm(chip);
1557
1558 if (chip->ss_en &&
1559 (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1560 rtsx_exit_ss(chip);
1561 wait_timeout(100);
1562 }
1563 rtsx_set_stat(chip, RTSX_STAT_RUN);
1564
1565 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1566 if (retval != STATUS_SUCCESS) {
1567 set_sense_type(chip, SCSI_LUN(srb),
1568 SENSE_TYPE_MEDIA_WRITE_ERR);
1569 rtsx_trace(chip);
1570 return TRANSPORT_FAILED;
1571 }
1572
1573 turn_off_led(chip, LED_GPIO);
1574 }
1575 } else {
1576 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1577 rtsx_trace(chip);
1578 return TRANSPORT_FAILED;
1579 }
1580
1581 return TRANSPORT_GOOD;
1582}
1583
1584static int get_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1585{
1586 unsigned int lun = SCSI_LUN(srb);
1587
1588 if (srb->cmnd[3] == 1) {
1589 struct xd_info *xd_card = &(chip->xd_card);
1590 struct sd_info *sd_card = &(chip->sd_card);
1591 struct ms_info *ms_card = &(chip->ms_card);
1592 u8 tmp;
1593
1594 switch (srb->cmnd[4]) {
1595 case XD_CARD:
1596 tmp = (u8)(xd_card->xd_clock);
1597 break;
1598
1599 case SD_CARD:
1600 tmp = (u8)(sd_card->sd_clock);
1601 break;
1602
1603 case MS_CARD:
1604 tmp = (u8)(ms_card->ms_clock);
1605 break;
1606
1607 default:
1608 set_sense_type(chip, lun,
1609 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1610 rtsx_trace(chip);
1611 return TRANSPORT_FAILED;
1612 }
1613
1614 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1615 } else if (srb->cmnd[3] == 2) {
1616 u8 tmp = chip->blink_led;
1617
1618 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1619 } else {
1620 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1621 rtsx_trace(chip);
1622 return TRANSPORT_FAILED;
1623 }
1624
1625 return TRANSPORT_GOOD;
1626}
1627
1628static int dma_access_ring_buffer(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1629{
1630 int retval;
1631 unsigned int lun = SCSI_LUN(srb);
1632 u16 len;
1633
1634 rtsx_disable_aspm(chip);
1635
1636 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1637 rtsx_exit_ss(chip);
1638 wait_timeout(100);
1639 }
1640 rtsx_set_stat(chip, RTSX_STAT_RUN);
1641
1642 len = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
1643 len = min_t(u16, len, scsi_bufflen(srb));
1644
1645 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1646 dev_dbg(rtsx_dev(chip), "Read from device\n");
1647 else
1648 dev_dbg(rtsx_dev(chip), "Write to device\n");
1649
1650 retval = rtsx_transfer_data(chip, 0, scsi_sglist(srb), len,
1651 scsi_sg_count(srb), srb->sc_data_direction, 1000);
1652 if (retval < 0) {
1653 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1654 set_sense_type(chip, lun,
1655 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1656 else
1657 set_sense_type(chip, lun,
1658 SENSE_TYPE_MEDIA_WRITE_ERR);
1659
1660 rtsx_trace(chip);
1661 return TRANSPORT_FAILED;
1662 }
1663 scsi_set_resid(srb, 0);
1664
1665 return TRANSPORT_GOOD;
1666}
1667
1668static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1669{
1670 struct sd_info *sd_card = &(chip->sd_card);
1671 struct ms_info *ms_card = &(chip->ms_card);
1672 int buf_len;
1673 unsigned int lun = SCSI_LUN(srb);
1674 u8 card = get_lun_card(chip, lun);
1675 u8 status[32];
1676#ifdef SUPPORT_OCP
1677 u8 oc_now_mask = 0, oc_ever_mask = 0;
1678#endif
1679
1680 memset(status, 0, 32);
1681
1682 status[0] = (u8)(chip->product_id);
1683 status[1] = chip->ic_version;
1684
1685 if (chip->auto_delink_en)
1686 status[2] = 0x10;
1687 else
1688 status[2] = 0x00;
1689
1690 status[3] = 20;
1691 status[4] = 10;
1692 status[5] = 05;
1693 status[6] = 21;
1694
1695 if (chip->card_wp)
1696 status[7] = 0x20;
1697 else
1698 status[7] = 0x00;
1699
1700#ifdef SUPPORT_OCP
1701 status[8] = 0;
1702 if (CHECK_LUN_MODE(chip,
1703 SD_MS_2LUN) && (chip->lun2card[lun] == MS_CARD)) {
1704 oc_now_mask = MS_OC_NOW;
1705 oc_ever_mask = MS_OC_EVER;
1706 } else {
1707 oc_now_mask = SD_OC_NOW;
1708 oc_ever_mask = SD_OC_EVER;
1709 }
1710
1711 if (chip->ocp_stat & oc_now_mask)
1712 status[8] |= 0x02;
1713
1714 if (chip->ocp_stat & oc_ever_mask)
1715 status[8] |= 0x01;
1716#endif
1717
1718 if (card == SD_CARD) {
1719 if (CHK_SD(sd_card)) {
1720 if (CHK_SD_HCXC(sd_card)) {
1721 if (sd_card->capacity > 0x4000000)
1722 status[0x0E] = 0x02;
1723 else
1724 status[0x0E] = 0x01;
1725 } else {
1726 status[0x0E] = 0x00;
1727 }
1728
1729 if (CHK_SD_SDR104(sd_card))
1730 status[0x0F] = 0x03;
1731 else if (CHK_SD_DDR50(sd_card))
1732 status[0x0F] = 0x04;
1733 else if (CHK_SD_SDR50(sd_card))
1734 status[0x0F] = 0x02;
1735 else if (CHK_SD_HS(sd_card))
1736 status[0x0F] = 0x01;
1737 else
1738 status[0x0F] = 0x00;
1739 } else {
1740 if (CHK_MMC_SECTOR_MODE(sd_card))
1741 status[0x0E] = 0x01;
1742 else
1743 status[0x0E] = 0x00;
1744
1745 if (CHK_MMC_DDR52(sd_card))
1746 status[0x0F] = 0x03;
1747 else if (CHK_MMC_52M(sd_card))
1748 status[0x0F] = 0x02;
1749 else if (CHK_MMC_26M(sd_card))
1750 status[0x0F] = 0x01;
1751 else
1752 status[0x0F] = 0x00;
1753 }
1754 } else if (card == MS_CARD) {
1755 if (CHK_MSPRO(ms_card)) {
1756 if (CHK_MSXC(ms_card))
1757 status[0x0E] = 0x01;
1758 else
1759 status[0x0E] = 0x00;
1760
1761 if (CHK_HG8BIT(ms_card))
1762 status[0x0F] = 0x01;
1763 else
1764 status[0x0F] = 0x00;
1765 }
1766 }
1767
1768#ifdef SUPPORT_SD_LOCK
1769 if (card == SD_CARD) {
1770 status[0x17] = 0x80;
1771 if (sd_card->sd_erase_status)
1772 status[0x17] |= 0x01;
1773 if (sd_card->sd_lock_status & SD_LOCKED) {
1774 status[0x17] |= 0x02;
1775 status[0x07] |= 0x40;
1776 }
1777 if (sd_card->sd_lock_status & SD_PWD_EXIST)
1778 status[0x17] |= 0x04;
1779 } else {
1780 status[0x17] = 0x00;
1781 }
1782
1783 dev_dbg(rtsx_dev(chip), "status[0x17] = 0x%x\n", status[0x17]);
1784#endif
1785
1786 status[0x18] = 0x8A;
1787 status[0x1A] = 0x28;
1788#ifdef SUPPORT_SD_LOCK
1789 status[0x1F] = 0x01;
1790#endif
1791
1792 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(status));
1793 rtsx_stor_set_xfer_buf(status, buf_len, srb);
1794 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1795
1796 return TRANSPORT_GOOD;
1797}
1798
1799static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1800{
1801 int phy_debug_mode;
1802 int retval;
1803 u16 reg;
1804
1805 if (!CHECK_PID(chip, 0x5208)) {
1806 set_sense_type(chip, SCSI_LUN(srb),
1807 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1808 rtsx_trace(chip);
1809 return TRANSPORT_FAILED;
1810 }
1811
1812 phy_debug_mode = (int)(srb->cmnd[3]);
1813
1814 if (phy_debug_mode) {
1815 chip->phy_debug_mode = 1;
1816 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0);
1817 if (retval != STATUS_SUCCESS) {
1818 rtsx_trace(chip);
1819 return TRANSPORT_FAILED;
1820 }
1821
1822 rtsx_disable_bus_int(chip);
1823
1824 retval = rtsx_read_phy_register(chip, 0x1C, ®);
1825 if (retval != STATUS_SUCCESS) {
1826 rtsx_trace(chip);
1827 return TRANSPORT_FAILED;
1828 }
1829
1830 reg |= 0x0001;
1831 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1832 if (retval != STATUS_SUCCESS) {
1833 rtsx_trace(chip);
1834 return TRANSPORT_FAILED;
1835 }
1836 } else {
1837 chip->phy_debug_mode = 0;
1838 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77);
1839 if (retval != STATUS_SUCCESS) {
1840 rtsx_trace(chip);
1841 return TRANSPORT_FAILED;
1842 }
1843
1844 rtsx_enable_bus_int(chip);
1845
1846 retval = rtsx_read_phy_register(chip, 0x1C, ®);
1847 if (retval != STATUS_SUCCESS) {
1848 rtsx_trace(chip);
1849 return TRANSPORT_FAILED;
1850 }
1851
1852 reg &= 0xFFFE;
1853 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1854 if (retval != STATUS_SUCCESS) {
1855 rtsx_trace(chip);
1856 return TRANSPORT_FAILED;
1857 }
1858 }
1859
1860 return TRANSPORT_GOOD;
1861}
1862
1863static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1864{
1865 int retval = STATUS_SUCCESS;
1866 unsigned int lun = SCSI_LUN(srb);
1867 u8 cmd_type, mask, value, idx;
1868 u16 addr;
1869
1870 rtsx_disable_aspm(chip);
1871
1872 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1873 rtsx_exit_ss(chip);
1874 wait_timeout(100);
1875 }
1876 rtsx_set_stat(chip, RTSX_STAT_RUN);
1877
1878 switch (srb->cmnd[3]) {
1879 case INIT_BATCHCMD:
1880 rtsx_init_cmd(chip);
1881 break;
1882
1883 case ADD_BATCHCMD:
1884 cmd_type = srb->cmnd[4];
1885 if (cmd_type > 2) {
1886 set_sense_type(chip, lun,
1887 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1888 rtsx_trace(chip);
1889 return TRANSPORT_FAILED;
1890 }
1891 addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1892 mask = srb->cmnd[7];
1893 value = srb->cmnd[8];
1894 rtsx_add_cmd(chip, cmd_type, addr, mask, value);
1895 break;
1896
1897 case SEND_BATCHCMD:
1898 retval = rtsx_send_cmd(chip, 0, 1000);
1899 break;
1900
1901 case GET_BATCHRSP:
1902 idx = srb->cmnd[4];
1903 value = *(rtsx_get_cmd_data(chip) + idx);
1904 if (scsi_bufflen(srb) < 1) {
1905 set_sense_type(chip, lun,
1906 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1907 rtsx_trace(chip);
1908 return TRANSPORT_FAILED;
1909 }
1910 rtsx_stor_set_xfer_buf(&value, 1, srb);
1911 scsi_set_resid(srb, 0);
1912 break;
1913
1914 default:
1915 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1916 rtsx_trace(chip);
1917 return TRANSPORT_FAILED;
1918 }
1919
1920 if (retval != STATUS_SUCCESS) {
1921 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1922 rtsx_trace(chip);
1923 return TRANSPORT_FAILED;
1924 }
1925
1926 return TRANSPORT_GOOD;
1927}
1928
1929static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1930{
1931 switch (srb->cmnd[3]) {
1932 case INIT_BATCHCMD:
1933 case ADD_BATCHCMD:
1934 case SEND_BATCHCMD:
1935 case GET_BATCHRSP:
1936 return rw_mem_cmd_buf(srb, chip);
1937 default:
1938 return TRANSPORT_ERROR;
1939 }
1940}
1941
1942static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1943{
1944 unsigned short addr, len, i;
1945 int retval;
1946 u8 *buf;
1947 u16 val;
1948
1949 rtsx_disable_aspm(chip);
1950
1951 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1952 rtsx_exit_ss(chip);
1953 wait_timeout(100);
1954 }
1955 rtsx_set_stat(chip, RTSX_STAT_RUN);
1956
1957 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1958 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1959
1960 if (len % 2)
1961 len -= len % 2;
1962
1963 if (len) {
1964 buf = vmalloc(len);
1965 if (!buf) {
1966 rtsx_trace(chip);
1967 return TRANSPORT_ERROR;
1968 }
1969
1970 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1971 if (retval != STATUS_SUCCESS) {
1972 vfree(buf);
1973 set_sense_type(chip, SCSI_LUN(srb),
1974 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1975 rtsx_trace(chip);
1976 return TRANSPORT_FAILED;
1977 }
1978
1979 for (i = 0; i < len / 2; i++) {
1980 retval = rtsx_read_phy_register(chip, addr + i, &val);
1981 if (retval != STATUS_SUCCESS) {
1982 vfree(buf);
1983 set_sense_type(chip, SCSI_LUN(srb),
1984 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1985 rtsx_trace(chip);
1986 return TRANSPORT_FAILED;
1987 }
1988
1989 buf[2 * i] = (u8)(val >> 8);
1990 buf[2 * i + 1] = (u8)val;
1991 }
1992
1993 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1994 len);
1995 rtsx_stor_set_xfer_buf(buf, len, srb);
1996 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1997
1998 vfree(buf);
1999 }
2000
2001 return TRANSPORT_GOOD;
2002}
2003
2004static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2005{
2006 unsigned short addr, len, i;
2007 int retval;
2008 u8 *buf;
2009 u16 val;
2010
2011 rtsx_disable_aspm(chip);
2012
2013 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2014 rtsx_exit_ss(chip);
2015 wait_timeout(100);
2016 }
2017 rtsx_set_stat(chip, RTSX_STAT_RUN);
2018
2019 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2020 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2021
2022 if (len % 2)
2023 len -= len % 2;
2024
2025 if (len) {
2026 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
2027 len);
2028
2029 buf = vmalloc(len);
2030 if (!buf) {
2031 rtsx_trace(chip);
2032 return TRANSPORT_ERROR;
2033 }
2034
2035 rtsx_stor_get_xfer_buf(buf, len, srb);
2036 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2037
2038 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2039 if (retval != STATUS_SUCCESS) {
2040 vfree(buf);
2041 set_sense_type(chip, SCSI_LUN(srb),
2042 SENSE_TYPE_MEDIA_WRITE_ERR);
2043 rtsx_trace(chip);
2044 return TRANSPORT_FAILED;
2045 }
2046
2047 for (i = 0; i < len / 2; i++) {
2048 val = ((u16)buf[2 * i] << 8) | buf[2 * i + 1];
2049 retval = rtsx_write_phy_register(chip, addr + i, val);
2050 if (retval != STATUS_SUCCESS) {
2051 vfree(buf);
2052 set_sense_type(chip, SCSI_LUN(srb),
2053 SENSE_TYPE_MEDIA_WRITE_ERR);
2054 rtsx_trace(chip);
2055 return TRANSPORT_FAILED;
2056 }
2057 }
2058
2059 vfree(buf);
2060 }
2061
2062 return TRANSPORT_GOOD;
2063}
2064
2065static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2066{
2067 unsigned short addr;
2068 int retval;
2069 u8 mode;
2070
2071 rtsx_disable_aspm(chip);
2072
2073 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2074 rtsx_exit_ss(chip);
2075 wait_timeout(100);
2076 }
2077 rtsx_set_stat(chip, RTSX_STAT_RUN);
2078
2079 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2080 if (retval != STATUS_SUCCESS) {
2081 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2082 rtsx_trace(chip);
2083 return TRANSPORT_FAILED;
2084 }
2085
2086 mode = srb->cmnd[3];
2087 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2088
2089 if (mode == 0) {
2090 retval = spi_erase_eeprom_chip(chip);
2091 if (retval != STATUS_SUCCESS) {
2092 set_sense_type(chip, SCSI_LUN(srb),
2093 SENSE_TYPE_MEDIA_WRITE_ERR);
2094 rtsx_trace(chip);
2095 return TRANSPORT_FAILED;
2096 }
2097 } else if (mode == 1) {
2098 retval = spi_erase_eeprom_byte(chip, addr);
2099 if (retval != STATUS_SUCCESS) {
2100 set_sense_type(chip, SCSI_LUN(srb),
2101 SENSE_TYPE_MEDIA_WRITE_ERR);
2102 rtsx_trace(chip);
2103 return TRANSPORT_FAILED;
2104 }
2105 } else {
2106 set_sense_type(chip, SCSI_LUN(srb),
2107 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2108 rtsx_trace(chip);
2109 return TRANSPORT_FAILED;
2110 }
2111
2112 return TRANSPORT_GOOD;
2113}
2114
2115static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2116{
2117 unsigned short addr, len, i;
2118 int retval;
2119 u8 *buf;
2120
2121 rtsx_disable_aspm(chip);
2122
2123 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2124 rtsx_exit_ss(chip);
2125 wait_timeout(100);
2126 }
2127 rtsx_set_stat(chip, RTSX_STAT_RUN);
2128
2129 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2130 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2131
2132 buf = vmalloc(len);
2133 if (!buf) {
2134 rtsx_trace(chip);
2135 return TRANSPORT_ERROR;
2136 }
2137
2138 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2139 if (retval != STATUS_SUCCESS) {
2140 vfree(buf);
2141 set_sense_type(chip, SCSI_LUN(srb),
2142 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2143 rtsx_trace(chip);
2144 return TRANSPORT_FAILED;
2145 }
2146
2147 for (i = 0; i < len; i++) {
2148 retval = spi_read_eeprom(chip, addr + i, buf + i);
2149 if (retval != STATUS_SUCCESS) {
2150 vfree(buf);
2151 set_sense_type(chip, SCSI_LUN(srb),
2152 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2153 rtsx_trace(chip);
2154 return TRANSPORT_FAILED;
2155 }
2156 }
2157
2158 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2159 rtsx_stor_set_xfer_buf(buf, len, srb);
2160 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2161
2162 vfree(buf);
2163
2164 return TRANSPORT_GOOD;
2165}
2166
2167static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2168{
2169 unsigned short addr, len, i;
2170 int retval;
2171 u8 *buf;
2172
2173 rtsx_disable_aspm(chip);
2174
2175 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2176 rtsx_exit_ss(chip);
2177 wait_timeout(100);
2178 }
2179 rtsx_set_stat(chip, RTSX_STAT_RUN);
2180
2181 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2182 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2183
2184 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2185 buf = vmalloc(len);
2186 if (!buf) {
2187 rtsx_trace(chip);
2188 return TRANSPORT_ERROR;
2189 }
2190
2191 rtsx_stor_get_xfer_buf(buf, len, srb);
2192 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2193
2194 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2195 if (retval != STATUS_SUCCESS) {
2196 vfree(buf);
2197 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2198 rtsx_trace(chip);
2199 return TRANSPORT_FAILED;
2200 }
2201
2202 for (i = 0; i < len; i++) {
2203 retval = spi_write_eeprom(chip, addr + i, buf[i]);
2204 if (retval != STATUS_SUCCESS) {
2205 vfree(buf);
2206 set_sense_type(chip, SCSI_LUN(srb),
2207 SENSE_TYPE_MEDIA_WRITE_ERR);
2208 rtsx_trace(chip);
2209 return TRANSPORT_FAILED;
2210 }
2211 }
2212
2213 vfree(buf);
2214
2215 return TRANSPORT_GOOD;
2216}
2217
2218static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2219{
2220 int retval;
2221 u8 addr, len, i;
2222 u8 *buf;
2223
2224 rtsx_disable_aspm(chip);
2225
2226 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2227 rtsx_exit_ss(chip);
2228 wait_timeout(100);
2229 }
2230 rtsx_set_stat(chip, RTSX_STAT_RUN);
2231
2232 addr = srb->cmnd[4];
2233 len = srb->cmnd[5];
2234
2235 buf = vmalloc(len);
2236 if (!buf) {
2237 rtsx_trace(chip);
2238 return TRANSPORT_ERROR;
2239 }
2240
2241 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2242 if (retval != STATUS_SUCCESS) {
2243 vfree(buf);
2244 set_sense_type(chip, SCSI_LUN(srb),
2245 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2246 rtsx_trace(chip);
2247 return TRANSPORT_FAILED;
2248 }
2249
2250 for (i = 0; i < len; i++) {
2251 retval = rtsx_read_efuse(chip, addr + i, buf + i);
2252 if (retval != STATUS_SUCCESS) {
2253 vfree(buf);
2254 set_sense_type(chip, SCSI_LUN(srb),
2255 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2256 rtsx_trace(chip);
2257 return TRANSPORT_FAILED;
2258 }
2259 }
2260
2261 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2262 rtsx_stor_set_xfer_buf(buf, len, srb);
2263 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2264
2265 vfree(buf);
2266
2267 return TRANSPORT_GOOD;
2268}
2269
2270static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2271{
2272 int retval, result = TRANSPORT_GOOD;
2273 u16 val;
2274 u8 addr, len, i;
2275 u8 *buf;
2276
2277 rtsx_disable_aspm(chip);
2278
2279 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2280 rtsx_exit_ss(chip);
2281 wait_timeout(100);
2282 }
2283 rtsx_set_stat(chip, RTSX_STAT_RUN);
2284
2285 addr = srb->cmnd[4];
2286 len = srb->cmnd[5];
2287
2288 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2289 buf = vmalloc(len);
2290 if (!buf) {
2291 rtsx_trace(chip);
2292 return TRANSPORT_ERROR;
2293 }
2294
2295 rtsx_stor_get_xfer_buf(buf, len, srb);
2296 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2297
2298 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2299 if (retval != STATUS_SUCCESS) {
2300 vfree(buf);
2301 rtsx_trace(chip);
2302 return TRANSPORT_ERROR;
2303 }
2304
2305 if (chip->asic_code) {
2306 retval = rtsx_read_phy_register(chip, 0x08, &val);
2307 if (retval != STATUS_SUCCESS) {
2308 vfree(buf);
2309 rtsx_trace(chip);
2310 return TRANSPORT_ERROR;
2311 }
2312
2313 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2314 LDO3318_PWR_MASK, LDO_OFF);
2315 if (retval != STATUS_SUCCESS) {
2316 vfree(buf);
2317 rtsx_trace(chip);
2318 return TRANSPORT_ERROR;
2319 }
2320
2321 wait_timeout(600);
2322
2323 retval = rtsx_write_phy_register(chip, 0x08,
2324 0x4C00 | chip->phy_voltage);
2325 if (retval != STATUS_SUCCESS) {
2326 vfree(buf);
2327 rtsx_trace(chip);
2328 return TRANSPORT_ERROR;
2329 }
2330
2331 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2332 LDO3318_PWR_MASK, LDO_ON);
2333 if (retval != STATUS_SUCCESS) {
2334 vfree(buf);
2335 rtsx_trace(chip);
2336 return TRANSPORT_ERROR;
2337 }
2338
2339 wait_timeout(600);
2340 }
2341
2342 retval = card_power_on(chip, SPI_CARD);
2343 if (retval != STATUS_SUCCESS) {
2344 vfree(buf);
2345 rtsx_trace(chip);
2346 return TRANSPORT_ERROR;
2347 }
2348
2349 wait_timeout(50);
2350
2351 for (i = 0; i < len; i++) {
2352 retval = rtsx_write_efuse(chip, addr + i, buf[i]);
2353 if (retval != STATUS_SUCCESS) {
2354 set_sense_type(chip, SCSI_LUN(srb),
2355 SENSE_TYPE_MEDIA_WRITE_ERR);
2356 result = TRANSPORT_FAILED;
2357 rtsx_trace(chip);
2358 goto Exit;
2359 }
2360 }
2361
2362Exit:
2363 vfree(buf);
2364
2365 retval = card_power_off(chip, SPI_CARD);
2366 if (retval != STATUS_SUCCESS) {
2367 rtsx_trace(chip);
2368 return TRANSPORT_ERROR;
2369 }
2370
2371 if (chip->asic_code) {
2372 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2373 LDO3318_PWR_MASK, LDO_OFF);
2374 if (retval != STATUS_SUCCESS) {
2375 rtsx_trace(chip);
2376 return TRANSPORT_ERROR;
2377 }
2378
2379 wait_timeout(600);
2380
2381 retval = rtsx_write_phy_register(chip, 0x08, val);
2382 if (retval != STATUS_SUCCESS) {
2383 rtsx_trace(chip);
2384 return TRANSPORT_ERROR;
2385 }
2386
2387 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2388 LDO3318_PWR_MASK, LDO_ON);
2389 if (retval != STATUS_SUCCESS) {
2390 rtsx_trace(chip);
2391 return TRANSPORT_ERROR;
2392 }
2393 }
2394
2395 return result;
2396}
2397
2398static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2399{
2400 int retval;
2401 bool func_max;
2402 u8 func;
2403 u16 addr, len;
2404 u8 *buf;
2405
2406 rtsx_disable_aspm(chip);
2407
2408 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2409 rtsx_exit_ss(chip);
2410 wait_timeout(100);
2411 }
2412 rtsx_set_stat(chip, RTSX_STAT_RUN);
2413
2414 func = srb->cmnd[3];
2415 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2416 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2417
2418 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x, len = %d\n",
2419 __func__, func, addr, len);
2420
2421 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2422 func_max = true;
2423 else
2424 func_max = false;
2425
2426 if (func > func_max) {
2427 set_sense_type(chip, SCSI_LUN(srb),
2428 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2429 rtsx_trace(chip);
2430 return TRANSPORT_FAILED;
2431 }
2432
2433 buf = vmalloc(len);
2434 if (!buf) {
2435 rtsx_trace(chip);
2436 return TRANSPORT_ERROR;
2437 }
2438
2439 retval = rtsx_read_cfg_seq(chip, func, addr, buf, len);
2440 if (retval != STATUS_SUCCESS) {
2441 set_sense_type(chip, SCSI_LUN(srb),
2442 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2443 vfree(buf);
2444 rtsx_trace(chip);
2445 return TRANSPORT_FAILED;
2446 }
2447
2448 len = (u16)min_t(unsigned int, scsi_bufflen(srb), len);
2449 rtsx_stor_set_xfer_buf(buf, len, srb);
2450 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2451
2452 vfree(buf);
2453
2454 return TRANSPORT_GOOD;
2455}
2456
2457static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2458{
2459 int retval;
2460 bool func_max;
2461 u8 func;
2462 u16 addr, len;
2463 u8 *buf;
2464
2465 rtsx_disable_aspm(chip);
2466
2467 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2468 rtsx_exit_ss(chip);
2469 wait_timeout(100);
2470 }
2471 rtsx_set_stat(chip, RTSX_STAT_RUN);
2472
2473 func = srb->cmnd[3];
2474 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2475 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2476
2477 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x\n",
2478 __func__, func, addr);
2479
2480 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2481 func_max = true;
2482 else
2483 func_max = false;
2484
2485 if (func > func_max) {
2486 set_sense_type(chip, SCSI_LUN(srb),
2487 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2488 rtsx_trace(chip);
2489 return TRANSPORT_FAILED;
2490 }
2491
2492 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2493 buf = vmalloc(len);
2494 if (!buf) {
2495 rtsx_trace(chip);
2496 return TRANSPORT_ERROR;
2497 }
2498
2499 rtsx_stor_get_xfer_buf(buf, len, srb);
2500 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2501
2502 retval = rtsx_write_cfg_seq(chip, func, addr, buf, len);
2503 if (retval != STATUS_SUCCESS) {
2504 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2505 vfree(buf);
2506 rtsx_trace(chip);
2507 return TRANSPORT_FAILED;
2508 }
2509
2510 vfree(buf);
2511
2512 return TRANSPORT_GOOD;
2513}
2514
2515static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2516{
2517 int result;
2518
2519 switch (srb->cmnd[2]) {
2520 case PP_READ10:
2521 case PP_WRITE10:
2522 result = read_write(srb, chip);
2523 break;
2524
2525 case READ_HOST_REG:
2526 result = read_host_reg(srb, chip);
2527 break;
2528
2529 case WRITE_HOST_REG:
2530 result = write_host_reg(srb, chip);
2531 break;
2532
2533 case GET_VAR:
2534 result = get_variable(srb, chip);
2535 break;
2536
2537 case SET_VAR:
2538 result = set_variable(srb, chip);
2539 break;
2540
2541 case DMA_READ:
2542 case DMA_WRITE:
2543 result = dma_access_ring_buffer(srb, chip);
2544 break;
2545
2546 case READ_PHY:
2547 result = read_phy_register(srb, chip);
2548 break;
2549
2550 case WRITE_PHY:
2551 result = write_phy_register(srb, chip);
2552 break;
2553
2554 case ERASE_EEPROM2:
2555 result = erase_eeprom2(srb, chip);
2556 break;
2557
2558 case READ_EEPROM2:
2559 result = read_eeprom2(srb, chip);
2560 break;
2561
2562 case WRITE_EEPROM2:
2563 result = write_eeprom2(srb, chip);
2564 break;
2565
2566 case READ_EFUSE:
2567 result = read_efuse(srb, chip);
2568 break;
2569
2570 case WRITE_EFUSE:
2571 result = write_efuse(srb, chip);
2572 break;
2573
2574 case READ_CFG:
2575 result = read_cfg_byte(srb, chip);
2576 break;
2577
2578 case WRITE_CFG:
2579 result = write_cfg_byte(srb, chip);
2580 break;
2581
2582 case SET_CHIP_MODE:
2583 result = set_chip_mode(srb, chip);
2584 break;
2585
2586 case SUIT_CMD:
2587 result = suit_cmd(srb, chip);
2588 break;
2589
2590 case GET_DEV_STATUS:
2591 result = get_dev_status(srb, chip);
2592 break;
2593
2594 default:
2595 set_sense_type(chip, SCSI_LUN(srb),
2596 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2597 rtsx_trace(chip);
2598 return TRANSPORT_FAILED;
2599 }
2600
2601 return result;
2602}
2603
2604static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2605{
2606 u8 rtsx_status[16];
2607 int buf_len;
2608 unsigned int lun = SCSI_LUN(srb);
2609
2610 rtsx_status[0] = (u8)(chip->vendor_id >> 8);
2611 rtsx_status[1] = (u8)(chip->vendor_id);
2612
2613 rtsx_status[2] = (u8)(chip->product_id >> 8);
2614 rtsx_status[3] = (u8)(chip->product_id);
2615
2616 rtsx_status[4] = (u8)lun;
2617
2618 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2619 if (chip->lun2card[lun] == SD_CARD)
2620 rtsx_status[5] = 2;
2621 else
2622 rtsx_status[5] = 3;
2623 } else {
2624 if (chip->card_exist) {
2625 if (chip->card_exist & XD_CARD)
2626 rtsx_status[5] = 4;
2627 else if (chip->card_exist & SD_CARD)
2628 rtsx_status[5] = 2;
2629 else if (chip->card_exist & MS_CARD)
2630 rtsx_status[5] = 3;
2631 else
2632 rtsx_status[5] = 7;
2633 } else {
2634 rtsx_status[5] = 7;
2635 }
2636 }
2637
2638 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2639 rtsx_status[6] = 2;
2640 else
2641 rtsx_status[6] = 1;
2642
2643 rtsx_status[7] = (u8)(chip->product_id);
2644 rtsx_status[8] = chip->ic_version;
2645
2646 if (check_card_exist(chip, lun))
2647 rtsx_status[9] = 1;
2648 else
2649 rtsx_status[9] = 0;
2650
2651 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2652 rtsx_status[10] = 0;
2653 else
2654 rtsx_status[10] = 1;
2655
2656 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2657 if (chip->lun2card[lun] == SD_CARD)
2658 rtsx_status[11] = SD_CARD;
2659 else
2660 rtsx_status[11] = MS_CARD;
2661 } else {
2662 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD;
2663 }
2664
2665 if (check_card_ready(chip, lun))
2666 rtsx_status[12] = 1;
2667 else
2668 rtsx_status[12] = 0;
2669
2670 if (get_lun_card(chip, lun) == XD_CARD) {
2671 rtsx_status[13] = 0x40;
2672 } else if (get_lun_card(chip, lun) == SD_CARD) {
2673 struct sd_info *sd_card = &(chip->sd_card);
2674
2675 rtsx_status[13] = 0x20;
2676 if (CHK_SD(sd_card)) {
2677 if (CHK_SD_HCXC(sd_card))
2678 rtsx_status[13] |= 0x04;
2679 if (CHK_SD_HS(sd_card))
2680 rtsx_status[13] |= 0x02;
2681 } else {
2682 rtsx_status[13] |= 0x08;
2683 if (CHK_MMC_52M(sd_card))
2684 rtsx_status[13] |= 0x02;
2685 if (CHK_MMC_SECTOR_MODE(sd_card))
2686 rtsx_status[13] |= 0x04;
2687 }
2688 } else if (get_lun_card(chip, lun) == MS_CARD) {
2689 struct ms_info *ms_card = &(chip->ms_card);
2690
2691 if (CHK_MSPRO(ms_card)) {
2692 rtsx_status[13] = 0x38;
2693 if (CHK_HG8BIT(ms_card))
2694 rtsx_status[13] |= 0x04;
2695#ifdef SUPPORT_MSXC
2696 if (CHK_MSXC(ms_card))
2697 rtsx_status[13] |= 0x01;
2698#endif
2699 } else {
2700 rtsx_status[13] = 0x30;
2701 }
2702 } else {
2703 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) {
2704#ifdef SUPPORT_SDIO
2705 if (chip->sd_io && chip->sd_int)
2706 rtsx_status[13] = 0x60;
2707 else
2708 rtsx_status[13] = 0x70;
2709#else
2710 rtsx_status[13] = 0x70;
2711#endif
2712 } else {
2713 if (chip->lun2card[lun] == SD_CARD)
2714 rtsx_status[13] = 0x20;
2715 else
2716 rtsx_status[13] = 0x30;
2717 }
2718 }
2719
2720 rtsx_status[14] = 0x78;
2721 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2722 rtsx_status[15] = 0x83;
2723 else
2724 rtsx_status[15] = 0x82;
2725
2726 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(rtsx_status));
2727 rtsx_stor_set_xfer_buf(rtsx_status, buf_len, srb);
2728 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
2729
2730 return TRANSPORT_GOOD;
2731}
2732
2733static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2734{
2735 unsigned int lun = SCSI_LUN(srb);
2736 u8 card, bus_width;
2737
2738 if (!check_card_ready(chip, lun)) {
2739 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2740 rtsx_trace(chip);
2741 return TRANSPORT_FAILED;
2742 }
2743
2744 card = get_lun_card(chip, lun);
2745 if ((card == SD_CARD) || (card == MS_CARD)) {
2746 bus_width = chip->card_bus_width[lun];
2747 } else {
2748 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2749 rtsx_trace(chip);
2750 return TRANSPORT_FAILED;
2751 }
2752
2753 scsi_set_resid(srb, 0);
2754 rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
2755
2756 return TRANSPORT_GOOD;
2757}
2758
2759static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2760{
2761 int result;
2762 unsigned int lun = SCSI_LUN(srb);
2763 u8 gpio_dir;
2764
2765 if (CHECK_PID(chip, 0x5208) || CHECK_PID(chip, 0x5288)) {
2766 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2767 rtsx_trace(chip);
2768 return TRANSPORT_FAILED;
2769 }
2770
2771 rtsx_disable_aspm(chip);
2772
2773 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2774 rtsx_exit_ss(chip);
2775 wait_timeout(100);
2776 }
2777 rtsx_set_stat(chip, RTSX_STAT_RUN);
2778
2779 rtsx_force_power_on(chip, SSC_PDCTL);
2780
2781 rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir);
2782 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06);
2783
2784 switch (srb->cmnd[2]) {
2785 case SCSI_SPI_GETSTATUS:
2786 result = spi_get_status(srb, chip);
2787 break;
2788
2789 case SCSI_SPI_SETPARAMETER:
2790 result = spi_set_parameter(srb, chip);
2791 break;
2792
2793 case SCSI_SPI_READFALSHID:
2794 result = spi_read_flash_id(srb, chip);
2795 break;
2796
2797 case SCSI_SPI_READFLASH:
2798 result = spi_read_flash(srb, chip);
2799 break;
2800
2801 case SCSI_SPI_WRITEFLASH:
2802 result = spi_write_flash(srb, chip);
2803 break;
2804
2805 case SCSI_SPI_WRITEFLASHSTATUS:
2806 result = spi_write_flash_status(srb, chip);
2807 break;
2808
2809 case SCSI_SPI_ERASEFLASH:
2810 result = spi_erase_flash(srb, chip);
2811 break;
2812
2813 default:
2814 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2815
2816 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2817 rtsx_trace(chip);
2818 return TRANSPORT_FAILED;
2819 }
2820
2821 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2822
2823 if (result != STATUS_SUCCESS) {
2824 rtsx_trace(chip);
2825 return TRANSPORT_FAILED;
2826 }
2827
2828 return TRANSPORT_GOOD;
2829}
2830
2831static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2832{
2833 int result;
2834
2835 switch (srb->cmnd[1]) {
2836 case READ_STATUS:
2837 result = read_status(srb, chip);
2838 break;
2839
2840 case READ_MEM:
2841 result = read_mem(srb, chip);
2842 break;
2843
2844 case WRITE_MEM:
2845 result = write_mem(srb, chip);
2846 break;
2847
2848 case READ_EEPROM:
2849 result = read_eeprom(srb, chip);
2850 break;
2851
2852 case WRITE_EEPROM:
2853 result = write_eeprom(srb, chip);
2854 break;
2855
2856 case TOGGLE_GPIO:
2857 result = toggle_gpio_cmd(srb, chip);
2858 break;
2859
2860 case GET_SD_CSD:
2861 result = get_sd_csd(srb, chip);
2862 break;
2863
2864 case GET_BUS_WIDTH:
2865 result = get_card_bus_width(srb, chip);
2866 break;
2867
2868#ifdef _MSG_TRACE
2869 case TRACE_MSG:
2870 result = trace_msg_cmd(srb, chip);
2871 break;
2872#endif
2873
2874 case SCSI_APP_CMD:
2875 result = app_cmd(srb, chip);
2876 break;
2877
2878 case SPI_VENDOR_COMMAND:
2879 result = spi_vendor_cmd(srb, chip);
2880 break;
2881
2882 default:
2883 set_sense_type(chip, SCSI_LUN(srb),
2884 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2885 rtsx_trace(chip);
2886 return TRANSPORT_FAILED;
2887 }
2888
2889 return result;
2890}
2891
2892#if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
2893void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2894{
2895 unsigned int lun = SCSI_LUN(srb);
2896 u16 sec_cnt;
2897
2898 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10))
2899 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
2900 else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
2901 sec_cnt = srb->cmnd[4];
2902 if (sec_cnt == 0)
2903 sec_cnt = 256;
2904 } else
2905 return;
2906
2907 if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) {
2908 toggle_gpio(chip, LED_GPIO);
2909 chip->rw_cap[lun] = 0;
2910 } else {
2911 chip->rw_cap[lun] += sec_cnt;
2912 }
2913}
2914#endif
2915
2916static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2917{
2918 struct ms_info *ms_card = &(chip->ms_card);
2919 unsigned int lun = SCSI_LUN(srb);
2920 bool quick_format;
2921 int retval;
2922
2923 if (get_lun_card(chip, lun) != MS_CARD) {
2924 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2925 rtsx_trace(chip);
2926 return TRANSPORT_FAILED;
2927 }
2928
2929 if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47) ||
2930 (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D) ||
2931 (srb->cmnd[7] != 0x74)) {
2932 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2933 rtsx_trace(chip);
2934 return TRANSPORT_FAILED;
2935 }
2936
2937 rtsx_disable_aspm(chip);
2938
2939 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2940 rtsx_exit_ss(chip);
2941 wait_timeout(100);
2942
2943 if (!check_card_ready(chip, lun) ||
2944 (get_card_size(chip, lun) == 0)) {
2945 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2946 rtsx_trace(chip);
2947 return TRANSPORT_FAILED;
2948 }
2949 }
2950 rtsx_set_stat(chip, RTSX_STAT_RUN);
2951
2952 if (srb->cmnd[8] & 0x01)
2953 quick_format = false;
2954 else
2955 quick_format = true;
2956
2957 if (!(chip->card_ready & MS_CARD)) {
2958 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2959 rtsx_trace(chip);
2960 return TRANSPORT_FAILED;
2961 }
2962
2963 if (chip->card_wp & MS_CARD) {
2964 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2965 rtsx_trace(chip);
2966 return TRANSPORT_FAILED;
2967 }
2968
2969 if (!CHK_MSPRO(ms_card)) {
2970 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2971 rtsx_trace(chip);
2972 return TRANSPORT_FAILED;
2973 }
2974
2975 retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
2976 if (retval != STATUS_SUCCESS) {
2977 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
2978 rtsx_trace(chip);
2979 return TRANSPORT_FAILED;
2980 }
2981
2982 scsi_set_resid(srb, 0);
2983 return TRANSPORT_GOOD;
2984}
2985
2986#ifdef SUPPORT_PCGL_1P18
2987static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2988{
2989 struct ms_info *ms_card = &(chip->ms_card);
2990 unsigned int lun = SCSI_LUN(srb);
2991 u8 dev_info_id, data_len;
2992 u8 *buf;
2993 unsigned int buf_len;
2994 int i;
2995
2996 if (!check_card_ready(chip, lun)) {
2997 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2998 rtsx_trace(chip);
2999 return TRANSPORT_FAILED;
3000 }
3001 if (get_lun_card(chip, lun) != MS_CARD) {
3002 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3003 rtsx_trace(chip);
3004 return TRANSPORT_FAILED;
3005 }
3006
3007 if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) ||
3008 (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) ||
3009 (srb->cmnd[7] != 0x44)) {
3010 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3011 rtsx_trace(chip);
3012 return TRANSPORT_FAILED;
3013 }
3014
3015 dev_info_id = srb->cmnd[3];
3016 if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) ||
3017 (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) ||
3018 !CHK_MSPRO(ms_card)) {
3019 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3020 rtsx_trace(chip);
3021 return TRANSPORT_FAILED;
3022 }
3023
3024 if (dev_info_id == 0x15)
3025 buf_len = data_len = 0x3A;
3026 else
3027 buf_len = data_len = 0x6A;
3028
3029 buf = kmalloc(buf_len, GFP_KERNEL);
3030 if (!buf) {
3031 rtsx_trace(chip);
3032 return TRANSPORT_ERROR;
3033 }
3034
3035 i = 0;
3036
3037 buf[i++] = 0x00;
3038 buf[i++] = data_len;
3039
3040 if (CHK_MSXC(ms_card))
3041 buf[i++] = 0x03;
3042 else
3043 buf[i++] = 0x02;
3044
3045
3046 buf[i++] = 0x01;
3047
3048 buf[i++] = 0x00;
3049 buf[i++] = 0x00;
3050 buf[i++] = 0x00;
3051
3052 buf[i++] = 0x01;
3053
3054
3055
3056
3057 buf[i++] = dev_info_id;
3058
3059 if (dev_info_id == 0x15)
3060 data_len = 0x31;
3061 else
3062 data_len = 0x61;
3063
3064 buf[i++] = 0x00;
3065 buf[i++] = data_len;
3066
3067 buf[i++] = 0x80;
3068 if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
3069
3070 memcpy(buf + i, ms_card->raw_sys_info, 96);
3071 } else {
3072
3073 memcpy(buf + i, ms_card->raw_model_name, 48);
3074 }
3075
3076 rtsx_stor_set_xfer_buf(buf, buf_len, srb);
3077
3078 if (dev_info_id == 0x15)
3079 scsi_set_resid(srb, scsi_bufflen(srb) - 0x3C);
3080 else
3081 scsi_set_resid(srb, scsi_bufflen(srb) - 0x6C);
3082
3083 kfree(buf);
3084 return STATUS_SUCCESS;
3085}
3086#endif
3087
3088static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3089{
3090 int retval = TRANSPORT_ERROR;
3091
3092 if (srb->cmnd[2] == MS_FORMAT)
3093 retval = ms_format_cmnd(srb, chip);
3094#ifdef SUPPORT_PCGL_1P18
3095 else if (srb->cmnd[2] == GET_MS_INFORMATION)
3096 retval = get_ms_information(srb, chip);
3097#endif
3098
3099 return retval;
3100}
3101
3102#ifdef SUPPORT_CPRM
3103static int sd_extention_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3104{
3105 unsigned int lun = SCSI_LUN(srb);
3106 int result;
3107
3108 rtsx_disable_aspm(chip);
3109
3110 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3111 rtsx_exit_ss(chip);
3112 wait_timeout(100);
3113 }
3114 rtsx_set_stat(chip, RTSX_STAT_RUN);
3115
3116 sd_cleanup_work(chip);
3117
3118 if (!check_card_ready(chip, lun)) {
3119 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3120 rtsx_trace(chip);
3121 return TRANSPORT_FAILED;
3122 }
3123 if (get_lun_card(chip, lun) != SD_CARD) {
3124 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3125 rtsx_trace(chip);
3126 return TRANSPORT_FAILED;
3127 }
3128
3129 switch (srb->cmnd[0]) {
3130 case SD_PASS_THRU_MODE:
3131 result = sd_pass_thru_mode(srb, chip);
3132 break;
3133
3134 case SD_EXECUTE_NO_DATA:
3135 result = sd_execute_no_data(srb, chip);
3136 break;
3137
3138 case SD_EXECUTE_READ:
3139 result = sd_execute_read_data(srb, chip);
3140 break;
3141
3142 case SD_EXECUTE_WRITE:
3143 result = sd_execute_write_data(srb, chip);
3144 break;
3145
3146 case SD_GET_RSP:
3147 result = sd_get_cmd_rsp(srb, chip);
3148 break;
3149
3150 case SD_HW_RST:
3151 result = sd_hw_rst(srb, chip);
3152 break;
3153
3154 default:
3155 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3156 rtsx_trace(chip);
3157 return TRANSPORT_FAILED;
3158 }
3159
3160 return result;
3161}
3162#endif
3163
3164#ifdef SUPPORT_MAGIC_GATE
3165static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3166{
3167 struct ms_info *ms_card = &(chip->ms_card);
3168 unsigned int lun = SCSI_LUN(srb);
3169 int retval;
3170 u8 key_format;
3171
3172 rtsx_disable_aspm(chip);
3173
3174 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3175 rtsx_exit_ss(chip);
3176 wait_timeout(100);
3177 }
3178 rtsx_set_stat(chip, RTSX_STAT_RUN);
3179
3180 ms_cleanup_work(chip);
3181
3182 if (!check_card_ready(chip, lun)) {
3183 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3184 rtsx_trace(chip);
3185 return TRANSPORT_FAILED;
3186 }
3187 if (get_lun_card(chip, lun) != MS_CARD) {
3188 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3189 rtsx_trace(chip);
3190 return TRANSPORT_FAILED;
3191 }
3192
3193 if (srb->cmnd[7] != KC_MG_R_PRO) {
3194 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3195 rtsx_trace(chip);
3196 return TRANSPORT_FAILED;
3197 }
3198
3199 if (!CHK_MSPRO(ms_card)) {
3200 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3201 rtsx_trace(chip);
3202 return TRANSPORT_FAILED;
3203 }
3204
3205 key_format = srb->cmnd[10] & 0x3F;
3206 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3207
3208 switch (key_format) {
3209 case KF_GET_LOC_EKB:
3210 if ((scsi_bufflen(srb) == 0x41C) &&
3211 (srb->cmnd[8] == 0x04) &&
3212 (srb->cmnd[9] == 0x1C)) {
3213 retval = mg_get_local_EKB(srb, chip);
3214 if (retval != STATUS_SUCCESS) {
3215 rtsx_trace(chip);
3216 return TRANSPORT_FAILED;
3217 }
3218
3219 } else {
3220 set_sense_type(chip, lun,
3221 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3222 rtsx_trace(chip);
3223 return TRANSPORT_FAILED;
3224 }
3225 break;
3226
3227 case KF_RSP_CHG:
3228 if ((scsi_bufflen(srb) == 0x24) &&
3229 (srb->cmnd[8] == 0x00) &&
3230 (srb->cmnd[9] == 0x24)) {
3231 retval = mg_get_rsp_chg(srb, chip);
3232 if (retval != STATUS_SUCCESS) {
3233 rtsx_trace(chip);
3234 return TRANSPORT_FAILED;
3235 }
3236
3237 } else {
3238 set_sense_type(chip, lun,
3239 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3240 rtsx_trace(chip);
3241 return TRANSPORT_FAILED;
3242 }
3243 break;
3244
3245 case KF_GET_ICV:
3246 ms_card->mg_entry_num = srb->cmnd[5];
3247 if ((scsi_bufflen(srb) == 0x404) &&
3248 (srb->cmnd[8] == 0x04) &&
3249 (srb->cmnd[9] == 0x04) &&
3250 (srb->cmnd[2] == 0x00) &&
3251 (srb->cmnd[3] == 0x00) &&
3252 (srb->cmnd[4] == 0x00) &&
3253 (srb->cmnd[5] < 32)) {
3254 retval = mg_get_ICV(srb, chip);
3255 if (retval != STATUS_SUCCESS) {
3256 rtsx_trace(chip);
3257 return TRANSPORT_FAILED;
3258 }
3259
3260 } else {
3261 set_sense_type(chip, lun,
3262 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3263 rtsx_trace(chip);
3264 return TRANSPORT_FAILED;
3265 }
3266 break;
3267
3268 default:
3269 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3270 rtsx_trace(chip);
3271 return TRANSPORT_FAILED;
3272 }
3273
3274 scsi_set_resid(srb, 0);
3275 return TRANSPORT_GOOD;
3276}
3277
3278static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3279{
3280 struct ms_info *ms_card = &(chip->ms_card);
3281 unsigned int lun = SCSI_LUN(srb);
3282 int retval;
3283 u8 key_format;
3284
3285 rtsx_disable_aspm(chip);
3286
3287 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3288 rtsx_exit_ss(chip);
3289 wait_timeout(100);
3290 }
3291 rtsx_set_stat(chip, RTSX_STAT_RUN);
3292
3293 ms_cleanup_work(chip);
3294
3295 if (!check_card_ready(chip, lun)) {
3296 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3297 rtsx_trace(chip);
3298 return TRANSPORT_FAILED;
3299 }
3300 if (check_card_wp(chip, lun)) {
3301 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
3302 rtsx_trace(chip);
3303 return TRANSPORT_FAILED;
3304 }
3305 if (get_lun_card(chip, lun) != MS_CARD) {
3306 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3307 rtsx_trace(chip);
3308 return TRANSPORT_FAILED;
3309 }
3310
3311 if (srb->cmnd[7] != KC_MG_R_PRO) {
3312 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3313 rtsx_trace(chip);
3314 return TRANSPORT_FAILED;
3315 }
3316
3317 if (!CHK_MSPRO(ms_card)) {
3318 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3319 rtsx_trace(chip);
3320 return TRANSPORT_FAILED;
3321 }
3322
3323 key_format = srb->cmnd[10] & 0x3F;
3324 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3325
3326 switch (key_format) {
3327 case KF_SET_LEAF_ID:
3328 if ((scsi_bufflen(srb) == 0x0C) &&
3329 (srb->cmnd[8] == 0x00) &&
3330 (srb->cmnd[9] == 0x0C)) {
3331 retval = mg_set_leaf_id(srb, chip);
3332 if (retval != STATUS_SUCCESS) {
3333 rtsx_trace(chip);
3334 return TRANSPORT_FAILED;
3335 }
3336
3337 } else {
3338 set_sense_type(chip, lun,
3339 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3340 rtsx_trace(chip);
3341 return TRANSPORT_FAILED;
3342 }
3343 break;
3344
3345 case KF_CHG_HOST:
3346 if ((scsi_bufflen(srb) == 0x0C) &&
3347 (srb->cmnd[8] == 0x00) &&
3348 (srb->cmnd[9] == 0x0C)) {
3349 retval = mg_chg(srb, chip);
3350 if (retval != STATUS_SUCCESS) {
3351 rtsx_trace(chip);
3352 return TRANSPORT_FAILED;
3353 }
3354
3355 } else {
3356 set_sense_type(chip, lun,
3357 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3358 rtsx_trace(chip);
3359 return TRANSPORT_FAILED;
3360 }
3361 break;
3362
3363 case KF_RSP_HOST:
3364 if ((scsi_bufflen(srb) == 0x0C) &&
3365 (srb->cmnd[8] == 0x00) &&
3366 (srb->cmnd[9] == 0x0C)) {
3367 retval = mg_rsp(srb, chip);
3368 if (retval != STATUS_SUCCESS) {
3369 rtsx_trace(chip);
3370 return TRANSPORT_FAILED;
3371 }
3372
3373 } else {
3374 set_sense_type(chip, lun,
3375 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3376 rtsx_trace(chip);
3377 return TRANSPORT_FAILED;
3378 }
3379 break;
3380
3381 case KF_SET_ICV:
3382 ms_card->mg_entry_num = srb->cmnd[5];
3383 if ((scsi_bufflen(srb) == 0x404) &&
3384 (srb->cmnd[8] == 0x04) &&
3385 (srb->cmnd[9] == 0x04) &&
3386 (srb->cmnd[2] == 0x00) &&
3387 (srb->cmnd[3] == 0x00) &&
3388 (srb->cmnd[4] == 0x00) &&
3389 (srb->cmnd[5] < 32)) {
3390 retval = mg_set_ICV(srb, chip);
3391 if (retval != STATUS_SUCCESS) {
3392 rtsx_trace(chip);
3393 return TRANSPORT_FAILED;
3394 }
3395
3396 } else {
3397 set_sense_type(chip, lun,
3398 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3399 rtsx_trace(chip);
3400 return TRANSPORT_FAILED;
3401 }
3402 break;
3403
3404 default:
3405 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3406 rtsx_trace(chip);
3407 return TRANSPORT_FAILED;
3408 }
3409
3410 scsi_set_resid(srb, 0);
3411 return TRANSPORT_GOOD;
3412}
3413#endif
3414
3415int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3416{
3417#ifdef SUPPORT_SD_LOCK
3418 struct sd_info *sd_card = &(chip->sd_card);
3419#endif
3420 struct ms_info *ms_card = &(chip->ms_card);
3421 unsigned int lun = SCSI_LUN(srb);
3422 int result;
3423
3424#ifdef SUPPORT_SD_LOCK
3425 if (sd_card->sd_erase_status) {
3426
3427
3428
3429 if (!((srb->cmnd[0] == VENDOR_CMND) &&
3430 (srb->cmnd[1] == SCSI_APP_CMD) &&
3431 (srb->cmnd[2] == GET_DEV_STATUS)) &&
3432 (srb->cmnd[0] != REQUEST_SENSE)) {
3433
3434 set_sense_data(chip, lun, CUR_ERR,
3435 0x02, 0, 0x04, 0x04, 0, 0);
3436 rtsx_trace(chip);
3437 return TRANSPORT_FAILED;
3438 }
3439 }
3440#endif
3441
3442 if ((get_lun_card(chip, lun) == MS_CARD) &&
3443 (ms_card->format_status == FORMAT_IN_PROGRESS)) {
3444 if ((srb->cmnd[0] != REQUEST_SENSE) &&
3445 (srb->cmnd[0] != INQUIRY)) {
3446
3447 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
3448 0, (u16)(ms_card->progress));
3449 rtsx_trace(chip);
3450 return TRANSPORT_FAILED;
3451 }
3452 }
3453
3454 switch (srb->cmnd[0]) {
3455 case READ_10:
3456 case WRITE_10:
3457 case READ_6:
3458 case WRITE_6:
3459 result = read_write(srb, chip);
3460#if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
3461 led_shine(srb, chip);
3462#endif
3463 break;
3464
3465 case TEST_UNIT_READY:
3466 result = test_unit_ready(srb, chip);
3467 break;
3468
3469 case INQUIRY:
3470 result = inquiry(srb, chip);
3471 break;
3472
3473 case READ_CAPACITY:
3474 result = read_capacity(srb, chip);
3475 break;
3476
3477 case START_STOP:
3478 result = start_stop_unit(srb, chip);
3479 break;
3480
3481 case ALLOW_MEDIUM_REMOVAL:
3482 result = allow_medium_removal(srb, chip);
3483 break;
3484
3485 case REQUEST_SENSE:
3486 result = request_sense(srb, chip);
3487 break;
3488
3489 case MODE_SENSE:
3490 case MODE_SENSE_10:
3491 result = mode_sense(srb, chip);
3492 break;
3493
3494 case 0x23:
3495 result = read_format_capacity(srb, chip);
3496 break;
3497
3498 case VENDOR_CMND:
3499 result = vendor_cmnd(srb, chip);
3500 break;
3501
3502 case MS_SP_CMND:
3503 result = ms_sp_cmnd(srb, chip);
3504 break;
3505
3506#ifdef SUPPORT_CPRM
3507 case SD_PASS_THRU_MODE:
3508 case SD_EXECUTE_NO_DATA:
3509 case SD_EXECUTE_READ:
3510 case SD_EXECUTE_WRITE:
3511 case SD_GET_RSP:
3512 case SD_HW_RST:
3513 result = sd_extention_cmnd(srb, chip);
3514 break;
3515#endif
3516
3517#ifdef SUPPORT_MAGIC_GATE
3518 case CMD_MSPRO_MG_RKEY:
3519 result = mg_report_key(srb, chip);
3520 break;
3521
3522 case CMD_MSPRO_MG_SKEY:
3523 result = mg_send_key(srb, chip);
3524 break;
3525#endif
3526
3527 case FORMAT_UNIT:
3528 case MODE_SELECT:
3529 case VERIFY:
3530 result = TRANSPORT_GOOD;
3531 break;
3532
3533 default:
3534 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3535 result = TRANSPORT_FAILED;
3536 }
3537
3538 return result;
3539}
3540
