Gitiles
Code Review Sign In
gerrit-public.fairphone.software / kernel / msm-4.9 / 1f224ad2f760288dcc58b26546892a6b200b2af2 / . / drivers / staging / rts5208 / rtsx_scsi.c
blob: bbfa665c5c99c11622bf1d9fe85c4778a6da0bce [file] [log] [blame]
Micky Chingfa590c22013-11-12 17:16:08 +0800[diff] [blame]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
38void scsi_show_command(struct scsi_cmnd *srb)
39{
40 char *what = NULL;
41 int i, unknown_cmd = 0;
42
43 switch (srb->cmnd[0]) {
44 case TEST_UNIT_READY:
45 what = "TEST_UNIT_READY";
46 break;
47 case REZERO_UNIT:
48 what = "REZERO_UNIT";
49 break;
50 case REQUEST_SENSE:
51 what = "REQUEST_SENSE";
52 break;
53 case FORMAT_UNIT:
54 what = "FORMAT_UNIT";
55 break;
56 case READ_BLOCK_LIMITS:
57 what = "READ_BLOCK_LIMITS";
58 break;
59 case REASSIGN_BLOCKS:
60 what = "REASSIGN_BLOCKS";
61 break;
62 case READ_6:
63 what = "READ_6";
64 break;
65 case WRITE_6:
66 what = "WRITE_6";
67 break;
68 case SEEK_6:
69 what = "SEEK_6";
70 break;
71 case READ_REVERSE:
72 what = "READ_REVERSE";
73 break;
74 case WRITE_FILEMARKS:
75 what = "WRITE_FILEMARKS";
76 break;
77 case SPACE:
78 what = "SPACE";
79 break;
80 case INQUIRY:
81 what = "INQUIRY";
82 break;
83 case RECOVER_BUFFERED_DATA:
84 what = "RECOVER_BUFFERED_DATA";
85 break;
86 case MODE_SELECT:
87 what = "MODE_SELECT";
88 break;
89 case RESERVE:
90 what = "RESERVE";
91 break;
92 case RELEASE:
93 what = "RELEASE";
94 break;
95 case COPY:
96 what = "COPY";
97 break;
98 case ERASE:
99 what = "ERASE";
100 break;
101 case MODE_SENSE:
102 what = "MODE_SENSE";
103 break;
104 case START_STOP:
105 what = "START_STOP";
106 break;
107 case RECEIVE_DIAGNOSTIC:
108 what = "RECEIVE_DIAGNOSTIC";
109 break;
110 case SEND_DIAGNOSTIC:
111 what = "SEND_DIAGNOSTIC";
112 break;
113 case ALLOW_MEDIUM_REMOVAL:
114 what = "ALLOW_MEDIUM_REMOVAL";
115 break;
116 case SET_WINDOW:
117 what = "SET_WINDOW";
118 break;
119 case READ_CAPACITY:
120 what = "READ_CAPACITY";
121 break;
122 case READ_10:
123 what = "READ_10";
124 break;
125 case WRITE_10:
126 what = "WRITE_10";
127 break;
128 case SEEK_10:
129 what = "SEEK_10";
130 break;
131 case WRITE_VERIFY:
132 what = "WRITE_VERIFY";
133 break;
134 case VERIFY:
135 what = "VERIFY";
136 break;
137 case SEARCH_HIGH:
138 what = "SEARCH_HIGH";
139 break;
140 case SEARCH_EQUAL:
141 what = "SEARCH_EQUAL";
142 break;
143 case SEARCH_LOW:
144 what = "SEARCH_LOW";
145 break;
146 case SET_LIMITS:
147 what = "SET_LIMITS";
148 break;
149 case READ_POSITION:
150 what = "READ_POSITION";
151 break;
152 case SYNCHRONIZE_CACHE:
153 what = "SYNCHRONIZE_CACHE";
154 break;
155 case LOCK_UNLOCK_CACHE:
156 what = "LOCK_UNLOCK_CACHE";
157 break;
158 case READ_DEFECT_DATA:
159 what = "READ_DEFECT_DATA";
160 break;
161 case MEDIUM_SCAN:
162 what = "MEDIUM_SCAN";
163 break;
164 case COMPARE:
165 what = "COMPARE";
166 break;
167 case COPY_VERIFY:
168 what = "COPY_VERIFY";
169 break;
170 case WRITE_BUFFER:
171 what = "WRITE_BUFFER";
172 break;
173 case READ_BUFFER:
174 what = "READ_BUFFER";
175 break;
176 case UPDATE_BLOCK:
177 what = "UPDATE_BLOCK";
178 break;
179 case READ_LONG:
180 what = "READ_LONG";
181 break;
182 case WRITE_LONG:
183 what = "WRITE_LONG";
184 break;
185 case CHANGE_DEFINITION:
186 what = "CHANGE_DEFINITION";
187 break;
188 case WRITE_SAME:
189 what = "WRITE_SAME";
190 break;
191 case GPCMD_READ_SUBCHANNEL:
192 what = "READ SUBCHANNEL";
193 break;
194 case READ_TOC:
195 what = "READ_TOC";
196 break;
197 case GPCMD_READ_HEADER:
198 what = "READ HEADER";
199 break;
200 case GPCMD_PLAY_AUDIO_10:
201 what = "PLAY AUDIO (10)";
202 break;
203 case GPCMD_PLAY_AUDIO_MSF:
204 what = "PLAY AUDIO MSF";
205 break;
206 case GPCMD_GET_EVENT_STATUS_NOTIFICATION:
207 what = "GET EVENT/STATUS NOTIFICATION";
208 break;
209 case GPCMD_PAUSE_RESUME:
210 what = "PAUSE/RESUME";
211 break;
212 case LOG_SELECT:
213 what = "LOG_SELECT";
214 break;
215 case LOG_SENSE:
216 what = "LOG_SENSE";
217 break;
218 case GPCMD_STOP_PLAY_SCAN:
219 what = "STOP PLAY/SCAN";
220 break;
221 case GPCMD_READ_DISC_INFO:
222 what = "READ DISC INFORMATION";
223 break;
224 case GPCMD_READ_TRACK_RZONE_INFO:
225 what = "READ TRACK INFORMATION";
226 break;
227 case GPCMD_RESERVE_RZONE_TRACK:
228 what = "RESERVE TRACK";
229 break;
230 case GPCMD_SEND_OPC:
231 what = "SEND OPC";
232 break;
233 case MODE_SELECT_10:
234 what = "MODE_SELECT_10";
235 break;
236 case GPCMD_REPAIR_RZONE_TRACK:
237 what = "REPAIR TRACK";
238 break;
239 case 0x59:
240 what = "READ MASTER CUE";
241 break;
242 case MODE_SENSE_10:
243 what = "MODE_SENSE_10";
244 break;
245 case GPCMD_CLOSE_TRACK:
246 what = "CLOSE TRACK/SESSION";
247 break;
248 case 0x5C:
249 what = "READ BUFFER CAPACITY";
250 break;
251 case 0x5D:
252 what = "SEND CUE SHEET";
253 break;
254 case GPCMD_BLANK:
255 what = "BLANK";
256 break;
257 case REPORT_LUNS:
258 what = "REPORT LUNS";
259 break;
260 case MOVE_MEDIUM:
261 what = "MOVE_MEDIUM or PLAY AUDIO (12)";
262 break;
263 case READ_12:
264 what = "READ_12";
265 break;
266 case WRITE_12:
267 what = "WRITE_12";
268 break;
269 case WRITE_VERIFY_12:
270 what = "WRITE_VERIFY_12";
271 break;
272 case SEARCH_HIGH_12:
273 what = "SEARCH_HIGH_12";
274 break;
275 case SEARCH_EQUAL_12:
276 what = "SEARCH_EQUAL_12";
277 break;
278 case SEARCH_LOW_12:
279 what = "SEARCH_LOW_12";
280 break;
281 case SEND_VOLUME_TAG:
282 what = "SEND_VOLUME_TAG";
283 break;
284 case READ_ELEMENT_STATUS:
285 what = "READ_ELEMENT_STATUS";
286 break;
287 case GPCMD_READ_CD_MSF:
288 what = "READ CD MSF";
289 break;
290 case GPCMD_SCAN:
291 what = "SCAN";
292 break;
293 case GPCMD_SET_SPEED:
294 what = "SET CD SPEED";
295 break;
296 case GPCMD_MECHANISM_STATUS:
297 what = "MECHANISM STATUS";
298 break;
299 case GPCMD_READ_CD:
300 what = "READ CD";
301 break;
302 case 0xE1:
303 what = "WRITE CONTINUE";
304 break;
305 case WRITE_LONG_2:
306 what = "WRITE_LONG_2";
307 break;
308 case VENDOR_CMND:
309 what = "Realtek's vendor command";
310 break;
311 default:
312 what = "(unknown command)"; unknown_cmd = 1;
313 break;
314 }
315
316 if (srb->cmnd[0] != TEST_UNIT_READY)
317 RTSX_DEBUGP("Command %s (%d bytes)\n", what, srb->cmd_len);
318
319 if (unknown_cmd) {
320 RTSX_DEBUGP("");
321 for (i = 0; i < srb->cmd_len && i < 16; i++)
322 RTSX_DEBUGPN(" %02x", srb->cmnd[i]);
323 RTSX_DEBUGPN("\n");
324 }
325}
326
327void 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
402void 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
425static 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 if (sd_card->sd_lock_notify) {
444 sd_card->sd_lock_notify = 0;
445 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
446 return TRANSPORT_FAILED;
447 } else if (sd_card->sd_lock_status & SD_LOCKED) {
448 set_sense_type(chip, lun,
449 SENSE_TYPE_MEDIA_READ_FORBIDDEN);
450 return TRANSPORT_FAILED;
451 }
452 }
453#endif
454
455 return TRANSPORT_GOOD;
456}
457
458static unsigned char formatter_inquiry_str[20] = {
459 'M', 'E', 'M', 'O', 'R', 'Y', 'S', 'T', 'I', 'C', 'K',
460#ifdef SUPPORT_MAGIC_GATE
461 '-', 'M', 'G', /* Byte[47:49] */
462#else
463 0x20, 0x20, 0x20, /* Byte[47:49] */
464#endif
465
466#ifdef SUPPORT_MAGIC_GATE
467 0x0B, /* Byte[50]: MG, MS, MSPro, MSXC */
468#else
469 0x09, /* Byte[50]: MS, MSPro, MSXC */
470#endif
471 0x00, /* Byte[51]: Category Specific Commands */
472 0x00, /* Byte[52]: Access Control and feature */
473 0x20, 0x20, 0x20, /* Byte[53:55] */
474};
475
476static int inquiry(struct scsi_cmnd *srb, struct rtsx_chip *chip)
477{
478 unsigned int lun = SCSI_LUN(srb);
479 char *inquiry_default = (char *)"Generic-xD/SD/M.S. 1.00 ";
480 char *inquiry_sdms = (char *)"Generic-SD/MemoryStick 1.00 ";
481 char *inquiry_sd = (char *)"Generic-SD/MMC 1.00 ";
482 char *inquiry_ms = (char *)"Generic-MemoryStick 1.00 ";
483 char *inquiry_string;
484 unsigned char sendbytes;
485 unsigned char *buf;
486 u8 card = get_lun_card(chip, lun);
487 int pro_formatter_flag = 0;
488 unsigned char inquiry_buf[] = {
489 QULIFIRE|DRCT_ACCESS_DEV,
490 RMB_DISC|0x0D,
491 0x00,
492 0x01,
493 0x1f,
494 0x02,
495 0,
496 REL_ADR|WBUS_32|WBUS_16|SYNC|LINKED|CMD_QUE|SFT_RE,
497 };
498
499 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
500 if (chip->lun2card[lun] == SD_CARD)
501 inquiry_string = inquiry_sd;
502 else
503 inquiry_string = inquiry_ms;
504
505 } else if (CHECK_LUN_MODE(chip, SD_MS_1LUN)) {
506 inquiry_string = inquiry_sdms;
507 } else {
508 inquiry_string = inquiry_default;
509 }
510
511 buf = vmalloc(scsi_bufflen(srb));
512 if (buf == NULL)
513 TRACE_RET(chip, TRANSPORT_ERROR);
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 {
522 if (!card || (card == MS_CARD))
523 pro_formatter_flag = 1;
524 }
525
526 if (pro_formatter_flag) {
527 if (scsi_bufflen(srb) < 56)
528 sendbytes = (unsigned char)(scsi_bufflen(srb));
529 else
530 sendbytes = 56;
531
532 } else {
533 if (scsi_bufflen(srb) < 36)
534 sendbytes = (unsigned char)(scsi_bufflen(srb));
535 else
536 sendbytes = 36;
537 }
538
539 if (sendbytes > 8) {
540 memcpy(buf, inquiry_buf, 8);
541 memcpy(buf + 8, inquiry_string, sendbytes - 8);
542 if (pro_formatter_flag) {
543 /* Additional Length */
544 buf[4] = 0x33;
545 }
546 } else {
547 memcpy(buf, inquiry_buf, sendbytes);
548 }
549
550 if (pro_formatter_flag) {
551 if (sendbytes > 36)
552 memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36);
553 }
554
555 scsi_set_resid(srb, 0);
556
557 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
558 vfree(buf);
559
560 return TRANSPORT_GOOD;
561}
562
563
564static int start_stop_unit(struct scsi_cmnd *srb, struct rtsx_chip *chip)
565{
566 unsigned int lun = SCSI_LUN(srb);
567
568 scsi_set_resid(srb, scsi_bufflen(srb));
569
570 if (srb->cmnd[1] == 1)
571 return TRANSPORT_GOOD;
572
573 switch (srb->cmnd[0x4]) {
574 case STOP_MEDIUM:
575 /* Media disabled */
576 return TRANSPORT_GOOD;
577
578 case UNLOAD_MEDIUM:
579 /* Media shall be unload */
580 if (check_card_ready(chip, lun))
581 eject_card(chip, lun);
582 return TRANSPORT_GOOD;
583
584 case MAKE_MEDIUM_READY:
585 case LOAD_MEDIUM:
586 if (check_card_ready(chip, lun)) {
587 return TRANSPORT_GOOD;
588 } else {
589 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
590 TRACE_RET(chip, TRANSPORT_FAILED);
591 }
592
593 break;
594 }
595
596 TRACE_RET(chip, TRANSPORT_ERROR);
597}
598
599
600static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip)
601{
602 int prevent;
603
604 prevent = srb->cmnd[4] & 0x1;
605
606 scsi_set_resid(srb, 0);
607
608 if (prevent) {
609 set_sense_type(chip, SCSI_LUN(srb),
610 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
611 TRACE_RET(chip, TRANSPORT_FAILED);
612 }
613
614 return TRANSPORT_GOOD;
615}
616
617
618static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
619{
620 struct sense_data_t *sense;
621 unsigned int lun = SCSI_LUN(srb);
622 struct ms_info *ms_card = &(chip->ms_card);
623 unsigned char *tmp, *buf;
624
625 sense = &(chip->sense_buffer[lun]);
626
627 if ((get_lun_card(chip, lun) == MS_CARD) &&
628 ms_card->pro_under_formatting) {
629 if (ms_card->format_status == FORMAT_SUCCESS) {
630 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
631 ms_card->pro_under_formatting = 0;
632 ms_card->progress = 0;
633 } else if (ms_card->format_status == FORMAT_IN_PROGRESS) {
634 /* Logical Unit Not Ready Format in Progress */
635 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
636 0, (u16)(ms_card->progress));
637 } else {
638 /* Format Command Failed */
639 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
640 ms_card->pro_under_formatting = 0;
641 ms_card->progress = 0;
642 }
643
644 rtsx_set_stat(chip, RTSX_STAT_RUN);
645 }
646
647 buf = vmalloc(scsi_bufflen(srb));
648 if (buf == NULL)
649 TRACE_RET(chip, TRANSPORT_ERROR);
650
651 tmp = (unsigned char *)sense;
652 memcpy(buf, tmp, scsi_bufflen(srb));
653
654 rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
655 vfree(buf);
656
657 scsi_set_resid(srb, 0);
658 /* Reset Sense Data */
659 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
660 return TRANSPORT_GOOD;
661}
662
663static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd,
664 int lun, u8 *buf, int buf_len)
665{
666 struct ms_info *ms_card = &(chip->ms_card);
667 int sys_info_offset;
668 int data_size = buf_len;
669 int support_format = 0;
670 int i = 0;
671
672 if (cmd == MODE_SENSE) {
673 sys_info_offset = 8;
674 if (data_size > 0x68)
675 data_size = 0x68;
676
677 buf[i++] = 0x67; /* Mode Data Length */
678 } else {
679 sys_info_offset = 12;
680 if (data_size > 0x6C)
681 data_size = 0x6C;
682
683 buf[i++] = 0x00; /* Mode Data Length (MSB) */
684 buf[i++] = 0x6A; /* Mode Data Length (LSB) */
685 }
686
687 /* Medium Type Code */
688 if (check_card_ready(chip, lun)) {
689 if (CHK_MSXC(ms_card)) {
690 support_format = 1;
691 buf[i++] = 0x40;
692 } else if (CHK_MSPRO(ms_card)) {
693 support_format = 1;
694 buf[i++] = 0x20;
695 } else {
696 buf[i++] = 0x10;
697 }
698
699 /* WP */
700 if (check_card_wp(chip, lun))
701 buf[i++] = 0x80;
702 else
703 buf[i++] = 0x00;
704
705 } else {
706 buf[i++] = 0x00; /* MediaType */
707 buf[i++] = 0x00; /* WP */
708 }
709
710 buf[i++] = 0x00; /* Reserved */
711
712 if (cmd == MODE_SENSE_10) {
713 buf[i++] = 0x00; /* Reserved */
714 buf[i++] = 0x00; /* Block descriptor length(MSB) */
715 buf[i++] = 0x00; /* Block descriptor length(LSB) */
716
717 /* The Following Data is the content of "Page 0x20" */
718 if (data_size >= 9)
719 buf[i++] = 0x20; /* Page Code */
720 if (data_size >= 10)
721 buf[i++] = 0x62; /* Page Length */
722 if (data_size >= 11)
723 buf[i++] = 0x00; /* No Access Control */
724 if (data_size >= 12) {
725 if (support_format)
726 buf[i++] = 0xC0; /* SF, SGM */
727 else
728 buf[i++] = 0x00;
729 }
730 } else {
731 /* The Following Data is the content of "Page 0x20" */
732 if (data_size >= 5)
733 buf[i++] = 0x20; /* Page Code */
734 if (data_size >= 6)
735 buf[i++] = 0x62; /* Page Length */
736 if (data_size >= 7)
737 buf[i++] = 0x00; /* No Access Control */
738 if (data_size >= 8) {
739 if (support_format)
740 buf[i++] = 0xC0; /* SF, SGM */
741 else
742 buf[i++] = 0x00;
743 }
744 }
745
746 if (data_size > sys_info_offset) {
747 /* 96 Bytes Attribute Data */
748 int len = data_size - sys_info_offset;
749 len = (len < 96) ? len : 96;
750
751 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len);
752 }
753}
754
755static 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
852static 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 RTSX_DEBUGP("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 RTSX_DEBUGP("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 RTSX_DEBUGP("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 RTSX_DEBUGP("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
980Exit:
981 return retval;
982}
983
984static 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
1062static 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
1102static int read_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1103{
1104 unsigned short len, i;
1105 int retval;
1106 u8 *buf;
1107
1108 rtsx_disable_aspm(chip);
1109
1110 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1111 rtsx_exit_ss(chip);
1112 wait_timeout(100);
1113 }
1114 rtsx_set_stat(chip, RTSX_STAT_RUN);
1115
1116 len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1117
1118 buf = vmalloc(len);
1119 if (!buf)
1120 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
1149static 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
1204static 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
1257static 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
1310static 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
1331static 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
1351static 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 RTSX_DEBUGP("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
1418static 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 RTSX_DEBUGP("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
1449static 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
1477static 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
1539static 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 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1572 } else {
1573 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1574 TRACE_RET(chip, TRANSPORT_FAILED);
1575 }
1576
1577 return TRANSPORT_GOOD;
1578}
1579
1580static int dma_access_ring_buffer(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1581{
1582 int retval;
1583 unsigned int lun = SCSI_LUN(srb);
1584 u16 len;
1585
1586 rtsx_disable_aspm(chip);
1587
1588 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1589 rtsx_exit_ss(chip);
1590 wait_timeout(100);
1591 }
1592 rtsx_set_stat(chip, RTSX_STAT_RUN);
1593
1594 len = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
1595 len = min_t(u16, len, scsi_bufflen(srb));
1596
1597 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1598 RTSX_DEBUGP("Read from device\n");
1599 else
1600 RTSX_DEBUGP("Write to device\n");
1601
1602 retval = rtsx_transfer_data(chip, 0, scsi_sglist(srb), len,
1603 scsi_sg_count(srb), srb->sc_data_direction, 1000);
1604 if (retval < 0) {
1605 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1606 set_sense_type(chip, lun,
1607 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1608 else
1609 set_sense_type(chip, lun,
1610 SENSE_TYPE_MEDIA_WRITE_ERR);
1611
1612 TRACE_RET(chip, TRANSPORT_FAILED);
1613 }
1614 scsi_set_resid(srb, 0);
1615
1616 return TRANSPORT_GOOD;
1617}
1618
1619static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1620{
1621 struct sd_info *sd_card = &(chip->sd_card);
1622 struct ms_info *ms_card = &(chip->ms_card);
1623 int buf_len;
1624 unsigned int lun = SCSI_LUN(srb);
1625 u8 card = get_lun_card(chip, lun);
1626 u8 status[32];
1627#ifdef SUPPORT_OCP
1628 u8 oc_now_mask = 0, oc_ever_mask = 0;
1629#endif
1630
1631 memset(status, 0, 32);
1632
1633 status[0] = (u8)(chip->product_id);
1634 status[1] = chip->ic_version;
1635
1636 if (chip->auto_delink_en)
1637 status[2] = 0x10;
1638 else
1639 status[2] = 0x00;
1640
1641 status[3] = 20;
1642 status[4] = 10;
1643 status[5] = 05;
1644 status[6] = 21;
1645
1646 if (chip->card_wp)
1647 status[7] = 0x20;
1648 else
1649 status[7] = 0x00;
1650
1651#ifdef SUPPORT_OCP
1652 status[8] = 0;
1653 if (CHECK_LUN_MODE(chip,
1654 SD_MS_2LUN) && (chip->lun2card[lun] == MS_CARD)) {
1655 oc_now_mask = MS_OC_NOW;
1656 oc_ever_mask = MS_OC_EVER;
1657 } else {
1658 oc_now_mask = SD_OC_NOW;
1659 oc_ever_mask = SD_OC_EVER;
1660 }
1661
1662 if (chip->ocp_stat & oc_now_mask)
1663 status[8] |= 0x02;
1664
1665 if (chip->ocp_stat & oc_ever_mask)
1666 status[8] |= 0x01;
1667#endif
1668
1669 if (card == SD_CARD) {
1670 if (CHK_SD(sd_card)) {
1671 if (CHK_SD_HCXC(sd_card)) {
1672 if (sd_card->capacity > 0x4000000)
1673 status[0x0E] = 0x02;
1674 else
1675 status[0x0E] = 0x01;
1676 } else {
1677 status[0x0E] = 0x00;
1678 }
1679
1680 if (CHK_SD_SDR104(sd_card))
1681 status[0x0F] = 0x03;
1682 else if (CHK_SD_DDR50(sd_card))
1683 status[0x0F] = 0x04;
1684 else if (CHK_SD_SDR50(sd_card))
1685 status[0x0F] = 0x02;
1686 else if (CHK_SD_HS(sd_card))
1687 status[0x0F] = 0x01;
1688 else
1689 status[0x0F] = 0x00;
1690 } else {
1691 if (CHK_MMC_SECTOR_MODE(sd_card))
1692 status[0x0E] = 0x01;
1693 else
1694 status[0x0E] = 0x00;
1695
1696 if (CHK_MMC_DDR52(sd_card))
1697 status[0x0F] = 0x03;
1698 else if (CHK_MMC_52M(sd_card))
1699 status[0x0F] = 0x02;
1700 else if (CHK_MMC_26M(sd_card))
1701 status[0x0F] = 0x01;
1702 else
1703 status[0x0F] = 0x00;
1704 }
1705 } else if (card == MS_CARD) {
1706 if (CHK_MSPRO(ms_card)) {
1707 if (CHK_MSXC(ms_card))
1708 status[0x0E] = 0x01;
1709 else
1710 status[0x0E] = 0x00;
1711
1712 if (CHK_HG8BIT(ms_card))
1713 status[0x0F] = 0x01;
1714 else
1715 status[0x0F] = 0x00;
1716 }
1717 }
1718
1719#ifdef SUPPORT_SD_LOCK
1720 if (card == SD_CARD) {
1721 status[0x17] = 0x80;
1722 if (sd_card->sd_erase_status)
1723 status[0x17] |= 0x01;
1724 if (sd_card->sd_lock_status & SD_LOCKED) {
1725 status[0x17] |= 0x02;
1726 status[0x07] |= 0x40;
1727 }
1728 if (sd_card->sd_lock_status & SD_PWD_EXIST)
1729 status[0x17] |= 0x04;
1730 } else {
1731 status[0x17] = 0x00;
1732 }
1733
1734 RTSX_DEBUGP("status[0x17] = 0x%x\n", status[0x17]);
1735#endif
1736
1737 status[0x18] = 0x8A;
1738 status[0x1A] = 0x28;
1739#ifdef SUPPORT_SD_LOCK
1740 status[0x1F] = 0x01;
1741#endif
1742
1743 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(status));
1744 rtsx_stor_set_xfer_buf(status, buf_len, srb);
1745 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1746
1747 return TRANSPORT_GOOD;
1748}
1749
1750static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1751{
1752 int phy_debug_mode;
1753 int retval;
1754 u16 reg;
1755
1756 if (!CHECK_PID(chip, 0x5208)) {
1757 set_sense_type(chip, SCSI_LUN(srb),
1758 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1759 TRACE_RET(chip, TRANSPORT_FAILED);
1760 }
1761
1762 phy_debug_mode = (int)(srb->cmnd[3]);
1763
1764 if (phy_debug_mode) {
1765 chip->phy_debug_mode = 1;
1766 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0);
1767 if (retval != STATUS_SUCCESS)
1768 TRACE_RET(chip, TRANSPORT_FAILED);
1769
1770 rtsx_disable_bus_int(chip);
1771
1772 retval = rtsx_read_phy_register(chip, 0x1C, &reg);
1773 if (retval != STATUS_SUCCESS)
1774 TRACE_RET(chip, TRANSPORT_FAILED);
1775
1776 reg |= 0x0001;
1777 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1778 if (retval != STATUS_SUCCESS)
1779 TRACE_RET(chip, TRANSPORT_FAILED);
1780 } else {
1781 chip->phy_debug_mode = 0;
1782 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77);
1783 if (retval != STATUS_SUCCESS)
1784 TRACE_RET(chip, TRANSPORT_FAILED);
1785
1786 rtsx_enable_bus_int(chip);
1787
1788 retval = rtsx_read_phy_register(chip, 0x1C, &reg);
1789 if (retval != STATUS_SUCCESS)
1790 TRACE_RET(chip, TRANSPORT_FAILED);
1791
1792 reg &= 0xFFFE;
1793 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1794 if (retval != STATUS_SUCCESS)
1795 TRACE_RET(chip, TRANSPORT_FAILED);
1796 }
1797
1798 return TRANSPORT_GOOD;
1799}
1800
1801static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1802{
1803 int retval = STATUS_SUCCESS;
1804 unsigned int lun = SCSI_LUN(srb);
1805 u8 cmd_type, mask, value, idx;
1806 u16 addr;
1807
1808 rtsx_disable_aspm(chip);
1809
1810 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1811 rtsx_exit_ss(chip);
1812 wait_timeout(100);
1813 }
1814 rtsx_set_stat(chip, RTSX_STAT_RUN);
1815
1816 switch (srb->cmnd[3]) {
1817 case INIT_BATCHCMD:
1818 rtsx_init_cmd(chip);
1819 break;
1820
1821 case ADD_BATCHCMD:
1822 cmd_type = srb->cmnd[4];
1823 if (cmd_type > 2) {
1824 set_sense_type(chip, lun,
1825 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1826 TRACE_RET(chip, TRANSPORT_FAILED);
1827 }
1828 addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1829 mask = srb->cmnd[7];
1830 value = srb->cmnd[8];
1831 rtsx_add_cmd(chip, cmd_type, addr, mask, value);
1832 break;
1833
1834 case SEND_BATCHCMD:
1835 retval = rtsx_send_cmd(chip, 0, 1000);
1836 break;
1837
1838 case GET_BATCHRSP:
1839 idx = srb->cmnd[4];
1840 value = *(rtsx_get_cmd_data(chip) + idx);
1841 if (scsi_bufflen(srb) < 1) {
1842 set_sense_type(chip, lun,
1843 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1844 TRACE_RET(chip, TRANSPORT_FAILED);
1845 }
1846 rtsx_stor_set_xfer_buf(&value, 1, srb);
1847 scsi_set_resid(srb, 0);
1848 break;
1849
1850 default:
1851 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1852 TRACE_RET(chip, TRANSPORT_FAILED);
1853 }
1854
1855 if (retval != STATUS_SUCCESS) {
1856 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1857 TRACE_RET(chip, TRANSPORT_FAILED);
1858 }
1859
1860 return TRANSPORT_GOOD;
1861}
1862
1863static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1864{
1865 int result;
1866
1867 switch (srb->cmnd[3]) {
1868 case INIT_BATCHCMD:
1869 case ADD_BATCHCMD:
1870 case SEND_BATCHCMD:
1871 case GET_BATCHRSP:
1872 result = rw_mem_cmd_buf(srb, chip);
1873 break;
1874 default:
1875 result = TRANSPORT_ERROR;
1876 }
1877
1878 return result;
1879}
1880
1881static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1882{
1883 unsigned short addr, len, i;
1884 int retval;
1885 u8 *buf;
1886 u16 val;
1887
1888 rtsx_disable_aspm(chip);
1889
1890 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1891 rtsx_exit_ss(chip);
1892 wait_timeout(100);
1893 }
1894 rtsx_set_stat(chip, RTSX_STAT_RUN);
1895
1896 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1897 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1898
1899 if (len % 2)
1900 len -= len % 2;
1901
1902 if (len) {
1903 buf = vmalloc(len);
1904 if (!buf)
1905 TRACE_RET(chip, TRANSPORT_ERROR);
1906
1907 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1908 if (retval != STATUS_SUCCESS) {
1909 vfree(buf);
1910 set_sense_type(chip, SCSI_LUN(srb),
1911 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1912 TRACE_RET(chip, TRANSPORT_FAILED);
1913 }
1914
1915 for (i = 0; i < len / 2; i++) {
1916 retval = rtsx_read_phy_register(chip, addr + i, &val);
1917 if (retval != STATUS_SUCCESS) {
1918 vfree(buf);
1919 set_sense_type(chip, SCSI_LUN(srb),
1920 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1921 TRACE_RET(chip, TRANSPORT_FAILED);
1922 }
1923
1924 buf[2*i] = (u8)(val >> 8);
1925 buf[2*i+1] = (u8)val;
1926 }
1927
1928 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1929 len);
1930 rtsx_stor_set_xfer_buf(buf, len, srb);
1931 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1932
1933 vfree(buf);
1934 }
1935
1936 return TRANSPORT_GOOD;
1937}
1938
1939static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1940{
1941 unsigned short addr, len, i;
1942 int retval;
1943 u8 *buf;
1944 u16 val;
1945
1946 rtsx_disable_aspm(chip);
1947
1948 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1949 rtsx_exit_ss(chip);
1950 wait_timeout(100);
1951 }
1952 rtsx_set_stat(chip, RTSX_STAT_RUN);
1953
1954 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1955 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1956
1957 if (len % 2)
1958 len -= len % 2;
1959
1960 if (len) {
1961 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1962 len);
1963
1964 buf = vmalloc(len);
1965 if (buf == NULL)
1966 TRACE_RET(chip, TRANSPORT_ERROR);
1967
1968 rtsx_stor_get_xfer_buf(buf, len, srb);
1969 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1970
1971 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1972 if (retval != STATUS_SUCCESS) {
1973 vfree(buf);
1974 set_sense_type(chip, SCSI_LUN(srb),
1975 SENSE_TYPE_MEDIA_WRITE_ERR);
1976 TRACE_RET(chip, TRANSPORT_FAILED);
1977 }
1978
1979 for (i = 0; i < len / 2; i++) {
1980 val = ((u16)buf[2*i] << 8) | buf[2*i+1];
1981 retval = rtsx_write_phy_register(chip, addr + i, val);
1982 if (retval != STATUS_SUCCESS) {
1983 vfree(buf);
1984 set_sense_type(chip, SCSI_LUN(srb),
1985 SENSE_TYPE_MEDIA_WRITE_ERR);
1986 TRACE_RET(chip, TRANSPORT_FAILED);
1987 }
1988 }
1989
1990 vfree(buf);
1991 }
1992
1993 return TRANSPORT_GOOD;
1994}
1995
1996static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1997{
1998 unsigned short addr;
1999 int retval;
2000 u8 mode;
2001
2002 rtsx_disable_aspm(chip);
2003
2004 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2005 rtsx_exit_ss(chip);
2006 wait_timeout(100);
2007 }
2008 rtsx_set_stat(chip, RTSX_STAT_RUN);
2009
2010 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2011 if (retval != STATUS_SUCCESS) {
2012 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2013 TRACE_RET(chip, TRANSPORT_FAILED);
2014 }
2015
2016 mode = srb->cmnd[3];
2017 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2018
2019 if (mode == 0) {
2020 retval = spi_erase_eeprom_chip(chip);
2021 if (retval != STATUS_SUCCESS) {
2022 set_sense_type(chip, SCSI_LUN(srb),
2023 SENSE_TYPE_MEDIA_WRITE_ERR);
2024 TRACE_RET(chip, TRANSPORT_FAILED);
2025 }
2026 } else if (mode == 1) {
2027 retval = spi_erase_eeprom_byte(chip, addr);
2028 if (retval != STATUS_SUCCESS) {
2029 set_sense_type(chip, SCSI_LUN(srb),
2030 SENSE_TYPE_MEDIA_WRITE_ERR);
2031 TRACE_RET(chip, TRANSPORT_FAILED);
2032 }
2033 } else {
2034 set_sense_type(chip, SCSI_LUN(srb),
2035 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2036 TRACE_RET(chip, TRANSPORT_FAILED);
2037 }
2038
2039 return TRANSPORT_GOOD;
2040}
2041
2042static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2043{
2044 unsigned short addr, len, i;
2045 int retval;
2046 u8 *buf;
2047
2048 rtsx_disable_aspm(chip);
2049
2050 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2051 rtsx_exit_ss(chip);
2052 wait_timeout(100);
2053 }
2054 rtsx_set_stat(chip, RTSX_STAT_RUN);
2055
2056 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2057 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2058
2059 buf = vmalloc(len);
2060 if (!buf)
2061 TRACE_RET(chip, TRANSPORT_ERROR);
2062
2063 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2064 if (retval != STATUS_SUCCESS) {
2065 vfree(buf);
2066 set_sense_type(chip, SCSI_LUN(srb),
2067 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2068 TRACE_RET(chip, TRANSPORT_FAILED);
2069 }
2070
2071 for (i = 0; i < len; i++) {
2072 retval = spi_read_eeprom(chip, addr + i, buf + i);
2073 if (retval != STATUS_SUCCESS) {
2074 vfree(buf);
2075 set_sense_type(chip, SCSI_LUN(srb),
2076 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2077 TRACE_RET(chip, TRANSPORT_FAILED);
2078 }
2079 }
2080
2081 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2082 rtsx_stor_set_xfer_buf(buf, len, srb);
2083 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2084
2085 vfree(buf);
2086
2087 return TRANSPORT_GOOD;
2088}
2089
2090static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2091{
2092 unsigned short addr, len, i;
2093 int retval;
2094 u8 *buf;
2095
2096 rtsx_disable_aspm(chip);
2097
2098 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2099 rtsx_exit_ss(chip);
2100 wait_timeout(100);
2101 }
2102 rtsx_set_stat(chip, RTSX_STAT_RUN);
2103
2104 addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2105 len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2106
2107 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2108 buf = vmalloc(len);
2109 if (buf == NULL)
2110 TRACE_RET(chip, TRANSPORT_ERROR);
2111
2112 rtsx_stor_get_xfer_buf(buf, len, srb);
2113 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2114
2115 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2116 if (retval != STATUS_SUCCESS) {
2117 vfree(buf);
2118 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2119 TRACE_RET(chip, TRANSPORT_FAILED);
2120 }
2121
2122 for (i = 0; i < len; i++) {
2123 retval = spi_write_eeprom(chip, addr + i, buf[i]);
2124 if (retval != STATUS_SUCCESS) {
2125 vfree(buf);
2126 set_sense_type(chip, SCSI_LUN(srb),
2127 SENSE_TYPE_MEDIA_WRITE_ERR);
2128 TRACE_RET(chip, TRANSPORT_FAILED);
2129 }
2130 }
2131
2132 vfree(buf);
2133
2134 return TRANSPORT_GOOD;
2135}
2136
2137static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2138{
2139 int retval;
2140 u8 addr, len, i;
2141 u8 *buf;
2142
2143 rtsx_disable_aspm(chip);
2144
2145 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2146 rtsx_exit_ss(chip);
2147 wait_timeout(100);
2148 }
2149 rtsx_set_stat(chip, RTSX_STAT_RUN);
2150
2151 addr = srb->cmnd[4];
2152 len = srb->cmnd[5];
2153
2154 buf = vmalloc(len);
2155 if (!buf)
2156 TRACE_RET(chip, TRANSPORT_ERROR);
2157
2158 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2159 if (retval != STATUS_SUCCESS) {
2160 vfree(buf);
2161 set_sense_type(chip, SCSI_LUN(srb),
2162 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2163 TRACE_RET(chip, TRANSPORT_FAILED);
2164 }
2165
2166 for (i = 0; i < len; i++) {
2167 retval = rtsx_read_efuse(chip, addr + i, buf + i);
2168 if (retval != STATUS_SUCCESS) {
2169 vfree(buf);
2170 set_sense_type(chip, SCSI_LUN(srb),
2171 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2172 TRACE_RET(chip, TRANSPORT_FAILED);
2173 }
2174 }
2175
2176 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2177 rtsx_stor_set_xfer_buf(buf, len, srb);
2178 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2179
2180 vfree(buf);
2181
2182 return TRANSPORT_GOOD;
2183}
2184
2185static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2186{
2187 int retval, result = TRANSPORT_GOOD;
2188 u16 val;
2189 u8 addr, len, i;
2190 u8 *buf;
2191
2192 rtsx_disable_aspm(chip);
2193
2194 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2195 rtsx_exit_ss(chip);
2196 wait_timeout(100);
2197 }
2198 rtsx_set_stat(chip, RTSX_STAT_RUN);
2199
2200 addr = srb->cmnd[4];
2201 len = srb->cmnd[5];
2202
2203 len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2204 buf = vmalloc(len);
2205 if (buf == NULL)
2206 TRACE_RET(chip, TRANSPORT_ERROR);
2207
2208 rtsx_stor_get_xfer_buf(buf, len, srb);
2209 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2210
2211 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2212 if (retval != STATUS_SUCCESS) {
2213 vfree(buf);
2214 TRACE_RET(chip, TRANSPORT_ERROR);
2215 }
2216
2217 if (chip->asic_code) {
2218 retval = rtsx_read_phy_register(chip, 0x08, &val);
2219 if (retval != STATUS_SUCCESS) {
2220 vfree(buf);
2221 TRACE_RET(chip, TRANSPORT_ERROR);
2222 }
2223
2224 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2225 LDO3318_PWR_MASK, LDO_OFF);
2226 if (retval != STATUS_SUCCESS) {
2227 vfree(buf);
2228 TRACE_RET(chip, TRANSPORT_ERROR);
2229 }
2230
2231 wait_timeout(600);
2232
2233 retval = rtsx_write_phy_register(chip, 0x08,
2234 0x4C00 | chip->phy_voltage);
2235 if (retval != STATUS_SUCCESS) {
2236 vfree(buf);
2237 TRACE_RET(chip, TRANSPORT_ERROR);
2238 }
2239
2240 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2241 LDO3318_PWR_MASK, LDO_ON);
2242 if (retval != STATUS_SUCCESS) {
2243 vfree(buf);
2244 TRACE_RET(chip, TRANSPORT_ERROR);
2245 }
2246
2247 wait_timeout(600);
2248 }
2249
2250 retval = card_power_on(chip, SPI_CARD);
2251 if (retval != STATUS_SUCCESS) {
2252 vfree(buf);
2253 TRACE_RET(chip, TRANSPORT_ERROR);
2254 }
2255
2256 wait_timeout(50);
2257
2258 for (i = 0; i < len; i++) {
2259 retval = rtsx_write_efuse(chip, addr + i, buf[i]);
2260 if (retval != STATUS_SUCCESS) {
2261 set_sense_type(chip, SCSI_LUN(srb),
2262 SENSE_TYPE_MEDIA_WRITE_ERR);
2263 result = TRANSPORT_FAILED;
2264 TRACE_GOTO(chip, Exit);
2265 }
2266 }
2267
2268Exit:
2269 vfree(buf);
2270
2271 retval = card_power_off(chip, SPI_CARD);
2272 if (retval != STATUS_SUCCESS)
2273 TRACE_RET(chip, TRANSPORT_ERROR);
2274
2275 if (chip->asic_code) {
2276 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2277 LDO3318_PWR_MASK, LDO_OFF);
2278 if (retval != STATUS_SUCCESS)
2279 TRACE_RET(chip, TRANSPORT_ERROR);
2280
2281 wait_timeout(600);
2282
2283 retval = rtsx_write_phy_register(chip, 0x08, val);
2284 if (retval != STATUS_SUCCESS)
2285 TRACE_RET(chip, TRANSPORT_ERROR);
2286
2287 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2288 LDO3318_PWR_MASK, LDO_ON);
2289 if (retval != STATUS_SUCCESS)
2290 TRACE_RET(chip, TRANSPORT_ERROR);
2291 }
2292
2293 return result;
2294}
2295
2296static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2297{
2298 int retval;
2299 u8 func, func_max;
2300 u16 addr, len;
2301 u8 *buf;
2302
2303 rtsx_disable_aspm(chip);
2304
2305 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2306 rtsx_exit_ss(chip);
2307 wait_timeout(100);
2308 }
2309 rtsx_set_stat(chip, RTSX_STAT_RUN);
2310
2311 func = srb->cmnd[3];
2312 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2313 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2314
2315 RTSX_DEBUGP("%s: func = %d, addr = 0x%x, len = %d\n", __func__, func,
2316 addr, len);
2317
2318 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2319 func_max = 1;
2320 else
2321 func_max = 0;
2322
2323 if (func > func_max) {
2324 set_sense_type(chip, SCSI_LUN(srb),
2325 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2326 TRACE_RET(chip, TRANSPORT_FAILED);
2327 }
2328
2329 buf = vmalloc(len);
2330 if (!buf)
2331 TRACE_RET(chip, TRANSPORT_ERROR);
2332
2333 retval = rtsx_read_cfg_seq(chip, func, addr, buf, len);
2334 if (retval != STATUS_SUCCESS) {
2335 set_sense_type(chip, SCSI_LUN(srb),
2336 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2337 vfree(buf);
2338 TRACE_RET(chip, TRANSPORT_FAILED);
2339 }
2340
2341 len = (u16)min_t(unsigned int, scsi_bufflen(srb), len);
2342 rtsx_stor_set_xfer_buf(buf, len, srb);
2343 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2344
2345 vfree(buf);
2346
2347 return TRANSPORT_GOOD;
2348}
2349
2350static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2351{
2352 int retval;
2353 u8 func, func_max;
2354 u16 addr, len;
2355 u8 *buf;
2356
2357 rtsx_disable_aspm(chip);
2358
2359 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2360 rtsx_exit_ss(chip);
2361 wait_timeout(100);
2362 }
2363 rtsx_set_stat(chip, RTSX_STAT_RUN);
2364
2365 func = srb->cmnd[3];
2366 addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2367 len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2368
2369 RTSX_DEBUGP("%s: func = %d, addr = 0x%x\n", __func__, func, addr);
2370
2371 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2372 func_max = 1;
2373 else
2374 func_max = 0;
2375
2376 if (func > func_max) {
2377 set_sense_type(chip, SCSI_LUN(srb),
2378 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2379 TRACE_RET(chip, TRANSPORT_FAILED);
2380 }
2381
2382 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2383 buf = vmalloc(len);
2384 if (!buf)
2385 TRACE_RET(chip, TRANSPORT_ERROR);
2386
2387 rtsx_stor_get_xfer_buf(buf, len, srb);
2388 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2389
2390 retval = rtsx_write_cfg_seq(chip, func, addr, buf, len);
2391 if (retval != STATUS_SUCCESS) {
2392 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2393 vfree(buf);
2394 TRACE_RET(chip, TRANSPORT_FAILED);
2395 }
2396
2397 vfree(buf);
2398
2399 return TRANSPORT_GOOD;
2400}
2401
2402static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2403{
2404 int result;
2405
2406 switch (srb->cmnd[2]) {
2407 case PP_READ10:
2408 case PP_WRITE10:
2409 result = read_write(srb, chip);
2410 break;
2411
2412 case READ_HOST_REG:
2413 result = read_host_reg(srb, chip);
2414 break;
2415
2416 case WRITE_HOST_REG:
2417 result = write_host_reg(srb, chip);
2418 break;
2419
2420 case GET_VAR:
2421 result = get_variable(srb, chip);
2422 break;
2423
2424 case SET_VAR:
2425 result = set_variable(srb, chip);
2426 break;
2427
2428 case DMA_READ:
2429 case DMA_WRITE:
2430 result = dma_access_ring_buffer(srb, chip);
2431 break;
2432
2433 case READ_PHY:
2434 result = read_phy_register(srb, chip);
2435 break;
2436
2437 case WRITE_PHY:
2438 result = write_phy_register(srb, chip);
2439 break;
2440
2441 case ERASE_EEPROM2:
2442 result = erase_eeprom2(srb, chip);
2443 break;
2444
2445 case READ_EEPROM2:
2446 result = read_eeprom2(srb, chip);
2447 break;
2448
2449 case WRITE_EEPROM2:
2450 result = write_eeprom2(srb, chip);
2451 break;
2452
2453 case READ_EFUSE:
2454 result = read_efuse(srb, chip);
2455 break;
2456
2457 case WRITE_EFUSE:
2458 result = write_efuse(srb, chip);
2459 break;
2460
2461 case READ_CFG:
2462 result = read_cfg_byte(srb, chip);
2463 break;
2464
2465 case WRITE_CFG:
2466 result = write_cfg_byte(srb, chip);
2467 break;
2468
2469 case SET_CHIP_MODE:
2470 result = set_chip_mode(srb, chip);
2471 break;
2472
2473 case SUIT_CMD:
2474 result = suit_cmd(srb, chip);
2475 break;
2476
2477 case GET_DEV_STATUS:
2478 result = get_dev_status(srb, chip);
2479 break;
2480
2481 default:
2482 set_sense_type(chip, SCSI_LUN(srb),
2483 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2484 TRACE_RET(chip, TRANSPORT_FAILED);
2485 }
2486
2487 return result;
2488}
2489
2490
2491static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2492{
2493 u8 rtsx_status[16];
2494 int buf_len;
2495 unsigned int lun = SCSI_LUN(srb);
2496
2497 rtsx_status[0] = (u8)(chip->vendor_id >> 8);
2498 rtsx_status[1] = (u8)(chip->vendor_id);
2499
2500 rtsx_status[2] = (u8)(chip->product_id >> 8);
2501 rtsx_status[3] = (u8)(chip->product_id);
2502
2503 rtsx_status[4] = (u8)lun;
2504
2505 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2506 if (chip->lun2card[lun] == SD_CARD)
2507 rtsx_status[5] = 2;
2508 else
2509 rtsx_status[5] = 3;
2510 } else {
2511 if (chip->card_exist) {
2512 if (chip->card_exist & XD_CARD)
2513 rtsx_status[5] = 4;
2514 else if (chip->card_exist & SD_CARD)
2515 rtsx_status[5] = 2;
2516 else if (chip->card_exist & MS_CARD)
2517 rtsx_status[5] = 3;
2518 else
2519 rtsx_status[5] = 7;
2520 } else {
2521 rtsx_status[5] = 7;
2522 }
2523 }
2524
2525 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2526 rtsx_status[6] = 2;
2527 else
2528 rtsx_status[6] = 1;
2529
2530 rtsx_status[7] = (u8)(chip->product_id);
2531 rtsx_status[8] = chip->ic_version;
2532
2533 if (check_card_exist(chip, lun))
2534 rtsx_status[9] = 1;
2535 else
2536 rtsx_status[9] = 0;
2537
2538 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2539 rtsx_status[10] = 0;
2540 else
2541 rtsx_status[10] = 1;
2542
2543 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2544 if (chip->lun2card[lun] == SD_CARD)
2545 rtsx_status[11] = SD_CARD;
2546 else
2547 rtsx_status[11] = MS_CARD;
2548 } else {
2549 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD;
2550 }
2551
2552 if (check_card_ready(chip, lun))
2553 rtsx_status[12] = 1;
2554 else
2555 rtsx_status[12] = 0;
2556
2557 if (get_lun_card(chip, lun) == XD_CARD) {
2558 rtsx_status[13] = 0x40;
2559 } else if (get_lun_card(chip, lun) == SD_CARD) {
2560 struct sd_info *sd_card = &(chip->sd_card);
2561
2562 rtsx_status[13] = 0x20;
2563 if (CHK_SD(sd_card)) {
2564 if (CHK_SD_HCXC(sd_card))
2565 rtsx_status[13] |= 0x04;
2566 if (CHK_SD_HS(sd_card))
2567 rtsx_status[13] |= 0x02;
2568 } else {
2569 rtsx_status[13] |= 0x08;
2570 if (CHK_MMC_52M(sd_card))
2571 rtsx_status[13] |= 0x02;
2572 if (CHK_MMC_SECTOR_MODE(sd_card))
2573 rtsx_status[13] |= 0x04;
2574 }
2575 } else if (get_lun_card(chip, lun) == MS_CARD) {
2576 struct ms_info *ms_card = &(chip->ms_card);
2577
2578 if (CHK_MSPRO(ms_card)) {
2579 rtsx_status[13] = 0x38;
2580 if (CHK_HG8BIT(ms_card))
2581 rtsx_status[13] |= 0x04;
2582#ifdef SUPPORT_MSXC
2583 if (CHK_MSXC(ms_card))
2584 rtsx_status[13] |= 0x01;
2585#endif
2586 } else {
2587 rtsx_status[13] = 0x30;
2588 }
2589 } else {
2590 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) {
2591#ifdef SUPPORT_SDIO
2592 if (chip->sd_io && chip->sd_int)
2593 rtsx_status[13] = 0x60;
2594 else
2595 rtsx_status[13] = 0x70;
2596#else
2597 rtsx_status[13] = 0x70;
2598#endif
2599 } else {
2600 if (chip->lun2card[lun] == SD_CARD)
2601 rtsx_status[13] = 0x20;
2602 else
2603 rtsx_status[13] = 0x30;
2604 }
2605 }
2606
2607 rtsx_status[14] = 0x78;
2608 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2609 rtsx_status[15] = 0x83;
2610 else
2611 rtsx_status[15] = 0x82;
2612
2613 buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(rtsx_status));
2614 rtsx_stor_set_xfer_buf(rtsx_status, buf_len, srb);
2615 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
2616
2617 return TRANSPORT_GOOD;
2618}
2619
2620static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2621{
2622 unsigned int lun = SCSI_LUN(srb);
2623 u8 card, bus_width;
2624
2625 if (!check_card_ready(chip, lun)) {
2626 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2627 TRACE_RET(chip, TRANSPORT_FAILED);
2628 }
2629
2630 card = get_lun_card(chip, lun);
2631 if ((card == SD_CARD) || (card == MS_CARD)) {
2632 bus_width = chip->card_bus_width[lun];
2633 } else {
2634 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2635 TRACE_RET(chip, TRANSPORT_FAILED);
2636 }
2637
2638 scsi_set_resid(srb, 0);
2639 rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
2640
2641 return TRANSPORT_GOOD;
2642}
2643
2644static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2645{
2646 int result;
2647 unsigned int lun = SCSI_LUN(srb);
2648 u8 gpio_dir;
2649
2650 if (CHECK_PID(chip, 0x5208) || CHECK_PID(chip, 0x5288)) {
2651 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2652 TRACE_RET(chip, TRANSPORT_FAILED);
2653 }
2654
2655 rtsx_disable_aspm(chip);
2656
2657 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2658 rtsx_exit_ss(chip);
2659 wait_timeout(100);
2660 }
2661 rtsx_set_stat(chip, RTSX_STAT_RUN);
2662
2663 rtsx_force_power_on(chip, SSC_PDCTL);
2664
2665 rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir);
2666 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06);
2667
2668 switch (srb->cmnd[2]) {
2669 case SCSI_SPI_GETSTATUS:
2670 result = spi_get_status(srb, chip);
2671 break;
2672
2673 case SCSI_SPI_SETPARAMETER:
2674 result = spi_set_parameter(srb, chip);
2675 break;
2676
2677 case SCSI_SPI_READFALSHID:
2678 result = spi_read_flash_id(srb, chip);
2679 break;
2680
2681 case SCSI_SPI_READFLASH:
2682 result = spi_read_flash(srb, chip);
2683 break;
2684
2685 case SCSI_SPI_WRITEFLASH:
2686 result = spi_write_flash(srb, chip);
2687 break;
2688
2689 case SCSI_SPI_WRITEFLASHSTATUS:
2690 result = spi_write_flash_status(srb, chip);
2691 break;
2692
2693 case SCSI_SPI_ERASEFLASH:
2694 result = spi_erase_flash(srb, chip);
2695 break;
2696
2697 default:
2698 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2699
2700 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2701 TRACE_RET(chip, TRANSPORT_FAILED);
2702 }
2703
2704 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2705
2706 if (result != STATUS_SUCCESS)
2707 TRACE_RET(chip, TRANSPORT_FAILED);
2708
2709 return TRANSPORT_GOOD;
2710}
2711
2712static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2713{
2714 int result;
2715
2716 switch (srb->cmnd[1]) {
2717 case READ_STATUS:
2718 result = read_status(srb, chip);
2719 break;
2720
2721 case READ_MEM:
2722 result = read_mem(srb, chip);
2723 break;
2724
2725 case WRITE_MEM:
2726 result = write_mem(srb, chip);
2727 break;
2728
2729 case READ_EEPROM:
2730 result = read_eeprom(srb, chip);
2731 break;
2732
2733 case WRITE_EEPROM:
2734 result = write_eeprom(srb, chip);
2735 break;
2736
2737 case TOGGLE_GPIO:
2738 result = toggle_gpio_cmd(srb, chip);
2739 break;
2740
2741 case GET_SD_CSD:
2742 result = get_sd_csd(srb, chip);
2743 break;
2744
2745 case GET_BUS_WIDTH:
2746 result = get_card_bus_width(srb, chip);
2747 break;
2748
2749#ifdef _MSG_TRACE
2750 case TRACE_MSG:
2751 result = trace_msg_cmd(srb, chip);
2752 break;
2753#endif
2754
2755 case SCSI_APP_CMD:
2756 result = app_cmd(srb, chip);
2757 break;
2758
2759 case SPI_VENDOR_COMMAND:
2760 result = spi_vendor_cmd(srb, chip);
2761 break;
2762
2763 default:
2764 set_sense_type(chip, SCSI_LUN(srb),
2765 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2766 TRACE_RET(chip, TRANSPORT_FAILED);
2767 }
2768
2769 return result;
2770}
2771
2772#if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
2773void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2774{
2775 unsigned int lun = SCSI_LUN(srb);
2776 u16 sec_cnt;
2777
2778 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10))
2779 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
2780 else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6))
2781 sec_cnt = srb->cmnd[4];
2782 else
2783 return;
2784
2785 if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) {
2786 toggle_gpio(chip, LED_GPIO);
2787 chip->rw_cap[lun] = 0;
2788 } else {
2789 chip->rw_cap[lun] += sec_cnt;
2790 }
2791}
2792#endif
2793
2794static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2795{
2796 struct ms_info *ms_card = &(chip->ms_card);
2797 unsigned int lun = SCSI_LUN(srb);
2798 int retval, quick_format;
2799
2800 if (get_lun_card(chip, lun) != MS_CARD) {
2801 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2802 TRACE_RET(chip, TRANSPORT_FAILED);
2803 }
2804
2805 if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47) ||
2806 (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D) ||
2807 (srb->cmnd[7] != 0x74)) {
2808 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2809 TRACE_RET(chip, TRANSPORT_FAILED);
2810 }
2811
2812 rtsx_disable_aspm(chip);
2813
2814 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2815 rtsx_exit_ss(chip);
2816 wait_timeout(100);
2817
2818 if (!check_card_ready(chip, lun) ||
2819 (get_card_size(chip, lun) == 0)) {
2820 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2821 TRACE_RET(chip, TRANSPORT_FAILED);
2822 }
2823 }
2824 rtsx_set_stat(chip, RTSX_STAT_RUN);
2825
2826 if (srb->cmnd[8] & 0x01)
2827 quick_format = 0;
2828 else
2829 quick_format = 1;
2830
2831 if (!(chip->card_ready & MS_CARD)) {
2832 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2833 TRACE_RET(chip, TRANSPORT_FAILED);
2834 }
2835
2836 if (chip->card_wp & MS_CARD) {
2837 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2838 TRACE_RET(chip, TRANSPORT_FAILED);
2839 }
2840
2841 if (!CHK_MSPRO(ms_card)) {
2842 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2843 TRACE_RET(chip, TRANSPORT_FAILED);
2844 }
2845
2846 retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
2847 if (retval != STATUS_SUCCESS) {
2848 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
2849 TRACE_RET(chip, TRANSPORT_FAILED);
2850 }
2851
2852 scsi_set_resid(srb, 0);
2853 return TRANSPORT_GOOD;
2854}
2855
2856#ifdef SUPPORT_PCGL_1P18
2857static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2858{
2859 struct ms_info *ms_card = &(chip->ms_card);
2860 unsigned int lun = SCSI_LUN(srb);
2861 u8 dev_info_id, data_len;
2862 u8 *buf;
2863 unsigned int buf_len;
2864 int i;
2865
2866 if (!check_card_ready(chip, lun)) {
2867 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2868 TRACE_RET(chip, TRANSPORT_FAILED);
2869 }
Georgiana Rodica Chelucd5b8f92014-03-05 17:23:10 +0200[diff] [blame]2870 if (get_lun_card(chip, lun) != MS_CARD) {
Micky Chingfa590c22013-11-12 17:16:08 +0800[diff] [blame]2871 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2872 TRACE_RET(chip, TRANSPORT_FAILED);
2873 }
2874
2875 if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) ||
2876 (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) ||
2877 (srb->cmnd[7] != 0x44)) {
2878 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2879 TRACE_RET(chip, TRANSPORT_FAILED);
2880 }
2881
2882 dev_info_id = srb->cmnd[3];
2883 if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) ||
2884 (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) ||
2885 !CHK_MSPRO(ms_card)) {
2886 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2887 TRACE_RET(chip, TRANSPORT_FAILED);
2888 }
2889
2890 if (dev_info_id == 0x15)
2891 buf_len = data_len = 0x3A;
2892 else
2893 buf_len = data_len = 0x6A;
2894
2895 buf = kmalloc(buf_len, GFP_KERNEL);
2896 if (!buf)
2897 TRACE_RET(chip, TRANSPORT_ERROR);
2898
2899 i = 0;
2900 /* GET Memory Stick Media Information Response Header */
2901 buf[i++] = 0x00; /* Data length MSB */
2902 buf[i++] = data_len; /* Data length LSB */
2903 /* Device Information Type Code */
2904 if (CHK_MSXC(ms_card))
2905 buf[i++] = 0x03;
2906 else
2907 buf[i++] = 0x02;
2908
2909 /* SGM bit */
2910 buf[i++] = 0x01;
2911 /* Reserved */
2912 buf[i++] = 0x00;
2913 buf[i++] = 0x00;
2914 buf[i++] = 0x00;
2915 /* Number of Device Information */
2916 buf[i++] = 0x01;
2917
2918 /* Device Information Body */
2919
2920 /* Device Information ID Number */
2921 buf[i++] = dev_info_id;
2922 /* Device Information Length */
2923 if (dev_info_id == 0x15)
2924 data_len = 0x31;
2925 else
2926 data_len = 0x61;
2927
2928 buf[i++] = 0x00; /* Data length MSB */
2929 buf[i++] = data_len; /* Data length LSB */
2930 /* Valid Bit */
2931 buf[i++] = 0x80;
2932 if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
2933 /* System Information */
2934 memcpy(buf+i, ms_card->raw_sys_info, 96);
2935 } else {
2936 /* Model Name */
2937 memcpy(buf+i, ms_card->raw_model_name, 48);
2938 }
2939
2940 rtsx_stor_set_xfer_buf(buf, buf_len, srb);
2941
2942 if (dev_info_id == 0x15)
2943 scsi_set_resid(srb, scsi_bufflen(srb)-0x3C);
2944 else
2945 scsi_set_resid(srb, scsi_bufflen(srb)-0x6C);
2946
2947 kfree(buf);
2948 return STATUS_SUCCESS;
2949}
2950#endif
2951
2952static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2953{
2954 int retval = TRANSPORT_ERROR;
2955
2956 if (srb->cmnd[2] == MS_FORMAT)
2957 retval = ms_format_cmnd(srb, chip);
2958#ifdef SUPPORT_PCGL_1P18
2959 else if (srb->cmnd[2] == GET_MS_INFORMATION)
2960 retval = get_ms_information(srb, chip);
2961#endif
2962
2963 return retval;
2964}
2965
2966#ifdef SUPPORT_CPRM
2967static int sd_extention_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2968{
2969 unsigned int lun = SCSI_LUN(srb);
2970 int result;
2971
2972 rtsx_disable_aspm(chip);
2973
2974 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2975 rtsx_exit_ss(chip);
2976 wait_timeout(100);
2977 }
2978 rtsx_set_stat(chip, RTSX_STAT_RUN);
2979
2980 sd_cleanup_work(chip);
2981
2982 if (!check_card_ready(chip, lun)) {
2983 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2984 TRACE_RET(chip, TRANSPORT_FAILED);
2985 }
Georgiana Rodica Chelucd5b8f92014-03-05 17:23:10 +0200[diff] [blame]2986 if (get_lun_card(chip, lun) != SD_CARD) {
Micky Chingfa590c22013-11-12 17:16:08 +0800[diff] [blame]2987 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2988 TRACE_RET(chip, TRANSPORT_FAILED);
2989 }
2990
2991 switch (srb->cmnd[0]) {
2992 case SD_PASS_THRU_MODE:
2993 result = sd_pass_thru_mode(srb, chip);
2994 break;
2995
2996 case SD_EXECUTE_NO_DATA:
2997 result = sd_execute_no_data(srb, chip);
2998 break;
2999
3000 case SD_EXECUTE_READ:
3001 result = sd_execute_read_data(srb, chip);
3002 break;
3003
3004 case SD_EXECUTE_WRITE:
3005 result = sd_execute_write_data(srb, chip);
3006 break;
3007
3008 case SD_GET_RSP:
3009 result = sd_get_cmd_rsp(srb, chip);
3010 break;
3011
3012 case SD_HW_RST:
3013 result = sd_hw_rst(srb, chip);
3014 break;
3015
3016 default:
3017 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3018 TRACE_RET(chip, TRANSPORT_FAILED);
3019 }
3020
3021 return result;
3022}
3023#endif
3024
3025#ifdef SUPPORT_MAGIC_GATE
3026static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3027{
3028 struct ms_info *ms_card = &(chip->ms_card);
3029 unsigned int lun = SCSI_LUN(srb);
3030 int retval;
3031 u8 key_format;
3032
3033 RTSX_DEBUGP("--%s--\n", __func__);
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 }
Georgiana Rodica Chelucd5b8f92014-03-05 17:23:10 +0200[diff] [blame]3049 if (get_lun_card(chip, lun) != MS_CARD) {
Micky Chingfa590c22013-11-12 17:16:08 +0800[diff] [blame]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 RTSX_DEBUGP("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
3127static 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_DEBUGP("--%s--\n", __func__);
3135
3136 rtsx_disable_aspm(chip);
3137
3138 if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3139 rtsx_exit_ss(chip);
3140 wait_timeout(100);
3141 }
3142 rtsx_set_stat(chip, RTSX_STAT_RUN);
3143
3144 ms_cleanup_work(chip);
3145
3146 if (!check_card_ready(chip, lun)) {
3147 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3148 TRACE_RET(chip, TRANSPORT_FAILED);
3149 }
3150 if (check_card_wp(chip, lun)) {
3151 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
3152 TRACE_RET(chip, TRANSPORT_FAILED);
3153 }
Georgiana Rodica Chelucd5b8f92014-03-05 17:23:10 +0200[diff] [blame]3154 if (get_lun_card(chip, lun) != MS_CARD) {
Micky Chingfa590c22013-11-12 17:16:08 +0800[diff] [blame]3155 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3156 TRACE_RET(chip, TRANSPORT_FAILED);
3157 }
3158
3159 if (srb->cmnd[7] != KC_MG_R_PRO) {
3160 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3161 TRACE_RET(chip, TRANSPORT_FAILED);
3162 }
3163
3164 if (!CHK_MSPRO(ms_card)) {
3165 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3166 TRACE_RET(chip, TRANSPORT_FAILED);
3167 }
3168
3169 key_format = srb->cmnd[10] & 0x3F;
3170 RTSX_DEBUGP("key_format = 0x%x\n", key_format);
3171
3172 switch (key_format) {
3173 case KF_SET_LEAF_ID:
3174 if ((scsi_bufflen(srb) == 0x0C) &&
3175 (srb->cmnd[8] == 0x00) &&
3176 (srb->cmnd[9] == 0x0C)) {
3177 retval = mg_set_leaf_id(srb, chip);
3178 if (retval != STATUS_SUCCESS)
3179 TRACE_RET(chip, TRANSPORT_FAILED);
3180
3181 } else {
3182 set_sense_type(chip, lun,
3183 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3184 TRACE_RET(chip, TRANSPORT_FAILED);
3185 }
3186 break;
3187
3188 case KF_CHG_HOST:
3189 if ((scsi_bufflen(srb) == 0x0C) &&
3190 (srb->cmnd[8] == 0x00) &&
3191 (srb->cmnd[9] == 0x0C)) {
3192 retval = mg_chg(srb, chip);
3193 if (retval != STATUS_SUCCESS)
3194 TRACE_RET(chip, TRANSPORT_FAILED);
3195
3196 } else {
3197 set_sense_type(chip, lun,
3198 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3199 TRACE_RET(chip, TRANSPORT_FAILED);
3200 }
3201 break;
3202
3203 case KF_RSP_HOST:
3204 if ((scsi_bufflen(srb) == 0x0C) &&
3205 (srb->cmnd[8] == 0x00) &&
3206 (srb->cmnd[9] == 0x0C)) {
3207 retval = mg_rsp(srb, chip);
3208 if (retval != STATUS_SUCCESS)
3209 TRACE_RET(chip, TRANSPORT_FAILED);
3210
3211 } else {
3212 set_sense_type(chip, lun,
3213 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3214 TRACE_RET(chip, TRANSPORT_FAILED);
3215 }
3216 break;
3217
3218 case KF_SET_ICV:
3219 ms_card->mg_entry_num = srb->cmnd[5];
3220 if ((scsi_bufflen(srb) == 0x404) &&
3221 (srb->cmnd[8] == 0x04) &&
3222 (srb->cmnd[9] == 0x04) &&
3223 (srb->cmnd[2] == 0x00) &&
3224 (srb->cmnd[3] == 0x00) &&
3225 (srb->cmnd[4] == 0x00) &&
3226 (srb->cmnd[5] < 32)) {
3227 retval = mg_set_ICV(srb, chip);
3228 if (retval != STATUS_SUCCESS)
3229 TRACE_RET(chip, TRANSPORT_FAILED);
3230
3231 } else {
3232 set_sense_type(chip, lun,
3233 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3234 TRACE_RET(chip, TRANSPORT_FAILED);
3235 }
3236 break;
3237
3238 default:
3239 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3240 TRACE_RET(chip, TRANSPORT_FAILED);
3241 }
3242
3243 scsi_set_resid(srb, 0);
3244 return TRANSPORT_GOOD;
3245}
3246#endif
3247
3248int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3249{
3250#ifdef SUPPORT_SD_LOCK
3251 struct sd_info *sd_card = &(chip->sd_card);
3252#endif
3253 struct ms_info *ms_card = &(chip->ms_card);
3254 unsigned int lun = SCSI_LUN(srb);
3255 int result;
3256
3257#ifdef SUPPORT_SD_LOCK
3258 if (sd_card->sd_erase_status) {
3259 /* Block all SCSI command except for
3260 * REQUEST_SENSE and rs_ppstatus
3261 */
3262 if (!((srb->cmnd[0] == VENDOR_CMND) &&
3263 (srb->cmnd[1] == SCSI_APP_CMD) &&
3264 (srb->cmnd[2] == GET_DEV_STATUS)) &&
3265 (srb->cmnd[0] != REQUEST_SENSE)) {
3266 /* Logical Unit Not Ready Format in Progress */
3267 set_sense_data(chip, lun, CUR_ERR,
3268 0x02, 0, 0x04, 0x04, 0, 0);
3269 TRACE_RET(chip, TRANSPORT_FAILED);
3270 }
3271 }
3272#endif
3273
3274 if ((get_lun_card(chip, lun) == MS_CARD) &&
3275 (ms_card->format_status == FORMAT_IN_PROGRESS)) {
3276 if ((srb->cmnd[0] != REQUEST_SENSE) &&
3277 (srb->cmnd[0] != INQUIRY)) {
3278 /* Logical Unit Not Ready Format in Progress */
3279 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
3280 0, (u16)(ms_card->progress));
3281 TRACE_RET(chip, TRANSPORT_FAILED);
3282 }
3283 }
3284
3285 switch (srb->cmnd[0]) {
3286 case READ_10:
3287 case WRITE_10:
3288 case READ_6:
3289 case WRITE_6:
3290 result = read_write(srb, chip);
3291#if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
3292 led_shine(srb, chip);
3293#endif
3294 break;
3295
3296 case TEST_UNIT_READY:
3297 result = test_unit_ready(srb, chip);
3298 break;
3299
3300 case INQUIRY:
3301 result = inquiry(srb, chip);
3302 break;
3303
3304 case READ_CAPACITY:
3305 result = read_capacity(srb, chip);
3306 break;
3307
3308 case START_STOP:
3309 result = start_stop_unit(srb, chip);
3310 break;
3311
3312 case ALLOW_MEDIUM_REMOVAL:
3313 result = allow_medium_removal(srb, chip);
3314 break;
3315
3316 case REQUEST_SENSE:
3317 result = request_sense(srb, chip);
3318 break;
3319
3320 case MODE_SENSE:
3321 case MODE_SENSE_10:
3322 result = mode_sense(srb, chip);
3323 break;
3324
3325 case 0x23:
3326 result = read_format_capacity(srb, chip);
3327 break;
3328
3329 case VENDOR_CMND:
3330 result = vendor_cmnd(srb, chip);
3331 break;
3332
3333 case MS_SP_CMND:
3334 result = ms_sp_cmnd(srb, chip);
3335 break;
3336
3337#ifdef SUPPORT_CPRM
3338 case SD_PASS_THRU_MODE:
3339 case SD_EXECUTE_NO_DATA:
3340 case SD_EXECUTE_READ:
3341 case SD_EXECUTE_WRITE:
3342 case SD_GET_RSP:
3343 case SD_HW_RST:
3344 result = sd_extention_cmnd(srb, chip);
3345 break;
3346#endif
3347
3348#ifdef SUPPORT_MAGIC_GATE
3349 case CMD_MSPRO_MG_RKEY:
3350 result = mg_report_key(srb, chip);
3351 break;
3352
3353 case CMD_MSPRO_MG_SKEY:
3354 result = mg_send_key(srb, chip);
3355 break;
3356#endif
3357
3358 case FORMAT_UNIT:
3359 case MODE_SELECT:
3360 case VERIFY:
3361 result = TRANSPORT_GOOD;
3362 break;
3363
3364 default:
3365 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3366 result = TRANSPORT_FAILED;
3367 }
3368
3369 return result;
3370}