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