]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/staging/rts5139/sd_cprm.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'soc-3.15' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc
[mirror_ubuntu-artful-kernel.git] / drivers / staging / rts5139 / sd_cprm.c
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_cprm.h"
39 #include "sd.h"
40
41 #ifdef SUPPORT_CPRM
42
43 static inline int get_rsp_type(u8 rsp_code, u8 *rsp_type, int *rsp_len)
44 {
45 if (!rsp_type || !rsp_len)
46 return STATUS_FAIL;
47
48 switch (rsp_code) {
49 case 0x03:
50 *rsp_type = SD_RSP_TYPE_R0; /* no response */
51 *rsp_len = 0;
52 break;
53
54 case 0x04:
55 *rsp_type = SD_RSP_TYPE_R1; /* R1,R6(,R4,R5) */
56 *rsp_len = 6;
57 break;
58
59 case 0x05:
60 *rsp_type = SD_RSP_TYPE_R1b; /* R1b */
61 *rsp_len = 6;
62 break;
63
64 case 0x06:
65 *rsp_type = SD_RSP_TYPE_R2; /* R2 */
66 *rsp_len = 17;
67 break;
68
69 case 0x07:
70 *rsp_type = SD_RSP_TYPE_R3; /* R3 */
71 *rsp_len = 6;
72 break;
73
74 default:
75 return STATUS_FAIL;
76 }
77
78 return STATUS_SUCCESS;
79 }
80
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,
83 int special_check)
84 {
85 int retval;
86 int timeout = 50;
87 u16 reg_addr;
88 u8 buf[17], stat;
89 int len = 2;
90 int rty_cnt = 0;
91
92 RTS51X_DEBUGP("EXT SD/MMC CMD %d\n", cmd_idx);
93
94 if (rsp_type == SD_RSP_TYPE_R1b)
95 timeout = 3000;
96
97 RTY_SEND_CMD:
98
99 rts51x_init_cmd(chip);
100
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);
106
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,
113 SD_TRANSFER_END);
114
115 rts51x_add_cmd(chip, READ_REG_CMD, SD_STAT1, 0, 0);
116
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,
122 0);
123 }
124 len = 19;
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;
128 reg_addr++) {
129 rts51x_add_cmd(chip, READ_REG_CMD, reg_addr, 0,
130 0);
131 }
132 len = 8;
133 } else {
134 len = 3;
135 }
136 rts51x_add_cmd(chip, READ_REG_CMD, SD_CMD5, 0, 0);
137 } else {
138 len = 2;
139 }
140
141 retval = rts51x_send_cmd(chip, MODE_CR, 100);
142 if (retval != STATUS_SUCCESS)
143 TRACE_RET(chip, retval);
144
145 retval = rts51x_get_rsp(chip, len, timeout);
146
147 if (CHECK_SD_TRANS_FAIL(chip, retval)) {
148 rts51x_clear_sd_error(chip);
149
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);
155 }
156 }
157 TRACE_RET(chip, STATUS_FAIL);
158 }
159
160 if (rsp_type == SD_RSP_TYPE_R0)
161 return STATUS_SUCCESS;
162
163 if (CHECK_USB(chip, USB_20)) {
164 rts51x_read_rsp_buf(chip, 2, buf, len - 2);
165 } else {
166 if (rsp_type == SD_RSP_TYPE_R2) {
167 reg_addr = PPBUF_BASE2;
168 len = 16;
169 } else {
170 reg_addr = SD_CMD0;
171 len = 5;
172 }
173 retval =
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);
179 }
180 stat = chip->rsp_buf[1];
181
182 if ((buf[0] & 0xC0) != 0)
183 TRACE_RET(chip, STATUS_FAIL);
184
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) {
190 wait_timeout(20);
191 rty_cnt++;
192 goto RTY_SEND_CMD;
193 } else {
194 TRACE_RET(chip, STATUS_FAIL);
195 }
196 }
197 }
198
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)) {
202 if (buf[1] & 0x80)
203 TRACE_RET(chip, STATUS_FAIL);
204 }
205 if (buf[1] & 0x7F)
206 TRACE_RET(chip, STATUS_FAIL);
207 if (buf[2] & 0xF8)
208 TRACE_RET(chip, STATUS_FAIL);
209
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);
217 }
218 }
219 }
220
221 if (rsp && rsp_len)
222 memcpy(rsp, buf, rsp_len);
223
224 return STATUS_SUCCESS;
225 }
226
227 static int ext_sd_get_rsp(struct rts51x_chip *chip, int len,
228 u8 *rsp, u8 rsp_type)
229 {
230 int retval, rsp_len;
231 u16 reg_addr;
232
233 if (rsp_type == SD_RSP_TYPE_R0)
234 return STATUS_SUCCESS;
235
236 rts51x_init_cmd(chip);
237
238 if (rsp_type == SD_RSP_TYPE_R2) {
239 for (reg_addr = PPBUF_BASE2; reg_addr < PPBUF_BASE2 + 16;
240 reg_addr++) {
241 rts51x_add_cmd(chip, READ_REG_CMD, reg_addr, 0xFF, 0);
242 }
243 rsp_len = 17;
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);
247 rsp_len = 6;
248 }
249 rts51x_add_cmd(chip, READ_REG_CMD, SD_CMD5, 0xFF, 0);
250
251 retval = rts51x_send_cmd(chip, MODE_CR, 100);
252 if (retval != STATUS_SUCCESS)
253 TRACE_RET(chip, retval);
254
255 retval = rts51x_get_rsp(chip, rsp_len, 100);
256
257 if (retval != STATUS_SUCCESS)
258 TRACE_RET(chip, retval);
259
260 if (rsp) {
261 int min_len = (rsp_len < len) ? rsp_len : len;
262
263 memcpy(rsp, rts51x_get_rsp_data(chip), min_len);
264
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]);
268 }
269
270 return STATUS_SUCCESS;
271 }
272
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,
275 u32 arg)
276 {
277 struct sd_info *sd_card = &(chip->sd_card);
278 int retval, rsp_len;
279 u8 rsp_type;
280
281 retval = rts51x_sd_switch_clock(chip);
282 if (retval != STATUS_SUCCESS)
283 TRACE_RET(chip, TRANSPORT_FAILED);
284
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);
289 }
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);
294 }
295 sd_card->last_rsp_type = rsp_type;
296
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);
302
303 if (standby) {
304 retval = rts51x_sd_select_card(chip, 0);
305 if (retval != STATUS_SUCCESS)
306 TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
307 }
308
309 if (acmd) {
310 retval =
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);
315 }
316
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);
321
322 if (standby) {
323 retval = rts51x_sd_select_card(chip, 1);
324 if (retval != STATUS_SUCCESS)
325 TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
326 }
327
328 return TRANSPORT_GOOD;
329
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);
337
338 TRACE_RET(chip, TRANSPORT_FAILED);
339 }
340
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)
345 {
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;
350
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);
355 }
356
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);
364 }
365 sd_card->last_rsp_type = rsp_type;
366
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;
371
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);
377 }
378
379 if (standby) {
380 retval = rts51x_sd_select_card(chip, 0);
381 if (retval != STATUS_SUCCESS)
382 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
383 }
384
385 if (acmd) {
386 retval =
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);
391 }
392
393 if (data_len <= 512) {
394 int min_len;
395 u8 *buf;
396 u16 byte_cnt, blk_cnt;
397 u8 cmd[5];
398 unsigned int offset = 0;
399 void *sg = NULL;
400
401 byte_cnt = (u16) (data_len & 0x3FF);
402 blk_cnt = 1;
403
404 cmd[0] = 0x40 | cmd_idx;
405 cmd[1] = (u8) (arg >> 24);
406 cmd[2] = (u8) (arg >> 16);
407 cmd[3] = (u8) (arg >> 8);
408 cmd[4] = (u8) arg;
409
410 buf = kmalloc(data_len, GFP_KERNEL);
411 if (buf == NULL)
412 TRACE_RET(chip, TRANSPORT_ERROR);
413
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) {
417 read_err = 1;
418 kfree(buf);
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);
423 }
424
425 min_len = min(data_len, buf_len);
426 if (use_sg)
427 rts51x_access_sglist(buf, min_len, (void *)data_buf,
428 &sg, &offset, TO_XFER_BUF);
429 else
430 memcpy(data_buf, buf, min_len);
431
432 kfree(buf);
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,
442 0x40 | cmd_idx);
443 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD1, 0xFF,
444 (u8) (arg >> 24));
445 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD2, 0xFF,
446 (u8) (arg >> 16));
447 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD3, 0xFF,
448 (u8) (arg >> 8));
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) {
459 read_err = 1;
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);
464 }
465
466 retval =
467 rts51x_transfer_data_rcc(chip, RCV_BULK_PIPE(chip),
468 data_buf, buf_len, use_sg, NULL,
469 10000, STAGE_DI);
470 if (retval != STATUS_SUCCESS) {
471 read_err = 1;
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);
476 }
477 retval = rts51x_get_rsp(chip, 1, 500);
478 if (CHECK_SD_TRANS_FAIL(chip, retval)) {
479 read_err = 1;
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);
484 }
485 } else {
486 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
487 }
488
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);
492
493 if (standby) {
494 retval = rts51x_sd_select_card(chip, 1);
495 if (retval != STATUS_SUCCESS)
496 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
497 }
498
499 if (cmd12) {
500 retval = ext_sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION,
501 0, SD_RSP_TYPE_R1b, NULL, 0,
502 0);
503 if (retval != STATUS_SUCCESS)
504 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
505 }
506
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);
512
513 rts51x_write_register(chip, SD_BYTE_CNT_H, 0xFF, 0x02);
514 rts51x_write_register(chip, SD_BYTE_CNT_L, 0xFF, 0x00);
515 }
516
517 if (standby || cmd12)
518 cmd13_checkbit = 1;
519
520 for (i = 0; i < 3; i++) {
521 retval =
522 ext_sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
523 SD_RSP_TYPE_R1, NULL, 0,
524 cmd13_checkbit);
525 if (retval == STATUS_SUCCESS)
526 break;
527 }
528 if (retval != STATUS_SUCCESS)
529 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
530
531 return TRANSPORT_GOOD;
532
533 SD_Execute_Read_Cmd_Failed:
534 sd_card->pre_cmd_err = 1;
535 rts51x_set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
536 if (read_err)
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);
542
543 TRACE_RET(chip, TRANSPORT_FAILED);
544 }
545
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)
550 {
551 struct sd_info *sd_card = &(chip->sd_card);
552 int retval, rsp_len;
553 int cmd13_checkbit = 0, write_err = 0;
554 u8 rsp_type;
555 u32 i;
556
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);
561 }
562
563 retval = rts51x_sd_switch_clock(chip);
564 if (retval != STATUS_SUCCESS)
565 TRACE_RET(chip, STATUS_FAIL);
566
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);
571 }
572 sd_card->last_rsp_type = rsp_type;
573
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);
578
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);
584 }
585
586 if (standby) {
587 retval = rts51x_sd_select_card(chip, 0);
588 if (retval != STATUS_SUCCESS)
589 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
590 }
591
592 if (acmd) {
593 retval =
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);
598 }
599
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);
604
605 if (data_len <= 512) {
606 u8 *buf;
607 unsigned int offset = 0;
608 void *sg = NULL;
609
610 buf = kmalloc(data_len, GFP_KERNEL);
611 if (buf == NULL)
612 TRACE_RET(chip, TRANSPORT_ERROR);
613
614 if (use_sg)
615 rts51x_access_sglist(buf, data_len, (void *)data_buf,
616 &sg, &offset, FROM_XFER_BUF);
617 else
618 memcpy(buf, data_buf, data_len);
619
620
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,
626 buf[i]);
627 }
628 retval = rts51x_send_cmd(chip, MODE_C, 250);
629 if (retval != STATUS_SUCCESS) {
630 kfree(buf);
631 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
632 }
633
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,
638 buf[i]);
639 }
640 retval = rts51x_send_cmd(chip, MODE_C, 250);
641 if (retval != STATUS_SUCCESS) {
642 kfree(buf);
643 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
644 }
645 } else {
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,
650 buf[i]);
651 }
652 retval = rts51x_send_cmd(chip, MODE_C, 250);
653 if (retval != STATUS_SUCCESS) {
654 kfree(buf);
655 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
656 }
657 }
658
659 kfree(buf);
660
661 rts51x_init_cmd(chip);
662
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,
666 (u8) data_len);
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,
670 PINGPONG_BUFFER);
671
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);
676
677 retval = rts51x_send_cmd(chip, MODE_CR, 100);
678 if (retval != STATUS_SUCCESS)
679 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
680
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);
686
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));
693
694 rts51x_trans_dma_enable(DMA_TO_DEVICE, chip, data_len, DMA_512);
695
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);
700
701 retval = rts51x_send_cmd(chip, MODE_CDOR, 100);
702 if (retval != STATUS_SUCCESS)
703 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
704
705 retval =
706 rts51x_transfer_data_rcc(chip, SND_BULK_PIPE(chip),
707 data_buf, buf_len, use_sg, NULL,
708 10000, STAGE_DO);
709 if (retval != STATUS_SUCCESS)
710 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
711
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);
715
716 } else {
717 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
718 }
719
720 if (retval < 0) {
721 write_err = 1;
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);
725 }
726
727 if (standby) {
728 retval = rts51x_sd_select_card(chip, 1);
729 if (retval != STATUS_SUCCESS)
730 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
731 }
732
733 if (cmd12) {
734 retval = ext_sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION,
735 0, SD_RSP_TYPE_R1b, NULL, 0,
736 0);
737 if (retval != STATUS_SUCCESS)
738 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
739 }
740
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);
746
747 rts51x_write_register(chip, SD_BYTE_CNT_H, 0xFF, 0x02);
748 rts51x_write_register(chip, SD_BYTE_CNT_L, 0xFF, 0x00);
749 }
750
751 if (cmd12 || standby) {
752 /* There is CMD7 or CMD12 sent before CMD13 */
753 cmd13_checkbit = 1;
754 }
755
756 for (i = 0; i < 3; i++) {
757 retval =
758 ext_sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
759 SD_RSP_TYPE_R1, NULL, 0,
760 cmd13_checkbit);
761 if (retval == STATUS_SUCCESS)
762 break;
763 }
764 if (retval != STATUS_SUCCESS)
765 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
766
767 return TRANSPORT_GOOD;
768
769 SD_Execute_Write_Cmd_Failed:
770 sd_card->pre_cmd_err = 1;
771 rts51x_set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
772 if (write_err)
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);
778
779 TRACE_RET(chip, TRANSPORT_FAILED);
780 }
781
782 int rts51x_sd_pass_thru_mode(struct scsi_cmnd *srb, struct rts51x_chip *chip)
783 {
784 struct sd_info *sd_card = &(chip->sd_card);
785 unsigned int lun = SCSI_LUN(srb);
786 int len;
787 u8 buf[18] = {
788 0x00,
789 0x00,
790 0x00,
791 0x0E,
792 0x00, /* Version Number */
793 0x00, /* WP | Media Type */
794 0x00, /* RCA (Low byte) */
795 0x00, /* RCA (High byte) */
796 0x53, /* 'S' */
797 0x44, /* 'D' */
798 0x20, /* ' ' */
799 0x43, /* 'C' */
800 0x61, /* 'a' */
801 0x72, /* 'r' */
802 0x64, /* 'd' */
803 0x00, /* Max LUN Number */
804 0x00,
805 0x00,
806 };
807
808 sd_card->pre_cmd_err = 0;
809
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);
814 }
815
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);
822 }
823
824 switch (srb->cmnd[1] & 0x0F) {
825 case 0:
826 sd_card->sd_pass_thru_en = 0;
827 break;
828
829 case 1:
830 sd_card->sd_pass_thru_en = 1;
831 break;
832
833 default:
834 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
835 TRACE_RET(chip, TRANSPORT_FAILED);
836 }
837
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)
841 buf[5] |= 0x80;
842
843 buf[6] = (u8) (sd_card->sd_addr >> 16);
844 buf[7] = (u8) (sd_card->sd_addr >> 24);
845
846 buf[15] = chip->max_lun;
847
848 len = min_t(unsigned, 18, scsi_bufflen(srb));
849 rts51x_set_xfer_buf(buf, len, srb);
850
851 return TRANSPORT_GOOD;
852 }
853
854 int rts51x_sd_execute_no_data(struct scsi_cmnd *srb, struct rts51x_chip *chip)
855 {
856 struct sd_info *sd_card = &(chip->sd_card);
857 unsigned int lun = SCSI_LUN(srb);
858 int retval;
859 u8 cmd_idx, rsp_code;
860 u8 standby = 0, acmd = 0;
861 u32 arg;
862
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);
866 }
867
868 cmd_idx = srb->cmnd[2] & 0x3F;
869 if (srb->cmnd[1] & 0x02)
870 standby = 1;
871 if (srb->cmnd[1] & 0x01)
872 acmd = 1;
873
874 arg = ((u32) srb->cmnd[3] << 24) | ((u32) srb->cmnd[4] << 16) |
875 ((u32) srb->cmnd[5] << 8) | srb->cmnd[6];
876
877 rsp_code = srb->cmnd[10];
878
879 retval =
880 ext_rts51x_sd_execute_no_data(chip, lun, cmd_idx, standby, acmd, rsp_code,
881 arg);
882 scsi_set_resid(srb, 0);
883 return retval;
884 }
885
886 int rts51x_sd_execute_read_data(struct scsi_cmnd *srb, struct rts51x_chip *chip)
887 {
888 struct sd_info *sd_card = &(chip->sd_card);
889 int retval;
890 unsigned int lun = SCSI_LUN(srb);
891 u8 cmd_idx, rsp_code, send_cmd12 = 0, standby = 0, acmd = 0;
892 u32 arg, data_len;
893
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);
897 }
898
899 cmd_idx = srb->cmnd[2] & 0x3F;
900 if (srb->cmnd[1] & 0x04)
901 send_cmd12 = 1;
902 if (srb->cmnd[1] & 0x02)
903 standby = 1;
904 if (srb->cmnd[1] & 0x01)
905 acmd = 1;
906
907 arg = ((u32) srb->cmnd[3] << 24) | ((u32) srb->cmnd[4] << 16) |
908 ((u32) srb->cmnd[5] << 8) | srb->cmnd[6];
909
910 data_len =
911 ((u32) srb->cmnd[7] << 16) | ((u32) srb->cmnd[8] << 8) |
912 srb->cmnd[9];
913 rsp_code = srb->cmnd[10];
914
915 retval =
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),
919 scsi_sg_count(srb));
920 scsi_set_resid(srb, 0);
921 return retval;
922 }
923
924 int rts51x_sd_execute_write_data(struct scsi_cmnd *srb, struct rts51x_chip *chip)
925 {
926 struct sd_info *sd_card = &(chip->sd_card);
927 int retval;
928 unsigned int lun = SCSI_LUN(srb);
929 u8 cmd_idx, rsp_code, send_cmd12 = 0, standby = 0, acmd = 0;
930 u32 data_len, arg;
931
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);
935 }
936
937 cmd_idx = srb->cmnd[2] & 0x3F;
938 if (srb->cmnd[1] & 0x04)
939 send_cmd12 = 1;
940 if (srb->cmnd[1] & 0x02)
941 standby = 1;
942 if (srb->cmnd[1] & 0x01)
943 acmd = 1;
944
945 data_len =
946 ((u32) srb->cmnd[7] << 16) | ((u32) srb->cmnd[8] << 8) |
947 srb->cmnd[9];
948 arg =
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];
952
953 retval =
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),
957 scsi_sg_count(srb));
958 scsi_set_resid(srb, 0);
959 return retval;
960 }
961
962 int rts51x_sd_get_cmd_rsp(struct scsi_cmnd *srb, struct rts51x_chip *chip)
963 {
964 struct sd_info *sd_card = &(chip->sd_card);
965 unsigned int lun = SCSI_LUN(srb);
966 int count;
967 u16 data_len;
968
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);
972 }
973
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);
978 }
979
980 data_len = ((u16) srb->cmnd[7] << 8) | srb->cmnd[8];
981
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;
987 } else {
988 count = (data_len < 6) ? data_len : 6;
989 }
990 rts51x_set_xfer_buf(sd_card->rsp, count, srb);
991
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],
995 sd_card->rsp[3]);
996
997 scsi_set_resid(srb, 0);
998 return TRANSPORT_GOOD;
999 }
1000
1001 int rts51x_sd_hw_rst(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1002 {
1003 struct sd_info *sd_card = &(chip->sd_card);
1004 unsigned int lun = SCSI_LUN(srb);
1005 int retval;
1006
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);
1010 }
1011
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);
1016 }
1017
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);
1024 }
1025
1026 switch (srb->cmnd[1] & 0x0F) {
1027 case 0:
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);
1034 }
1035 break;
1036
1037 case 1:
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);
1045 }
1046 break;
1047
1048 default:
1049 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1050 TRACE_RET(chip, TRANSPORT_FAILED);
1051 }
1052
1053 scsi_set_resid(srb, 0);
1054 return TRANSPORT_GOOD;
1055 }
1056 #endif
Ubuntu Artful kernel mirror