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