?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging:iio:dac:ad5791: Allow asymmetrical reference voltages
[zen-stable.git] / drivers / staging / rts5139 / rts51x_scsi.c
blob3b32f9e6e4f09a38f62afb07038286790e2d8f60
1 /* Driver for Realtek RTS51xx USB 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 * Maintainer:
22 * Edwin Rong (edwin_rong@realsil.com.cn)
23 * No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
24 */
25
26 #include <linux/blkdev.h>
27 #include <linux/kthread.h>
28 #include <linux/sched.h>
29 #include <linux/slab.h>
30 #include <linux/vmalloc.h>
31
32 #include <scsi/scsi.h>
33 #include <scsi/scsi_eh.h>
34 #include <scsi/scsi_device.h>
35
36 #include "debug.h"
37 #include "rts51x.h"
38 #include "rts51x_chip.h"
39 #include "rts51x_scsi.h"
40 #include "rts51x_card.h"
41 #include "rts51x_transport.h"
42 #include "rts51x_sys.h"
43 #include "sd_cprm.h"
44 #include "ms_mg.h"
45 #include "trace.h"
46
47 void scsi_show_command(struct scsi_cmnd *srb)
48 {
49 char *what = NULL;
50 int i, unknown_cmd = 0;
51
52 switch (srb->cmnd[0]) {
53 case TEST_UNIT_READY:
54 what = (char *)"TEST_UNIT_READY";
55 break;
56 case REZERO_UNIT:
57 what = (char *)"REZERO_UNIT";
58 break;
59 case REQUEST_SENSE:
60 what = (char *)"REQUEST_SENSE";
61 break;
62 case FORMAT_UNIT:
63 what = (char *)"FORMAT_UNIT";
64 break;
65 case READ_BLOCK_LIMITS:
66 what = (char *)"READ_BLOCK_LIMITS";
67 break;
68 case 0x07:
69 what = (char *)"REASSIGN_BLOCKS";
70 break;
71 case READ_6:
72 what = (char *)"READ_6";
73 break;
74 case WRITE_6:
75 what = (char *)"WRITE_6";
76 break;
77 case SEEK_6:
78 what = (char *)"SEEK_6";
79 break;
80 case READ_REVERSE:
81 what = (char *)"READ_REVERSE";
82 break;
83 case WRITE_FILEMARKS:
84 what = (char *)"WRITE_FILEMARKS";
85 break;
86 case SPACE:
87 what = (char *)"SPACE";
88 break;
89 case INQUIRY:
90 what = (char *)"INQUIRY";
91 break;
92 case RECOVER_BUFFERED_DATA:
93 what = (char *)"RECOVER_BUFFERED_DATA";
94 break;
95 case MODE_SELECT:
96 what = (char *)"MODE_SELECT";
97 break;
98 case RESERVE:
99 what = (char *)"RESERVE";
100 break;
101 case RELEASE:
102 what = (char *)"RELEASE";
103 break;
104 case COPY:
105 what = (char *)"COPY";
106 break;
107 case ERASE:
108 what = (char *)"ERASE";
109 break;
110 case MODE_SENSE:
111 what = (char *)"MODE_SENSE";
112 break;
113 case START_STOP:
114 what = (char *)"START_STOP";
115 break;
116 case RECEIVE_DIAGNOSTIC:
117 what = (char *)"RECEIVE_DIAGNOSTIC";
118 break;
119 case SEND_DIAGNOSTIC:
120 what = (char *)"SEND_DIAGNOSTIC";
121 break;
122 case ALLOW_MEDIUM_REMOVAL:
123 what = (char *)"ALLOW_MEDIUM_REMOVAL";
124 break;
125 case SET_WINDOW:
126 what = (char *)"SET_WINDOW";
127 break;
128 case READ_CAPACITY:
129 what = (char *)"READ_CAPACITY";
130 break;
131 case READ_10:
132 what = (char *)"READ_10";
133 break;
134 case WRITE_10:
135 what = (char *)"WRITE_10";
136 break;
137 case SEEK_10:
138 what = (char *)"SEEK_10";
139 break;
140 case WRITE_VERIFY:
141 what = (char *)"WRITE_VERIFY";
142 break;
143 case VERIFY:
144 what = (char *)"VERIFY";
145 break;
146 case SEARCH_HIGH:
147 what = (char *)"SEARCH_HIGH";
148 break;
149 case SEARCH_EQUAL:
150 what = (char *)"SEARCH_EQUAL";
151 break;
152 case SEARCH_LOW:
153 what = (char *)"SEARCH_LOW";
154 break;
155 case SET_LIMITS:
156 what = (char *)"SET_LIMITS";
157 break;
158 case READ_POSITION:
159 what = (char *)"READ_POSITION";
160 break;
161 case SYNCHRONIZE_CACHE:
162 what = (char *)"SYNCHRONIZE_CACHE";
163 break;
164 case LOCK_UNLOCK_CACHE:
165 what = (char *)"LOCK_UNLOCK_CACHE";
166 break;
167 case READ_DEFECT_DATA:
168 what = (char *)"READ_DEFECT_DATA";
169 break;
170 case MEDIUM_SCAN:
171 what = (char *)"MEDIUM_SCAN";
172 break;
173 case COMPARE:
174 what = (char *)"COMPARE";
175 break;
176 case COPY_VERIFY:
177 what = (char *)"COPY_VERIFY";
178 break;
179 case WRITE_BUFFER:
180 what = (char *)"WRITE_BUFFER";
181 break;
182 case READ_BUFFER:
183 what = (char *)"READ_BUFFER";
184 break;
185 case UPDATE_BLOCK:
186 what = (char *)"UPDATE_BLOCK";
187 break;
188 case READ_LONG:
189 what = (char *)"READ_LONG";
190 break;
191 case WRITE_LONG:
192 what = (char *)"WRITE_LONG";
193 break;
194 case CHANGE_DEFINITION:
195 what = (char *)"CHANGE_DEFINITION";
196 break;
197 case WRITE_SAME:
198 what = (char *)"WRITE_SAME";
199 break;
200 case GPCMD_READ_SUBCHANNEL:
201 what = (char *)"READ SUBCHANNEL";
202 break;
203 case READ_TOC:
204 what = (char *)"READ_TOC";
205 break;
206 case GPCMD_READ_HEADER:
207 what = (char *)"READ HEADER";
208 break;
209 case GPCMD_PLAY_AUDIO_10:
210 what = (char *)"PLAY AUDIO (10)";
211 break;
212 case GPCMD_PLAY_AUDIO_MSF:
213 what = (char *)"PLAY AUDIO MSF";
214 break;
215 case GPCMD_GET_EVENT_STATUS_NOTIFICATION:
216 what = (char *)"GET EVENT/STATUS NOTIFICATION";
217 break;
218 case GPCMD_PAUSE_RESUME:
219 what = (char *)"PAUSE/RESUME";
220 break;
221 case LOG_SELECT:
222 what = (char *)"LOG_SELECT";
223 break;
224 case LOG_SENSE:
225 what = (char *)"LOG_SENSE";
226 break;
227 case GPCMD_STOP_PLAY_SCAN:
228 what = (char *)"STOP PLAY/SCAN";
229 break;
230 case GPCMD_READ_DISC_INFO:
231 what = (char *)"READ DISC INFORMATION";
232 break;
233 case GPCMD_READ_TRACK_RZONE_INFO:
234 what = (char *)"READ TRACK INFORMATION";
235 break;
236 case GPCMD_RESERVE_RZONE_TRACK:
237 what = (char *)"RESERVE TRACK";
238 break;
239 case GPCMD_SEND_OPC:
240 what = (char *)"SEND OPC";
241 break;
242 case MODE_SELECT_10:
243 what = (char *)"MODE_SELECT_10";
244 break;
245 case GPCMD_REPAIR_RZONE_TRACK:
246 what = (char *)"REPAIR TRACK";
247 break;
248 case 0x59:
249 what = (char *)"READ MASTER CUE";
250 break;
251 case MODE_SENSE_10:
252 what = (char *)"MODE_SENSE_10";
253 break;
254 case GPCMD_CLOSE_TRACK:
255 what = (char *)"CLOSE TRACK/SESSION";
256 break;
257 case 0x5C:
258 what = (char *)"READ BUFFER CAPACITY";
259 break;
260 case 0x5D:
261 what = (char *)"SEND CUE SHEET";
262 break;
263 case GPCMD_BLANK:
264 what = (char *)"BLANK";
265 break;
266 case REPORT_LUNS:
267 what = (char *)"REPORT LUNS";
268 break;
269 case MOVE_MEDIUM:
270 what = (char *)"MOVE_MEDIUM or PLAY AUDIO (12)";
271 break;
272 case READ_12:
273 what = (char *)"READ_12";
274 break;
275 case WRITE_12:
276 what = (char *)"WRITE_12";
277 break;
278 case WRITE_VERIFY_12:
279 what = (char *)"WRITE_VERIFY_12";
280 break;
281 case SEARCH_HIGH_12:
282 what = (char *)"SEARCH_HIGH_12";
283 break;
284 case SEARCH_EQUAL_12:
285 what = (char *)"SEARCH_EQUAL_12";
286 break;
287 case SEARCH_LOW_12:
288 what = (char *)"SEARCH_LOW_12";
289 break;
290 case SEND_VOLUME_TAG:
291 what = (char *)"SEND_VOLUME_TAG";
292 break;
293 case READ_ELEMENT_STATUS:
294 what = (char *)"READ_ELEMENT_STATUS";
295 break;
296 case GPCMD_READ_CD_MSF:
297 what = (char *)"READ CD MSF";
298 break;
299 case GPCMD_SCAN:
300 what = (char *)"SCAN";
301 break;
302 case GPCMD_SET_SPEED:
303 what = (char *)"SET CD SPEED";
304 break;
305 case GPCMD_MECHANISM_STATUS:
306 what = (char *)"MECHANISM STATUS";
307 break;
308 case GPCMD_READ_CD:
309 what = (char *)"READ CD";
310 break;
311 case 0xE1:
312 what = (char *)"WRITE CONTINUE";
313 break;
314 case WRITE_LONG_2:
315 what = (char *)"WRITE_LONG_2";
316 break;
317 case VENDOR_CMND:
318 what = (char *)"Realtek's vendor command";
319 break;
320 default:
321 what = (char *)"(unknown command)";
322 unknown_cmd = 1;
323 break;
324 }
325
326 if (srb->cmnd[0] != TEST_UNIT_READY)
327 RTS51X_DEBUGP("Command %s (%d bytes)\n", what, srb->cmd_len);
328 if (unknown_cmd) {
329 RTS51X_DEBUGP("");
330 for (i = 0; i < srb->cmd_len && i < 16; i++)
331 RTS51X_DEBUGPN(" %02x", srb->cmnd[i]);
332 RTS51X_DEBUGPN("\n");
333 }
334 }
335
336 void set_sense_type(struct rts51x_chip *chip, unsigned int lun, int sense_type)
337 {
338 switch (sense_type) {
339 case SENSE_TYPE_MEDIA_CHANGE:
340 set_sense_data(chip, lun, CUR_ERR, 0x06, 0, 0x28, 0, 0, 0);
341 break;
342
343 case SENSE_TYPE_MEDIA_NOT_PRESENT:
344 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x3A, 0, 0, 0);
345 break;
346
347 case SENSE_TYPE_MEDIA_LBA_OVER_RANGE:
348 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x21, 0, 0, 0);
349 break;
350
351 case SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT:
352 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x25, 0, 0, 0);
353 break;
354
355 case SENSE_TYPE_MEDIA_WRITE_PROTECT:
356 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x27, 0, 0, 0);
357 break;
358
359 case SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR:
360 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x11, 0, 0, 0);
361 break;
362
363 case SENSE_TYPE_MEDIA_WRITE_ERR:
364 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x02, 0, 0);
365 break;
366
367 case SENSE_TYPE_MEDIA_INVALID_CMD_FIELD:
368 set_sense_data(chip, lun, CUR_ERR, ILGAL_REQ, 0,
369 ASC_INVLD_CDB, ASCQ_INVLD_CDB, CDB_ILLEGAL, 1);
370 break;
371
372 case SENSE_TYPE_FORMAT_IN_PROGRESS:
373 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 0, 0);
374 break;
375
376 case SENSE_TYPE_FORMAT_CMD_FAILED:
377 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x31, 0x01, 0, 0);
378 break;
379
380 #ifdef SUPPORT_MAGIC_GATE
381 case SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB:
382 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x02, 0, 0);
383 break;
384
385 case SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN:
386 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x00, 0, 0);
387 break;
388
389 case SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM:
390 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x30, 0x00, 0, 0);
391 break;
392
393 case SENSE_TYPE_MG_WRITE_ERR:
394 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x00, 0, 0);
395 break;
396 #endif
397
398 #ifdef SUPPORT_SD_LOCK
399 case SENSE_TYPE_MEDIA_READ_FORBIDDEN:
400 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x11, 0x13, 0, 0);
401 break;
402 #endif
403
404 case SENSE_TYPE_NO_SENSE:
405 default:
406 set_sense_data(chip, lun, CUR_ERR, 0, 0, 0, 0, 0, 0);
407 break;
408 }
409 }
410
411 void set_sense_data(struct rts51x_chip *chip, unsigned int lun, u8 err_code,
412 u8 sense_key, u32 info, u8 asc, u8 ascq, u8 sns_key_info0,
413 u16 sns_key_info1)
414 {
415 struct sense_data_t *sense = &(chip->sense_buffer[lun]);
416
417 sense->err_code = err_code;
418 sense->sense_key = sense_key;
419 sense->info[0] = (u8) (info >> 24);
420 sense->info[1] = (u8) (info >> 16);
421 sense->info[2] = (u8) (info >> 8);
422 sense->info[3] = (u8) info;
423
424 sense->ad_sense_len = sizeof(struct sense_data_t) - 8;
425 sense->asc = asc;
426 sense->ascq = ascq;
427 if (sns_key_info0 != 0) {
428 sense->sns_key_info[0] = SKSV | sns_key_info0;
429 sense->sns_key_info[1] = (sns_key_info1 & 0xf0) >> 8;
430 sense->sns_key_info[2] = sns_key_info1 & 0x0f;
431 }
432 }
433
434 static int test_unit_ready(struct scsi_cmnd *srb, struct rts51x_chip *chip)
435 {
436 unsigned int lun = SCSI_LUN(srb);
437
438 rts51x_init_cards(chip);
439
440 if (!check_card_ready(chip, lun)) {
441 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
442 return TRANSPORT_FAILED;
443 }
444
445 if (!check_lun_mc(chip, lun)) {
446 set_lun_mc(chip, lun);
447 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
448 return TRANSPORT_FAILED;
449 }
450 #ifdef SUPPORT_SD_LOCK
451 if (get_lun_card(chip, SCSI_LUN(srb)) == SD_CARD) {
452 struct sd_info *sd_card = &(chip->sd_card);
453 if (sd_card->sd_lock_notify) {
454 sd_card->sd_lock_notify = 0;
455 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
456 return TRANSPORT_FAILED;
457 } else if (sd_card->sd_lock_status & SD_LOCKED) {
458 set_sense_type(chip, lun,
459 SENSE_TYPE_MEDIA_READ_FORBIDDEN);
460 return TRANSPORT_FAILED;
461 }
462 }
463 #endif
464
465 return TRANSPORT_GOOD;
466 }
467
468 unsigned char formatter_inquiry_str[20] = {
469 'M', 'E', 'M', 'O', 'R', 'Y', 'S', 'T', 'I', 'C', 'K',
470 '-', 'M', 'G', /* Byte[47:49] */
471 0x0B, /* Byte[50]: MG, MS, MSPro, MSXC */
472 0x00, /* Byte[51]: Category Specific Commands */
473 0x00, /* Byte[52]: Access Control and feature */
474 0x20, 0x20, 0x20, /* Byte[53:55] */
475 };
476
477 static int inquiry(struct scsi_cmnd *srb, struct rts51x_chip *chip)
478 {
479 unsigned int lun = SCSI_LUN(srb);
480 char *inquiry_default = (char *)"Generic-xD/SD/M.S. 1.00 ";
481 char *inquiry_string;
482 unsigned char sendbytes;
483 unsigned char *buf;
484 u8 card = get_lun_card(chip, lun);
485 int pro_formatter_flag = 0;
486 unsigned char inquiry_buf[] = {
487 QULIFIRE | DRCT_ACCESS_DEV,
488 RMB_DISC | 0x0D,
489 0x00,
490 0x01,
491 0x1f,
492 0x02,
493 0,
494 REL_ADR | WBUS_32 | WBUS_16 | SYNC | LINKED | CMD_QUE | SFT_RE,
495 };
496
497 inquiry_string = inquiry_default;
498
499 buf = vmalloc(scsi_bufflen(srb));
500 if (buf == NULL)
501 TRACE_RET(chip, TRANSPORT_ERROR);
502
503 if (MS_FORMATTER_ENABLED(chip) && (get_lun2card(chip, lun) & MS_CARD)) {
504 if (!card || (card == MS_CARD))
505 pro_formatter_flag = 1;
506 }
507
508 if (pro_formatter_flag) {
509 if (scsi_bufflen(srb) < 56)
510 sendbytes = (unsigned char)(scsi_bufflen(srb));
511 else
512 sendbytes = 56;
513 } else {
514 if (scsi_bufflen(srb) < 36)
515 sendbytes = (unsigned char)(scsi_bufflen(srb));
516 else
517 sendbytes = 36;
518 }
519
520 if (sendbytes > 8) {
521 memcpy(buf, inquiry_buf, 8);
522 memcpy(buf + 8, inquiry_string, sendbytes - 8);
523 if (pro_formatter_flag)
524 buf[4] = 0x33; /* Additional Length */
525 } else {
526 memcpy(buf, inquiry_buf, sendbytes);
527 }
528
529 if (pro_formatter_flag) {
530 if (sendbytes > 36)
531 memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36);
532 }
533
534 scsi_set_resid(srb, 0);
535
536 rts51x_set_xfer_buf(buf, scsi_bufflen(srb), srb);
537 vfree(buf);
538
539 return TRANSPORT_GOOD;
540 }
541
542 static int start_stop_unit(struct scsi_cmnd *srb, struct rts51x_chip *chip)
543 {
544 unsigned int lun = SCSI_LUN(srb);
545
546 scsi_set_resid(srb, scsi_bufflen(srb));
547
548 if (srb->cmnd[1] == 1)
549 return TRANSPORT_GOOD;
550
551 switch (srb->cmnd[0x4]) {
552 case STOP_MEDIUM:
553 /* Media disabled */
554 return TRANSPORT_GOOD;
555
556 case UNLOAD_MEDIUM:
557 /* Media shall be unload */
558 if (check_card_ready(chip, lun))
559 eject_card(chip, lun);
560 return TRANSPORT_GOOD;
561
562 case MAKE_MEDIUM_READY:
563 case LOAD_MEDIUM:
564 if (check_card_ready(chip, lun)) {
565 return TRANSPORT_GOOD;
566 } else {
567 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
568 TRACE_RET(chip, TRANSPORT_FAILED);
569 }
570
571 break;
572 }
573
574 TRACE_RET(chip, TRANSPORT_ERROR);
575 }
576
577 static int allow_medium_removal(struct scsi_cmnd *srb, struct rts51x_chip *chip)
578 {
579 int prevent;
580
581 prevent = srb->cmnd[4] & 0x1;
582
583 scsi_set_resid(srb, 0);
584
585 if (prevent) {
586 set_sense_type(chip, SCSI_LUN(srb),
587 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
588 TRACE_RET(chip, TRANSPORT_FAILED);
589 }
590
591 return TRANSPORT_GOOD;
592 }
593
594 static void ms_mode_sense(struct rts51x_chip *chip, u8 cmd,
595 int lun, u8 *buf, int buf_len)
596 {
597 struct ms_info *ms_card = &(chip->ms_card);
598 int sys_info_offset;
599 int data_size = buf_len;
600 int support_format = 0;
601 int i = 0;
602
603 if (cmd == MODE_SENSE) {
604 sys_info_offset = 8;
605 if (data_size > 0x68)
606 data_size = 0x68;
607 buf[i++] = 0x67; /* Mode Data Length */
608 } else {
609 sys_info_offset = 12;
610 if (data_size > 0x6C)
611 data_size = 0x6C;
612 buf[i++] = 0x00; /* Mode Data Length (MSB) */
613 buf[i++] = 0x6A; /* Mode Data Length (LSB) */
614 }
615
616 /* Medium Type Code */
617 if (check_card_ready(chip, lun)) {
618 if (CHK_MSXC(ms_card)) {
619 support_format = 1;
620 buf[i++] = 0x40;
621 } else if (CHK_MSPRO(ms_card)) {
622 support_format = 1;
623 buf[i++] = 0x20;
624 } else {
625 buf[i++] = 0x10;
626 }
627
628 /* WP */
629 if (check_card_wp(chip, lun))
630 buf[i++] = 0x80;
631 else
632 buf[i++] = 0x00;
633 } else {
634 buf[i++] = 0x00; /* MediaType */
635 buf[i++] = 0x00; /* WP */
636 }
637
638 buf[i++] = 0x00; /* Reserved */
639
640 if (cmd == MODE_SENSE_10) {
641 buf[i++] = 0x00; /* Reserved */
642 buf[i++] = 0x00; /* Block descriptor length(MSB) */
643 buf[i++] = 0x00; /* Block descriptor length(LSB) */
644
645 /* The Following Data is the content of "Page 0x20" */
646 if (data_size >= 9)
647 buf[i++] = 0x20; /* Page Code */
648 if (data_size >= 10)
649 buf[i++] = 0x62; /* Page Length */
650 if (data_size >= 11)
651 buf[i++] = 0x00; /* No Access Control */
652 if (data_size >= 12) {
653 if (support_format)
654 buf[i++] = 0xC0; /* SF, SGM */
655 else
656 buf[i++] = 0x00;
657 }
658 } else {
659 /* The Following Data is the content of "Page 0x20" */
660 if (data_size >= 5)
661 buf[i++] = 0x20; /* Page Code */
662 if (data_size >= 6)
663 buf[i++] = 0x62; /* Page Length */
664 if (data_size >= 7)
665 buf[i++] = 0x00; /* No Access Control */
666 if (data_size >= 8) {
667 if (support_format)
668 buf[i++] = 0xC0; /* SF, SGM */
669 else
670 buf[i++] = 0x00;
671 }
672 }
673
674 if (data_size > sys_info_offset) {
675 /* 96 Bytes Attribute Data */
676 int len = data_size - sys_info_offset;
677 len = (len < 96) ? len : 96;
678
679 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len);
680 }
681 }
682
683 static int mode_sense(struct scsi_cmnd *srb, struct rts51x_chip *chip)
684 {
685 unsigned int lun = SCSI_LUN(srb);
686 unsigned int dataSize;
687 int status;
688 int pro_formatter_flag;
689 unsigned char pageCode, *buf;
690 u8 card = get_lun_card(chip, lun);
691
692 if (!check_card_ready(chip, lun)) {
693 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
694 scsi_set_resid(srb, scsi_bufflen(srb));
695 TRACE_RET(chip, TRANSPORT_FAILED);
696 }
697
698 pro_formatter_flag = 0;
699 dataSize = 8;
700 /* In Combo mode, device responses ModeSense command as a MS LUN
701 * when no card is inserted */
702 if ((get_lun2card(chip, lun) & MS_CARD)) {
703 if (!card || (card == MS_CARD)) {
704 dataSize = 108;
705 if (chip->option.mspro_formatter_enable)
706 pro_formatter_flag = 1;
707 }
708 }
709
710 buf = kmalloc(dataSize, GFP_KERNEL);
711 if (buf == NULL)
712 TRACE_RET(chip, TRANSPORT_ERROR);
713
714 pageCode = srb->cmnd[2] & 0x3f;
715
716 if ((pageCode == 0x3F) || (pageCode == 0x1C) ||
717 (pageCode == 0x00) || (pro_formatter_flag && (pageCode == 0x20))) {
718 if (srb->cmnd[0] == MODE_SENSE) {
719 if ((pageCode == 0x3F) || (pageCode == 0x20)) {
720 ms_mode_sense(chip, srb->cmnd[0], lun, buf,
721 dataSize);
722 } else {
723 dataSize = 4;
724 buf[0] = 0x03;
725 buf[1] = 0x00;
726 if (check_card_wp(chip, lun))
727 buf[2] = 0x80;
728 else
729 buf[3] = 0x00;
730 }
731 } else {
732 if ((pageCode == 0x3F) || (pageCode == 0x20)) {
733 ms_mode_sense(chip, srb->cmnd[0], lun, buf,
734 dataSize);
735 } else {
736 dataSize = 8;
737 buf[0] = 0x00;
738 buf[1] = 0x06;
739 buf[2] = 0x00;
740 if (check_card_wp(chip, lun))
741 buf[3] = 0x80;
742 else
743 buf[3] = 0x00;
744 buf[4] = 0x00;
745 buf[5] = 0x00;
746 buf[6] = 0x00;
747 buf[7] = 0x00;
748 }
749 }
750 status = TRANSPORT_GOOD;
751 } else {
752 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
753 scsi_set_resid(srb, scsi_bufflen(srb));
754 status = TRANSPORT_FAILED;
755 }
756
757 if (status == TRANSPORT_GOOD) {
758 unsigned int len = min(scsi_bufflen(srb), dataSize);
759 rts51x_set_xfer_buf(buf, len, srb);
760 scsi_set_resid(srb, scsi_bufflen(srb) - len);
761 }
762 kfree(buf);
763
764 return status;
765 }
766
767 static int request_sense(struct scsi_cmnd *srb, struct rts51x_chip *chip)
768 {
769 struct sense_data_t *sense;
770 unsigned int lun = SCSI_LUN(srb);
771 struct ms_info *ms_card = &(chip->ms_card);
772 unsigned char *tmp, *buf;
773
774 sense = &(chip->sense_buffer[lun]);
775
776 if ((get_lun_card(chip, lun) == MS_CARD)
777 && PRO_UNDER_FORMATTING(ms_card)) {
778 mspro_format_sense(chip, lun);
779 }
780
781 buf = vmalloc(scsi_bufflen(srb));
782 if (buf == NULL)
783 TRACE_RET(chip, TRANSPORT_ERROR);
784
785 tmp = (unsigned char *)sense;
786 memcpy(buf, tmp, scsi_bufflen(srb));
787
788 rts51x_set_xfer_buf(buf, scsi_bufflen(srb), srb);
789 vfree(buf);
790
791 scsi_set_resid(srb, 0);
792 /* Reset Sense Data */
793 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
794 return TRANSPORT_GOOD;
795 }
796
797 static int read_write(struct scsi_cmnd *srb, struct rts51x_chip *chip)
798 {
799 #ifdef SUPPORT_SD_LOCK
800 struct sd_info *sd_card = &(chip->sd_card);
801 #endif
802 unsigned int lun = SCSI_LUN(srb);
803 int retval;
804 u32 start_sec;
805 u16 sec_cnt;
806
807 if (!check_card_ready(chip, lun) || (chip->capacity[lun] == 0)) {
808 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
809 TRACE_RET(chip, TRANSPORT_FAILED);
810 }
811
812 if (!check_lun_mc(chip, lun)) {
813 set_lun_mc(chip, lun);
814 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
815 return TRANSPORT_FAILED;
816 }
817
818 rts51x_prepare_run(chip);
819 RTS51X_SET_STAT(chip, STAT_RUN);
820
821 #ifdef SUPPORT_SD_LOCK
822 if (sd_card->sd_erase_status) {
823 /* Accessing to any card is forbidden
824 * until the erase procedure of SD is completed */
825 RTS51X_DEBUGP("SD card being erased!\n");
826 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
827 TRACE_RET(chip, TRANSPORT_FAILED);
828 }
829
830 if (get_lun_card(chip, lun) == SD_CARD) {
831 if (sd_card->sd_lock_status & SD_LOCKED) {
832 RTS51X_DEBUGP("SD card locked!\n");
833 set_sense_type(chip, lun,
834 SENSE_TYPE_MEDIA_READ_FORBIDDEN);
835 TRACE_RET(chip, TRANSPORT_FAILED);
836 }
837 }
838 #endif
839
840 if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
841 start_sec =
842 ((u32) srb->cmnd[2] << 24) |
843 ((u32) srb->cmnd[3] << 16) |
844 ((u32) srb->cmnd[4] << 8) |
845 ((u32) srb->cmnd[5]);
846 sec_cnt = ((u16) (srb->cmnd[7]) << 8) | srb->cmnd[8];
847 } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
848 start_sec = ((u32) (srb->cmnd[1] & 0x1F) << 16) |
849 ((u32) srb->cmnd[2] << 8) | ((u32) srb->cmnd[3]);
850 sec_cnt = srb->cmnd[4];
851 } else if ((srb->cmnd[0] == VENDOR_CMND) &&
852 (srb->cmnd[1] == SCSI_APP_CMD) &&
853 ((srb->cmnd[2] == PP_READ10) ||
854 (srb->cmnd[2] == PP_WRITE10))) {
855 start_sec = ((u32) srb->cmnd[4] << 24) |
856 ((u32) srb->cmnd[5] << 16) |
857 ((u32) srb->cmnd[6] << 8) |
858 ((u32) srb->cmnd[7]);
859 sec_cnt = ((u16) (srb->cmnd[9]) << 8) | srb->cmnd[10];
860 } else {
861 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
862 TRACE_RET(chip, TRANSPORT_FAILED);
863 }
864
865 if ((start_sec > chip->capacity[lun]) ||
866 ((start_sec + sec_cnt) > chip->capacity[lun])) {
867 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE);
868 TRACE_RET(chip, TRANSPORT_FAILED);
869 }
870
871 if (sec_cnt == 0) {
872 scsi_set_resid(srb, 0);
873 return TRANSPORT_GOOD;
874 }
875
876 if ((srb->sc_data_direction == DMA_TO_DEVICE)
877 && check_card_wp(chip, lun)) {
878 RTS51X_DEBUGP("Write protected card!\n");
879 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
880 TRACE_RET(chip, TRANSPORT_FAILED);
881 }
882
883 retval = card_rw(srb, chip, start_sec, sec_cnt);
884 if (retval != STATUS_SUCCESS) {
885 #if 0
886 if (chip->need_release & chip->lun2card[lun]) {
887 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
888 } else {
889 #endif
890 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
891 set_sense_type(chip, lun,
892 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
893 } else {
894 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
895 }
896 #if 0
897 }
898 #endif
899 TRACE_RET(chip, TRANSPORT_FAILED);
900 }
901
902 scsi_set_resid(srb, 0);
903
904 return TRANSPORT_GOOD;
905 }
906
907 static int read_format_capacity(struct scsi_cmnd *srb, struct rts51x_chip *chip)
908 {
909 unsigned char *buf;
910 unsigned int lun = SCSI_LUN(srb);
911 unsigned int buf_len;
912 u8 card = get_lun_card(chip, lun);
913 int desc_cnt;
914 int i = 0;
915
916 if (!check_card_ready(chip, lun)) {
917 if (!chip->option.mspro_formatter_enable) {
918 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
919 TRACE_RET(chip, TRANSPORT_FAILED);
920 }
921 }
922
923 buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12;
924
925 buf = kmalloc(buf_len, GFP_KERNEL);
926 if (buf == NULL)
927 TRACE_RET(chip, TRANSPORT_ERROR);
928
929 buf[i++] = 0;
930 buf[i++] = 0;
931 buf[i++] = 0;
932
933 /* Capacity List Length */
934 if ((buf_len > 12) && chip->option.mspro_formatter_enable &&
935 (chip->lun2card[lun] & MS_CARD) && (!card || (card == MS_CARD))) {
936 buf[i++] = 0x10;
937 desc_cnt = 2;
938 } else {
939 buf[i++] = 0x08;
940 desc_cnt = 1;
941 }
942
943 while (desc_cnt) {
944 if (check_card_ready(chip, lun)) {
945 buf[i++] = (unsigned char)((chip->capacity[lun]) >> 24);
946 buf[i++] = (unsigned char)((chip->capacity[lun]) >> 16);
947 buf[i++] = (unsigned char)((chip->capacity[lun]) >> 8);
948 buf[i++] = (unsigned char)(chip->capacity[lun]);
949
950 if (desc_cnt == 2)
951 /* Byte[8]: Descriptor Type: Formatted medium */
952 buf[i++] = 2;
953 else
954 buf[i++] = 0; /* Byte[16] */
955 } else {
956 buf[i++] = 0xFF;
957 buf[i++] = 0xFF;
958 buf[i++] = 0xFF;
959 buf[i++] = 0xFF;
960
961 if (desc_cnt == 2)
962 /* Byte[8]: Descriptor Type: No medium */
963 buf[i++] = 3;
964 else
965 buf[i++] = 0; /*Byte[16] */
966 }
967
968 buf[i++] = 0x00;
969 buf[i++] = 0x02;
970 buf[i++] = 0x00;
971
972 desc_cnt--;
973 }
974
975 buf_len = min(scsi_bufflen(srb), buf_len);
976 rts51x_set_xfer_buf(buf, buf_len, srb);
977 kfree(buf);
978
979 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
980
981 return TRANSPORT_GOOD;
982 }
983
984 static int read_capacity(struct scsi_cmnd *srb, struct rts51x_chip *chip)
985 {
986 unsigned char *buf;
987 unsigned int lun = SCSI_LUN(srb);
988
989 if (!check_card_ready(chip, lun)) {
990 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
991 TRACE_RET(chip, TRANSPORT_FAILED);
992 }
993
994 if (!check_lun_mc(chip, lun)) {
995 set_lun_mc(chip, lun);
996 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
997 return TRANSPORT_FAILED;
998 }
999
1000 buf = kmalloc(8, GFP_KERNEL);
1001 if (buf == NULL)
1002 TRACE_RET(chip, TRANSPORT_ERROR);
1003
1004 buf[0] = (unsigned char)((chip->capacity[lun] - 1) >> 24);
1005 buf[1] = (unsigned char)((chip->capacity[lun] - 1) >> 16);
1006 buf[2] = (unsigned char)((chip->capacity[lun] - 1) >> 8);
1007 buf[3] = (unsigned char)(chip->capacity[lun] - 1);
1008
1009 buf[4] = 0x00;
1010 buf[5] = 0x00;
1011 buf[6] = 0x02;
1012 buf[7] = 0x00;
1013
1014 rts51x_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1015 kfree(buf);
1016
1017 scsi_set_resid(srb, 0);
1018
1019 return TRANSPORT_GOOD;
1020 }
1021
1022 static int get_dev_status(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1023 {
1024 unsigned int lun = SCSI_LUN(srb);
1025 unsigned int buf_len;
1026 u8 status[32] = { 0 };
1027
1028 rts51x_pp_status(chip, lun, status, 32);
1029
1030 buf_len = min(scsi_bufflen(srb), (unsigned int)sizeof(status));
1031 rts51x_set_xfer_buf(status, buf_len, srb);
1032 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1033
1034 return TRANSPORT_GOOD;
1035 }
1036
1037 static int read_status(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1038 {
1039 u8 rts51x_status[16];
1040 unsigned int buf_len;
1041 unsigned int lun = SCSI_LUN(srb);
1042
1043 rts51x_read_status(chip, lun, rts51x_status, 16);
1044
1045 buf_len = min(scsi_bufflen(srb), (unsigned int)sizeof(rts51x_status));
1046 rts51x_set_xfer_buf(rts51x_status, buf_len, srb);
1047 scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1048
1049 return TRANSPORT_GOOD;
1050 }
1051
1052 static int read_mem(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1053 {
1054 unsigned int lun = SCSI_LUN(srb);
1055 unsigned short addr, len, i;
1056 int retval;
1057 u8 *buf;
1058
1059 rts51x_prepare_run(chip);
1060 RTS51X_SET_STAT(chip, STAT_RUN);
1061
1062 addr = ((u16) srb->cmnd[2] << 8) | srb->cmnd[3];
1063 len = ((u16) srb->cmnd[4] << 8) | srb->cmnd[5];
1064
1065 if (addr < 0xe000) {
1066 RTS51X_DEBUGP("filter!addr=0x%x\n", addr);
1067 return TRANSPORT_GOOD;
1068 }
1069
1070 buf = vmalloc(len);
1071 if (!buf)
1072 TRACE_RET(chip, TRANSPORT_ERROR);
1073
1074 for (i = 0; i < len; i++) {
1075 retval = rts51x_ep0_read_register(chip, addr + i, buf + i);
1076 if (retval != STATUS_SUCCESS) {
1077 vfree(buf);
1078 set_sense_type(chip, lun,
1079 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1080 TRACE_RET(chip, TRANSPORT_FAILED);
1081 }
1082 }
1083
1084 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1085 rts51x_set_xfer_buf(buf, len, srb);
1086 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1087
1088 vfree(buf);
1089
1090 return TRANSPORT_GOOD;
1091 }
1092
1093 static int write_mem(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1094 {
1095 unsigned int lun = SCSI_LUN(srb);
1096 unsigned short addr, len, i;
1097 int retval;
1098 u8 *buf;
1099
1100 rts51x_prepare_run(chip);
1101 RTS51X_SET_STAT(chip, STAT_RUN);
1102
1103 addr = ((u16) srb->cmnd[2] << 8) | srb->cmnd[3];
1104 len = ((u16) srb->cmnd[4] << 8) | srb->cmnd[5];
1105
1106 if (addr < 0xe000) {
1107 RTS51X_DEBUGP("filter!addr=0x%x\n", addr);
1108 return TRANSPORT_GOOD;
1109 }
1110
1111 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1112 buf = vmalloc(len);
1113 if (!buf)
1114 TRACE_RET(chip, TRANSPORT_ERROR);
1115
1116 rts51x_get_xfer_buf(buf, len, srb);
1117
1118 for (i = 0; i < len; i++) {
1119 retval =
1120 rts51x_ep0_write_register(chip, addr + i, 0xFF, buf[i]);
1121 if (retval != STATUS_SUCCESS) {
1122 vfree(buf);
1123 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1124 TRACE_RET(chip, TRANSPORT_FAILED);
1125 }
1126 }
1127
1128 vfree(buf);
1129 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1130
1131 return TRANSPORT_GOOD;
1132 }
1133
1134 static int get_sd_csd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1135 {
1136 struct sd_info *sd_card = &(chip->sd_card);
1137 unsigned int lun = SCSI_LUN(srb);
1138
1139 if (!check_card_ready(chip, lun)) {
1140 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1141 TRACE_RET(chip, TRANSPORT_FAILED);
1142 }
1143
1144 if (get_lun_card(chip, lun) != SD_CARD) {
1145 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1146 TRACE_RET(chip, TRANSPORT_FAILED);
1147 }
1148
1149 scsi_set_resid(srb, 0);
1150 rts51x_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb);
1151
1152 return TRANSPORT_GOOD;
1153 }
1154
1155 static int read_phy_register(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1156 {
1157 int retval;
1158 u8 addr, len, i;
1159 u8 *buf;
1160
1161 rts51x_prepare_run(chip);
1162 RTS51X_SET_STAT(chip, STAT_RUN);
1163
1164 addr = srb->cmnd[5];
1165 len = srb->cmnd[7];
1166
1167 if (len) {
1168 buf = vmalloc(len);
1169 if (!buf)
1170 TRACE_RET(chip, TRANSPORT_ERROR);
1171
1172 for (i = 0; i < len; i++) {
1173 retval =
1174 rts51x_read_phy_register(chip, addr + i, buf + i);
1175 if (retval != STATUS_SUCCESS) {
1176 vfree(buf);
1177 set_sense_type(chip, SCSI_LUN(srb),
1178 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1179 TRACE_RET(chip, TRANSPORT_FAILED);
1180 }
1181 }
1182
1183 len = min(scsi_bufflen(srb), (unsigned int)len);
1184 rts51x_set_xfer_buf(buf, len, srb);
1185 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1186
1187 vfree(buf);
1188 }
1189
1190 return TRANSPORT_GOOD;
1191 }
1192
1193 static int write_phy_register(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1194 {
1195 int retval;
1196 u8 addr, len, i;
1197 u8 *buf;
1198
1199 rts51x_prepare_run(chip);
1200 RTS51X_SET_STAT(chip, STAT_RUN);
1201
1202 addr = srb->cmnd[5];
1203 len = srb->cmnd[7];
1204
1205 if (len) {
1206 len = min(scsi_bufflen(srb), (unsigned int)len);
1207
1208 buf = vmalloc(len);
1209 if (buf == NULL)
1210 TRACE_RET(chip, TRANSPORT_ERROR);
1211
1212 rts51x_get_xfer_buf(buf, len, srb);
1213 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1214
1215 for (i = 0; i < len; i++) {
1216 retval =
1217 rts51x_write_phy_register(chip, addr + i, buf[i]);
1218 if (retval != STATUS_SUCCESS) {
1219 vfree(buf);
1220 set_sense_type(chip, SCSI_LUN(srb),
1221 SENSE_TYPE_MEDIA_WRITE_ERR);
1222 TRACE_RET(chip, TRANSPORT_FAILED);
1223 }
1224 }
1225
1226 vfree(buf);
1227 }
1228
1229 return TRANSPORT_GOOD;
1230 }
1231
1232 static int get_card_bus_width(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1233 {
1234 unsigned int lun = SCSI_LUN(srb);
1235 u8 card, bus_width;
1236
1237 if (!check_card_ready(chip, lun)) {
1238 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1239 TRACE_RET(chip, TRANSPORT_FAILED);
1240 }
1241
1242 card = get_lun_card(chip, lun);
1243 if ((card == SD_CARD) || (card == MS_CARD)) {
1244 bus_width = chip->card_bus_width[lun];
1245 } else {
1246 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1247 TRACE_RET(chip, TRANSPORT_FAILED);
1248 }
1249
1250 scsi_set_resid(srb, 0);
1251 rts51x_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
1252
1253 return TRANSPORT_GOOD;
1254 }
1255
1256 #ifdef _MSG_TRACE
1257 static int trace_msg_cmd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1258 {
1259 unsigned char *buf = NULL;
1260 u8 clear;
1261 unsigned int buf_len;
1262
1263 buf_len =
1264 4 +
1265 ((2 + MSG_FUNC_LEN + MSG_FILE_LEN + TIME_VAL_LEN) * TRACE_ITEM_CNT);
1266
1267 if ((scsi_bufflen(srb) < buf_len) || (scsi_sglist(srb) == NULL)) {
1268 set_sense_type(chip, SCSI_LUN(srb),
1269 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1270 TRACE_RET(chip, TRANSPORT_FAILED);
1271 }
1272
1273 clear = srb->cmnd[2];
1274
1275 buf = vmalloc(scsi_bufflen(srb));
1276 if (buf == NULL)
1277 TRACE_RET(chip, TRANSPORT_ERROR);
1278
1279 rts51x_trace_msg(chip, buf, clear);
1280
1281 rts51x_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1282 vfree(buf);
1283
1284 scsi_set_resid(srb, 0);
1285 return TRANSPORT_GOOD;
1286 }
1287 #endif
1288
1289 static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1290 {
1291 int retval = STATUS_SUCCESS;
1292 unsigned int lun = SCSI_LUN(srb);
1293 u8 cmd_type, mask, value, idx, mode, len;
1294 u16 addr;
1295 u32 timeout;
1296
1297 rts51x_prepare_run(chip);
1298 RTS51X_SET_STAT(chip, STAT_RUN);
1299
1300 switch (srb->cmnd[3]) {
1301 case INIT_BATCHCMD:
1302 rts51x_init_cmd(chip);
1303 break;
1304
1305 case ADD_BATCHCMD:
1306 cmd_type = srb->cmnd[4];
1307 if (cmd_type > 2) {
1308 set_sense_type(chip, lun,
1309 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1310 TRACE_RET(chip, TRANSPORT_FAILED);
1311 }
1312 addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1313 mask = srb->cmnd[7];
1314 value = srb->cmnd[8];
1315 rts51x_add_cmd(chip, cmd_type, addr, mask, value);
1316 break;
1317
1318 case SEND_BATCHCMD:
1319 mode = srb->cmnd[4];
1320 len = srb->cmnd[5];
1321 timeout =
1322 ((u32) srb->cmnd[6] << 24) | ((u32) srb->
1323 cmnd[7] << 16) | ((u32) srb->
1324 cmnd[8] <<
1325 8) | ((u32)
1326 srb->
1327 cmnd
1328 [9]);
1329 retval = rts51x_send_cmd(chip, mode, 1000);
1330 if (retval != STATUS_SUCCESS) {
1331 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1332 TRACE_RET(chip, TRANSPORT_FAILED);
1333 }
1334 if (mode & STAGE_R) {
1335 retval = rts51x_get_rsp(chip, len, timeout);
1336 if (retval != STATUS_SUCCESS) {
1337 set_sense_type(chip, lun,
1338 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1339 TRACE_RET(chip, TRANSPORT_FAILED);
1340 }
1341 }
1342 break;
1343
1344 case GET_BATCHRSP:
1345 idx = srb->cmnd[4];
1346 value = chip->rsp_buf[idx];
1347 if (scsi_bufflen(srb) < 1) {
1348 set_sense_type(chip, lun,
1349 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1350 TRACE_RET(chip, TRANSPORT_FAILED);
1351 }
1352 rts51x_set_xfer_buf(&value, 1, srb);
1353 scsi_set_resid(srb, 0);
1354 break;
1355
1356 default:
1357 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1358 TRACE_RET(chip, TRANSPORT_FAILED);
1359 }
1360
1361 if (retval != STATUS_SUCCESS) {
1362 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1363 TRACE_RET(chip, TRANSPORT_FAILED);
1364 }
1365
1366 return TRANSPORT_GOOD;
1367 }
1368
1369 static int suit_cmd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1370 {
1371 int result;
1372
1373 switch (srb->cmnd[3]) {
1374 case INIT_BATCHCMD:
1375 case ADD_BATCHCMD:
1376 case SEND_BATCHCMD:
1377 case GET_BATCHRSP:
1378 result = rw_mem_cmd_buf(srb, chip);
1379 break;
1380 default:
1381 result = TRANSPORT_ERROR;
1382 }
1383
1384 return result;
1385 }
1386
1387 static int app_cmd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1388 {
1389 int result;
1390
1391 switch (srb->cmnd[2]) {
1392 case PP_READ10:
1393 case PP_WRITE10:
1394 result = read_write(srb, chip);
1395 break;
1396
1397 case SUIT_CMD:
1398 result = suit_cmd(srb, chip);
1399 break;
1400
1401 case READ_PHY:
1402 result = read_phy_register(srb, chip);
1403 break;
1404
1405 case WRITE_PHY:
1406 result = write_phy_register(srb, chip);
1407 break;
1408
1409 case GET_DEV_STATUS:
1410 result = get_dev_status(srb, chip);
1411 break;
1412
1413 default:
1414 set_sense_type(chip, SCSI_LUN(srb),
1415 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1416 TRACE_RET(chip, TRANSPORT_FAILED);
1417 }
1418
1419 return result;
1420 }
1421
1422 static int vendor_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1423 {
1424 int result = TRANSPORT_GOOD;
1425
1426 switch (srb->cmnd[1]) {
1427 case READ_STATUS:
1428 result = read_status(srb, chip);
1429 break;
1430
1431 case READ_MEM:
1432 result = read_mem(srb, chip);
1433 break;
1434
1435 case WRITE_MEM:
1436 result = write_mem(srb, chip);
1437 break;
1438
1439 case GET_BUS_WIDTH:
1440 result = get_card_bus_width(srb, chip);
1441 break;
1442
1443 case GET_SD_CSD:
1444 result = get_sd_csd(srb, chip);
1445 break;
1446
1447 #ifdef _MSG_TRACE
1448 case TRACE_MSG:
1449 result = trace_msg_cmd(srb, chip);
1450 break;
1451 #endif
1452
1453 case SCSI_APP_CMD:
1454 result = app_cmd(srb, chip);
1455 break;
1456
1457 default:
1458 set_sense_type(chip, SCSI_LUN(srb),
1459 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1460 TRACE_RET(chip, TRANSPORT_FAILED);
1461 }
1462
1463 return result;
1464 }
1465
1466 static int ms_format_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1467 {
1468 struct ms_info *ms_card = &(chip->ms_card);
1469 unsigned int lun = SCSI_LUN(srb);
1470 int retval, quick_format;
1471
1472 if (get_lun_card(chip, lun) != MS_CARD) {
1473 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1474 TRACE_RET(chip, TRANSPORT_FAILED);
1475 }
1476
1477 if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47)
1478 || (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D)
1479 || (srb->cmnd[7] != 0x74)) {
1480 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1481 TRACE_RET(chip, TRANSPORT_FAILED);
1482 }
1483
1484 if (srb->cmnd[8] & 0x01)
1485 quick_format = 0;
1486 else
1487 quick_format = 1;
1488
1489 if (!(chip->card_ready & MS_CARD)) {
1490 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1491 TRACE_RET(chip, TRANSPORT_FAILED);
1492 }
1493
1494 if (chip->card_wp & MS_CARD) {
1495 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
1496 TRACE_RET(chip, TRANSPORT_FAILED);
1497 }
1498
1499 if (!CHK_MSPRO(ms_card)) {
1500 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1501 TRACE_RET(chip, TRANSPORT_FAILED);
1502 }
1503
1504 rts51x_prepare_run(chip);
1505 RTS51X_SET_STAT(chip, STAT_RUN);
1506
1507 retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
1508 if (retval != STATUS_SUCCESS) {
1509 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
1510 TRACE_RET(chip, TRANSPORT_FAILED);
1511 }
1512
1513 scsi_set_resid(srb, 0);
1514 return TRANSPORT_GOOD;
1515 }
1516
1517 #ifdef SUPPORT_PCGL_1P18
1518 int get_ms_information(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1519 {
1520 struct ms_info *ms_card = &(chip->ms_card);
1521 unsigned int lun = SCSI_LUN(srb);
1522 u8 dev_info_id, data_len;
1523 u8 *buf;
1524 unsigned int buf_len;
1525 int i;
1526
1527 if (!check_card_ready(chip, lun)) {
1528 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1529 TRACE_RET(chip, TRANSPORT_FAILED);
1530 }
1531 if ((get_lun_card(chip, lun) != MS_CARD)) {
1532 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1533 TRACE_RET(chip, TRANSPORT_FAILED);
1534 }
1535
1536 if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) ||
1537 (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) ||
1538 (srb->cmnd[7] != 0x44)) {
1539 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1540 TRACE_RET(chip, TRANSPORT_FAILED);
1541 }
1542
1543 dev_info_id = srb->cmnd[3];
1544 if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) ||
1545 (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) ||
1546 !CHK_MSPRO(ms_card)) {
1547 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1548 TRACE_RET(chip, TRANSPORT_FAILED);
1549 }
1550
1551 if (dev_info_id == 0x15)
1552 buf_len = data_len = 0x3A;
1553 else
1554 buf_len = data_len = 0x6A;
1555
1556 buf = kmalloc(buf_len, GFP_KERNEL);
1557 if (!buf)
1558 TRACE_RET(chip, TRANSPORT_ERROR);
1559
1560 i = 0;
1561 /* GET Memory Stick Media Information Response Header */
1562 buf[i++] = 0x00; /* Data length MSB */
1563 buf[i++] = data_len; /* Data length LSB */
1564 /* Device Information Type Code */
1565 if (CHK_MSXC(ms_card))
1566 buf[i++] = 0x03;
1567 else
1568 buf[i++] = 0x02;
1569 /* SGM bit */
1570 buf[i++] = 0x01;
1571 /* Reserved */
1572 buf[i++] = 0x00;
1573 buf[i++] = 0x00;
1574 buf[i++] = 0x00;
1575 /* Number of Device Information */
1576 buf[i++] = 0x01;
1577
1578 /* Device Information Body
1579 * Device Information ID Number */
1580 buf[i++] = dev_info_id;
1581 /* Device Information Length */
1582 if (dev_info_id == 0x15)
1583 data_len = 0x31;
1584 else
1585 data_len = 0x61;
1586 buf[i++] = 0x00; /* Data length MSB */
1587 buf[i++] = data_len; /* Data length LSB */
1588 /* Valid Bit */
1589 buf[i++] = 0x80;
1590 if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
1591 /* System Information */
1592 memcpy(buf + i, ms_card->raw_sys_info, 96);
1593 } else {
1594 /* Model Name */
1595 memcpy(buf + i, ms_card->raw_model_name, 48);
1596 }
1597
1598 rts51x_set_xfer_buf(buf, buf_len, srb);
1599
1600 if (dev_info_id == 0x15)
1601 scsi_set_resid(srb, scsi_bufflen(srb) - 0x3C);
1602 else
1603 scsi_set_resid(srb, scsi_bufflen(srb) - 0x6C);
1604
1605 kfree(buf);
1606 return STATUS_SUCCESS;
1607 }
1608 #endif
1609
1610 static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1611 {
1612 int retval = TRANSPORT_ERROR;
1613
1614 if (srb->cmnd[2] == MS_FORMAT)
1615 retval = ms_format_cmnd(srb, chip);
1616 #ifdef SUPPORT_PCGL_1P18
1617 else if (srb->cmnd[2] == GET_MS_INFORMATION)
1618 retval = get_ms_information(srb, chip);
1619 #endif
1620
1621 return retval;
1622 }
1623
1624 #ifdef SUPPORT_CPRM
1625 static int sd_extention_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1626 {
1627 unsigned int lun = SCSI_LUN(srb);
1628 int result;
1629
1630 rts51x_prepare_run(chip);
1631 RTS51X_SET_STAT(chip, STAT_RUN);
1632
1633 sd_cleanup_work(chip);
1634
1635 if (!check_card_ready(chip, lun)) {
1636 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1637 TRACE_RET(chip, TRANSPORT_FAILED);
1638 }
1639 if ((get_lun_card(chip, lun) != SD_CARD)) {
1640 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1641 TRACE_RET(chip, TRANSPORT_FAILED);
1642 }
1643
1644 switch (srb->cmnd[0]) {
1645 case SD_PASS_THRU_MODE:
1646 result = sd_pass_thru_mode(srb, chip);
1647 break;
1648
1649 case SD_EXECUTE_NO_DATA:
1650 result = sd_execute_no_data(srb, chip);
1651 break;
1652
1653 case SD_EXECUTE_READ:
1654 result = sd_execute_read_data(srb, chip);
1655 break;
1656
1657 case SD_EXECUTE_WRITE:
1658 result = sd_execute_write_data(srb, chip);
1659 break;
1660
1661 case SD_GET_RSP:
1662 result = sd_get_cmd_rsp(srb, chip);
1663 break;
1664
1665 case SD_HW_RST:
1666 result = sd_hw_rst(srb, chip);
1667 break;
1668
1669 default:
1670 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1671 TRACE_RET(chip, TRANSPORT_FAILED);
1672 }
1673
1674 return result;
1675 }
1676 #endif
1677
1678 #ifdef SUPPORT_MAGIC_GATE
1679 int mg_report_key(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1680 {
1681 struct ms_info *ms_card = &(chip->ms_card);
1682 unsigned int lun = SCSI_LUN(srb);
1683 int retval;
1684 u8 key_format;
1685
1686 rts51x_prepare_run(chip);
1687 RTS51X_SET_STAT(chip, STAT_RUN);
1688
1689 ms_cleanup_work(chip);
1690
1691 if (!check_card_ready(chip, lun)) {
1692 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1693 TRACE_RET(chip, TRANSPORT_FAILED);
1694 }
1695 if ((get_lun_card(chip, lun) != MS_CARD)) {
1696 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1697 TRACE_RET(chip, TRANSPORT_FAILED);
1698 }
1699
1700 if (srb->cmnd[7] != KC_MG_R_PRO) {
1701 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1702 TRACE_RET(chip, TRANSPORT_FAILED);
1703 }
1704
1705 if (!CHK_MSPRO(ms_card)) {
1706 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
1707 TRACE_RET(chip, TRANSPORT_FAILED);
1708 }
1709
1710 key_format = srb->cmnd[10] & 0x3F;
1711
1712 switch (key_format) {
1713 case KF_GET_LOC_EKB:
1714 if ((scsi_bufflen(srb) == 0x41C) &&
1715 (srb->cmnd[8] == 0x04) && (srb->cmnd[9] == 0x1C)) {
1716 retval = mg_get_local_EKB(srb, chip);
1717 if (retval != STATUS_SUCCESS)
1718 TRACE_RET(chip, TRANSPORT_FAILED);
1719 } else {
1720 set_sense_type(chip, lun,
1721 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1722 TRACE_RET(chip, TRANSPORT_FAILED);
1723 }
1724 break;
1725
1726 case KF_RSP_CHG:
1727 if ((scsi_bufflen(srb) == 0x24) &&
1728 (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x24)) {
1729 retval = mg_get_rsp_chg(srb, chip);
1730 if (retval != STATUS_SUCCESS)
1731 TRACE_RET(chip, TRANSPORT_FAILED);
1732 } else {
1733 set_sense_type(chip, lun,
1734 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1735 TRACE_RET(chip, TRANSPORT_FAILED);
1736 }
1737 break;
1738
1739 case KF_GET_ICV:
1740 ms_card->mg_entry_num = srb->cmnd[5];
1741 if ((scsi_bufflen(srb) == 0x404) &&
1742 (srb->cmnd[8] == 0x04) &&
1743 (srb->cmnd[9] == 0x04) &&
1744 (srb->cmnd[2] == 0x00) &&
1745 (srb->cmnd[3] == 0x00) &&
1746 (srb->cmnd[4] == 0x00) && (srb->cmnd[5] < 32)) {
1747 retval = mg_get_ICV(srb, chip);
1748 if (retval != STATUS_SUCCESS)
1749 TRACE_RET(chip, TRANSPORT_FAILED);
1750 } else {
1751 set_sense_type(chip, lun,
1752 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1753 TRACE_RET(chip, TRANSPORT_FAILED);
1754 }
1755 break;
1756
1757 default:
1758 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1759 TRACE_RET(chip, TRANSPORT_FAILED);
1760 }
1761
1762 scsi_set_resid(srb, 0);
1763 return TRANSPORT_GOOD;
1764 }
1765
1766 int mg_send_key(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1767 {
1768 struct ms_info *ms_card = &(chip->ms_card);
1769 unsigned int lun = SCSI_LUN(srb);
1770 int retval;
1771 u8 key_format;
1772
1773 rts51x_prepare_run(chip);
1774 RTS51X_SET_STAT(chip, STAT_RUN);
1775
1776 ms_cleanup_work(chip);
1777
1778 if (!check_card_ready(chip, lun)) {
1779 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1780 TRACE_RET(chip, TRANSPORT_FAILED);
1781 }
1782 if (check_card_wp(chip, lun)) {
1783 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
1784 TRACE_RET(chip, TRANSPORT_FAILED);
1785 }
1786 if ((get_lun_card(chip, lun) != MS_CARD)) {
1787 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1788 TRACE_RET(chip, TRANSPORT_FAILED);
1789 }
1790
1791 if (srb->cmnd[7] != KC_MG_R_PRO) {
1792 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1793 TRACE_RET(chip, TRANSPORT_FAILED);
1794 }
1795
1796 if (!CHK_MSPRO(ms_card)) {
1797 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
1798 TRACE_RET(chip, TRANSPORT_FAILED);
1799 }
1800
1801 key_format = srb->cmnd[10] & 0x3F;
1802
1803 switch (key_format) {
1804 case KF_SET_LEAF_ID:
1805 if ((scsi_bufflen(srb) == 0x0C) &&
1806 (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x0C)) {
1807 retval = mg_set_leaf_id(srb, chip);
1808 if (retval != STATUS_SUCCESS)
1809 TRACE_RET(chip, TRANSPORT_FAILED);
1810 } else {
1811 set_sense_type(chip, lun,
1812 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1813 TRACE_RET(chip, TRANSPORT_FAILED);
1814 }
1815 break;
1816
1817 case KF_CHG_HOST:
1818 if ((scsi_bufflen(srb) == 0x0C) &&
1819 (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x0C)) {
1820 retval = mg_chg(srb, chip);
1821 if (retval != STATUS_SUCCESS)
1822 TRACE_RET(chip, TRANSPORT_FAILED);
1823 } else {
1824 set_sense_type(chip, lun,
1825 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1826 TRACE_RET(chip, TRANSPORT_FAILED);
1827 }
1828 break;
1829
1830 case KF_RSP_HOST:
1831 if ((scsi_bufflen(srb) == 0x0C) &&
1832 (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x0C)) {
1833 retval = mg_rsp(srb, chip);
1834 if (retval != STATUS_SUCCESS)
1835 TRACE_RET(chip, TRANSPORT_FAILED);
1836 } else {
1837 set_sense_type(chip, lun,
1838 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1839 TRACE_RET(chip, TRANSPORT_FAILED);
1840 }
1841 break;
1842
1843 case KF_SET_ICV:
1844 ms_card->mg_entry_num = srb->cmnd[5];
1845 if ((scsi_bufflen(srb) == 0x404) &&
1846 (srb->cmnd[8] == 0x04) &&
1847 (srb->cmnd[9] == 0x04) &&
1848 (srb->cmnd[2] == 0x00) &&
1849 (srb->cmnd[3] == 0x00) &&
1850 (srb->cmnd[4] == 0x00) && (srb->cmnd[5] < 32)) {
1851 retval = mg_set_ICV(srb, chip);
1852 if (retval != STATUS_SUCCESS)
1853 TRACE_RET(chip, TRANSPORT_FAILED);
1854 } else {
1855 set_sense_type(chip, lun,
1856 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1857 TRACE_RET(chip, TRANSPORT_FAILED);
1858 }
1859 break;
1860
1861 default:
1862 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1863 TRACE_RET(chip, TRANSPORT_FAILED);
1864 }
1865
1866 scsi_set_resid(srb, 0);
1867 return TRANSPORT_GOOD;
1868 }
1869 #endif
1870
1871 int rts51x_scsi_handler(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1872 {
1873 #ifdef SUPPORT_SD_LOCK
1874 struct sd_info *sd_card = &(chip->sd_card);
1875 #endif
1876 struct ms_info *ms_card = &(chip->ms_card);
1877 unsigned int lun = SCSI_LUN(srb);
1878 int result = TRANSPORT_GOOD;
1879
1880 #ifdef SUPPORT_SD_LOCK
1881 if (sd_card->sd_erase_status) {
1882 /* Block all SCSI command except for REQUEST_SENSE
1883 * and rs_ppstatus */
1884 if (!
1885 ((srb->cmnd[0] == VENDOR_CMND)
1886 && (srb->cmnd[1] == SCSI_APP_CMD)
1887 && (srb->cmnd[2] == GET_DEV_STATUS))
1888 && (srb->cmnd[0] != REQUEST_SENSE)) {
1889 /* Logical Unit Not Ready Format in Progress */
1890 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
1891 0, 0);
1892 TRACE_RET(chip, TRANSPORT_FAILED);
1893 }
1894 }
1895 #endif
1896
1897 if ((get_lun_card(chip, lun) == MS_CARD) &&
1898 (ms_card->format_status == FORMAT_IN_PROGRESS)) {
1899 if ((srb->cmnd[0] != REQUEST_SENSE)
1900 && (srb->cmnd[0] != INQUIRY)) {
1901 /* Logical Unit Not Ready Format in Progress */
1902 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
1903 0, (u16) (ms_card->progress));
1904 TRACE_RET(chip, TRANSPORT_FAILED);
1905 }
1906 }
1907
1908 switch (srb->cmnd[0]) {
1909 case READ_10:
1910 case WRITE_10:
1911 case READ_6:
1912 case WRITE_6:
1913 result = read_write(srb, chip);
1914 break;
1915
1916 case TEST_UNIT_READY:
1917 result = test_unit_ready(srb, chip);
1918 break;
1919
1920 case INQUIRY:
1921 result = inquiry(srb, chip);
1922 break;
1923
1924 case READ_CAPACITY:
1925 result = read_capacity(srb, chip);
1926 break;
1927
1928 case START_STOP:
1929 result = start_stop_unit(srb, chip);
1930 break;
1931
1932 case ALLOW_MEDIUM_REMOVAL:
1933 result = allow_medium_removal(srb, chip);
1934 break;
1935
1936 case REQUEST_SENSE:
1937 result = request_sense(srb, chip);
1938 break;
1939
1940 case MODE_SENSE:
1941 case MODE_SENSE_10:
1942 result = mode_sense(srb, chip);
1943 break;
1944
1945 case 0x23:
1946 result = read_format_capacity(srb, chip);
1947 break;
1948
1949 case VENDOR_CMND:
1950 result = vendor_cmnd(srb, chip);
1951 break;
1952
1953 case MS_SP_CMND:
1954 result = ms_sp_cmnd(srb, chip);
1955 break;
1956
1957 #ifdef SUPPORT_CPRM
1958 case SD_PASS_THRU_MODE:
1959 case SD_EXECUTE_NO_DATA:
1960 case SD_EXECUTE_READ:
1961 case SD_EXECUTE_WRITE:
1962 case SD_GET_RSP:
1963 case SD_HW_RST:
1964 result = sd_extention_cmnd(srb, chip);
1965 break;
1966 #endif
1967
1968 #ifdef SUPPORT_MAGIC_GATE
1969 case CMD_MSPRO_MG_RKEY:
1970 result = mg_report_key(srb, chip);
1971 break;
1972
1973 case CMD_MSPRO_MG_SKEY:
1974 result = mg_send_key(srb, chip);
1975 break;
1976 #endif
1977
1978 case FORMAT_UNIT:
1979 case MODE_SELECT:
1980 case VERIFY:
1981 result = TRANSPORT_GOOD;
1982 break;
1983
1984 default:
1985 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1986 result = TRANSPORT_FAILED;
1987 }
1988
1989 return result;
1990 }
1991
1992 /***********************************************************************
1993 * Host functions
1994 ***********************************************************************/
1995
1996 const char *host_info(struct Scsi_Host *host)
1997 {
1998 return "SCSI emulation for RTS51xx USB driver-based card reader";
1999 }
2000
2001 int slave_alloc(struct scsi_device *sdev)
2002 {
2003 /*
2004 * Set the INQUIRY transfer length to 36. We don't use any of
2005 * the extra data and many devices choke if asked for more or
2006 * less than 36 bytes.
2007 */
2008 sdev->inquiry_len = 36;
2009 return 0;
2010 }
2011
2012 int slave_configure(struct scsi_device *sdev)
2013 {
2014 /* Scatter-gather buffers (all but the last) must have a length
2015 * divisible by the bulk maxpacket size. Otherwise a data packet
2016 * would end up being short, causing a premature end to the data
2017 * transfer. Since high-speed bulk pipes have a maxpacket size
2018 * of 512, we'll use that as the scsi device queue's DMA alignment
2019 * mask. Guaranteeing proper alignment of the first buffer will
2020 * have the desired effect because, except at the beginning and
2021 * the end, scatter-gather buffers follow page boundaries. */
2022 blk_queue_dma_alignment(sdev->request_queue, (512 - 1));
2023
2024 /* Set the SCSI level to at least 2. We'll leave it at 3 if that's
2025 * what is originally reported. We need this to avoid confusing
2026 * the SCSI layer with devices that report 0 or 1, but need 10-byte
2027 * commands (ala ATAPI devices behind certain bridges, or devices
2028 * which simply have broken INQUIRY data).
2029 *
2030 * NOTE: This means /dev/sg programs (ala cdrecord) will get the
2031 * actual information. This seems to be the preference for
2032 * programs like that.
2033 *
2034 * NOTE: This also means that /proc/scsi/scsi and sysfs may report
2035 * the actual value or the modified one, depending on where the
2036 * data comes from.
2037 */
2038 if (sdev->scsi_level < SCSI_2)
2039 sdev->scsi_level = sdev->sdev_target->scsi_level = SCSI_2;
2040
2041 return 0;
2042 }
2043
2044 /***********************************************************************
2045 * /proc/scsi/ functions
2046 ***********************************************************************/
2047
2048 /* we use this macro to help us write into the buffer */
2049 #undef SPRINTF
2050 #define SPRINTF(args...) \
2051 do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0)
2052
2053 int proc_info(struct Scsi_Host *host, char *buffer,
2054 char **start, off_t offset, int length, int inout)
2055 {
2056 char *pos = buffer;
2057
2058 /* if someone is sending us data, just throw it away */
2059 if (inout)
2060 return length;
2061
2062 /* print the controller name */
2063 SPRINTF(" Host scsi%d: %s\n", host->host_no, RTS51X_NAME);
2064
2065 /* print product, vendor, and driver version strings */
2066 SPRINTF(" Vendor: Realtek Corp.\n");
2067 SPRINTF(" Product: RTS51xx USB Card Reader\n");
2068 SPRINTF(" Version: %s\n", DRIVER_VERSION);
2069 SPRINTF(" Build: %s\n", __TIME__);
2070
2071 /*
2072 * Calculate start of next buffer, and return value.
2073 */
2074 *start = buffer + offset;
2075
2076 if ((pos - buffer) < offset)
2077 return 0;
2078 else if ((pos - buffer - offset) < length)
2079 return pos - buffer - offset;
2080 else
2081 return length;
2082 }
2083
2084 /* queue a command */
2085 /* This is always called with scsi_lock(host) held */
2086 int queuecommand_lck(struct scsi_cmnd *srb, void (*done) (struct scsi_cmnd *))
2087 {
2088 struct rts51x_chip *chip = host_to_rts51x(srb->device->host);
2089
2090 /* check for state-transition errors */
2091 if (chip->srb != NULL) {
2092 RTS51X_DEBUGP("Error in %s: chip->srb = %p\n",
2093 __func__, chip->srb);
2094 return SCSI_MLQUEUE_HOST_BUSY;
2095 }
2096
2097 /* fail the command if we are disconnecting */
2098 if (test_bit(FLIDX_DISCONNECTING, &chip->usb->dflags)) {
2099 RTS51X_DEBUGP("Fail command during disconnect\n");
2100 srb->result = DID_NO_CONNECT << 16;
2101 done(srb);
2102 return 0;
2103 }
2104
2105 /* enqueue the command and wake up the control thread */
2106 srb->scsi_done = done;
2107 chip->srb = srb;
2108 complete(&chip->usb->cmnd_ready);
2109
2110 return 0;
2111 }
2112
2113 #if 0 /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 37) */
2114 int queuecommand(struct scsi_cmnd *srb, void (*done) (struct scsi_cmnd *))
2115 {
2116 return queuecommand_lck(srb, done);
2117 }
2118 #else
2119 DEF_SCSI_QCMD(queuecommand)
2120 #endif
2121 /***********************************************************************
2122 * Error handling functions
2123 ***********************************************************************/
2124 /* Command timeout and abort */
2125 int command_abort(struct scsi_cmnd *srb)
2126 {
2127 struct rts51x_chip *chip = host_to_rts51x(srb->device->host);
2128
2129 RTS51X_DEBUGP("%s called\n", __func__);
2130
2131 /* us->srb together with the TIMED_OUT, RESETTING, and ABORTING
2132 * bits are protected by the host lock. */
2133 scsi_lock(rts51x_to_host(chip));
2134
2135 /* Is this command still active? */
2136 if (chip->srb != srb) {
2137 scsi_unlock(rts51x_to_host(chip));
2138 RTS51X_DEBUGP("-- nothing to abort\n");
2139 return FAILED;
2140 }
2141
2142 /* Set the TIMED_OUT bit. Also set the ABORTING bit, but only if
2143 * a device reset isn't already in progress (to avoid interfering
2144 * with the reset). Note that we must retain the host lock while
2145 * calling usb_stor_stop_transport(); otherwise it might interfere
2146 * with an auto-reset that begins as soon as we release the lock. */
2147 set_bit(FLIDX_TIMED_OUT, &chip->usb->dflags);
2148 if (!test_bit(FLIDX_RESETTING, &chip->usb->dflags)) {
2149 set_bit(FLIDX_ABORTING, &chip->usb->dflags);
2150 /* rts51x_stop_transport(us); */
2151 }
2152 scsi_unlock(rts51x_to_host(chip));
2153
2154 /* Wait for the aborted command to finish */
2155 wait_for_completion(&chip->usb->notify);
2156 return SUCCESS;
2157 }
2158
2159 /* This invokes the transport reset mechanism to reset the state of the
2160 * device */
2161 int device_reset(struct scsi_cmnd *srb)
2162 {
2163 int result = 0;
2164
2165 RTS51X_DEBUGP("%s called\n", __func__);
2166
2167 return result < 0 ? FAILED : SUCCESS;
2168 }
2169
2170 /* Simulate a SCSI bus reset by resetting the device's USB port. */
2171 int bus_reset(struct scsi_cmnd *srb)
2172 {
2173 int result = 0;
2174
2175 RTS51X_DEBUGP("%s called\n", __func__);
2176
2177 return result < 0 ? FAILED : SUCCESS;
2178 }
2179
2180 static const char *rts5139_info(struct Scsi_Host *host)
2181 {
2182 return "SCSI emulation for RTS5139 USB card reader";
2183 }
2184
2185 struct scsi_host_template rts51x_host_template = {
2186 /* basic userland interface stuff */
2187 .name = RTS51X_NAME,
2188 .proc_name = RTS51X_NAME,
2189 .proc_info = proc_info,
2190 .info = rts5139_info,
2191
2192 /* command interface -- queued only */
2193 .queuecommand = queuecommand,
2194
2195 /* error and abort handlers */
2196 .eh_abort_handler = command_abort,
2197 .eh_device_reset_handler = device_reset,
2198 .eh_bus_reset_handler = bus_reset,
2199
2200 /* queue commands only, only one command per LUN */
2201 .can_queue = 1,
2202 .cmd_per_lun = 1,
2203
2204 /* unknown initiator id */
2205 .this_id = -1,
2206
2207 .slave_alloc = slave_alloc,
2208 .slave_configure = slave_configure,
2209
2210 /* lots of sg segments can be handled */
2211 .sg_tablesize = SG_ALL,
2212
2213 /* limit the total size of a transfer to 120 KB */
2214 .max_sectors = 240,
2215
2216 /* merge commands... this seems to help performance, but
2217 * periodically someone should test to see which setting is more
2218 * optimal.
2219 */
2220 .use_clustering = 1,
2221
2222 /* emulated HBA */
2223 .emulated = 1,
2224
2225 /* we do our own delay after a device or bus reset */
2226 .skip_settle_delay = 1,
2227
2228 /* sysfs device attributes */
2229 /* .sdev_attrs = sysfs_device_attr_list, */
2230
2231 /* module management */
2232 .module = THIS_MODULE
2233 };
2234