1 /* Driver for Realtek RTS51xx USB card reader
3 * Copyright(c) 2009 Realtek Semiconductor Corp. All rights reserved.
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
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.
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/>.
19 * wwang (wei_wang@realsil.com.cn)
20 * No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
22 * Edwin Rong (edwin_rong@realsil.com.cn)
23 * No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
26 #include <linux/blkdev.h>
27 #include <linux/kthread.h>
28 #include <linux/sched.h>
29 #include <linux/slab.h>
34 #include "rts51x_transport.h"
35 #include "rts51x_scsi.h"
36 #include "rts51x_card.h"
37 #include "rts51x_chip.h"
43 static inline int get_rsp_type(u8 rsp_code
, u8
*rsp_type
, int *rsp_len
)
45 if (!rsp_type
|| !rsp_len
)
50 *rsp_type
= SD_RSP_TYPE_R0
; /* no response */
55 *rsp_type
= SD_RSP_TYPE_R1
; /* R1,R6(,R4,R5) */
60 *rsp_type
= SD_RSP_TYPE_R1b
; /* R1b */
65 *rsp_type
= SD_RSP_TYPE_R2
; /* R2 */
70 *rsp_type
= SD_RSP_TYPE_R3
; /* R3 */
78 return STATUS_SUCCESS
;
81 static int ext_sd_send_cmd_get_rsp(struct rts51x_chip
*chip
, u8 cmd_idx
,
82 u32 arg
, u8 rsp_type
, u8
*rsp
, int rsp_len
,
92 RTS51X_DEBUGP("EXT SD/MMC CMD %d\n", cmd_idx
);
94 if (rsp_type
== SD_RSP_TYPE_R1b
)
99 rts51x_init_cmd(chip
);
101 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_CMD0
, 0xFF, 0x40 | cmd_idx
);
102 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_CMD1
, 0xFF, (u8
) (arg
>> 24));
103 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_CMD2
, 0xFF, (u8
) (arg
>> 16));
104 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_CMD3
, 0xFF, (u8
) (arg
>> 8));
105 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_CMD4
, 0xFF, (u8
) arg
);
107 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_CFG2
, 0xFF, rsp_type
);
108 rts51x_add_cmd(chip
, WRITE_REG_CMD
, CARD_DATA_SOURCE
,
109 0x01, PINGPONG_BUFFER
);
110 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_TRANSFER
,
111 0xFF, SD_TM_CMD_RSP
| SD_TRANSFER_START
);
112 rts51x_add_cmd(chip
, CHECK_REG_CMD
, SD_TRANSFER
, SD_TRANSFER_END
,
115 rts51x_add_cmd(chip
, READ_REG_CMD
, SD_STAT1
, 0, 0);
117 if (CHECK_USB(chip
, USB_20
)) {
118 if (rsp_type
== SD_RSP_TYPE_R2
) {
119 for (reg_addr
= PPBUF_BASE2
;
120 reg_addr
< PPBUF_BASE2
+ 16; reg_addr
++) {
121 rts51x_add_cmd(chip
, READ_REG_CMD
, reg_addr
, 0,
125 } else if (rsp_type
!= SD_RSP_TYPE_R0
) {
126 /* Read data from SD_CMDx registers */
127 for (reg_addr
= SD_CMD0
; reg_addr
<= SD_CMD4
;
129 rts51x_add_cmd(chip
, READ_REG_CMD
, reg_addr
, 0,
136 rts51x_add_cmd(chip
, READ_REG_CMD
, SD_CMD5
, 0, 0);
141 retval
= rts51x_send_cmd(chip
, MODE_CR
, 100);
142 if (retval
!= STATUS_SUCCESS
)
143 TRACE_RET(chip
, retval
);
145 retval
= rts51x_get_rsp(chip
, len
, timeout
);
147 if (CHECK_SD_TRANS_FAIL(chip
, retval
)) {
148 rts51x_clear_sd_error(chip
);
150 if (retval
== STATUS_TIMEDOUT
) {
151 if (rsp_type
& SD_WAIT_BUSY_END
) {
152 retval
= sd_check_data0_status(chip
);
153 if (retval
!= STATUS_SUCCESS
)
154 TRACE_RET(chip
, retval
);
157 TRACE_RET(chip
, STATUS_FAIL
);
160 if (rsp_type
== SD_RSP_TYPE_R0
)
161 return STATUS_SUCCESS
;
163 if (CHECK_USB(chip
, USB_20
)) {
164 rts51x_read_rsp_buf(chip
, 2, buf
, len
- 2);
166 if (rsp_type
== SD_RSP_TYPE_R2
) {
167 reg_addr
= PPBUF_BASE2
;
174 rts51x_seq_read_register(chip
, reg_addr
,
175 (unsigned short)len
, buf
);
176 if (retval
!= STATUS_SUCCESS
)
177 TRACE_RET(chip
, retval
);
178 RTS51X_READ_REG(chip
, SD_CMD5
, buf
+ len
);
180 stat
= chip
->rsp_buf
[1];
182 if ((buf
[0] & 0xC0) != 0)
183 TRACE_RET(chip
, STATUS_FAIL
);
185 if (!(rsp_type
& SD_NO_CHECK_CRC7
)) {
186 if (stat
& SD_CRC7_ERR
) {
187 if (cmd_idx
== WRITE_MULTIPLE_BLOCK
)
188 TRACE_RET(chip
, STATUS_FAIL
);
189 if (rty_cnt
< SD_MAX_RETRY_COUNT
) {
194 TRACE_RET(chip
, STATUS_FAIL
);
199 if ((cmd_idx
== SELECT_CARD
) || (cmd_idx
== APP_CMD
) ||
200 (cmd_idx
== SEND_STATUS
) || (cmd_idx
== STOP_TRANSMISSION
)) {
201 if ((cmd_idx
!= STOP_TRANSMISSION
) && (special_check
== 0)) {
203 TRACE_RET(chip
, STATUS_FAIL
);
206 TRACE_RET(chip
, STATUS_FAIL
);
208 TRACE_RET(chip
, STATUS_FAIL
);
210 if (cmd_idx
== SELECT_CARD
) {
211 if (rsp_type
== SD_RSP_TYPE_R2
) {
212 if ((buf
[3] & 0x1E) != 0x04)
213 TRACE_RET(chip
, STATUS_FAIL
);
214 } else if (rsp_type
== SD_RSP_TYPE_R2
) {
215 if ((buf
[3] & 0x1E) != 0x03)
216 TRACE_RET(chip
, STATUS_FAIL
);
222 memcpy(rsp
, buf
, rsp_len
);
224 return STATUS_SUCCESS
;
227 static int ext_sd_get_rsp(struct rts51x_chip
*chip
, int len
,
228 u8
*rsp
, u8 rsp_type
)
233 if (rsp_type
== SD_RSP_TYPE_R0
)
234 return STATUS_SUCCESS
;
236 rts51x_init_cmd(chip
);
238 if (rsp_type
== SD_RSP_TYPE_R2
) {
239 for (reg_addr
= PPBUF_BASE2
; reg_addr
< PPBUF_BASE2
+ 16;
241 rts51x_add_cmd(chip
, READ_REG_CMD
, reg_addr
, 0xFF, 0);
244 } else if (rsp_type
!= SD_RSP_TYPE_R0
) {
245 for (reg_addr
= SD_CMD0
; reg_addr
<= SD_CMD4
; reg_addr
++)
246 rts51x_add_cmd(chip
, READ_REG_CMD
, reg_addr
, 0xFF, 0);
249 rts51x_add_cmd(chip
, READ_REG_CMD
, SD_CMD5
, 0xFF, 0);
251 retval
= rts51x_send_cmd(chip
, MODE_CR
, 100);
252 if (retval
!= STATUS_SUCCESS
)
253 TRACE_RET(chip
, retval
);
255 retval
= rts51x_get_rsp(chip
, rsp_len
, 100);
257 if (retval
!= STATUS_SUCCESS
)
258 TRACE_RET(chip
, retval
);
261 int min_len
= (rsp_len
< len
) ? rsp_len
: len
;
263 memcpy(rsp
, rts51x_get_rsp_data(chip
), min_len
);
265 RTS51X_DEBUGP("min_len = %d\n", min_len
);
266 RTS51X_DEBUGP("Response in cmd buf: 0x%x 0x%x 0x%x 0x%x\n",
267 rsp
[0], rsp
[1], rsp
[2], rsp
[3]);
270 return STATUS_SUCCESS
;
273 int ext_rts51x_sd_execute_no_data(struct rts51x_chip
*chip
, unsigned int lun
,
274 u8 cmd_idx
, u8 standby
, u8 acmd
, u8 rsp_code
,
277 struct sd_info
*sd_card
= &(chip
->sd_card
);
281 retval
= rts51x_sd_switch_clock(chip
);
282 if (retval
!= STATUS_SUCCESS
)
283 TRACE_RET(chip
, TRANSPORT_FAILED
);
285 if (sd_card
->pre_cmd_err
) {
286 sd_card
->pre_cmd_err
= 0;
287 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_CHANGE
);
288 TRACE_RET(chip
, TRANSPORT_FAILED
);
290 retval
= get_rsp_type(rsp_code
, &rsp_type
, &rsp_len
);
291 if (retval
!= STATUS_SUCCESS
) {
292 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
293 TRACE_RET(chip
, TRANSPORT_FAILED
);
295 sd_card
->last_rsp_type
= rsp_type
;
297 retval
= rts51x_sd_switch_clock(chip
);
298 if (retval
!= STATUS_SUCCESS
)
299 TRACE_RET(chip
, TRANSPORT_FAILED
);
300 /* Set H/W SD/MMC Bus Width */
301 rts51x_write_register(chip
, SD_CFG1
, 0x03, SD_BUS_WIDTH_4
);
304 retval
= rts51x_sd_select_card(chip
, 0);
305 if (retval
!= STATUS_SUCCESS
)
306 TRACE_GOTO(chip
, SD_Execute_Cmd_Failed
);
311 ext_sd_send_cmd_get_rsp(chip
, APP_CMD
, sd_card
->sd_addr
,
312 SD_RSP_TYPE_R1
, NULL
, 0, 0);
313 if (retval
!= STATUS_SUCCESS
)
314 TRACE_GOTO(chip
, SD_Execute_Cmd_Failed
);
317 retval
= ext_sd_send_cmd_get_rsp(chip
, cmd_idx
, arg
, rsp_type
,
318 sd_card
->rsp
, rsp_len
, 0);
319 if (retval
!= STATUS_SUCCESS
)
320 TRACE_GOTO(chip
, SD_Execute_Cmd_Failed
);
323 retval
= rts51x_sd_select_card(chip
, 1);
324 if (retval
!= STATUS_SUCCESS
)
325 TRACE_GOTO(chip
, SD_Execute_Cmd_Failed
);
328 return TRANSPORT_GOOD
;
330 SD_Execute_Cmd_Failed
:
331 sd_card
->pre_cmd_err
= 1;
332 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_NO_SENSE
);
333 rts51x_release_sd_card(chip
);
334 rts51x_do_rts51x_reset_sd_card(chip
);
335 if (!(chip
->card_ready
& SD_CARD
))
336 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_NOT_PRESENT
);
338 TRACE_RET(chip
, TRANSPORT_FAILED
);
341 int ext_rts51x_sd_execute_read_data(struct rts51x_chip
*chip
, unsigned int lun
,
342 u8 cmd_idx
, u8 cmd12
, u8 standby
,
343 u8 acmd
, u8 rsp_code
, u32 arg
, u32 data_len
,
344 void *data_buf
, unsigned int buf_len
, int use_sg
)
346 struct sd_info
*sd_card
= &(chip
->sd_card
);
347 int retval
, rsp_len
, i
;
348 int cmd13_checkbit
= 0, read_err
= 0;
349 u8 rsp_type
, bus_width
;
351 if (sd_card
->pre_cmd_err
) {
352 sd_card
->pre_cmd_err
= 0;
353 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_CHANGE
);
354 TRACE_RET(chip
, TRANSPORT_FAILED
);
357 retval
= rts51x_sd_switch_clock(chip
);
358 if (retval
!= STATUS_SUCCESS
)
359 TRACE_RET(chip
, STATUS_FAIL
);
360 retval
= get_rsp_type(rsp_code
, &rsp_type
, &rsp_len
);
361 if (retval
!= STATUS_SUCCESS
) {
362 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
363 TRACE_RET(chip
, TRANSPORT_FAILED
);
365 sd_card
->last_rsp_type
= rsp_type
;
367 retval
= rts51x_sd_switch_clock(chip
);
368 if (retval
!= STATUS_SUCCESS
)
369 TRACE_RET(chip
, TRANSPORT_FAILED
);
370 bus_width
= SD_BUS_WIDTH_4
;
372 if (data_len
< 512) {
373 retval
= ext_sd_send_cmd_get_rsp(chip
, SET_BLOCKLEN
, data_len
,
374 SD_RSP_TYPE_R1
, NULL
, 0, 0);
375 if (retval
!= STATUS_SUCCESS
)
376 TRACE_GOTO(chip
, SD_Execute_Read_Cmd_Failed
);
380 retval
= rts51x_sd_select_card(chip
, 0);
381 if (retval
!= STATUS_SUCCESS
)
382 TRACE_GOTO(chip
, SD_Execute_Read_Cmd_Failed
);
387 ext_sd_send_cmd_get_rsp(chip
, APP_CMD
, sd_card
->sd_addr
,
388 SD_RSP_TYPE_R1
, NULL
, 0, 0);
389 if (retval
!= STATUS_SUCCESS
)
390 TRACE_GOTO(chip
, SD_Execute_Read_Cmd_Failed
);
393 if (data_len
<= 512) {
396 u16 byte_cnt
, blk_cnt
;
398 unsigned int offset
= 0;
401 byte_cnt
= (u16
) (data_len
& 0x3FF);
404 cmd
[0] = 0x40 | cmd_idx
;
405 cmd
[1] = (u8
) (arg
>> 24);
406 cmd
[2] = (u8
) (arg
>> 16);
407 cmd
[3] = (u8
) (arg
>> 8);
410 buf
= kmalloc(data_len
, GFP_KERNEL
);
412 TRACE_RET(chip
, TRANSPORT_ERROR
);
414 retval
= sd_read_data(chip
, SD_TM_NORMAL_READ
, cmd
, 5, byte_cnt
,
415 blk_cnt
, bus_width
, buf
, data_len
, 2000);
416 if (retval
!= STATUS_SUCCESS
) {
419 rts51x_write_register(chip
, CARD_STOP
,
420 SD_STOP
| SD_CLR_ERR
,
421 SD_STOP
| SD_CLR_ERR
);
422 TRACE_GOTO(chip
, SD_Execute_Read_Cmd_Failed
);
425 min_len
= min(data_len
, buf_len
);
427 rts51x_access_sglist(buf
, min_len
, (void *)data_buf
,
428 &sg
, &offset
, TO_XFER_BUF
);
430 memcpy(data_buf
, buf
, min_len
);
433 } else if (!(data_len
& 0x1FF)) {
434 rts51x_init_cmd(chip
);
435 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_BYTE_CNT_H
, 0xFF, 0x02);
436 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_BYTE_CNT_L
, 0xFF, 0x00);
437 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_BLOCK_CNT_H
,
438 0xFF, (u8
) (data_len
>> 17));
439 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_BLOCK_CNT_L
,
440 0xFF, (u8
) ((data_len
& 0x0001FE00) >> 9));
441 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_CMD0
, 0xFF,
443 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_CMD1
, 0xFF,
445 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_CMD2
, 0xFF,
447 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_CMD3
, 0xFF,
449 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_CMD4
, 0xFF, (u8
) arg
);
450 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_CFG1
, 0x03, bus_width
);
451 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_CFG2
, 0xFF, rsp_type
);
452 rts51x_trans_dma_enable(DMA_FROM_DEVICE
, chip
, data_len
, DMA_512
);
453 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_TRANSFER
, 0xFF,
454 SD_TM_AUTO_READ_2
| SD_TRANSFER_START
);
455 rts51x_add_cmd(chip
, CHECK_REG_CMD
, SD_TRANSFER
,
456 SD_TRANSFER_END
, SD_TRANSFER_END
);
457 retval
= rts51x_send_cmd(chip
, MODE_CDIR
, 100);
458 if (retval
!= STATUS_SUCCESS
) {
460 rts51x_ep0_write_register(chip
, CARD_STOP
,
461 SD_STOP
| SD_CLR_ERR
,
462 SD_STOP
| SD_CLR_ERR
);
463 TRACE_GOTO(chip
, SD_Execute_Read_Cmd_Failed
);
467 rts51x_transfer_data_rcc(chip
, RCV_BULK_PIPE(chip
),
468 data_buf
, buf_len
, use_sg
, NULL
,
470 if (retval
!= STATUS_SUCCESS
) {
472 rts51x_ep0_write_register(chip
, CARD_STOP
,
473 SD_STOP
| SD_CLR_ERR
,
474 SD_STOP
| SD_CLR_ERR
);
475 TRACE_GOTO(chip
, SD_Execute_Read_Cmd_Failed
);
477 retval
= rts51x_get_rsp(chip
, 1, 500);
478 if (CHECK_SD_TRANS_FAIL(chip
, retval
)) {
480 rts51x_ep0_write_register(chip
, CARD_STOP
,
481 SD_STOP
| SD_CLR_ERR
,
482 SD_STOP
| SD_CLR_ERR
);
483 TRACE_GOTO(chip
, SD_Execute_Read_Cmd_Failed
);
486 TRACE_GOTO(chip
, SD_Execute_Read_Cmd_Failed
);
489 retval
= ext_sd_get_rsp(chip
, rsp_len
, sd_card
->rsp
, rsp_type
);
490 if (retval
!= STATUS_SUCCESS
)
491 TRACE_GOTO(chip
, SD_Execute_Read_Cmd_Failed
);
494 retval
= rts51x_sd_select_card(chip
, 1);
495 if (retval
!= STATUS_SUCCESS
)
496 TRACE_GOTO(chip
, SD_Execute_Read_Cmd_Failed
);
500 retval
= ext_sd_send_cmd_get_rsp(chip
, STOP_TRANSMISSION
,
501 0, SD_RSP_TYPE_R1b
, NULL
, 0,
503 if (retval
!= STATUS_SUCCESS
)
504 TRACE_GOTO(chip
, SD_Execute_Read_Cmd_Failed
);
507 if (data_len
< 512) {
508 retval
= ext_sd_send_cmd_get_rsp(chip
, SET_BLOCKLEN
, 0x200,
509 SD_RSP_TYPE_R1
, NULL
, 0, 0);
510 if (retval
!= STATUS_SUCCESS
)
511 TRACE_GOTO(chip
, SD_Execute_Read_Cmd_Failed
);
513 rts51x_write_register(chip
, SD_BYTE_CNT_H
, 0xFF, 0x02);
514 rts51x_write_register(chip
, SD_BYTE_CNT_L
, 0xFF, 0x00);
517 if (standby
|| cmd12
)
520 for (i
= 0; i
< 3; i
++) {
522 ext_sd_send_cmd_get_rsp(chip
, SEND_STATUS
, sd_card
->sd_addr
,
523 SD_RSP_TYPE_R1
, NULL
, 0,
525 if (retval
== STATUS_SUCCESS
)
528 if (retval
!= STATUS_SUCCESS
)
529 TRACE_GOTO(chip
, SD_Execute_Read_Cmd_Failed
);
531 return TRANSPORT_GOOD
;
533 SD_Execute_Read_Cmd_Failed
:
534 sd_card
->pre_cmd_err
= 1;
535 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_NO_SENSE
);
537 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR
);
538 rts51x_release_sd_card(chip
);
539 rts51x_do_rts51x_reset_sd_card(chip
);
540 if (!(chip
->card_ready
& SD_CARD
))
541 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_NOT_PRESENT
);
543 TRACE_RET(chip
, TRANSPORT_FAILED
);
546 int ext_rts51x_sd_execute_write_data(struct rts51x_chip
*chip
, unsigned int lun
,
547 u8 cmd_idx
, u8 cmd12
, u8 standby
, u8 acmd
,
548 u8 rsp_code
, u32 arg
, u32 data_len
,
549 void *data_buf
, unsigned int buf_len
, int use_sg
)
551 struct sd_info
*sd_card
= &(chip
->sd_card
);
553 int cmd13_checkbit
= 0, write_err
= 0;
557 if (sd_card
->pre_cmd_err
) {
558 sd_card
->pre_cmd_err
= 0;
559 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_CHANGE
);
560 TRACE_RET(chip
, TRANSPORT_FAILED
);
563 retval
= rts51x_sd_switch_clock(chip
);
564 if (retval
!= STATUS_SUCCESS
)
565 TRACE_RET(chip
, STATUS_FAIL
);
567 retval
= get_rsp_type(rsp_code
, &rsp_type
, &rsp_len
);
568 if (retval
!= STATUS_SUCCESS
) {
569 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
570 TRACE_RET(chip
, TRANSPORT_FAILED
);
572 sd_card
->last_rsp_type
= rsp_type
;
574 retval
= rts51x_sd_switch_clock(chip
);
575 if (retval
!= STATUS_SUCCESS
)
576 TRACE_RET(chip
, TRANSPORT_FAILED
);
577 rts51x_write_register(chip
, SD_CFG1
, 0x03, SD_BUS_WIDTH_4
);
579 if (data_len
< 512) {
580 retval
= ext_sd_send_cmd_get_rsp(chip
, SET_BLOCKLEN
, data_len
,
581 SD_RSP_TYPE_R1
, NULL
, 0, 0);
582 if (retval
!= STATUS_SUCCESS
)
583 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
587 retval
= rts51x_sd_select_card(chip
, 0);
588 if (retval
!= STATUS_SUCCESS
)
589 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
594 ext_sd_send_cmd_get_rsp(chip
, APP_CMD
, sd_card
->sd_addr
,
595 SD_RSP_TYPE_R1
, NULL
, 0, 0);
596 if (retval
!= STATUS_SUCCESS
)
597 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
600 retval
= ext_sd_send_cmd_get_rsp(chip
, cmd_idx
, arg
, rsp_type
,
601 sd_card
->rsp
, rsp_len
, 0);
602 if (retval
!= STATUS_SUCCESS
)
603 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
605 if (data_len
<= 512) {
607 unsigned int offset
= 0;
610 buf
= kmalloc(data_len
, GFP_KERNEL
);
612 TRACE_RET(chip
, TRANSPORT_ERROR
);
615 rts51x_access_sglist(buf
, data_len
, (void *)data_buf
,
616 &sg
, &offset
, FROM_XFER_BUF
);
618 memcpy(buf
, data_buf
, data_len
);
621 if (data_len
> 256) {
622 rts51x_init_cmd(chip
);
623 for (i
= 0; i
< 256; i
++) {
624 rts51x_add_cmd(chip
, WRITE_REG_CMD
,
625 (u16
) (PPBUF_BASE2
+ i
), 0xFF,
628 retval
= rts51x_send_cmd(chip
, MODE_C
, 250);
629 if (retval
!= STATUS_SUCCESS
) {
631 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
634 rts51x_init_cmd(chip
);
635 for (i
= 256; i
< data_len
; i
++) {
636 rts51x_add_cmd(chip
, WRITE_REG_CMD
,
637 (u16
) (PPBUF_BASE2
+ i
), 0xFF,
640 retval
= rts51x_send_cmd(chip
, MODE_C
, 250);
641 if (retval
!= STATUS_SUCCESS
) {
643 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
646 rts51x_init_cmd(chip
);
647 for (i
= 0; i
< data_len
; i
++) {
648 rts51x_add_cmd(chip
, WRITE_REG_CMD
,
649 (u16
) (PPBUF_BASE2
+ i
), 0xFF,
652 retval
= rts51x_send_cmd(chip
, MODE_C
, 250);
653 if (retval
!= STATUS_SUCCESS
) {
655 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
661 rts51x_init_cmd(chip
);
663 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_BYTE_CNT_H
, 0xFF,
664 (u8
) ((data_len
>> 8) & 0x03));
665 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_BYTE_CNT_L
, 0xFF,
667 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_BLOCK_CNT_H
, 0xFF, 0x00);
668 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_BLOCK_CNT_L
, 0xFF, 0x01);
669 rts51x_add_cmd(chip
, WRITE_REG_CMD
, CARD_DATA_SOURCE
, 0x01,
672 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_TRANSFER
, 0xFF,
673 SD_TM_AUTO_WRITE_3
| SD_TRANSFER_START
);
674 rts51x_add_cmd(chip
, CHECK_REG_CMD
, SD_TRANSFER
,
675 SD_TRANSFER_END
, SD_TRANSFER_END
);
677 retval
= rts51x_send_cmd(chip
, MODE_CR
, 100);
678 if (retval
!= STATUS_SUCCESS
)
679 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
681 retval
= rts51x_get_rsp(chip
, 1, 250);
682 if (CHECK_SD_TRANS_FAIL(chip
, retval
))
683 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
684 } else if (!(data_len
& 0x1FF)) {
685 rts51x_init_cmd(chip
);
687 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_BYTE_CNT_H
, 0xFF, 0x02);
688 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_BYTE_CNT_L
, 0xFF, 0x00);
689 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_BLOCK_CNT_H
,
690 0xFF, (u8
) (data_len
>> 17));
691 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_BLOCK_CNT_L
,
692 0xFF, (u8
) ((data_len
& 0x0001FE00) >> 9));
694 rts51x_trans_dma_enable(DMA_TO_DEVICE
, chip
, data_len
, DMA_512
);
696 rts51x_add_cmd(chip
, WRITE_REG_CMD
, SD_TRANSFER
, 0xFF,
697 SD_TM_AUTO_WRITE_3
| SD_TRANSFER_START
);
698 rts51x_add_cmd(chip
, CHECK_REG_CMD
, SD_TRANSFER
,
699 SD_TRANSFER_END
, SD_TRANSFER_END
);
701 retval
= rts51x_send_cmd(chip
, MODE_CDOR
, 100);
702 if (retval
!= STATUS_SUCCESS
)
703 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
706 rts51x_transfer_data_rcc(chip
, SND_BULK_PIPE(chip
),
707 data_buf
, buf_len
, use_sg
, NULL
,
709 if (retval
!= STATUS_SUCCESS
)
710 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
712 retval
= rts51x_get_rsp(chip
, 1, 10000);
713 if (CHECK_SD_TRANS_FAIL(chip
, retval
))
714 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
717 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
722 rts51x_write_register(chip
, CARD_STOP
, SD_STOP
| SD_CLR_ERR
,
723 SD_STOP
| SD_CLR_ERR
);
724 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
728 retval
= rts51x_sd_select_card(chip
, 1);
729 if (retval
!= STATUS_SUCCESS
)
730 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
734 retval
= ext_sd_send_cmd_get_rsp(chip
, STOP_TRANSMISSION
,
735 0, SD_RSP_TYPE_R1b
, NULL
, 0,
737 if (retval
!= STATUS_SUCCESS
)
738 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
741 if (data_len
< 512) {
742 retval
= ext_sd_send_cmd_get_rsp(chip
, SET_BLOCKLEN
, 0x200,
743 SD_RSP_TYPE_R1
, NULL
, 0, 0);
744 if (retval
!= STATUS_SUCCESS
)
745 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
747 rts51x_write_register(chip
, SD_BYTE_CNT_H
, 0xFF, 0x02);
748 rts51x_write_register(chip
, SD_BYTE_CNT_L
, 0xFF, 0x00);
751 if (cmd12
|| standby
) {
752 /* There is CMD7 or CMD12 sent before CMD13 */
756 for (i
= 0; i
< 3; i
++) {
758 ext_sd_send_cmd_get_rsp(chip
, SEND_STATUS
, sd_card
->sd_addr
,
759 SD_RSP_TYPE_R1
, NULL
, 0,
761 if (retval
== STATUS_SUCCESS
)
764 if (retval
!= STATUS_SUCCESS
)
765 TRACE_GOTO(chip
, SD_Execute_Write_Cmd_Failed
);
767 return TRANSPORT_GOOD
;
769 SD_Execute_Write_Cmd_Failed
:
770 sd_card
->pre_cmd_err
= 1;
771 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_NO_SENSE
);
773 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_WRITE_ERR
);
774 rts51x_release_sd_card(chip
);
775 rts51x_do_rts51x_reset_sd_card(chip
);
776 if (!(chip
->card_ready
& SD_CARD
))
777 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_NOT_PRESENT
);
779 TRACE_RET(chip
, TRANSPORT_FAILED
);
782 int rts51x_sd_pass_thru_mode(struct scsi_cmnd
*srb
, struct rts51x_chip
*chip
)
784 struct sd_info
*sd_card
= &(chip
->sd_card
);
785 unsigned int lun
= SCSI_LUN(srb
);
792 0x00, /* Version Number */
793 0x00, /* WP | Media Type */
794 0x00, /* RCA (Low byte) */
795 0x00, /* RCA (High byte) */
803 0x00, /* Max LUN Number */
808 sd_card
->pre_cmd_err
= 0;
810 if (!(CHK_BIT(chip
->lun_mc
, lun
))) {
811 SET_BIT(chip
->lun_mc
, lun
);
812 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_CHANGE
);
813 TRACE_RET(chip
, TRANSPORT_FAILED
);
816 if ((0x53 != srb
->cmnd
[2]) || (0x44 != srb
->cmnd
[3])
817 || (0x20 != srb
->cmnd
[4]) || (0x43 != srb
->cmnd
[5])
818 || (0x61 != srb
->cmnd
[6]) || (0x72 != srb
->cmnd
[7])
819 || (0x64 != srb
->cmnd
[8])) {
820 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
821 TRACE_RET(chip
, TRANSPORT_FAILED
);
824 switch (srb
->cmnd
[1] & 0x0F) {
826 sd_card
->sd_pass_thru_en
= 0;
830 sd_card
->sd_pass_thru_en
= 1;
834 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
835 TRACE_RET(chip
, TRANSPORT_FAILED
);
838 /* 0x01:SD Memory Card; 0x02:Other Media; 0x03:Illegal Media; */
839 buf
[5] = (1 == CHK_SD(sd_card
)) ? 0x01 : 0x02;
840 if (chip
->card_wp
& SD_CARD
)
843 buf
[6] = (u8
) (sd_card
->sd_addr
>> 16);
844 buf
[7] = (u8
) (sd_card
->sd_addr
>> 24);
846 buf
[15] = chip
->max_lun
;
848 len
= min_t(unsigned, 18, scsi_bufflen(srb
));
849 rts51x_set_xfer_buf(buf
, len
, srb
);
851 return TRANSPORT_GOOD
;
854 int rts51x_sd_execute_no_data(struct scsi_cmnd
*srb
, struct rts51x_chip
*chip
)
856 struct sd_info
*sd_card
= &(chip
->sd_card
);
857 unsigned int lun
= SCSI_LUN(srb
);
859 u8 cmd_idx
, rsp_code
;
860 u8 standby
= 0, acmd
= 0;
863 if (!sd_card
->sd_pass_thru_en
) {
864 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
865 TRACE_RET(chip
, TRANSPORT_FAILED
);
868 cmd_idx
= srb
->cmnd
[2] & 0x3F;
869 if (srb
->cmnd
[1] & 0x02)
871 if (srb
->cmnd
[1] & 0x01)
874 arg
= ((u32
) srb
->cmnd
[3] << 24) | ((u32
) srb
->cmnd
[4] << 16) |
875 ((u32
) srb
->cmnd
[5] << 8) | srb
->cmnd
[6];
877 rsp_code
= srb
->cmnd
[10];
880 ext_rts51x_sd_execute_no_data(chip
, lun
, cmd_idx
, standby
, acmd
, rsp_code
,
882 scsi_set_resid(srb
, 0);
886 int rts51x_sd_execute_read_data(struct scsi_cmnd
*srb
, struct rts51x_chip
*chip
)
888 struct sd_info
*sd_card
= &(chip
->sd_card
);
890 unsigned int lun
= SCSI_LUN(srb
);
891 u8 cmd_idx
, rsp_code
, send_cmd12
= 0, standby
= 0, acmd
= 0;
894 if (!sd_card
->sd_pass_thru_en
) {
895 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
896 TRACE_RET(chip
, TRANSPORT_FAILED
);
899 cmd_idx
= srb
->cmnd
[2] & 0x3F;
900 if (srb
->cmnd
[1] & 0x04)
902 if (srb
->cmnd
[1] & 0x02)
904 if (srb
->cmnd
[1] & 0x01)
907 arg
= ((u32
) srb
->cmnd
[3] << 24) | ((u32
) srb
->cmnd
[4] << 16) |
908 ((u32
) srb
->cmnd
[5] << 8) | srb
->cmnd
[6];
911 ((u32
) srb
->cmnd
[7] << 16) | ((u32
) srb
->cmnd
[8] << 8) |
913 rsp_code
= srb
->cmnd
[10];
916 ext_rts51x_sd_execute_read_data(chip
, lun
, cmd_idx
, send_cmd12
, standby
,
917 acmd
, rsp_code
, arg
, data_len
,
918 scsi_sglist(srb
), scsi_bufflen(srb
),
920 scsi_set_resid(srb
, 0);
924 int rts51x_sd_execute_write_data(struct scsi_cmnd
*srb
, struct rts51x_chip
*chip
)
926 struct sd_info
*sd_card
= &(chip
->sd_card
);
928 unsigned int lun
= SCSI_LUN(srb
);
929 u8 cmd_idx
, rsp_code
, send_cmd12
= 0, standby
= 0, acmd
= 0;
932 if (!sd_card
->sd_pass_thru_en
) {
933 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
934 TRACE_RET(chip
, TRANSPORT_FAILED
);
937 cmd_idx
= srb
->cmnd
[2] & 0x3F;
938 if (srb
->cmnd
[1] & 0x04)
940 if (srb
->cmnd
[1] & 0x02)
942 if (srb
->cmnd
[1] & 0x01)
946 ((u32
) srb
->cmnd
[7] << 16) | ((u32
) srb
->cmnd
[8] << 8) |
949 ((u32
) srb
->cmnd
[3] << 24) | ((u32
) srb
->cmnd
[4] << 16) |
950 ((u32
) srb
->cmnd
[5] << 8) | srb
->cmnd
[6];
951 rsp_code
= srb
->cmnd
[10];
954 ext_rts51x_sd_execute_write_data(chip
, lun
, cmd_idx
, send_cmd12
, standby
,
955 acmd
, rsp_code
, arg
, data_len
,
956 scsi_sglist(srb
), scsi_bufflen(srb
),
958 scsi_set_resid(srb
, 0);
962 int rts51x_sd_get_cmd_rsp(struct scsi_cmnd
*srb
, struct rts51x_chip
*chip
)
964 struct sd_info
*sd_card
= &(chip
->sd_card
);
965 unsigned int lun
= SCSI_LUN(srb
);
969 if (!sd_card
->sd_pass_thru_en
) {
970 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
971 TRACE_RET(chip
, TRANSPORT_FAILED
);
974 if (sd_card
->pre_cmd_err
) {
975 sd_card
->pre_cmd_err
= 0;
976 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_CHANGE
);
977 TRACE_RET(chip
, TRANSPORT_FAILED
);
980 data_len
= ((u16
) srb
->cmnd
[7] << 8) | srb
->cmnd
[8];
982 if (sd_card
->last_rsp_type
== SD_RSP_TYPE_R0
) {
983 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
984 TRACE_RET(chip
, TRANSPORT_FAILED
);
985 } else if (sd_card
->last_rsp_type
== SD_RSP_TYPE_R2
) {
986 count
= (data_len
< 17) ? data_len
: 17;
988 count
= (data_len
< 6) ? data_len
: 6;
990 rts51x_set_xfer_buf(sd_card
->rsp
, count
, srb
);
992 RTS51X_DEBUGP("Response length: %d\n", data_len
);
993 RTS51X_DEBUGP("Response: 0x%x 0x%x 0x%x 0x%x\n",
994 sd_card
->rsp
[0], sd_card
->rsp
[1], sd_card
->rsp
[2],
997 scsi_set_resid(srb
, 0);
998 return TRANSPORT_GOOD
;
1001 int rts51x_sd_hw_rst(struct scsi_cmnd
*srb
, struct rts51x_chip
*chip
)
1003 struct sd_info
*sd_card
= &(chip
->sd_card
);
1004 unsigned int lun
= SCSI_LUN(srb
);
1007 if (!sd_card
->sd_pass_thru_en
) {
1008 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
1009 TRACE_RET(chip
, TRANSPORT_FAILED
);
1012 if (sd_card
->pre_cmd_err
) {
1013 sd_card
->pre_cmd_err
= 0;
1014 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_CHANGE
);
1015 TRACE_RET(chip
, TRANSPORT_FAILED
);
1018 if ((0x53 != srb
->cmnd
[2]) || (0x44 != srb
->cmnd
[3])
1019 || (0x20 != srb
->cmnd
[4]) || (0x43 != srb
->cmnd
[5])
1020 || (0x61 != srb
->cmnd
[6]) || (0x72 != srb
->cmnd
[7])
1021 || (0x64 != srb
->cmnd
[8])) {
1022 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
1023 TRACE_RET(chip
, TRANSPORT_FAILED
);
1026 switch (srb
->cmnd
[1] & 0x0F) {
1028 /* SD Card Power Off -> ON and Initialization */
1029 retval
= rts51x_reset_sd_card(chip
);
1030 if (retval
!= STATUS_SUCCESS
) {
1031 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_NOT_PRESENT
);
1032 sd_card
->pre_cmd_err
= 1;
1033 TRACE_RET(chip
, TRANSPORT_FAILED
);
1038 /* reset CMD(CMD0) and Initialization
1039 * (without SD Card Power Off -> ON) */
1040 retval
= reset_sd(chip
);
1041 if (retval
!= STATUS_SUCCESS
) {
1042 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_NOT_PRESENT
);
1043 sd_card
->pre_cmd_err
= 1;
1044 TRACE_RET(chip
, TRANSPORT_FAILED
);
1049 rts51x_set_sense_type(chip
, lun
, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD
);
1050 TRACE_RET(chip
, TRANSPORT_FAILED
);
1053 scsi_set_resid(srb
, 0);
1054 return TRANSPORT_GOOD
;