?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'gpio-v3.13-3' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw...
[linux-2.6.git] / drivers / staging / rts5139 / sd_cprm.c
blobd4689839e15ab95a441c81b7f95b0b58bf8e0987
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
31 #include "debug.h"
32 #include "trace.h"
33 #include "rts51x.h"
34 #include "rts51x_transport.h"
35 #include "rts51x_scsi.h"
36 #include "rts51x_card.h"
37 #include "rts51x_chip.h"
38 #include "sd.h"
39
40 #ifdef SUPPORT_CPRM
41
42 static inline int get_rsp_type(u8 rsp_code, u8 *rsp_type, int *rsp_len)
43 {
44 if (!rsp_type || !rsp_len)
45 return STATUS_FAIL;
46
47 switch (rsp_code) {
48 case 0x03:
49 *rsp_type = SD_RSP_TYPE_R0; /* no response */
50 *rsp_len = 0;
51 break;
52
53 case 0x04:
54 *rsp_type = SD_RSP_TYPE_R1; /* R1,R6(,R4,R5) */
55 *rsp_len = 6;
56 break;
57
58 case 0x05:
59 *rsp_type = SD_RSP_TYPE_R1b; /* R1b */
60 *rsp_len = 6;
61 break;
62
63 case 0x06:
64 *rsp_type = SD_RSP_TYPE_R2; /* R2 */
65 *rsp_len = 17;
66 break;
67
68 case 0x07:
69 *rsp_type = SD_RSP_TYPE_R3; /* R3 */
70 *rsp_len = 6;
71 break;
72
73 default:
74 return STATUS_FAIL;
75 }
76
77 return STATUS_SUCCESS;
78 }
79
80 static int ext_sd_send_cmd_get_rsp(struct rts51x_chip *chip, u8 cmd_idx,
81 u32 arg, u8 rsp_type, u8 *rsp, int rsp_len,
82 int special_check)
83 {
84 int retval;
85 int timeout = 50;
86 u16 reg_addr;
87 u8 buf[17], stat;
88 int len = 2;
89 int rty_cnt = 0;
90
91 RTS51X_DEBUGP("EXT SD/MMC CMD %d\n", cmd_idx);
92
93 if (rsp_type == SD_RSP_TYPE_R1b)
94 timeout = 3000;
95
96 RTY_SEND_CMD:
97
98 rts51x_init_cmd(chip);
99
100 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD0, 0xFF, 0x40 | cmd_idx);
101 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD1, 0xFF, (u8) (arg >> 24));
102 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD2, 0xFF, (u8) (arg >> 16));
103 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD3, 0xFF, (u8) (arg >> 8));
104 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD4, 0xFF, (u8) arg);
105
106 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CFG2, 0xFF, rsp_type);
107 rts51x_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE,
108 0x01, PINGPONG_BUFFER);
109 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_TRANSFER,
110 0xFF, SD_TM_CMD_RSP | SD_TRANSFER_START);
111 rts51x_add_cmd(chip, CHECK_REG_CMD, SD_TRANSFER, SD_TRANSFER_END,
112 SD_TRANSFER_END);
113
114 rts51x_add_cmd(chip, READ_REG_CMD, SD_STAT1, 0, 0);
115
116 if (CHECK_USB(chip, USB_20)) {
117 if (rsp_type == SD_RSP_TYPE_R2) {
118 for (reg_addr = PPBUF_BASE2;
119 reg_addr < PPBUF_BASE2 + 16; reg_addr++) {
120 rts51x_add_cmd(chip, READ_REG_CMD, reg_addr, 0,
121 0);
122 }
123 len = 19;
124 } else if (rsp_type != SD_RSP_TYPE_R0) {
125 /* Read data from SD_CMDx registers */
126 for (reg_addr = SD_CMD0; reg_addr <= SD_CMD4;
127 reg_addr++) {
128 rts51x_add_cmd(chip, READ_REG_CMD, reg_addr, 0,
129 0);
130 }
131 len = 8;
132 } else {
133 len = 3;
134 }
135 rts51x_add_cmd(chip, READ_REG_CMD, SD_CMD5, 0, 0);
136 } else {
137 len = 2;
138 }
139
140 retval = rts51x_send_cmd(chip, MODE_CR, 100);
141 if (retval != STATUS_SUCCESS)
142 TRACE_RET(chip, retval);
143
144 retval = rts51x_get_rsp(chip, len, timeout);
145
146 if (CHECK_SD_TRANS_FAIL(chip, retval)) {
147 rts51x_clear_sd_error(chip);
148
149 if (retval == STATUS_TIMEDOUT) {
150 if (rsp_type & SD_WAIT_BUSY_END) {
151 retval = sd_check_data0_status(chip);
152 if (retval != STATUS_SUCCESS)
153 TRACE_RET(chip, retval);
154 }
155 }
156 TRACE_RET(chip, STATUS_FAIL);
157 }
158
159 if (rsp_type == SD_RSP_TYPE_R0)
160 return STATUS_SUCCESS;
161
162 if (CHECK_USB(chip, USB_20)) {
163 rts51x_read_rsp_buf(chip, 2, buf, len - 2);
164 } else {
165 if (rsp_type == SD_RSP_TYPE_R2) {
166 reg_addr = PPBUF_BASE2;
167 len = 16;
168 } else {
169 reg_addr = SD_CMD0;
170 len = 5;
171 }
172 retval =
173 rts51x_seq_read_register(chip, reg_addr,
174 (unsigned short)len, buf);
175 if (retval != STATUS_SUCCESS)
176 TRACE_RET(chip, retval);
177 RTS51X_READ_REG(chip, SD_CMD5, buf + len);
178 }
179 stat = chip->rsp_buf[1];
180
181 if ((buf[0] & 0xC0) != 0)
182 TRACE_RET(chip, STATUS_FAIL);
183
184 if (!(rsp_type & SD_NO_CHECK_CRC7)) {
185 if (stat & SD_CRC7_ERR) {
186 if (cmd_idx == WRITE_MULTIPLE_BLOCK)
187 TRACE_RET(chip, STATUS_FAIL);
188 if (rty_cnt < SD_MAX_RETRY_COUNT) {
189 wait_timeout(20);
190 rty_cnt++;
191 goto RTY_SEND_CMD;
192 } else {
193 TRACE_RET(chip, STATUS_FAIL);
194 }
195 }
196 }
197
198 if ((cmd_idx == SELECT_CARD) || (cmd_idx == APP_CMD) ||
199 (cmd_idx == SEND_STATUS) || (cmd_idx == STOP_TRANSMISSION)) {
200 if ((cmd_idx != STOP_TRANSMISSION) && (special_check == 0)) {
201 if (buf[1] & 0x80)
202 TRACE_RET(chip, STATUS_FAIL);
203 }
204 if (buf[1] & 0x7F)
205 TRACE_RET(chip, STATUS_FAIL);
206 if (buf[2] & 0xF8)
207 TRACE_RET(chip, STATUS_FAIL);
208
209 if (cmd_idx == SELECT_CARD) {
210 if (rsp_type == SD_RSP_TYPE_R2) {
211 if ((buf[3] & 0x1E) != 0x04)
212 TRACE_RET(chip, STATUS_FAIL);
213 } else if (rsp_type == SD_RSP_TYPE_R2) {
214 if ((buf[3] & 0x1E) != 0x03)
215 TRACE_RET(chip, STATUS_FAIL);
216 }
217 }
218 }
219
220 if (rsp && rsp_len)
221 memcpy(rsp, buf, rsp_len);
222
223 return STATUS_SUCCESS;
224 }
225
226 static int ext_sd_get_rsp(struct rts51x_chip *chip, int len,
227 u8 *rsp, u8 rsp_type)
228 {
229 int retval, rsp_len;
230 u16 reg_addr;
231
232 if (rsp_type == SD_RSP_TYPE_R0)
233 return STATUS_SUCCESS;
234
235 rts51x_init_cmd(chip);
236
237 if (rsp_type == SD_RSP_TYPE_R2) {
238 for (reg_addr = PPBUF_BASE2; reg_addr < PPBUF_BASE2 + 16;
239 reg_addr++) {
240 rts51x_add_cmd(chip, READ_REG_CMD, reg_addr, 0xFF, 0);
241 }
242 rsp_len = 17;
243 } else if (rsp_type != SD_RSP_TYPE_R0) {
244 for (reg_addr = SD_CMD0; reg_addr <= SD_CMD4; reg_addr++)
245 rts51x_add_cmd(chip, READ_REG_CMD, reg_addr, 0xFF, 0);
246 rsp_len = 6;
247 }
248 rts51x_add_cmd(chip, READ_REG_CMD, SD_CMD5, 0xFF, 0);
249
250 retval = rts51x_send_cmd(chip, MODE_CR, 100);
251 if (retval != STATUS_SUCCESS)
252 TRACE_RET(chip, retval);
253
254 retval = rts51x_get_rsp(chip, rsp_len, 100);
255
256 if (retval != STATUS_SUCCESS)
257 TRACE_RET(chip, retval);
258
259 if (rsp) {
260 int min_len = (rsp_len < len) ? rsp_len : len;
261
262 memcpy(rsp, rts51x_get_rsp_data(chip), min_len);
263
264 RTS51X_DEBUGP("min_len = %d\n", min_len);
265 RTS51X_DEBUGP("Response in cmd buf: 0x%x 0x%x 0x%x 0x%x\n",
266 rsp[0], rsp[1], rsp[2], rsp[3]);
267 }
268
269 return STATUS_SUCCESS;
270 }
271
272 int ext_rts51x_sd_execute_no_data(struct rts51x_chip *chip, unsigned int lun,
273 u8 cmd_idx, u8 standby, u8 acmd, u8 rsp_code,
274 u32 arg)
275 {
276 struct sd_info *sd_card = &(chip->sd_card);
277 int retval, rsp_len;
278 u8 rsp_type;
279
280 retval = rts51x_sd_switch_clock(chip);
281 if (retval != STATUS_SUCCESS)
282 TRACE_RET(chip, TRANSPORT_FAILED);
283
284 if (sd_card->pre_cmd_err) {
285 sd_card->pre_cmd_err = 0;
286 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
287 TRACE_RET(chip, TRANSPORT_FAILED);
288 }
289 retval = get_rsp_type(rsp_code, &rsp_type, &rsp_len);
290 if (retval != STATUS_SUCCESS) {
291 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
292 TRACE_RET(chip, TRANSPORT_FAILED);
293 }
294 sd_card->last_rsp_type = rsp_type;
295
296 retval = rts51x_sd_switch_clock(chip);
297 if (retval != STATUS_SUCCESS)
298 TRACE_RET(chip, TRANSPORT_FAILED);
299 /* Set H/W SD/MMC Bus Width */
300 rts51x_write_register(chip, SD_CFG1, 0x03, SD_BUS_WIDTH_4);
301
302 if (standby) {
303 retval = rts51x_sd_select_card(chip, 0);
304 if (retval != STATUS_SUCCESS)
305 TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
306 }
307
308 if (acmd) {
309 retval =
310 ext_sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
311 SD_RSP_TYPE_R1, NULL, 0, 0);
312 if (retval != STATUS_SUCCESS)
313 TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
314 }
315
316 retval = ext_sd_send_cmd_get_rsp(chip, cmd_idx, arg, rsp_type,
317 sd_card->rsp, rsp_len, 0);
318 if (retval != STATUS_SUCCESS)
319 TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
320
321 if (standby) {
322 retval = rts51x_sd_select_card(chip, 1);
323 if (retval != STATUS_SUCCESS)
324 TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
325 }
326
327 return TRANSPORT_GOOD;
328
329 SD_Execute_Cmd_Failed:
330 sd_card->pre_cmd_err = 1;
331 rts51x_set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
332 rts51x_release_sd_card(chip);
333 rts51x_do_rts51x_reset_sd_card(chip);
334 if (!(chip->card_ready & SD_CARD))
335 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
336
337 TRACE_RET(chip, TRANSPORT_FAILED);
338 }
339
340 int ext_rts51x_sd_execute_read_data(struct rts51x_chip *chip, unsigned int lun,
341 u8 cmd_idx, u8 cmd12, u8 standby,
342 u8 acmd, u8 rsp_code, u32 arg, u32 data_len,
343 void *data_buf, unsigned int buf_len, int use_sg)
344 {
345 struct sd_info *sd_card = &(chip->sd_card);
346 int retval, rsp_len, i;
347 int cmd13_checkbit = 0, read_err = 0;
348 u8 rsp_type, bus_width;
349
350 if (sd_card->pre_cmd_err) {
351 sd_card->pre_cmd_err = 0;
352 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
353 TRACE_RET(chip, TRANSPORT_FAILED);
354 }
355
356 retval = rts51x_sd_switch_clock(chip);
357 if (retval != STATUS_SUCCESS)
358 TRACE_RET(chip, STATUS_FAIL);
359 retval = get_rsp_type(rsp_code, &rsp_type, &rsp_len);
360 if (retval != STATUS_SUCCESS) {
361 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
362 TRACE_RET(chip, TRANSPORT_FAILED);
363 }
364 sd_card->last_rsp_type = rsp_type;
365
366 retval = rts51x_sd_switch_clock(chip);
367 if (retval != STATUS_SUCCESS)
368 TRACE_RET(chip, TRANSPORT_FAILED);
369 bus_width = SD_BUS_WIDTH_4;
370
371 if (data_len < 512) {
372 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len,
373 SD_RSP_TYPE_R1, NULL, 0, 0);
374 if (retval != STATUS_SUCCESS)
375 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
376 }
377
378 if (standby) {
379 retval = rts51x_sd_select_card(chip, 0);
380 if (retval != STATUS_SUCCESS)
381 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
382 }
383
384 if (acmd) {
385 retval =
386 ext_sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
387 SD_RSP_TYPE_R1, NULL, 0, 0);
388 if (retval != STATUS_SUCCESS)
389 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
390 }
391
392 if (data_len <= 512) {
393 int min_len;
394 u8 *buf;
395 u16 byte_cnt, blk_cnt;
396 u8 cmd[5];
397 unsigned int offset = 0;
398 void *sg = NULL;
399
400 byte_cnt = (u16) (data_len & 0x3FF);
401 blk_cnt = 1;
402
403 cmd[0] = 0x40 | cmd_idx;
404 cmd[1] = (u8) (arg >> 24);
405 cmd[2] = (u8) (arg >> 16);
406 cmd[3] = (u8) (arg >> 8);
407 cmd[4] = (u8) arg;
408
409 buf = kmalloc(data_len, GFP_KERNEL);
410 if (buf == NULL)
411 TRACE_RET(chip, TRANSPORT_ERROR);
412
413 retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd, 5, byte_cnt,
414 blk_cnt, bus_width, buf, data_len, 2000);
415 if (retval != STATUS_SUCCESS) {
416 read_err = 1;
417 kfree(buf);
418 rts51x_write_register(chip, CARD_STOP,
419 SD_STOP | SD_CLR_ERR,
420 SD_STOP | SD_CLR_ERR);
421 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
422 }
423
424 min_len = min(data_len, buf_len);
425 if (use_sg)
426 rts51x_access_sglist(buf, min_len, (void *)data_buf,
427 &sg, &offset, TO_XFER_BUF);
428 else
429 memcpy(data_buf, buf, min_len);
430
431 kfree(buf);
432 } else if (!(data_len & 0x1FF)) {
433 rts51x_init_cmd(chip);
434 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BYTE_CNT_H, 0xFF, 0x02);
435 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BYTE_CNT_L, 0xFF, 0x00);
436 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_H,
437 0xFF, (u8) (data_len >> 17));
438 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_L,
439 0xFF, (u8) ((data_len & 0x0001FE00) >> 9));
440 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD0, 0xFF,
441 0x40 | cmd_idx);
442 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD1, 0xFF,
443 (u8) (arg >> 24));
444 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD2, 0xFF,
445 (u8) (arg >> 16));
446 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD3, 0xFF,
447 (u8) (arg >> 8));
448 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD4, 0xFF, (u8) arg);
449 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CFG1, 0x03, bus_width);
450 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CFG2, 0xFF, rsp_type);
451 rts51x_trans_dma_enable(DMA_FROM_DEVICE, chip, data_len, DMA_512);
452 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_TRANSFER, 0xFF,
453 SD_TM_AUTO_READ_2 | SD_TRANSFER_START);
454 rts51x_add_cmd(chip, CHECK_REG_CMD, SD_TRANSFER,
455 SD_TRANSFER_END, SD_TRANSFER_END);
456 retval = rts51x_send_cmd(chip, MODE_CDIR, 100);
457 if (retval != STATUS_SUCCESS) {
458 read_err = 1;
459 rts51x_ep0_write_register(chip, CARD_STOP,
460 SD_STOP | SD_CLR_ERR,
461 SD_STOP | SD_CLR_ERR);
462 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
463 }
464
465 retval =
466 rts51x_transfer_data_rcc(chip, RCV_BULK_PIPE(chip),
467 data_buf, buf_len, use_sg, NULL,
468 10000, STAGE_DI);
469 if (retval != STATUS_SUCCESS) {
470 read_err = 1;
471 rts51x_ep0_write_register(chip, CARD_STOP,
472 SD_STOP | SD_CLR_ERR,
473 SD_STOP | SD_CLR_ERR);
474 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
475 }
476 retval = rts51x_get_rsp(chip, 1, 500);
477 if (CHECK_SD_TRANS_FAIL(chip, retval)) {
478 read_err = 1;
479 rts51x_ep0_write_register(chip, CARD_STOP,
480 SD_STOP | SD_CLR_ERR,
481 SD_STOP | SD_CLR_ERR);
482 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
483 }
484 } else {
485 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
486 }
487
488 retval = ext_sd_get_rsp(chip, rsp_len, sd_card->rsp, rsp_type);
489 if (retval != STATUS_SUCCESS)
490 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
491
492 if (standby) {
493 retval = rts51x_sd_select_card(chip, 1);
494 if (retval != STATUS_SUCCESS)
495 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
496 }
497
498 if (cmd12) {
499 retval = ext_sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION,
500 0, SD_RSP_TYPE_R1b, NULL, 0,
501 0);
502 if (retval != STATUS_SUCCESS)
503 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
504 }
505
506 if (data_len < 512) {
507 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200,
508 SD_RSP_TYPE_R1, NULL, 0, 0);
509 if (retval != STATUS_SUCCESS)
510 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
511
512 rts51x_write_register(chip, SD_BYTE_CNT_H, 0xFF, 0x02);
513 rts51x_write_register(chip, SD_BYTE_CNT_L, 0xFF, 0x00);
514 }
515
516 if (standby || cmd12)
517 cmd13_checkbit = 1;
518
519 for (i = 0; i < 3; i++) {
520 retval =
521 ext_sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
522 SD_RSP_TYPE_R1, NULL, 0,
523 cmd13_checkbit);
524 if (retval == STATUS_SUCCESS)
525 break;
526 }
527 if (retval != STATUS_SUCCESS)
528 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
529
530 return TRANSPORT_GOOD;
531
532 SD_Execute_Read_Cmd_Failed:
533 sd_card->pre_cmd_err = 1;
534 rts51x_set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
535 if (read_err)
536 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
537 rts51x_release_sd_card(chip);
538 rts51x_do_rts51x_reset_sd_card(chip);
539 if (!(chip->card_ready & SD_CARD))
540 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
541
542 TRACE_RET(chip, TRANSPORT_FAILED);
543 }
544
545 int ext_rts51x_sd_execute_write_data(struct rts51x_chip *chip, unsigned int lun,
546 u8 cmd_idx, u8 cmd12, u8 standby, u8 acmd,
547 u8 rsp_code, u32 arg, u32 data_len,
548 void *data_buf, unsigned int buf_len, int use_sg)
549 {
550 struct sd_info *sd_card = &(chip->sd_card);
551 int retval, rsp_len;
552 int cmd13_checkbit = 0, write_err = 0;
553 u8 rsp_type;
554 u32 i;
555
556 if (sd_card->pre_cmd_err) {
557 sd_card->pre_cmd_err = 0;
558 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
559 TRACE_RET(chip, TRANSPORT_FAILED);
560 }
561
562 retval = rts51x_sd_switch_clock(chip);
563 if (retval != STATUS_SUCCESS)
564 TRACE_RET(chip, STATUS_FAIL);
565
566 retval = get_rsp_type(rsp_code, &rsp_type, &rsp_len);
567 if (retval != STATUS_SUCCESS) {
568 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
569 TRACE_RET(chip, TRANSPORT_FAILED);
570 }
571 sd_card->last_rsp_type = rsp_type;
572
573 retval = rts51x_sd_switch_clock(chip);
574 if (retval != STATUS_SUCCESS)
575 TRACE_RET(chip, TRANSPORT_FAILED);
576 rts51x_write_register(chip, SD_CFG1, 0x03, SD_BUS_WIDTH_4);
577
578 if (data_len < 512) {
579 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len,
580 SD_RSP_TYPE_R1, NULL, 0, 0);
581 if (retval != STATUS_SUCCESS)
582 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
583 }
584
585 if (standby) {
586 retval = rts51x_sd_select_card(chip, 0);
587 if (retval != STATUS_SUCCESS)
588 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
589 }
590
591 if (acmd) {
592 retval =
593 ext_sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
594 SD_RSP_TYPE_R1, NULL, 0, 0);
595 if (retval != STATUS_SUCCESS)
596 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
597 }
598
599 retval = ext_sd_send_cmd_get_rsp(chip, cmd_idx, arg, rsp_type,
600 sd_card->rsp, rsp_len, 0);
601 if (retval != STATUS_SUCCESS)
602 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
603
604 if (data_len <= 512) {
605 u8 *buf;
606 unsigned int offset = 0;
607 void *sg = NULL;
608
609 buf = kmalloc(data_len, GFP_KERNEL);
610 if (buf == NULL)
611 TRACE_RET(chip, TRANSPORT_ERROR);
612
613 if (use_sg)
614 rts51x_access_sglist(buf, data_len, (void *)data_buf,
615 &sg, &offset, FROM_XFER_BUF);
616 else
617 memcpy(buf, data_buf, data_len);
618
619
620 if (data_len > 256) {
621 rts51x_init_cmd(chip);
622 for (i = 0; i < 256; i++) {
623 rts51x_add_cmd(chip, WRITE_REG_CMD,
624 (u16) (PPBUF_BASE2 + i), 0xFF,
625 buf[i]);
626 }
627 retval = rts51x_send_cmd(chip, MODE_C, 250);
628 if (retval != STATUS_SUCCESS) {
629 kfree(buf);
630 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
631 }
632
633 rts51x_init_cmd(chip);
634 for (i = 256; i < data_len; i++) {
635 rts51x_add_cmd(chip, WRITE_REG_CMD,
636 (u16) (PPBUF_BASE2 + i), 0xFF,
637 buf[i]);
638 }
639 retval = rts51x_send_cmd(chip, MODE_C, 250);
640 if (retval != STATUS_SUCCESS) {
641 kfree(buf);
642 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
643 }
644 } else {
645 rts51x_init_cmd(chip);
646 for (i = 0; i < data_len; i++) {
647 rts51x_add_cmd(chip, WRITE_REG_CMD,
648 (u16) (PPBUF_BASE2 + i), 0xFF,
649 buf[i]);
650 }
651 retval = rts51x_send_cmd(chip, MODE_C, 250);
652 if (retval != STATUS_SUCCESS) {
653 kfree(buf);
654 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
655 }
656 }
657
658 kfree(buf);
659
660 rts51x_init_cmd(chip);
661
662 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BYTE_CNT_H, 0xFF,
663 (u8) ((data_len >> 8) & 0x03));
664 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BYTE_CNT_L, 0xFF,
665 (u8) data_len);
666 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_H, 0xFF, 0x00);
667 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_L, 0xFF, 0x01);
668 rts51x_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 0x01,
669 PINGPONG_BUFFER);
670
671 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_TRANSFER, 0xFF,
672 SD_TM_AUTO_WRITE_3 | SD_TRANSFER_START);
673 rts51x_add_cmd(chip, CHECK_REG_CMD, SD_TRANSFER,
674 SD_TRANSFER_END, SD_TRANSFER_END);
675
676 retval = rts51x_send_cmd(chip, MODE_CR, 100);
677 if (retval != STATUS_SUCCESS)
678 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
679
680 retval = rts51x_get_rsp(chip, 1, 250);
681 if (CHECK_SD_TRANS_FAIL(chip, retval))
682 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
683 } else if (!(data_len & 0x1FF)) {
684 rts51x_init_cmd(chip);
685
686 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BYTE_CNT_H, 0xFF, 0x02);
687 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BYTE_CNT_L, 0xFF, 0x00);
688 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_H,
689 0xFF, (u8) (data_len >> 17));
690 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_L,
691 0xFF, (u8) ((data_len & 0x0001FE00) >> 9));
692
693 rts51x_trans_dma_enable(DMA_TO_DEVICE, chip, data_len, DMA_512);
694
695 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_TRANSFER, 0xFF,
696 SD_TM_AUTO_WRITE_3 | SD_TRANSFER_START);
697 rts51x_add_cmd(chip, CHECK_REG_CMD, SD_TRANSFER,
698 SD_TRANSFER_END, SD_TRANSFER_END);
699
700 retval = rts51x_send_cmd(chip, MODE_CDOR, 100);
701 if (retval != STATUS_SUCCESS)
702 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
703
704 retval =
705 rts51x_transfer_data_rcc(chip, SND_BULK_PIPE(chip),
706 data_buf, buf_len, use_sg, NULL,
707 10000, STAGE_DO);
708 if (retval != STATUS_SUCCESS)
709 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
710
711 retval = rts51x_get_rsp(chip, 1, 10000);
712 if (CHECK_SD_TRANS_FAIL(chip, retval))
713 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
714
715 } else {
716 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
717 }
718
719 if (retval < 0) {
720 write_err = 1;
721 rts51x_write_register(chip, CARD_STOP, SD_STOP | SD_CLR_ERR,
722 SD_STOP | SD_CLR_ERR);
723 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
724 }
725
726 if (standby) {
727 retval = rts51x_sd_select_card(chip, 1);
728 if (retval != STATUS_SUCCESS)
729 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
730 }
731
732 if (cmd12) {
733 retval = ext_sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION,
734 0, SD_RSP_TYPE_R1b, NULL, 0,
735 0);
736 if (retval != STATUS_SUCCESS)
737 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
738 }
739
740 if (data_len < 512) {
741 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200,
742 SD_RSP_TYPE_R1, NULL, 0, 0);
743 if (retval != STATUS_SUCCESS)
744 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
745
746 rts51x_write_register(chip, SD_BYTE_CNT_H, 0xFF, 0x02);
747 rts51x_write_register(chip, SD_BYTE_CNT_L, 0xFF, 0x00);
748 }
749
750 if (cmd12 || standby) {
751 /* There is CMD7 or CMD12 sent before CMD13 */
752 cmd13_checkbit = 1;
753 }
754
755 for (i = 0; i < 3; i++) {
756 retval =
757 ext_sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
758 SD_RSP_TYPE_R1, NULL, 0,
759 cmd13_checkbit);
760 if (retval == STATUS_SUCCESS)
761 break;
762 }
763 if (retval != STATUS_SUCCESS)
764 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
765
766 return TRANSPORT_GOOD;
767
768 SD_Execute_Write_Cmd_Failed:
769 sd_card->pre_cmd_err = 1;
770 rts51x_set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
771 if (write_err)
772 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
773 rts51x_release_sd_card(chip);
774 rts51x_do_rts51x_reset_sd_card(chip);
775 if (!(chip->card_ready & SD_CARD))
776 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
777
778 TRACE_RET(chip, TRANSPORT_FAILED);
779 }
780
781 int rts51x_sd_pass_thru_mode(struct scsi_cmnd *srb, struct rts51x_chip *chip)
782 {
783 struct sd_info *sd_card = &(chip->sd_card);
784 unsigned int lun = SCSI_LUN(srb);
785 int len;
786 u8 buf[18] = {
787 0x00,
788 0x00,
789 0x00,
790 0x0E,
791 0x00, /* Version Number */
792 0x00, /* WP | Media Type */
793 0x00, /* RCA (Low byte) */
794 0x00, /* RCA (High byte) */
795 0x53, /* 'S' */
796 0x44, /* 'D' */
797 0x20, /* ' ' */
798 0x43, /* 'C' */
799 0x61, /* 'a' */
800 0x72, /* 'r' */
801 0x64, /* 'd' */
802 0x00, /* Max LUN Number */
803 0x00,
804 0x00,
805 };
806
807 sd_card->pre_cmd_err = 0;
808
809 if (!(CHK_BIT(chip->lun_mc, lun))) {
810 SET_BIT(chip->lun_mc, lun);
811 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
812 TRACE_RET(chip, TRANSPORT_FAILED);
813 }
814
815 if ((0x53 != srb->cmnd[2]) || (0x44 != srb->cmnd[3])
816 || (0x20 != srb->cmnd[4]) || (0x43 != srb->cmnd[5])
817 || (0x61 != srb->cmnd[6]) || (0x72 != srb->cmnd[7])
818 || (0x64 != srb->cmnd[8])) {
819 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
820 TRACE_RET(chip, TRANSPORT_FAILED);
821 }
822
823 switch (srb->cmnd[1] & 0x0F) {
824 case 0:
825 sd_card->sd_pass_thru_en = 0;
826 break;
827
828 case 1:
829 sd_card->sd_pass_thru_en = 1;
830 break;
831
832 default:
833 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
834 TRACE_RET(chip, TRANSPORT_FAILED);
835 }
836
837 /* 0x01:SD Memory Card; 0x02:Other Media; 0x03:Illegal Media; */
838 buf[5] = (1 == CHK_SD(sd_card)) ? 0x01 : 0x02;
839 if (chip->card_wp & SD_CARD)
840 buf[5] |= 0x80;
841
842 buf[6] = (u8) (sd_card->sd_addr >> 16);
843 buf[7] = (u8) (sd_card->sd_addr >> 24);
844
845 buf[15] = chip->max_lun;
846
847 len = min_t(unsigned, 18, scsi_bufflen(srb));
848 rts51x_set_xfer_buf(buf, len, srb);
849
850 return TRANSPORT_GOOD;
851 }
852
853 int rts51x_sd_execute_no_data(struct scsi_cmnd *srb, struct rts51x_chip *chip)
854 {
855 struct sd_info *sd_card = &(chip->sd_card);
856 unsigned int lun = SCSI_LUN(srb);
857 int retval;
858 u8 cmd_idx, rsp_code;
859 u8 standby = 0, acmd = 0;
860 u32 arg;
861
862 if (!sd_card->sd_pass_thru_en) {
863 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
864 TRACE_RET(chip, TRANSPORT_FAILED);
865 }
866
867 cmd_idx = srb->cmnd[2] & 0x3F;
868 if (srb->cmnd[1] & 0x02)
869 standby = 1;
870 if (srb->cmnd[1] & 0x01)
871 acmd = 1;
872
873 arg = ((u32) srb->cmnd[3] << 24) | ((u32) srb->cmnd[4] << 16) |
874 ((u32) srb->cmnd[5] << 8) | srb->cmnd[6];
875
876 rsp_code = srb->cmnd[10];
877
878 retval =
879 ext_rts51x_sd_execute_no_data(chip, lun, cmd_idx, standby, acmd, rsp_code,
880 arg);
881 scsi_set_resid(srb, 0);
882 return retval;
883 }
884
885 int rts51x_sd_execute_read_data(struct scsi_cmnd *srb, struct rts51x_chip *chip)
886 {
887 struct sd_info *sd_card = &(chip->sd_card);
888 int retval;
889 unsigned int lun = SCSI_LUN(srb);
890 u8 cmd_idx, rsp_code, send_cmd12 = 0, standby = 0, acmd = 0;
891 u32 arg, data_len;
892
893 if (!sd_card->sd_pass_thru_en) {
894 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
895 TRACE_RET(chip, TRANSPORT_FAILED);
896 }
897
898 cmd_idx = srb->cmnd[2] & 0x3F;
899 if (srb->cmnd[1] & 0x04)
900 send_cmd12 = 1;
901 if (srb->cmnd[1] & 0x02)
902 standby = 1;
903 if (srb->cmnd[1] & 0x01)
904 acmd = 1;
905
906 arg = ((u32) srb->cmnd[3] << 24) | ((u32) srb->cmnd[4] << 16) |
907 ((u32) srb->cmnd[5] << 8) | srb->cmnd[6];
908
909 data_len =
910 ((u32) srb->cmnd[7] << 16) | ((u32) srb->cmnd[8] << 8) |
911 srb->cmnd[9];
912 rsp_code = srb->cmnd[10];
913
914 retval =
915 ext_rts51x_sd_execute_read_data(chip, lun, cmd_idx, send_cmd12, standby,
916 acmd, rsp_code, arg, data_len,
917 scsi_sglist(srb), scsi_bufflen(srb),
918 scsi_sg_count(srb));
919 scsi_set_resid(srb, 0);
920 return retval;
921 }
922
923 int rts51x_sd_execute_write_data(struct scsi_cmnd *srb, struct rts51x_chip *chip)
924 {
925 struct sd_info *sd_card = &(chip->sd_card);
926 int retval;
927 unsigned int lun = SCSI_LUN(srb);
928 u8 cmd_idx, rsp_code, send_cmd12 = 0, standby = 0, acmd = 0;
929 u32 data_len, arg;
930
931 if (!sd_card->sd_pass_thru_en) {
932 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
933 TRACE_RET(chip, TRANSPORT_FAILED);
934 }
935
936 cmd_idx = srb->cmnd[2] & 0x3F;
937 if (srb->cmnd[1] & 0x04)
938 send_cmd12 = 1;
939 if (srb->cmnd[1] & 0x02)
940 standby = 1;
941 if (srb->cmnd[1] & 0x01)
942 acmd = 1;
943
944 data_len =
945 ((u32) srb->cmnd[7] << 16) | ((u32) srb->cmnd[8] << 8) |
946 srb->cmnd[9];
947 arg =
948 ((u32) srb->cmnd[3] << 24) | ((u32) srb->cmnd[4] << 16) |
949 ((u32) srb->cmnd[5] << 8) | srb->cmnd[6];
950 rsp_code = srb->cmnd[10];
951
952 retval =
953 ext_rts51x_sd_execute_write_data(chip, lun, cmd_idx, send_cmd12, standby,
954 acmd, rsp_code, arg, data_len,
955 scsi_sglist(srb), scsi_bufflen(srb),
956 scsi_sg_count(srb));
957 scsi_set_resid(srb, 0);
958 return retval;
959 }
960
961 int rts51x_sd_get_cmd_rsp(struct scsi_cmnd *srb, struct rts51x_chip *chip)
962 {
963 struct sd_info *sd_card = &(chip->sd_card);
964 unsigned int lun = SCSI_LUN(srb);
965 int count;
966 u16 data_len;
967
968 if (!sd_card->sd_pass_thru_en) {
969 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
970 TRACE_RET(chip, TRANSPORT_FAILED);
971 }
972
973 if (sd_card->pre_cmd_err) {
974 sd_card->pre_cmd_err = 0;
975 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
976 TRACE_RET(chip, TRANSPORT_FAILED);
977 }
978
979 data_len = ((u16) srb->cmnd[7] << 8) | srb->cmnd[8];
980
981 if (sd_card->last_rsp_type == SD_RSP_TYPE_R0) {
982 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
983 TRACE_RET(chip, TRANSPORT_FAILED);
984 } else if (sd_card->last_rsp_type == SD_RSP_TYPE_R2) {
985 count = (data_len < 17) ? data_len : 17;
986 } else {
987 count = (data_len < 6) ? data_len : 6;
988 }
989 rts51x_set_xfer_buf(sd_card->rsp, count, srb);
990
991 RTS51X_DEBUGP("Response length: %d\n", data_len);
992 RTS51X_DEBUGP("Response: 0x%x 0x%x 0x%x 0x%x\n",
993 sd_card->rsp[0], sd_card->rsp[1], sd_card->rsp[2],
994 sd_card->rsp[3]);
995
996 scsi_set_resid(srb, 0);
997 return TRANSPORT_GOOD;
998 }
999
1000 int rts51x_sd_hw_rst(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1001 {
1002 struct sd_info *sd_card = &(chip->sd_card);
1003 unsigned int lun = SCSI_LUN(srb);
1004 int retval;
1005
1006 if (!sd_card->sd_pass_thru_en) {
1007 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1008 TRACE_RET(chip, TRANSPORT_FAILED);
1009 }
1010
1011 if (sd_card->pre_cmd_err) {
1012 sd_card->pre_cmd_err = 0;
1013 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
1014 TRACE_RET(chip, TRANSPORT_FAILED);
1015 }
1016
1017 if ((0x53 != srb->cmnd[2]) || (0x44 != srb->cmnd[3])
1018 || (0x20 != srb->cmnd[4]) || (0x43 != srb->cmnd[5])
1019 || (0x61 != srb->cmnd[6]) || (0x72 != srb->cmnd[7])
1020 || (0x64 != srb->cmnd[8])) {
1021 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1022 TRACE_RET(chip, TRANSPORT_FAILED);
1023 }
1024
1025 switch (srb->cmnd[1] & 0x0F) {
1026 case 0:
1027 /* SD Card Power Off -> ON and Initialization */
1028 retval = rts51x_reset_sd_card(chip);
1029 if (retval != STATUS_SUCCESS) {
1030 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1031 sd_card->pre_cmd_err = 1;
1032 TRACE_RET(chip, TRANSPORT_FAILED);
1033 }
1034 break;
1035
1036 case 1:
1037 /* reset CMD(CMD0) and Initialization
1038 * (without SD Card Power Off -> ON) */
1039 retval = reset_sd(chip);
1040 if (retval != STATUS_SUCCESS) {
1041 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1042 sd_card->pre_cmd_err = 1;
1043 TRACE_RET(chip, TRANSPORT_FAILED);
1044 }
1045 break;
1046
1047 default:
1048 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1049 TRACE_RET(chip, TRANSPORT_FAILED);
1050 }
1051
1052 scsi_set_resid(srb, 0);
1053 return TRANSPORT_GOOD;
1054 }
1055 #endif
Linus' kernel tree