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) >> 4;
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 return TRANSPORT_ERROR;
512 }
513
514#ifdef SUPPORT_MAGIC_GATE
515 if ((chip->mspro_formatter_enable) &&
516 (chip->lun2card[lun] & MS_CARD))
517#else
518 if (chip->mspro_formatter_enable)
519#endif
520 if (!card || (card == MS_CARD))
521 pro_formatter_flag = true;
522
523 if (pro_formatter_flag) {
524 if (scsi_bufflen(srb) < 56)
525 sendbytes = (unsigned char)(scsi_bufflen(srb));
526 else
527 sendbytes = 56;
528
529 } else {
530 if (scsi_bufflen(srb) < 36)
531 sendbytes = (unsigned char)(scsi_bufflen(srb));
532 else
533 sendbytes = 36;
534 }
535
536 if (sendbytes > 8) {
537 memcpy(buf, inquiry_buf, 8);
538 strncpy(buf + 8, inquiry_string, sendbytes - 8);
539 if (pro_formatter_flag) {
540
541 buf[4] = 0x33;
542 }
543 } else {
544 memcpy(buf, inquiry_buf, sendbytes);
545 }
546
547 if (pro_formatter_flag) {
548 if (sendbytes > 36)
549 memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36);
550 }
551
552 scsi_set_resid(srb, 0);
553
554 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
555 vfree(buf);
556
557 return TRANSPORT_GOOD;
558}
559
560static int start_stop_unit(struct scsi_cmnd *srb, struct rtsx_chip *chip)
561{
562 unsigned int lun = SCSI_LUN(srb);
563
564 scsi_set_resid(srb, scsi_bufflen(srb));
565
566 if (srb->cmnd[1] == 1)
567 return TRANSPORT_GOOD;
568
569 switch (srb->cmnd[0x4]) {
570 case STOP_MEDIUM:
571
572 return TRANSPORT_GOOD;
573
574 case UNLOAD_MEDIUM:
575
576 if (check_card_ready(chip, lun))
577 eject_card(chip, lun);
578 return TRANSPORT_GOOD;
579
580 case MAKE_MEDIUM_READY:
581 case LOAD_MEDIUM:
582 if (check_card_ready(chip, lun))
583 return TRANSPORT_GOOD;
584 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
585 return TRANSPORT_FAILED;
586
587 break;
588 }
589
590 return TRANSPORT_ERROR;
591}
592
593static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip)
594{
595 int prevent;
596
597 prevent = srb->cmnd[4] & 0x1;
598
599 scsi_set_resid(srb, 0);
600
601 if (prevent) {
602 set_sense_type(chip, SCSI_LUN(srb),
603 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
604 return TRANSPORT_FAILED;
605 }
606
607 return TRANSPORT_GOOD;
608}
609
610static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
611{
612 struct sense_data_t *sense;
613 unsigned int lun = SCSI_LUN(srb);
614 struct ms_info *ms_card = &chip->ms_card;
615 unsigned char *tmp, *buf;
616
617 sense = &chip->sense_buffer[lun];
618
619 if ((get_lun_card(chip, lun) == MS_CARD) &&
620 ms_card->pro_under_formatting) {
621 if (ms_card->format_status == FORMAT_SUCCESS) {
622 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
623 ms_card->pro_under_formatting = 0;
624 ms_card->progress = 0;
625 } else if (ms_card->format_status == FORMAT_IN_PROGRESS) {
626
627 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
628 0, (u16)(ms_card->progress));
629 } else {
630
631 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
632 ms_card->pro_under_formatting = 0;
633 ms_card->progress = 0;
634 }
635
636 rtsx_set_stat(chip, RTSX_STAT_RUN);
637 }
638
639 buf = vmalloc(scsi_bufflen(srb));
640 if (!buf) {
641 return TRANSPORT_ERROR;
642 }
643
644 tmp = (unsigned char *)sense;
645 memcpy(buf, tmp, scsi_bufflen(srb));
646
647 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
648 vfree(buf);
649
650 scsi_set_resid(srb, 0);
651
652 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
653 return TRANSPORT_GOOD;
654}
655
656static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd,
657 int lun, u8 *buf, int buf_len)
658{
659 struct ms_info *ms_card = &chip->ms_card;
660 int sys_info_offset;
661 int data_size = buf_len;
662 bool support_format = false;
663 int i = 0;
664
665 if (cmd == MODE_SENSE) {
666 sys_info_offset = 8;
667 if (data_size > 0x68)
668 data_size = 0x68;
669
670 buf[i++] = 0x67;
671 } else {
672 sys_info_offset = 12;
673 if (data_size > 0x6C)
674 data_size = 0x6C;
675
676 buf[i++] = 0x00;
677 buf[i++] = 0x6A;
678 }
679
680
681 if (check_card_ready(chip, lun)) {
682 if (CHK_MSXC(ms_card)) {
683 support_format = true;
684 buf[i++] = 0x40;
685 } else if (CHK_MSPRO(ms_card)) {
686 support_format = true;
687 buf[i++] = 0x20;
688 } else {
689 buf[i++] = 0x10;
690 }
691
692
693 if (check_card_wp(chip, lun))
694 buf[i++] = 0x80;
695 else
696 buf[i++] = 0x00;
697
698 } else {
699 buf[i++] = 0x00;
700 buf[i++] = 0x00;
701 }
702
703 buf[i++] = 0x00;
704
705 if (cmd == MODE_SENSE_10) {
706 buf[i++] = 0x00;
707 buf[i++] = 0x00;
708 buf[i++] = 0x00;
709
710
711 if (data_size >= 9)
712 buf[i++] = 0x20;
713 if (data_size >= 10)
714 buf[i++] = 0x62;
715 if (data_size >= 11)
716 buf[i++] = 0x00;
717 if (data_size >= 12) {
718 if (support_format)
719 buf[i++] = 0xC0;
720 else
721 buf[i++] = 0x00;
722 }
723 } else {
724
725 if (data_size >= 5)
726 buf[i++] = 0x20;
727 if (data_size >= 6)
728 buf[i++] = 0x62;
729 if (data_size >= 7)
730 buf[i++] = 0x00;
731 if (data_size >= 8) {
732 if (support_format)
733 buf[i++] = 0xC0;
734 else
735 buf[i++] = 0x00;
736 }
737 }
738
739 if (data_size > sys_info_offset) {
740
741 int len = data_size - sys_info_offset;
742
743 len = (len < 96) ? len : 96;
744
745 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len);
746 }
747}
748
749static int mode_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
750{
751 unsigned int lun = SCSI_LUN(srb);
752 unsigned int data_size;
753 int status;
754 bool pro_formatter_flag;
755 unsigned char page_code, *buf;
756 u8 card = get_lun_card(chip, lun);
757
758#ifndef SUPPORT_MAGIC_GATE
759 if (!check_card_ready(chip, lun)) {
760 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
761 scsi_set_resid(srb, scsi_bufflen(srb));
762 return TRANSPORT_FAILED;
763 }
764#endif
765
766 pro_formatter_flag = false;
767 data_size = 8;
768#ifdef SUPPORT_MAGIC_GATE
769 if ((chip->lun2card[lun] & MS_CARD)) {
770 if (!card || (card == MS_CARD)) {
771 data_size = 108;
772 if (chip->mspro_formatter_enable)
773 pro_formatter_flag = true;
774 }
775 }
776#else
777 if (card == MS_CARD) {
778 if (chip->mspro_formatter_enable) {
779 pro_formatter_flag = true;
780 data_size = 108;
781 }
782 }
783#endif
784
785 buf = kmalloc(data_size, GFP_KERNEL);
786 if (!buf) {
787 return TRANSPORT_ERROR;
788 }
789
790 page_code = srb->cmnd[2] & 0x3f;
791
792 if ((page_code == 0x3F) || (page_code == 0x1C) ||
793 (page_code == 0x00) ||
794 (pro_formatter_flag && (page_code == 0x20))) {
795 if (srb->cmnd[0] == MODE_SENSE) {
796 if ((page_code == 0x3F) || (page_code == 0x20)) {
797 ms_mode_sense(chip, srb->cmnd[0],
798 lun, buf, data_size);
799 } else {
800 data_size = 4;
801 buf[0] = 0x03;
802 buf[1] = 0x00;
803 if (check_card_wp(chip, lun))
804 buf[2] = 0x80;
805 else
806 buf[2] = 0x00;
807
808 buf[3] = 0x00;
809 }
810 } else {
811 if ((page_code == 0x3F) || (page_code == 0x20)) {
812 ms_mode_sense(chip, srb->cmnd[0],
813 lun, buf, data_size);
814 } else {
815 data_size = 8;
816 buf[0] = 0x00;
817 buf[1] = 0x06;
818 buf[2] = 0x00;
819 if (check_card_wp(chip, lun))
820 buf[3] = 0x80;
821 else
822 buf[3] = 0x00;
823 buf[4] = 0x00;
824 buf[5] = 0x00;
825 buf[6] = 0x00;
826 buf[7] = 0x00;
827 }
828 }
829 status = TRANSPORT_GOOD;
830 } else {
831 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
832 scsi_set_resid(srb, scsi_bufflen(srb));
833 status = TRANSPORT_FAILED;
834 }
835
836 if (status == TRANSPORT_GOOD) {
837 unsigned int len = min_t(unsigned int, scsi_bufflen(srb),
838 data_size);
839 rtsx_stor_set_xfer_buf(buf, len, srb);
840 scsi_set_resid(srb, scsi_bufflen(srb) - len);
841 }
842 kfree(buf);
843
844 return status;
845}
846
847static int read_write(struct scsi_cmnd *srb, struct rtsx_chip *chip)
848{
849#ifdef SUPPORT_SD_LOCK
850 struct sd_info *sd_card = &chip->sd_card;
851#endif
852 unsigned int lun = SCSI_LUN(srb);
853 int retval;
854 u32 start_sec;
855 u16 sec_cnt;
856
857 rtsx_disable_aspm(chip);
858
859 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
860 rtsx_exit_ss(chip);
861 wait_timeout(100);
862 }
863 rtsx_set_stat(chip, RTSX_STAT_RUN);
864
865 if (!check_card_ready(chip, lun) || (get_card_size(chip, lun) == 0)) {
866 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
867 return TRANSPORT_FAILED;
868 }
869
870 if (!(CHK_BIT(chip->lun_mc, lun))) {
871 SET_BIT(chip->lun_mc, lun);
872 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
873 return TRANSPORT_FAILED;
874 }
875
876#ifdef SUPPORT_SD_LOCK
877 if (sd_card->sd_erase_status) {
878
879
880
881 dev_dbg(rtsx_dev(chip), "SD card being erased!\n");
882 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
883 return TRANSPORT_FAILED;
884 }
885
886 if (get_lun_card(chip, lun) == SD_CARD) {
887 if (sd_card->sd_lock_status & SD_LOCKED) {
888 dev_dbg(rtsx_dev(chip), "SD card locked!\n");
889 set_sense_type(chip, lun,
890 SENSE_TYPE_MEDIA_READ_FORBIDDEN);
891 return TRANSPORT_FAILED;
892 }
893 }
894#endif
895
896 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
897 start_sec = ((u32)srb->cmnd[2] << 24) |
898 ((u32)srb->cmnd[3] << 16) |
899 ((u32)srb->cmnd[4] << 8) | ((u32)srb->cmnd[5]);
900 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
901 } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
902 start_sec = ((u32)(srb->cmnd[1] & 0x1F) << 16) |
903 ((u32)srb->cmnd[2] << 8) | ((u32)srb->cmnd[3]);
904 sec_cnt = srb->cmnd[4];
905 if (sec_cnt == 0)
906 sec_cnt = 256;
907 } else if ((srb->cmnd[0] == VENDOR_CMND) &&
908 (srb->cmnd[1] == SCSI_APP_CMD) &&
909 ((srb->cmnd[2] == PP_READ10) || (srb->cmnd[2] == PP_WRITE10))) {
910 start_sec = ((u32)srb->cmnd[4] << 24) |
911 ((u32)srb->cmnd[5] << 16) |
912 ((u32)srb->cmnd[6] << 8) | ((u32)srb->cmnd[7]);
913 sec_cnt = ((u16)(srb->cmnd[9]) << 8) | srb->cmnd[10];
914 } else {
915 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
916 return TRANSPORT_FAILED;
917 }
918
919
920
921
922
923 if ((start_sec > get_card_size(chip, lun)) ||
924 ((start_sec + sec_cnt) > get_card_size(chip, lun))) {
925 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE);
926 return TRANSPORT_FAILED;
927 }
928
929 if (sec_cnt == 0) {
930 scsi_set_resid(srb, 0);
931 return TRANSPORT_GOOD;
932 }
933
934 if (chip->rw_fail_cnt[lun] == 3) {
935 dev_dbg(rtsx_dev(chip), "read/write fail three times in succession\n");
936 if (srb->sc_data_direction == DMA_FROM_DEVICE)
937 set_sense_type(chip, lun,
938 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
939 else
940 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
941
942 return TRANSPORT_FAILED;
943 }
944
945 if (srb->sc_data_direction == DMA_TO_DEVICE) {
946 if (check_card_wp(chip, lun)) {
947 dev_dbg(rtsx_dev(chip), "Write protected card!\n");
948 set_sense_type(chip, lun,
949 SENSE_TYPE_MEDIA_WRITE_PROTECT);
950 return TRANSPORT_FAILED;
951 }
952 }
953
954 retval = card_rw(srb, chip, start_sec, sec_cnt);
955 if (retval != STATUS_SUCCESS) {
956 if (chip->need_release & chip->lun2card[lun]) {
957 chip->rw_fail_cnt[lun] = 0;
958 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
959 } else {
960 chip->rw_fail_cnt[lun]++;
961 if (srb->sc_data_direction == DMA_FROM_DEVICE)
962 set_sense_type
963 (chip, lun,
964 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
965 else
966 set_sense_type(chip, lun,
967 SENSE_TYPE_MEDIA_WRITE_ERR);
968 }
969 retval = TRANSPORT_FAILED;
970 goto exit;
971 } else {
972 chip->rw_fail_cnt[lun] = 0;
973 retval = TRANSPORT_GOOD;
974 }
975
976 scsi_set_resid(srb, 0);
977
978exit:
979 return retval;
980}
981
982static int read_format_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
983{
984 unsigned char *buf;
985 unsigned int lun = SCSI_LUN(srb);
986 unsigned int buf_len;
987 u8 card = get_lun_card(chip, lun);
988 u32 card_size;
989 int desc_cnt;
990 int i = 0;
991
992 if (!check_card_ready(chip, lun)) {
993 if (!chip->mspro_formatter_enable) {
994 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
995 return TRANSPORT_FAILED;
996 }
997 }
998
999 buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12;
1000
1001 buf = kmalloc(buf_len, GFP_KERNEL);
1002 if (!buf) {
1003 return TRANSPORT_ERROR;
1004 }
1005
1006 buf[i++] = 0;
1007 buf[i++] = 0;
1008 buf[i++] = 0;
1009
1010
1011 if ((buf_len > 12) && chip->mspro_formatter_enable &&
1012 (chip->lun2card[lun] & MS_CARD) &&
1013 (!card || (card == MS_CARD))) {
1014 buf[i++] = 0x10;
1015 desc_cnt = 2;
1016 } else {
1017 buf[i++] = 0x08;
1018 desc_cnt = 1;
1019 }
1020
1021 while (desc_cnt) {
1022 if (check_card_ready(chip, lun)) {
1023 card_size = get_card_size(chip, lun);
1024 buf[i++] = (unsigned char)(card_size >> 24);
1025 buf[i++] = (unsigned char)(card_size >> 16);
1026 buf[i++] = (unsigned char)(card_size >> 8);
1027 buf[i++] = (unsigned char)card_size;
1028
1029 if (desc_cnt == 2)
1030 buf[i++] = 2;
1031 else
1032 buf[i++] = 0;
1033 } else {
1034 buf[i++] = 0xFF;
1035 buf[i++] = 0xFF;
1036 buf[i++] = 0xFF;
1037 buf[i++] = 0xFF;
1038
1039 if (desc_cnt == 2)
1040 buf[i++] = 3;
1041 else
1042 buf[i++] = 0;
1043 }
1044
1045 buf[i++] = 0x00;
1046 buf[i++] = 0x02;
1047 buf[i++] = 0x00;
1048
1049 desc_cnt--;
1050 }
1051
1052 buf_len = min_t(unsigned int, scsi_bufflen(srb), buf_len);
1053 rtsx_stor_set_xfer_buf(buf, buf_len, srb);
1054 kfree(buf);
1055
1056 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1057
1058 return TRANSPORT_GOOD;
1059}
1060
1061static int read_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1062{
1063 unsigned char *buf;
1064 unsigned int lun = SCSI_LUN(srb);
1065 u32 card_size;
1066
1067 if (!check_card_ready(chip, lun)) {
1068 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1069 return TRANSPORT_FAILED;
1070 }
1071
1072 if (!(CHK_BIT(chip->lun_mc, lun))) {
1073 SET_BIT(chip->lun_mc, lun);
1074 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
1075 return TRANSPORT_FAILED;
1076 }
1077
1078 buf = kmalloc(8, GFP_KERNEL);
1079 if (!buf) {
1080 return TRANSPORT_ERROR;
1081 }
1082
1083 card_size = get_card_size(chip, lun);
1084 buf[0] = (unsigned char)((card_size - 1) >> 24);
1085 buf[1] = (unsigned char)((card_size - 1) >> 16);
1086 buf[2] = (unsigned char)((card_size - 1) >> 8);
1087 buf[3] = (unsigned char)(card_size - 1);
1088
1089 buf[4] = 0x00;
1090 buf[5] = 0x00;
1091 buf[6] = 0x02;
1092 buf[7] = 0x00;
1093
1094 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1095 kfree(buf);
1096
1097 scsi_set_resid(srb, 0);
1098
1099 return TRANSPORT_GOOD;
1100}
1101
1102static int read_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1103{
1104 unsigned short len, i;
1105 int retval;
1106 u8 *buf;
1107
1108 rtsx_disable_aspm(chip);
1109
1110 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1111 rtsx_exit_ss(chip);
1112 wait_timeout(100);
1113 }
1114 rtsx_set_stat(chip, RTSX_STAT_RUN);
1115
1116 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1117
1118 buf = vmalloc(len);
1119 if (!buf) {
1120 return TRANSPORT_ERROR;
1121 }
1122
1123 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1124 if (retval != STATUS_SUCCESS) {
1125 vfree(buf);
1126 set_sense_type(chip, SCSI_LUN(srb),
1127 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1128 return TRANSPORT_FAILED;
1129 }
1130
1131 for (i = 0; i < len; i++) {
1132 retval = spi_read_eeprom(chip, i, buf + i);
1133 if (retval != STATUS_SUCCESS) {
1134 vfree(buf);
1135 set_sense_type(chip, SCSI_LUN(srb),
1136 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1137 return TRANSPORT_FAILED;
1138 }
1139 }
1140
1141 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1142 rtsx_stor_set_xfer_buf(buf, len, srb);
1143 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1144
1145 vfree(buf);
1146
1147 return TRANSPORT_GOOD;
1148}
1149
1150static int write_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1151{
1152 unsigned short len, i;
1153 int retval;
1154 u8 *buf;
1155
1156 rtsx_disable_aspm(chip);
1157
1158 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1159 rtsx_exit_ss(chip);
1160 wait_timeout(100);
1161 }
1162 rtsx_set_stat(chip, RTSX_STAT_RUN);
1163
1164 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1165
1166 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1167 if (retval != STATUS_SUCCESS) {
1168 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1169 return TRANSPORT_FAILED;
1170 }
1171
1172 if (len == 511) {
1173 retval = spi_erase_eeprom_chip(chip);
1174 if (retval != STATUS_SUCCESS) {
1175 set_sense_type(chip, SCSI_LUN(srb),
1176 SENSE_TYPE_MEDIA_WRITE_ERR);
1177 return TRANSPORT_FAILED;
1178 }
1179 } else {
1180 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1181 len);
1182 buf = vmalloc(len);
1183 if (!buf) {
1184 return TRANSPORT_ERROR;
1185 }
1186
1187 rtsx_stor_get_xfer_buf(buf, len, srb);
1188 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1189
1190 for (i = 0; i < len; i++) {
1191 retval = spi_write_eeprom(chip, i, buf[i]);
1192 if (retval != STATUS_SUCCESS) {
1193 vfree(buf);
1194 set_sense_type(chip, SCSI_LUN(srb),
1195 SENSE_TYPE_MEDIA_WRITE_ERR);
1196 return TRANSPORT_FAILED;
1197 }
1198 }
1199
1200 vfree(buf);
1201 }
1202
1203 return TRANSPORT_GOOD;
1204}
1205
1206static int read_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1207{
1208 unsigned short addr, len, i;
1209 int retval;
1210 u8 *buf;
1211
1212 rtsx_disable_aspm(chip);
1213
1214 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1215 rtsx_exit_ss(chip);
1216 wait_timeout(100);
1217 }
1218 rtsx_set_stat(chip, RTSX_STAT_RUN);
1219
1220 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1221 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1222
1223 if (addr < 0xFC00) {
1224 set_sense_type(chip, SCSI_LUN(srb),
1225 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1226 return TRANSPORT_FAILED;
1227 }
1228
1229 buf = vmalloc(len);
1230 if (!buf) {
1231 return TRANSPORT_ERROR;
1232 }
1233
1234 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1235 if (retval != STATUS_SUCCESS) {
1236 vfree(buf);
1237 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1238 return TRANSPORT_FAILED;
1239 }
1240
1241 for (i = 0; i < len; i++) {
1242 retval = rtsx_read_register(chip, addr + i, buf + i);
1243 if (retval != STATUS_SUCCESS) {
1244 vfree(buf);
1245 set_sense_type(chip, SCSI_LUN(srb),
1246 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1247 return TRANSPORT_FAILED;
1248 }
1249 }
1250
1251 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1252 rtsx_stor_set_xfer_buf(buf, len, srb);
1253 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1254
1255 vfree(buf);
1256
1257 return TRANSPORT_GOOD;
1258}
1259
1260static int write_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1261{
1262 unsigned short addr, len, i;
1263 int retval;
1264 u8 *buf;
1265
1266 rtsx_disable_aspm(chip);
1267
1268 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1269 rtsx_exit_ss(chip);
1270 wait_timeout(100);
1271 }
1272 rtsx_set_stat(chip, RTSX_STAT_RUN);
1273
1274 addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1275 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1276
1277 if (addr < 0xFC00) {
1278 set_sense_type(chip, SCSI_LUN(srb),
1279 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1280 return TRANSPORT_FAILED;
1281 }
1282
1283 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1284 buf = vmalloc(len);
1285 if (!buf) {
1286 return TRANSPORT_ERROR;
1287 }
1288
1289 rtsx_stor_get_xfer_buf(buf, len, srb);
1290 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1291
1292 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1293 if (retval != STATUS_SUCCESS) {
1294 vfree(buf);
1295 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1296 return TRANSPORT_FAILED;
1297 }
1298
1299 for (i = 0; i < len; i++) {
1300 retval = rtsx_write_register(chip, addr + i, 0xFF, buf[i]);
1301 if (retval != STATUS_SUCCESS) {
1302 vfree(buf);
1303 set_sense_type(chip, SCSI_LUN(srb),
1304 SENSE_TYPE_MEDIA_WRITE_ERR);
1305 return TRANSPORT_FAILED;
1306 }
1307 }
1308
1309 vfree(buf);
1310
1311 return TRANSPORT_GOOD;
1312}
1313
1314static int get_sd_csd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1315{
1316 struct sd_info *sd_card = &chip->sd_card;
1317 unsigned int lun = SCSI_LUN(srb);
1318
1319 if (!check_card_ready(chip, lun)) {
1320 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1321 return TRANSPORT_FAILED;
1322 }
1323
1324 if (get_lun_card(chip, lun) != SD_CARD) {
1325 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1326 return TRANSPORT_FAILED;
1327 }
1328
1329 scsi_set_resid(srb, 0);
1330 rtsx_stor_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb);
1331
1332 return TRANSPORT_GOOD;
1333}
1334
1335static int toggle_gpio_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1336{
1337 u8 gpio = srb->cmnd[2];
1338
1339 rtsx_disable_aspm(chip);
1340
1341 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1342 rtsx_exit_ss(chip);
1343 wait_timeout(100);
1344 }
1345 rtsx_set_stat(chip, RTSX_STAT_RUN);
1346
1347 if (gpio > 3)
1348 gpio = 1;
1349 toggle_gpio(chip, gpio);
1350
1351 return TRANSPORT_GOOD;
1352}
1353
1354static int read_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1355{
1356 u8 addr, buf[4];
1357 u32 val;
1358 unsigned int len;
1359
1360 rtsx_disable_aspm(chip);
1361
1362 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1363 rtsx_exit_ss(chip);
1364 wait_timeout(100);
1365 }
1366 rtsx_set_stat(chip, RTSX_STAT_RUN);
1367
1368 addr = srb->cmnd[4];
1369
1370 val = rtsx_readl(chip, addr);
1371 dev_dbg(rtsx_dev(chip), "Host register (0x%x): 0x%x\n", addr, val);
1372
1373 buf[0] = (u8)(val >> 24);
1374 buf[1] = (u8)(val >> 16);
1375 buf[2] = (u8)(val >> 8);
1376 buf[3] = (u8)val;
1377
1378 len = min_t(unsigned int, scsi_bufflen(srb), 4);
1379 rtsx_stor_set_xfer_buf(buf, len, srb);
1380 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1381
1382 return TRANSPORT_GOOD;
1383}
1384
1385static int write_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1386{
1387 u8 addr, buf[4];
1388 u32 val;
1389 unsigned int len;
1390
1391 rtsx_disable_aspm(chip);
1392
1393 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1394 rtsx_exit_ss(chip);
1395 wait_timeout(100);
1396 }
1397 rtsx_set_stat(chip, RTSX_STAT_RUN);
1398
1399 addr = srb->cmnd[4];
1400
1401 len = min_t(unsigned int, scsi_bufflen(srb), 4);
1402 rtsx_stor_get_xfer_buf(buf, len, srb);
1403 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1404
1405 val = ((u32)buf[0] << 24) | ((u32)buf[1] << 16) | ((u32)buf[2]
1406 << 8) | buf[3];
1407
1408 rtsx_writel(chip, addr, val);
1409
1410 return TRANSPORT_GOOD;
1411}
1412
1413static int set_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1414{
1415 unsigned int lun = SCSI_LUN(srb);
1416
1417 if (srb->cmnd[3] == 1) {
1418
1419 struct xd_info *xd_card = &chip->xd_card;
1420 struct sd_info *sd_card = &chip->sd_card;
1421 struct ms_info *ms_card = &chip->ms_card;
1422
1423 switch (srb->cmnd[4]) {
1424 case XD_CARD:
1425 xd_card->xd_clock = srb->cmnd[5];
1426 break;
1427
1428 case SD_CARD:
1429 sd_card->sd_clock = srb->cmnd[5];
1430 break;
1431
1432 case MS_CARD:
1433 ms_card->ms_clock = srb->cmnd[5];
1434 break;
1435
1436 default:
1437 set_sense_type(chip, lun,
1438 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1439 return TRANSPORT_FAILED;
1440 }
1441 } else if (srb->cmnd[3] == 2) {
1442 if (srb->cmnd[4]) {
1443 chip->blink_led = 1;
1444 } else {
1445 int retval;
1446
1447 chip->blink_led = 0;
1448
1449 rtsx_disable_aspm(chip);
1450
1451 if (chip->ss_en &&
1452 (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1453 rtsx_exit_ss(chip);
1454 wait_timeout(100);
1455 }
1456 rtsx_set_stat(chip, RTSX_STAT_RUN);
1457
1458 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1459 if (retval != STATUS_SUCCESS) {
1460 set_sense_type(chip, SCSI_LUN(srb),
1461 SENSE_TYPE_MEDIA_WRITE_ERR);
1462 return TRANSPORT_FAILED;
1463 }
1464
1465 turn_off_led(chip, LED_GPIO);
1466 }
1467 } else {
1468 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1469 return TRANSPORT_FAILED;
1470 }
1471
1472 return TRANSPORT_GOOD;
1473}
1474
1475static int get_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1476{
1477 unsigned int lun = SCSI_LUN(srb);
1478
1479 if (srb->cmnd[3] == 1) {
1480 struct xd_info *xd_card = &chip->xd_card;
1481 struct sd_info *sd_card = &chip->sd_card;
1482 struct ms_info *ms_card = &chip->ms_card;
1483 u8 tmp;
1484
1485 switch (srb->cmnd[4]) {
1486 case XD_CARD:
1487 tmp = (u8)(xd_card->xd_clock);
1488 break;
1489
1490 case SD_CARD:
1491 tmp = (u8)(sd_card->sd_clock);
1492 break;
1493
1494 case MS_CARD:
1495 tmp = (u8)(ms_card->ms_clock);
1496 break;
1497
1498 default:
1499 set_sense_type(chip, lun,
1500 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1501 return TRANSPORT_FAILED;
1502 }
1503
1504 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1505 } else if (srb->cmnd[3] == 2) {
1506 u8 tmp = chip->blink_led;
1507
1508 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1509 } else {
1510 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1511 return TRANSPORT_FAILED;
1512 }
1513
1514 return TRANSPORT_GOOD;
1515}
1516
1517static int dma_access_ring_buffer(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1518{
1519 int retval;
1520 unsigned int lun = SCSI_LUN(srb);
1521 u16 len;
1522
1523 rtsx_disable_aspm(chip);
1524
1525 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1526 rtsx_exit_ss(chip);
1527 wait_timeout(100);
1528 }
1529 rtsx_set_stat(chip, RTSX_STAT_RUN);
1530
1531 len = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
1532 len = min_t(u16, len, scsi_bufflen(srb));
1533
1534 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1535 dev_dbg(rtsx_dev(chip), "Read from device\n");
1536 else
1537 dev_dbg(rtsx_dev(chip), "Write to device\n");
1538
1539 retval = rtsx_transfer_data(chip, 0, scsi_sglist(srb), len,
1540 scsi_sg_count(srb), srb->sc_data_direction,
1541 1000);
1542 if (retval < 0) {
1543 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1544 set_sense_type(chip, lun,
1545 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1546 else
1547 set_sense_type(chip, lun,
1548 SENSE_TYPE_MEDIA_WRITE_ERR);
1549
1550 return TRANSPORT_FAILED;
1551 }
1552 scsi_set_resid(srb, 0);
1553
1554 return TRANSPORT_GOOD;
1555}
1556
1557static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1558{
1559 struct sd_info *sd_card = &chip->sd_card;
1560 struct ms_info *ms_card = &chip->ms_card;
1561 int buf_len;
1562 unsigned int lun = SCSI_LUN(srb);
1563 u8 card = get_lun_card(chip, lun);
1564 u8 status[32];
1565#ifdef SUPPORT_OCP
1566 u8 oc_now_mask = 0, oc_ever_mask = 0;
1567#endif
1568
1569 memset(status, 0, 32);
1570
1571 status[0] = (u8)(chip->product_id);
1572 status[1] = chip->ic_version;
1573
1574 if (chip->auto_delink_en)
1575 status[2] = 0x10;
1576 else
1577 status[2] = 0x00;
1578
1579 status[3] = 20;
1580 status[4] = 10;
1581 status[5] = 05;
1582 status[6] = 21;
1583
1584 if (chip->card_wp)
1585 status[7] = 0x20;
1586 else
1587 status[7] = 0x00;
1588
1589#ifdef SUPPORT_OCP
1590 status[8] = 0;
1591 if (CHECK_LUN_MODE(chip, SD_MS_2LUN) &&
1592 (chip->lun2card[lun] == MS_CARD)) {
1593 oc_now_mask = MS_OC_NOW;
1594 oc_ever_mask = MS_OC_EVER;
1595 } else {
1596 oc_now_mask = SD_OC_NOW;
1597 oc_ever_mask = SD_OC_EVER;
1598 }
1599
1600 if (chip->ocp_stat & oc_now_mask)
1601 status[8] |= 0x02;
1602
1603 if (chip->ocp_stat & oc_ever_mask)
1604 status[8] |= 0x01;
1605#endif
1606
1607 if (card == SD_CARD) {
1608 if (CHK_SD(sd_card)) {
1609 if (CHK_SD_HCXC(sd_card)) {
1610 if (sd_card->capacity > 0x4000000)
1611 status[0x0E] = 0x02;
1612 else
1613 status[0x0E] = 0x01;
1614 } else {
1615 status[0x0E] = 0x00;
1616 }
1617
1618 if (CHK_SD_SDR104(sd_card))
1619 status[0x0F] = 0x03;
1620 else if (CHK_SD_DDR50(sd_card))
1621 status[0x0F] = 0x04;
1622 else if (CHK_SD_SDR50(sd_card))
1623 status[0x0F] = 0x02;
1624 else if (CHK_SD_HS(sd_card))
1625 status[0x0F] = 0x01;
1626 else
1627 status[0x0F] = 0x00;
1628 } else {
1629 if (CHK_MMC_SECTOR_MODE(sd_card))
1630 status[0x0E] = 0x01;
1631 else
1632 status[0x0E] = 0x00;
1633
1634 if (CHK_MMC_DDR52(sd_card))
1635 status[0x0F] = 0x03;
1636 else if (CHK_MMC_52M(sd_card))
1637 status[0x0F] = 0x02;
1638 else if (CHK_MMC_26M(sd_card))
1639 status[0x0F] = 0x01;
1640 else
1641 status[0x0F] = 0x00;
1642 }
1643 } else if (card == MS_CARD) {
1644 if (CHK_MSPRO(ms_card)) {
1645 if (CHK_MSXC(ms_card))
1646 status[0x0E] = 0x01;
1647 else
1648 status[0x0E] = 0x00;
1649
1650 if (CHK_HG8BIT(ms_card))
1651 status[0x0F] = 0x01;
1652 else
1653 status[0x0F] = 0x00;
1654 }
1655 }
1656
1657#ifdef SUPPORT_SD_LOCK
1658 if (card == SD_CARD) {
1659 status[0x17] = 0x80;
1660 if (sd_card->sd_erase_status)
1661 status[0x17] |= 0x01;
1662 if (sd_card->sd_lock_status & SD_LOCKED) {
1663 status[0x17] |= 0x02;
1664 status[0x07] |= 0x40;
1665 }
1666 if (sd_card->sd_lock_status & SD_PWD_EXIST)
1667 status[0x17] |= 0x04;
1668 } else {
1669 status[0x17] = 0x00;
1670 }
1671
1672 dev_dbg(rtsx_dev(chip), "status[0x17] = 0x%x\n", status[0x17]);
1673#endif
1674
1675 status[0x18] = 0x8A;
1676 status[0x1A] = 0x28;
1677#ifdef SUPPORT_SD_LOCK
1678 status[0x1F] = 0x01;
1679#endif
1680
1681 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(status));
1682 rtsx_stor_set_xfer_buf(status, buf_len, srb);
1683 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1684
1685 return TRANSPORT_GOOD;
1686}
1687
1688static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1689{
1690 int phy_debug_mode;
1691 int retval;
1692 u16 reg;
1693
1694 if (!CHECK_PID(chip, 0x5208)) {
1695 set_sense_type(chip, SCSI_LUN(srb),
1696 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1697 return TRANSPORT_FAILED;
1698 }
1699
1700 phy_debug_mode = (int)(srb->cmnd[3]);
1701
1702 if (phy_debug_mode) {
1703 chip->phy_debug_mode = 1;
1704 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0);
1705 if (retval != STATUS_SUCCESS) {
1706 return TRANSPORT_FAILED;
1707 }
1708
1709 rtsx_disable_bus_int(chip);
1710
1711 retval = rtsx_read_phy_register(chip, 0x1C, ®);
1712 if (retval != STATUS_SUCCESS) {
1713 return TRANSPORT_FAILED;
1714 }
1715
1716 reg |= 0x0001;
1717 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1718 if (retval != STATUS_SUCCESS) {
1719 return TRANSPORT_FAILED;
1720 }
1721 } else {
1722 chip->phy_debug_mode = 0;
1723 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77);
1724 if (retval != STATUS_SUCCESS) {
1725 return TRANSPORT_FAILED;
1726 }
1727
1728 rtsx_enable_bus_int(chip);
1729
1730 retval = rtsx_read_phy_register(chip, 0x1C, ®);
1731 if (retval != STATUS_SUCCESS) {
1732 return TRANSPORT_FAILED;
1733 }
1734
1735 reg &= 0xFFFE;
1736 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1737 if (retval != STATUS_SUCCESS) {
1738 return TRANSPORT_FAILED;
1739 }
1740 }
1741
1742 return TRANSPORT_GOOD;
1743}
1744
1745static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1746{
1747 int retval = STATUS_SUCCESS;
1748 unsigned int lun = SCSI_LUN(srb);
1749 u8 cmd_type, mask, value, idx;
1750 u16 addr;
1751
1752 rtsx_disable_aspm(chip);
1753
1754 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1755 rtsx_exit_ss(chip);
1756 wait_timeout(100);
1757 }
1758 rtsx_set_stat(chip, RTSX_STAT_RUN);
1759
1760 switch (srb->cmnd[3]) {
1761 case INIT_BATCHCMD:
1762 rtsx_init_cmd(chip);
1763 break;
1764
1765 case ADD_BATCHCMD:
1766 cmd_type = srb->cmnd[4];
1767 if (cmd_type > 2) {
1768 set_sense_type(chip, lun,
1769 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1770 return TRANSPORT_FAILED;
1771 }
1772 addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1773 mask = srb->cmnd[7];
1774 value = srb->cmnd[8];
1775 rtsx_add_cmd(chip, cmd_type, addr, mask, value);
1776 break;
1777
1778 case SEND_BATCHCMD:
1779 retval = rtsx_send_cmd(chip, 0, 1000);
1780 break;
1781
1782 case GET_BATCHRSP:
1783 idx = srb->cmnd[4];
1784 value = *(rtsx_get_cmd_data(chip) + idx);
1785 if (scsi_bufflen(srb) < 1) {
1786 set_sense_type(chip, lun,
1787 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1788 return TRANSPORT_FAILED;
1789 }
1790 rtsx_stor_set_xfer_buf(&value, 1, srb);
1791 scsi_set_resid(srb, 0);
1792 break;
1793
1794 default:
1795 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1796 return TRANSPORT_FAILED;
1797 }
1798
1799 if (retval != STATUS_SUCCESS) {
1800 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1801 return TRANSPORT_FAILED;
1802 }
1803
1804 return TRANSPORT_GOOD;
1805}
1806
1807static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1808{
1809 switch (srb->cmnd[3]) {
1810 case INIT_BATCHCMD:
1811 case ADD_BATCHCMD:
1812 case SEND_BATCHCMD:
1813 case GET_BATCHRSP:
1814 return rw_mem_cmd_buf(srb, chip);
1815 default:
1816 return TRANSPORT_ERROR;
1817 }
1818}
1819
1820static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1821{
1822 unsigned short addr, len, i;
1823 int retval;
1824 u8 *buf;
1825 u16 val;
1826
1827 rtsx_disable_aspm(chip);
1828
1829 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1830 rtsx_exit_ss(chip);
1831 wait_timeout(100);
1832 }
1833 rtsx_set_stat(chip, RTSX_STAT_RUN);
1834
1835 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1836 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1837
1838 if (len % 2)
1839 len -= len % 2;
1840
1841 if (len) {
1842 buf = vmalloc(len);
1843 if (!buf) {
1844 return TRANSPORT_ERROR;
1845 }
1846
1847 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1848 if (retval != STATUS_SUCCESS) {
1849 vfree(buf);
1850 set_sense_type(chip, SCSI_LUN(srb),
1851 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1852 return TRANSPORT_FAILED;
1853 }
1854
1855 for (i = 0; i < len / 2; i++) {
1856 retval = rtsx_read_phy_register(chip, addr + i, &val);
1857 if (retval != STATUS_SUCCESS) {
1858 vfree(buf);
1859 set_sense_type
1860 (chip, SCSI_LUN(srb),
1861 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1862 return TRANSPORT_FAILED;
1863 }
1864
1865 buf[2 * i] = (u8)(val >> 8);
1866 buf[2 * i + 1] = (u8)val;
1867 }
1868
1869 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1870 len);
1871 rtsx_stor_set_xfer_buf(buf, len, srb);
1872 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1873
1874 vfree(buf);
1875 }
1876
1877 return TRANSPORT_GOOD;
1878}
1879
1880static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1881{
1882 unsigned short addr, len, i;
1883 int retval;
1884 u8 *buf;
1885 u16 val;
1886
1887 rtsx_disable_aspm(chip);
1888
1889 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1890 rtsx_exit_ss(chip);
1891 wait_timeout(100);
1892 }
1893 rtsx_set_stat(chip, RTSX_STAT_RUN);
1894
1895 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1896 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1897
1898 if (len % 2)
1899 len -= len % 2;
1900
1901 if (len) {
1902 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1903 len);
1904
1905 buf = vmalloc(len);
1906 if (!buf) {
1907 return TRANSPORT_ERROR;
1908 }
1909
1910 rtsx_stor_get_xfer_buf(buf, len, srb);
1911 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1912
1913 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1914 if (retval != STATUS_SUCCESS) {
1915 vfree(buf);
1916 set_sense_type(chip, SCSI_LUN(srb),
1917 SENSE_TYPE_MEDIA_WRITE_ERR);
1918 return TRANSPORT_FAILED;
1919 }
1920
1921 for (i = 0; i < len / 2; i++) {
1922 val = ((u16)buf[2 * i] << 8) | buf[2 * i + 1];
1923 retval = rtsx_write_phy_register(chip, addr + i, val);
1924 if (retval != STATUS_SUCCESS) {
1925 vfree(buf);
1926 set_sense_type(chip, SCSI_LUN(srb),
1927 SENSE_TYPE_MEDIA_WRITE_ERR);
1928 return TRANSPORT_FAILED;
1929 }
1930 }
1931
1932 vfree(buf);
1933 }
1934
1935 return TRANSPORT_GOOD;
1936}
1937
1938static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1939{
1940 unsigned short addr;
1941 int retval;
1942 u8 mode;
1943
1944 rtsx_disable_aspm(chip);
1945
1946 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1947 rtsx_exit_ss(chip);
1948 wait_timeout(100);
1949 }
1950 rtsx_set_stat(chip, RTSX_STAT_RUN);
1951
1952 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1953 if (retval != STATUS_SUCCESS) {
1954 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1955 return TRANSPORT_FAILED;
1956 }
1957
1958 mode = srb->cmnd[3];
1959 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1960
1961 if (mode == 0) {
1962 retval = spi_erase_eeprom_chip(chip);
1963 if (retval != STATUS_SUCCESS) {
1964 set_sense_type(chip, SCSI_LUN(srb),
1965 SENSE_TYPE_MEDIA_WRITE_ERR);
1966 return TRANSPORT_FAILED;
1967 }
1968 } else if (mode == 1) {
1969 retval = spi_erase_eeprom_byte(chip, addr);
1970 if (retval != STATUS_SUCCESS) {
1971 set_sense_type(chip, SCSI_LUN(srb),
1972 SENSE_TYPE_MEDIA_WRITE_ERR);
1973 return TRANSPORT_FAILED;
1974 }
1975 } else {
1976 set_sense_type(chip, SCSI_LUN(srb),
1977 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1978 return TRANSPORT_FAILED;
1979 }
1980
1981 return TRANSPORT_GOOD;
1982}
1983
1984static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1985{
1986 unsigned short addr, len, i;
1987 int retval;
1988 u8 *buf;
1989
1990 rtsx_disable_aspm(chip);
1991
1992 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1993 rtsx_exit_ss(chip);
1994 wait_timeout(100);
1995 }
1996 rtsx_set_stat(chip, RTSX_STAT_RUN);
1997
1998 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1999 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2000
2001 buf = vmalloc(len);
2002 if (!buf) {
2003 return TRANSPORT_ERROR;
2004 }
2005
2006 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2007 if (retval != STATUS_SUCCESS) {
2008 vfree(buf);
2009 set_sense_type(chip, SCSI_LUN(srb),
2010 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2011 return TRANSPORT_FAILED;
2012 }
2013
2014 for (i = 0; i < len; i++) {
2015 retval = spi_read_eeprom(chip, addr + i, buf + i);
2016 if (retval != STATUS_SUCCESS) {
2017 vfree(buf);
2018 set_sense_type(chip, SCSI_LUN(srb),
2019 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2020 return TRANSPORT_FAILED;
2021 }
2022 }
2023
2024 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2025 rtsx_stor_set_xfer_buf(buf, len, srb);
2026 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2027
2028 vfree(buf);
2029
2030 return TRANSPORT_GOOD;
2031}
2032
2033static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2034{
2035 unsigned short addr, len, i;
2036 int retval;
2037 u8 *buf;
2038
2039 rtsx_disable_aspm(chip);
2040
2041 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2042 rtsx_exit_ss(chip);
2043 wait_timeout(100);
2044 }
2045 rtsx_set_stat(chip, RTSX_STAT_RUN);
2046
2047 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2048 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2049
2050 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2051 buf = vmalloc(len);
2052 if (!buf) {
2053 return TRANSPORT_ERROR;
2054 }
2055
2056 rtsx_stor_get_xfer_buf(buf, len, srb);
2057 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2058
2059 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2060 if (retval != STATUS_SUCCESS) {
2061 vfree(buf);
2062 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2063 return TRANSPORT_FAILED;
2064 }
2065
2066 for (i = 0; i < len; i++) {
2067 retval = spi_write_eeprom(chip, addr + i, buf[i]);
2068 if (retval != STATUS_SUCCESS) {
2069 vfree(buf);
2070 set_sense_type(chip, SCSI_LUN(srb),
2071 SENSE_TYPE_MEDIA_WRITE_ERR);
2072 return TRANSPORT_FAILED;
2073 }
2074 }
2075
2076 vfree(buf);
2077
2078 return TRANSPORT_GOOD;
2079}
2080
2081static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2082{
2083 int retval;
2084 u8 addr, len, i;
2085 u8 *buf;
2086
2087 rtsx_disable_aspm(chip);
2088
2089 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2090 rtsx_exit_ss(chip);
2091 wait_timeout(100);
2092 }
2093 rtsx_set_stat(chip, RTSX_STAT_RUN);
2094
2095 addr = srb->cmnd[4];
2096 len = srb->cmnd[5];
2097
2098 buf = vmalloc(len);
2099 if (!buf) {
2100 return TRANSPORT_ERROR;
2101 }
2102
2103 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2104 if (retval != STATUS_SUCCESS) {
2105 vfree(buf);
2106 set_sense_type(chip, SCSI_LUN(srb),
2107 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2108 return TRANSPORT_FAILED;
2109 }
2110
2111 for (i = 0; i < len; i++) {
2112 retval = rtsx_read_efuse(chip, addr + i, buf + i);
2113 if (retval != STATUS_SUCCESS) {
2114 vfree(buf);
2115 set_sense_type(chip, SCSI_LUN(srb),
2116 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2117 return TRANSPORT_FAILED;
2118 }
2119 }
2120
2121 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2122 rtsx_stor_set_xfer_buf(buf, len, srb);
2123 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2124
2125 vfree(buf);
2126
2127 return TRANSPORT_GOOD;
2128}
2129
2130static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2131{
2132 int retval, result = TRANSPORT_GOOD;
2133 u16 val;
2134 u8 addr, len, i;
2135 u8 *buf;
2136
2137 rtsx_disable_aspm(chip);
2138
2139 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2140 rtsx_exit_ss(chip);
2141 wait_timeout(100);
2142 }
2143 rtsx_set_stat(chip, RTSX_STAT_RUN);
2144
2145 addr = srb->cmnd[4];
2146 len = srb->cmnd[5];
2147
2148 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2149 buf = vmalloc(len);
2150 if (!buf) {
2151 return TRANSPORT_ERROR;
2152 }
2153
2154 rtsx_stor_get_xfer_buf(buf, len, srb);
2155 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2156
2157 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2158 if (retval != STATUS_SUCCESS) {
2159 vfree(buf);
2160 return TRANSPORT_ERROR;
2161 }
2162
2163 if (chip->asic_code) {
2164 retval = rtsx_read_phy_register(chip, 0x08, &val);
2165 if (retval != STATUS_SUCCESS) {
2166 vfree(buf);
2167 return TRANSPORT_ERROR;
2168 }
2169
2170 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2171 LDO3318_PWR_MASK, LDO_OFF);
2172 if (retval != STATUS_SUCCESS) {
2173 vfree(buf);
2174 return TRANSPORT_ERROR;
2175 }
2176
2177 wait_timeout(600);
2178
2179 retval = rtsx_write_phy_register(chip, 0x08,
2180 0x4C00 | chip->phy_voltage);
2181 if (retval != STATUS_SUCCESS) {
2182 vfree(buf);
2183 return TRANSPORT_ERROR;
2184 }
2185
2186 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2187 LDO3318_PWR_MASK, LDO_ON);
2188 if (retval != STATUS_SUCCESS) {
2189 vfree(buf);
2190 return TRANSPORT_ERROR;
2191 }
2192
2193 wait_timeout(600);
2194 }
2195
2196 retval = card_power_on(chip, SPI_CARD);
2197 if (retval != STATUS_SUCCESS) {
2198 vfree(buf);
2199 return TRANSPORT_ERROR;
2200 }
2201
2202 wait_timeout(50);
2203
2204 for (i = 0; i < len; i++) {
2205 retval = rtsx_write_efuse(chip, addr + i, buf[i]);
2206 if (retval != STATUS_SUCCESS) {
2207 set_sense_type(chip, SCSI_LUN(srb),
2208 SENSE_TYPE_MEDIA_WRITE_ERR);
2209 result = TRANSPORT_FAILED;
2210 goto exit;
2211 }
2212 }
2213
2214exit:
2215 vfree(buf);
2216
2217 retval = card_power_off(chip, SPI_CARD);
2218 if (retval != STATUS_SUCCESS) {
2219 return TRANSPORT_ERROR;
2220 }
2221
2222 if (chip->asic_code) {
2223 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2224 LDO3318_PWR_MASK, LDO_OFF);
2225 if (retval != STATUS_SUCCESS) {
2226 return TRANSPORT_ERROR;
2227 }
2228
2229 wait_timeout(600);
2230
2231 retval = rtsx_write_phy_register(chip, 0x08, val);
2232 if (retval != STATUS_SUCCESS) {
2233 return TRANSPORT_ERROR;
2234 }
2235
2236 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2237 LDO3318_PWR_MASK, LDO_ON);
2238 if (retval != STATUS_SUCCESS) {
2239 return TRANSPORT_ERROR;
2240 }
2241 }
2242
2243 return result;
2244}
2245
2246static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2247{
2248 int retval;
2249 bool func_max;
2250 u8 func;
2251 u16 addr, len;
2252 u8 *buf;
2253
2254 rtsx_disable_aspm(chip);
2255
2256 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2257 rtsx_exit_ss(chip);
2258 wait_timeout(100);
2259 }
2260 rtsx_set_stat(chip, RTSX_STAT_RUN);
2261
2262 func = srb->cmnd[3];
2263 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2264 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2265
2266 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x, len = %d\n",
2267 __func__, func, addr, len);
2268
2269 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2270 func_max = true;
2271 else
2272 func_max = false;
2273
2274 if (func > func_max) {
2275 set_sense_type(chip, SCSI_LUN(srb),
2276 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2277 return TRANSPORT_FAILED;
2278 }
2279
2280 buf = vmalloc(len);
2281 if (!buf) {
2282 return TRANSPORT_ERROR;
2283 }
2284
2285 retval = rtsx_read_cfg_seq(chip, func, addr, buf, len);
2286 if (retval != STATUS_SUCCESS) {
2287 set_sense_type(chip, SCSI_LUN(srb),
2288 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2289 vfree(buf);
2290 return TRANSPORT_FAILED;
2291 }
2292
2293 len = (u16)min_t(unsigned int, scsi_bufflen(srb), len);
2294 rtsx_stor_set_xfer_buf(buf, len, srb);
2295 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2296
2297 vfree(buf);
2298
2299 return TRANSPORT_GOOD;
2300}
2301
2302static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2303{
2304 int retval;
2305 bool func_max;
2306 u8 func;
2307 u16 addr, len;
2308 u8 *buf;
2309
2310 rtsx_disable_aspm(chip);
2311
2312 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2313 rtsx_exit_ss(chip);
2314 wait_timeout(100);
2315 }
2316 rtsx_set_stat(chip, RTSX_STAT_RUN);
2317
2318 func = srb->cmnd[3];
2319 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2320 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2321
2322 dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x\n",
2323 __func__, func, addr);
2324
2325 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2326 func_max = true;
2327 else
2328 func_max = false;
2329
2330 if (func > func_max) {
2331 set_sense_type(chip, SCSI_LUN(srb),
2332 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2333 return TRANSPORT_FAILED;
2334 }
2335
2336 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2337 buf = vmalloc(len);
2338 if (!buf) {
2339 return TRANSPORT_ERROR;
2340 }
2341
2342 rtsx_stor_get_xfer_buf(buf, len, srb);
2343 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2344
2345 retval = rtsx_write_cfg_seq(chip, func, addr, buf, len);
2346 if (retval != STATUS_SUCCESS) {
2347 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2348 vfree(buf);
2349 return TRANSPORT_FAILED;
2350 }
2351
2352 vfree(buf);
2353
2354 return TRANSPORT_GOOD;
2355}
2356
2357static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2358{
2359 int result;
2360
2361 switch (srb->cmnd[2]) {
2362 case PP_READ10:
2363 case PP_WRITE10:
2364 result = read_write(srb, chip);
2365 break;
2366
2367 case READ_HOST_REG:
2368 result = read_host_reg(srb, chip);
2369 break;
2370
2371 case WRITE_HOST_REG:
2372 result = write_host_reg(srb, chip);
2373 break;
2374
2375 case GET_VAR:
2376 result = get_variable(srb, chip);
2377 break;
2378
2379 case SET_VAR:
2380 result = set_variable(srb, chip);
2381 break;
2382
2383 case DMA_READ:
2384 case DMA_WRITE:
2385 result = dma_access_ring_buffer(srb, chip);
2386 break;
2387
2388 case READ_PHY:
2389 result = read_phy_register(srb, chip);
2390 break;
2391
2392 case WRITE_PHY:
2393 result = write_phy_register(srb, chip);
2394 break;
2395
2396 case ERASE_EEPROM2:
2397 result = erase_eeprom2(srb, chip);
2398 break;
2399
2400 case READ_EEPROM2:
2401 result = read_eeprom2(srb, chip);
2402 break;
2403
2404 case WRITE_EEPROM2:
2405 result = write_eeprom2(srb, chip);
2406 break;
2407
2408 case READ_EFUSE:
2409 result = read_efuse(srb, chip);
2410 break;
2411
2412 case WRITE_EFUSE:
2413 result = write_efuse(srb, chip);
2414 break;
2415
2416 case READ_CFG:
2417 result = read_cfg_byte(srb, chip);
2418 break;
2419
2420 case WRITE_CFG:
2421 result = write_cfg_byte(srb, chip);
2422 break;
2423
2424 case SET_CHIP_MODE:
2425 result = set_chip_mode(srb, chip);
2426 break;
2427
2428 case SUIT_CMD:
2429 result = suit_cmd(srb, chip);
2430 break;
2431
2432 case GET_DEV_STATUS:
2433 result = get_dev_status(srb, chip);
2434 break;
2435
2436 default:
2437 set_sense_type(chip, SCSI_LUN(srb),
2438 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2439 return TRANSPORT_FAILED;
2440 }
2441
2442 return result;
2443}
2444
2445static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2446{
2447 u8 rtsx_status[16];
2448 int buf_len;
2449 unsigned int lun = SCSI_LUN(srb);
2450
2451 rtsx_status[0] = (u8)(chip->vendor_id >> 8);
2452 rtsx_status[1] = (u8)(chip->vendor_id);
2453
2454 rtsx_status[2] = (u8)(chip->product_id >> 8);
2455 rtsx_status[3] = (u8)(chip->product_id);
2456
2457 rtsx_status[4] = (u8)lun;
2458
2459 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2460 if (chip->lun2card[lun] == SD_CARD)
2461 rtsx_status[5] = 2;
2462 else
2463 rtsx_status[5] = 3;
2464 } else {
2465 if (chip->card_exist) {
2466 if (chip->card_exist & XD_CARD)
2467 rtsx_status[5] = 4;
2468 else if (chip->card_exist & SD_CARD)
2469 rtsx_status[5] = 2;
2470 else if (chip->card_exist & MS_CARD)
2471 rtsx_status[5] = 3;
2472 else
2473 rtsx_status[5] = 7;
2474 } else {
2475 rtsx_status[5] = 7;
2476 }
2477 }
2478
2479 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2480 rtsx_status[6] = 2;
2481 else
2482 rtsx_status[6] = 1;
2483
2484 rtsx_status[7] = (u8)(chip->product_id);
2485 rtsx_status[8] = chip->ic_version;
2486
2487 if (check_card_exist(chip, lun))
2488 rtsx_status[9] = 1;
2489 else
2490 rtsx_status[9] = 0;
2491
2492 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2493 rtsx_status[10] = 0;
2494 else
2495 rtsx_status[10] = 1;
2496
2497 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2498 if (chip->lun2card[lun] == SD_CARD)
2499 rtsx_status[11] = SD_CARD;
2500 else
2501 rtsx_status[11] = MS_CARD;
2502 } else {
2503 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD;
2504 }
2505
2506 if (check_card_ready(chip, lun))
2507 rtsx_status[12] = 1;
2508 else
2509 rtsx_status[12] = 0;
2510
2511 if (get_lun_card(chip, lun) == XD_CARD) {
2512 rtsx_status[13] = 0x40;
2513 } else if (get_lun_card(chip, lun) == SD_CARD) {
2514 struct sd_info *sd_card = &chip->sd_card;
2515
2516 rtsx_status[13] = 0x20;
2517 if (CHK_SD(sd_card)) {
2518 if (CHK_SD_HCXC(sd_card))
2519 rtsx_status[13] |= 0x04;
2520 if (CHK_SD_HS(sd_card))
2521 rtsx_status[13] |= 0x02;
2522 } else {
2523 rtsx_status[13] |= 0x08;
2524 if (CHK_MMC_52M(sd_card))
2525 rtsx_status[13] |= 0x02;
2526 if (CHK_MMC_SECTOR_MODE(sd_card))
2527 rtsx_status[13] |= 0x04;
2528 }
2529 } else if (get_lun_card(chip, lun) == MS_CARD) {
2530 struct ms_info *ms_card = &chip->ms_card;
2531
2532 if (CHK_MSPRO(ms_card)) {
2533 rtsx_status[13] = 0x38;
2534 if (CHK_HG8BIT(ms_card))
2535 rtsx_status[13] |= 0x04;
2536#ifdef SUPPORT_MSXC
2537 if (CHK_MSXC(ms_card))
2538 rtsx_status[13] |= 0x01;
2539#endif
2540 } else {
2541 rtsx_status[13] = 0x30;
2542 }
2543 } else {
2544 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) {
2545#ifdef SUPPORT_SDIO
2546 if (chip->sd_io && chip->sd_int)
2547 rtsx_status[13] = 0x60;
2548 else
2549 rtsx_status[13] = 0x70;
2550#else
2551 rtsx_status[13] = 0x70;
2552#endif
2553 } else {
2554 if (chip->lun2card[lun] == SD_CARD)
2555 rtsx_status[13] = 0x20;
2556 else
2557 rtsx_status[13] = 0x30;
2558 }
2559 }
2560
2561 rtsx_status[14] = 0x78;
2562 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2563 rtsx_status[15] = 0x83;
2564 else
2565 rtsx_status[15] = 0x82;
2566
2567 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(rtsx_status));
2568 rtsx_stor_set_xfer_buf(rtsx_status, buf_len, srb);
2569 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
2570
2571 return TRANSPORT_GOOD;
2572}
2573
2574static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2575{
2576 unsigned int lun = SCSI_LUN(srb);
2577 u8 card, bus_width;
2578
2579 if (!check_card_ready(chip, lun)) {
2580 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2581 return TRANSPORT_FAILED;
2582 }
2583
2584 card = get_lun_card(chip, lun);
2585 if ((card == SD_CARD) || (card == MS_CARD)) {
2586 bus_width = chip->card_bus_width[lun];
2587 } else {
2588 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2589 return TRANSPORT_FAILED;
2590 }
2591
2592 scsi_set_resid(srb, 0);
2593 rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
2594
2595 return TRANSPORT_GOOD;
2596}
2597
2598static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2599{
2600 int result;
2601 unsigned int lun = SCSI_LUN(srb);
2602 u8 gpio_dir;
2603
2604 if (CHECK_PID(chip, 0x5208) || CHECK_PID(chip, 0x5288)) {
2605 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2606 return TRANSPORT_FAILED;
2607 }
2608
2609 rtsx_disable_aspm(chip);
2610
2611 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2612 rtsx_exit_ss(chip);
2613 wait_timeout(100);
2614 }
2615 rtsx_set_stat(chip, RTSX_STAT_RUN);
2616
2617 rtsx_force_power_on(chip, SSC_PDCTL);
2618
2619 rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir);
2620 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06);
2621
2622 switch (srb->cmnd[2]) {
2623 case SCSI_SPI_GETSTATUS:
2624 result = spi_get_status(srb, chip);
2625 break;
2626
2627 case SCSI_SPI_SETPARAMETER:
2628 result = spi_set_parameter(srb, chip);
2629 break;
2630
2631 case SCSI_SPI_READFALSHID:
2632 result = spi_read_flash_id(srb, chip);
2633 break;
2634
2635 case SCSI_SPI_READFLASH:
2636 result = spi_read_flash(srb, chip);
2637 break;
2638
2639 case SCSI_SPI_WRITEFLASH:
2640 result = spi_write_flash(srb, chip);
2641 break;
2642
2643 case SCSI_SPI_WRITEFLASHSTATUS:
2644 result = spi_write_flash_status(srb, chip);
2645 break;
2646
2647 case SCSI_SPI_ERASEFLASH:
2648 result = spi_erase_flash(srb, chip);
2649 break;
2650
2651 default:
2652 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2653
2654 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2655 return TRANSPORT_FAILED;
2656 }
2657
2658 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2659
2660 if (result != STATUS_SUCCESS) {
2661 return TRANSPORT_FAILED;
2662 }
2663
2664 return TRANSPORT_GOOD;
2665}
2666
2667static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2668{
2669 int result;
2670
2671 switch (srb->cmnd[1]) {
2672 case READ_STATUS:
2673 result = read_status(srb, chip);
2674 break;
2675
2676 case READ_MEM:
2677 result = read_mem(srb, chip);
2678 break;
2679
2680 case WRITE_MEM:
2681 result = write_mem(srb, chip);
2682 break;
2683
2684 case READ_EEPROM:
2685 result = read_eeprom(srb, chip);
2686 break;
2687
2688 case WRITE_EEPROM:
2689 result = write_eeprom(srb, chip);
2690 break;
2691
2692 case TOGGLE_GPIO:
2693 result = toggle_gpio_cmd(srb, chip);
2694 break;
2695
2696 case GET_SD_CSD:
2697 result = get_sd_csd(srb, chip);
2698 break;
2699
2700 case GET_BUS_WIDTH:
2701 result = get_card_bus_width(srb, chip);
2702 break;
2703
2704 case SCSI_APP_CMD:
2705 result = app_cmd(srb, chip);
2706 break;
2707
2708 case SPI_VENDOR_COMMAND:
2709 result = spi_vendor_cmd(srb, chip);
2710 break;
2711
2712 default:
2713 set_sense_type(chip, SCSI_LUN(srb),
2714 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2715 return TRANSPORT_FAILED;
2716 }
2717
2718 return result;
2719}
2720
2721#if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
2722void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2723{
2724 unsigned int lun = SCSI_LUN(srb);
2725 u16 sec_cnt;
2726
2727 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
2728 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
2729 } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
2730 sec_cnt = srb->cmnd[4];
2731 if (sec_cnt == 0)
2732 sec_cnt = 256;
2733 } else {
2734 return;
2735 }
2736
2737 if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) {
2738 toggle_gpio(chip, LED_GPIO);
2739 chip->rw_cap[lun] = 0;
2740 } else {
2741 chip->rw_cap[lun] += sec_cnt;
2742 }
2743}
2744#endif
2745
2746static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2747{
2748 struct ms_info *ms_card = &chip->ms_card;
2749 unsigned int lun = SCSI_LUN(srb);
2750 bool quick_format;
2751 int retval;
2752
2753 if (get_lun_card(chip, lun) != MS_CARD) {
2754 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2755 return TRANSPORT_FAILED;
2756 }
2757
2758 if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47) ||
2759 (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D) ||
2760 (srb->cmnd[7] != 0x74)) {
2761 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2762 return TRANSPORT_FAILED;
2763 }
2764
2765 rtsx_disable_aspm(chip);
2766
2767 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2768 rtsx_exit_ss(chip);
2769 wait_timeout(100);
2770
2771 if (!check_card_ready(chip, lun) ||
2772 (get_card_size(chip, lun) == 0)) {
2773 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2774 return TRANSPORT_FAILED;
2775 }
2776 }
2777 rtsx_set_stat(chip, RTSX_STAT_RUN);
2778
2779 if (srb->cmnd[8] & 0x01)
2780 quick_format = false;
2781 else
2782 quick_format = true;
2783
2784 if (!(chip->card_ready & MS_CARD)) {
2785 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2786 return TRANSPORT_FAILED;
2787 }
2788
2789 if (chip->card_wp & MS_CARD) {
2790 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2791 return TRANSPORT_FAILED;
2792 }
2793
2794 if (!CHK_MSPRO(ms_card)) {
2795 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2796 return TRANSPORT_FAILED;
2797 }
2798
2799 retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
2800 if (retval != STATUS_SUCCESS) {
2801 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
2802 return TRANSPORT_FAILED;
2803 }
2804
2805 scsi_set_resid(srb, 0);
2806 return TRANSPORT_GOOD;
2807}
2808
2809#ifdef SUPPORT_PCGL_1P18
2810static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2811{
2812 struct ms_info *ms_card = &chip->ms_card;
2813 unsigned int lun = SCSI_LUN(srb);
2814 u8 dev_info_id, data_len;
2815 u8 *buf;
2816 unsigned int buf_len;
2817 int i;
2818
2819 if (!check_card_ready(chip, lun)) {
2820 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2821 return TRANSPORT_FAILED;
2822 }
2823 if (get_lun_card(chip, lun) != MS_CARD) {
2824 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2825 return TRANSPORT_FAILED;
2826 }
2827
2828 if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) ||
2829 (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) ||
2830 (srb->cmnd[7] != 0x44)) {
2831 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2832 return TRANSPORT_FAILED;
2833 }
2834
2835 dev_info_id = srb->cmnd[3];
2836 if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) ||
2837 (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) ||
2838 !CHK_MSPRO(ms_card)) {
2839 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2840 return TRANSPORT_FAILED;
2841 }
2842
2843 if (dev_info_id == 0x15) {
2844 buf_len = 0x3A;
2845 data_len = 0x3A;
2846 } else {
2847 buf_len = 0x6A;
2848 data_len = 0x6A;
2849 }
2850
2851 buf = kmalloc(buf_len, GFP_KERNEL);
2852 if (!buf) {
2853 return TRANSPORT_ERROR;
2854 }
2855
2856 i = 0;
2857
2858 buf[i++] = 0x00;
2859 buf[i++] = data_len;
2860
2861 if (CHK_MSXC(ms_card))
2862 buf[i++] = 0x03;
2863 else
2864 buf[i++] = 0x02;
2865
2866
2867 buf[i++] = 0x01;
2868
2869 buf[i++] = 0x00;
2870 buf[i++] = 0x00;
2871 buf[i++] = 0x00;
2872
2873 buf[i++] = 0x01;
2874
2875
2876
2877
2878 buf[i++] = dev_info_id;
2879
2880 if (dev_info_id == 0x15)
2881 data_len = 0x31;
2882 else
2883 data_len = 0x61;
2884
2885 buf[i++] = 0x00;
2886 buf[i++] = data_len;
2887
2888 buf[i++] = 0x80;
2889 if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
2890
2891 memcpy(buf + i, ms_card->raw_sys_info, 96);
2892 } else {
2893
2894 memcpy(buf + i, ms_card->raw_model_name, 48);
2895 }
2896
2897 rtsx_stor_set_xfer_buf(buf, buf_len, srb);
2898
2899 if (dev_info_id == 0x15)
2900 scsi_set_resid(srb, scsi_bufflen(srb) - 0x3C);
2901 else
2902 scsi_set_resid(srb, scsi_bufflen(srb) - 0x6C);
2903
2904 kfree(buf);
2905 return STATUS_SUCCESS;
2906}
2907#endif
2908
2909static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2910{
2911 int retval = TRANSPORT_ERROR;
2912
2913 if (srb->cmnd[2] == MS_FORMAT)
2914 retval = ms_format_cmnd(srb, chip);
2915#ifdef SUPPORT_PCGL_1P18
2916 else if (srb->cmnd[2] == GET_MS_INFORMATION)
2917 retval = get_ms_information(srb, chip);
2918#endif
2919
2920 return retval;
2921}
2922
2923#ifdef SUPPORT_CPRM
2924static int sd_extension_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2925{
2926 unsigned int lun = SCSI_LUN(srb);
2927 int result;
2928
2929 rtsx_disable_aspm(chip);
2930
2931 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2932 rtsx_exit_ss(chip);
2933 wait_timeout(100);
2934 }
2935 rtsx_set_stat(chip, RTSX_STAT_RUN);
2936
2937 sd_cleanup_work(chip);
2938
2939 if (!check_card_ready(chip, lun)) {
2940 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2941 return TRANSPORT_FAILED;
2942 }
2943 if (get_lun_card(chip, lun) != SD_CARD) {
2944 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2945 return TRANSPORT_FAILED;
2946 }
2947
2948 switch (srb->cmnd[0]) {
2949 case SD_PASS_THRU_MODE:
2950 result = sd_pass_thru_mode(srb, chip);
2951 break;
2952
2953 case SD_EXECUTE_NO_DATA:
2954 result = sd_execute_no_data(srb, chip);
2955 break;
2956
2957 case SD_EXECUTE_READ:
2958 result = sd_execute_read_data(srb, chip);
2959 break;
2960
2961 case SD_EXECUTE_WRITE:
2962 result = sd_execute_write_data(srb, chip);
2963 break;
2964
2965 case SD_GET_RSP:
2966 result = sd_get_cmd_rsp(srb, chip);
2967 break;
2968
2969 case SD_HW_RST:
2970 result = sd_hw_rst(srb, chip);
2971 break;
2972
2973 default:
2974 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2975 return TRANSPORT_FAILED;
2976 }
2977
2978 return result;
2979}
2980#endif
2981
2982#ifdef SUPPORT_MAGIC_GATE
2983static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2984{
2985 struct ms_info *ms_card = &chip->ms_card;
2986 unsigned int lun = SCSI_LUN(srb);
2987 int retval;
2988 u8 key_format;
2989
2990 rtsx_disable_aspm(chip);
2991
2992 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2993 rtsx_exit_ss(chip);
2994 wait_timeout(100);
2995 }
2996 rtsx_set_stat(chip, RTSX_STAT_RUN);
2997
2998 ms_cleanup_work(chip);
2999
3000 if (!check_card_ready(chip, lun)) {
3001 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3002 return TRANSPORT_FAILED;
3003 }
3004 if (get_lun_card(chip, lun) != MS_CARD) {
3005 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3006 return TRANSPORT_FAILED;
3007 }
3008
3009 if (srb->cmnd[7] != KC_MG_R_PRO) {
3010 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3011 return TRANSPORT_FAILED;
3012 }
3013
3014 if (!CHK_MSPRO(ms_card)) {
3015 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3016 return TRANSPORT_FAILED;
3017 }
3018
3019 key_format = srb->cmnd[10] & 0x3F;
3020 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3021
3022 switch (key_format) {
3023 case KF_GET_LOC_EKB:
3024 if ((scsi_bufflen(srb) == 0x41C) &&
3025 (srb->cmnd[8] == 0x04) &&
3026 (srb->cmnd[9] == 0x1C)) {
3027 retval = mg_get_local_EKB(srb, chip);
3028 if (retval != STATUS_SUCCESS) {
3029 return TRANSPORT_FAILED;
3030 }
3031
3032 } else {
3033 set_sense_type(chip, lun,
3034 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3035 return TRANSPORT_FAILED;
3036 }
3037 break;
3038
3039 case KF_RSP_CHG:
3040 if ((scsi_bufflen(srb) == 0x24) &&
3041 (srb->cmnd[8] == 0x00) &&
3042 (srb->cmnd[9] == 0x24)) {
3043 retval = mg_get_rsp_chg(srb, chip);
3044 if (retval != STATUS_SUCCESS) {
3045 return TRANSPORT_FAILED;
3046 }
3047
3048 } else {
3049 set_sense_type(chip, lun,
3050 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3051 return TRANSPORT_FAILED;
3052 }
3053 break;
3054
3055 case KF_GET_ICV:
3056 ms_card->mg_entry_num = srb->cmnd[5];
3057 if ((scsi_bufflen(srb) == 0x404) &&
3058 (srb->cmnd[8] == 0x04) &&
3059 (srb->cmnd[9] == 0x04) &&
3060 (srb->cmnd[2] == 0x00) &&
3061 (srb->cmnd[3] == 0x00) &&
3062 (srb->cmnd[4] == 0x00) &&
3063 (srb->cmnd[5] < 32)) {
3064 retval = mg_get_ICV(srb, chip);
3065 if (retval != STATUS_SUCCESS) {
3066 return TRANSPORT_FAILED;
3067 }
3068
3069 } else {
3070 set_sense_type(chip, lun,
3071 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3072 return TRANSPORT_FAILED;
3073 }
3074 break;
3075
3076 default:
3077 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3078 return TRANSPORT_FAILED;
3079 }
3080
3081 scsi_set_resid(srb, 0);
3082 return TRANSPORT_GOOD;
3083}
3084
3085static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3086{
3087 struct ms_info *ms_card = &chip->ms_card;
3088 unsigned int lun = SCSI_LUN(srb);
3089 int retval;
3090 u8 key_format;
3091
3092 rtsx_disable_aspm(chip);
3093
3094 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3095 rtsx_exit_ss(chip);
3096 wait_timeout(100);
3097 }
3098 rtsx_set_stat(chip, RTSX_STAT_RUN);
3099
3100 ms_cleanup_work(chip);
3101
3102 if (!check_card_ready(chip, lun)) {
3103 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3104 return TRANSPORT_FAILED;
3105 }
3106 if (check_card_wp(chip, lun)) {
3107 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
3108 return TRANSPORT_FAILED;
3109 }
3110 if (get_lun_card(chip, lun) != MS_CARD) {
3111 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3112 return TRANSPORT_FAILED;
3113 }
3114
3115 if (srb->cmnd[7] != KC_MG_R_PRO) {
3116 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3117 return TRANSPORT_FAILED;
3118 }
3119
3120 if (!CHK_MSPRO(ms_card)) {
3121 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3122 return TRANSPORT_FAILED;
3123 }
3124
3125 key_format = srb->cmnd[10] & 0x3F;
3126 dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3127
3128 switch (key_format) {
3129 case KF_SET_LEAF_ID:
3130 if ((scsi_bufflen(srb) == 0x0C) &&
3131 (srb->cmnd[8] == 0x00) &&
3132 (srb->cmnd[9] == 0x0C)) {
3133 retval = mg_set_leaf_id(srb, chip);
3134 if (retval != STATUS_SUCCESS) {
3135 return TRANSPORT_FAILED;
3136 }
3137
3138 } else {
3139 set_sense_type(chip, lun,
3140 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3141 return TRANSPORT_FAILED;
3142 }
3143 break;
3144
3145 case KF_CHG_HOST:
3146 if ((scsi_bufflen(srb) == 0x0C) &&
3147 (srb->cmnd[8] == 0x00) &&
3148 (srb->cmnd[9] == 0x0C)) {
3149 retval = mg_chg(srb, chip);
3150 if (retval != STATUS_SUCCESS) {
3151 return TRANSPORT_FAILED;
3152 }
3153
3154 } else {
3155 set_sense_type(chip, lun,
3156 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3157 return TRANSPORT_FAILED;
3158 }
3159 break;
3160
3161 case KF_RSP_HOST:
3162 if ((scsi_bufflen(srb) == 0x0C) &&
3163 (srb->cmnd[8] == 0x00) &&
3164 (srb->cmnd[9] == 0x0C)) {
3165 retval = mg_rsp(srb, chip);
3166 if (retval != STATUS_SUCCESS) {
3167 return TRANSPORT_FAILED;
3168 }
3169
3170 } else {
3171 set_sense_type(chip, lun,
3172 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3173 return TRANSPORT_FAILED;
3174 }
3175 break;
3176
3177 case KF_SET_ICV:
3178 ms_card->mg_entry_num = srb->cmnd[5];
3179 if ((scsi_bufflen(srb) == 0x404) &&
3180 (srb->cmnd[8] == 0x04) &&
3181 (srb->cmnd[9] == 0x04) &&
3182 (srb->cmnd[2] == 0x00) &&
3183 (srb->cmnd[3] == 0x00) &&
3184 (srb->cmnd[4] == 0x00) &&
3185 (srb->cmnd[5] < 32)) {
3186 retval = mg_set_ICV(srb, chip);
3187 if (retval != STATUS_SUCCESS) {
3188 return TRANSPORT_FAILED;
3189 }
3190
3191 } else {
3192 set_sense_type(chip, lun,
3193 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3194 return TRANSPORT_FAILED;
3195 }
3196 break;
3197
3198 default:
3199 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3200 return TRANSPORT_FAILED;
3201 }
3202
3203 scsi_set_resid(srb, 0);
3204 return TRANSPORT_GOOD;
3205}
3206#endif
3207
3208int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3209{
3210#ifdef SUPPORT_SD_LOCK
3211 struct sd_info *sd_card = &chip->sd_card;
3212#endif
3213 struct ms_info *ms_card = &chip->ms_card;
3214 unsigned int lun = SCSI_LUN(srb);
3215 int result;
3216
3217#ifdef SUPPORT_SD_LOCK
3218 if (sd_card->sd_erase_status) {
3219
3220
3221
3222 if (!((srb->cmnd[0] == VENDOR_CMND) &&
3223 (srb->cmnd[1] == SCSI_APP_CMD) &&
3224 (srb->cmnd[2] == GET_DEV_STATUS)) &&
3225 (srb->cmnd[0] != REQUEST_SENSE)) {
3226
3227 set_sense_data(chip, lun, CUR_ERR,
3228 0x02, 0, 0x04, 0x04, 0, 0);
3229 return TRANSPORT_FAILED;
3230 }
3231 }
3232#endif
3233
3234 if ((get_lun_card(chip, lun) == MS_CARD) &&
3235 (ms_card->format_status == FORMAT_IN_PROGRESS)) {
3236 if ((srb->cmnd[0] != REQUEST_SENSE) &&
3237 (srb->cmnd[0] != INQUIRY)) {
3238
3239 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
3240 0, (u16)(ms_card->progress));
3241 return TRANSPORT_FAILED;
3242 }
3243 }
3244
3245 switch (srb->cmnd[0]) {
3246 case READ_10:
3247 case WRITE_10:
3248 case READ_6:
3249 case WRITE_6:
3250 result = read_write(srb, chip);
3251#if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
3252 led_shine(srb, chip);
3253#endif
3254 break;
3255
3256 case TEST_UNIT_READY:
3257 result = test_unit_ready(srb, chip);
3258 break;
3259
3260 case INQUIRY:
3261 result = inquiry(srb, chip);
3262 break;
3263
3264 case READ_CAPACITY:
3265 result = read_capacity(srb, chip);
3266 break;
3267
3268 case START_STOP:
3269 result = start_stop_unit(srb, chip);
3270 break;
3271
3272 case ALLOW_MEDIUM_REMOVAL:
3273 result = allow_medium_removal(srb, chip);
3274 break;
3275
3276 case REQUEST_SENSE:
3277 result = request_sense(srb, chip);
3278 break;
3279
3280 case MODE_SENSE:
3281 case MODE_SENSE_10:
3282 result = mode_sense(srb, chip);
3283 break;
3284
3285 case 0x23:
3286 result = read_format_capacity(srb, chip);
3287 break;
3288
3289 case VENDOR_CMND:
3290 result = vendor_cmnd(srb, chip);
3291 break;
3292
3293 case MS_SP_CMND:
3294 result = ms_sp_cmnd(srb, chip);
3295 break;
3296
3297#ifdef SUPPORT_CPRM
3298 case SD_PASS_THRU_MODE:
3299 case SD_EXECUTE_NO_DATA:
3300 case SD_EXECUTE_READ:
3301 case SD_EXECUTE_WRITE:
3302 case SD_GET_RSP:
3303 case SD_HW_RST:
3304 result = sd_extension_cmnd(srb, chip);
3305 break;
3306#endif
3307
3308#ifdef SUPPORT_MAGIC_GATE
3309 case CMD_MSPRO_MG_RKEY:
3310 result = mg_report_key(srb, chip);
3311 break;
3312
3313 case CMD_MSPRO_MG_SKEY:
3314 result = mg_send_key(srb, chip);
3315 break;
3316#endif
3317
3318 case FORMAT_UNIT:
3319 case MODE_SELECT:
3320 case VERIFY:
3321 result = TRANSPORT_GOOD;
3322 break;
3323
3324 default:
3325 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3326 result = TRANSPORT_FAILED;
3327 }
3328
3329 return result;
3330}
3331
