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