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