1 /* Driver for Realtek PCI-Express 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
23 #include <linux/blkdev.h>
24 #include <linux/kthread.h>
25 #include <linux/sched.h>
28 #include "rtsx_transport.h"
29 #include "rtsx_scsi.h"
30 #include "rtsx_card.h"
33 #define SD_MAX_RETRY_COUNT 3
35 static u16 REG_SD_CFG1;
36 static u16 REG_SD_CFG2;
37 static u16 REG_SD_CFG3;
38 static u16 REG_SD_STAT1;
39 static u16 REG_SD_STAT2;
40 static u16 REG_SD_BUS_STAT;
41 static u16 REG_SD_PAD_CTL;
42 static u16 REG_SD_SAMPLE_POINT_CTL;
43 static u16 REG_SD_PUSH_POINT_CTL;
44 static u16 REG_SD_CMD0;
45 static u16 REG_SD_CMD1;
46 static u16 REG_SD_CMD2;
47 static u16 REG_SD_CMD3;
48 static u16 REG_SD_CMD4;
49 static u16 REG_SD_CMD5;
50 static u16 REG_SD_BYTE_CNT_L;
51 static u16 REG_SD_BYTE_CNT_H;
52 static u16 REG_SD_BLOCK_CNT_L;
53 static u16 REG_SD_BLOCK_CNT_H;
54 static u16 REG_SD_TRANSFER;
55 static u16 REG_SD_VPCLK0_CTL;
56 static u16 REG_SD_VPCLK1_CTL;
57 static u16 REG_SD_DCMPS0_CTL;
58 static u16 REG_SD_DCMPS1_CTL;
60 static inline void sd_set_err_code(struct rtsx_chip *chip, u8 err_code)
62 struct sd_info *sd_card = &(chip->sd_card);
64 sd_card->err_code |= err_code;
67 static inline void sd_clr_err_code(struct rtsx_chip *chip)
69 struct sd_info *sd_card = &(chip->sd_card);
71 sd_card->err_code = 0;
74 static inline int sd_check_err_code(struct rtsx_chip *chip, u8 err_code)
76 struct sd_info *sd_card = &(chip->sd_card);
78 return sd_card->err_code & err_code;
81 static void sd_init_reg_addr(struct rtsx_chip *chip)
83 if (CHECK_PID(chip, 0x5209)) {
84 REG_SD_CFG1 = SD_CFG1;
85 REG_SD_CFG2 = SD_CFG2;
86 REG_SD_CFG3 = SD_CFG3;
87 REG_SD_STAT1 = SD_STAT1;
88 REG_SD_STAT2 = SD_STAT2;
89 REG_SD_BUS_STAT = SD_BUS_STAT;
90 REG_SD_PAD_CTL = SD_PAD_CTL;
91 REG_SD_SAMPLE_POINT_CTL = SD_SAMPLE_POINT_CTL;
92 REG_SD_PUSH_POINT_CTL = SD_PUSH_POINT_CTL;
93 REG_SD_CMD0 = SD_CMD0;
94 REG_SD_CMD1 = SD_CMD1;
95 REG_SD_CMD2 = SD_CMD2;
96 REG_SD_CMD3 = SD_CMD3;
97 REG_SD_CMD4 = SD_CMD4;
98 REG_SD_CMD5 = SD_CMD5;
99 REG_SD_BYTE_CNT_L = SD_BYTE_CNT_L;
100 REG_SD_BYTE_CNT_H = SD_BYTE_CNT_H;
101 REG_SD_BLOCK_CNT_L = SD_BLOCK_CNT_L;
102 REG_SD_BLOCK_CNT_H = SD_BLOCK_CNT_H;
103 REG_SD_TRANSFER = SD_TRANSFER;
104 REG_SD_VPCLK0_CTL = SD_VPCLK0_CTL;
105 REG_SD_VPCLK1_CTL = SD_VPCLK1_CTL;
106 REG_SD_DCMPS0_CTL = SD_DCMPS0_CTL;
107 REG_SD_DCMPS1_CTL = SD_DCMPS1_CTL;
109 REG_SD_CFG1 = 0xFD31;
110 REG_SD_CFG2 = 0xFD33;
111 REG_SD_CFG3 = 0xFD3E;
112 REG_SD_STAT1 = 0xFD30;
116 REG_SD_SAMPLE_POINT_CTL = 0;
117 REG_SD_PUSH_POINT_CTL = 0;
118 REG_SD_CMD0 = 0xFD34;
119 REG_SD_CMD1 = 0xFD35;
120 REG_SD_CMD2 = 0xFD36;
121 REG_SD_CMD3 = 0xFD37;
122 REG_SD_CMD4 = 0xFD38;
123 REG_SD_CMD5 = 0xFD5A;
124 REG_SD_BYTE_CNT_L = 0xFD39;
125 REG_SD_BYTE_CNT_H = 0xFD3A;
126 REG_SD_BLOCK_CNT_L = 0xFD3B;
127 REG_SD_BLOCK_CNT_H = 0xFD3C;
128 REG_SD_TRANSFER = 0xFD32;
129 REG_SD_VPCLK0_CTL = 0;
130 REG_SD_VPCLK1_CTL = 0;
131 REG_SD_DCMPS0_CTL = 0;
132 REG_SD_DCMPS1_CTL = 0;
136 static int sd_check_data0_status(struct rtsx_chip *chip)
140 if (CHECK_PID(chip, 0x5209)) {
141 RTSX_READ_REG(chip, REG_SD_BUS_STAT, &stat);
143 RTSX_READ_REG(chip, REG_SD_STAT1, &stat);
146 if (!(stat & SD_DAT0_STATUS)) {
147 sd_set_err_code(chip, SD_BUSY);
148 TRACE_RET(chip, STATUS_FAIL);
151 return STATUS_SUCCESS;
154 static int sd_send_cmd_get_rsp(struct rtsx_chip *chip, u8 cmd_idx,
155 u32 arg, u8 rsp_type, u8 *rsp, int rsp_len)
157 struct sd_info *sd_card = &(chip->sd_card);
165 sd_clr_err_code(chip);
167 RTSX_DEBUGP("SD/MMC CMD %d, arg = 0x%08x\n", cmd_idx, arg);
169 if (rsp_type == SD_RSP_TYPE_R1b)
176 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD0, 0xFF, 0x40 | cmd_idx);
177 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD1, 0xFF, (u8)(arg >> 24));
178 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD2, 0xFF, (u8)(arg >> 16));
179 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD3, 0xFF, (u8)(arg >> 8));
180 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD4, 0xFF, (u8)arg);
182 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF, rsp_type);
183 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE,
184 0x01, PINGPONG_BUFFER);
185 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER,
186 0xFF, SD_TM_CMD_RSP | SD_TRANSFER_START);
187 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER,
188 SD_TRANSFER_END | SD_STAT_IDLE, SD_TRANSFER_END | SD_STAT_IDLE);
190 if (rsp_type == SD_RSP_TYPE_R2) {
191 for (reg_addr = PPBUF_BASE2; reg_addr < PPBUF_BASE2 + 16; reg_addr++) {
192 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0, 0);
195 } else if (rsp_type != SD_RSP_TYPE_R0) {
196 for (reg_addr = REG_SD_CMD0; reg_addr <= REG_SD_CMD4; reg_addr++) {
197 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0, 0);
202 rtsx_add_cmd(chip, READ_REG_CMD, REG_SD_STAT1, 0, 0);
204 retval = rtsx_send_cmd(chip, SD_CARD, timeout);
208 rtsx_read_register(chip, REG_SD_STAT1, &val);
209 RTSX_DEBUGP("SD_STAT1: 0x%x\n", val);
211 if (CHECK_PID(chip, 0x5209)) {
212 rtsx_read_register(chip, REG_SD_STAT2, &val);
213 RTSX_DEBUGP("SD_STAT2: 0x%x\n", val);
215 if (val & SD_RSP_80CLK_TIMEOUT) {
216 rtsx_clear_sd_error(chip);
217 sd_set_err_code(chip, SD_RSP_TIMEOUT);
218 TRACE_RET(chip, STATUS_FAIL);
221 rtsx_read_register(chip, REG_SD_BUS_STAT, &val);
222 RTSX_DEBUGP("SD_BUS_STAT: 0x%x\n", val);
224 rtsx_read_register(chip, REG_SD_CFG3, &val);
225 RTSX_DEBUGP("SD_CFG3: 0x%x\n", val);
228 if (retval == -ETIMEDOUT) {
229 if (rsp_type & SD_WAIT_BUSY_END) {
230 retval = sd_check_data0_status(chip);
231 if (retval != STATUS_SUCCESS) {
232 rtsx_clear_sd_error(chip);
233 TRACE_RET(chip, retval);
236 sd_set_err_code(chip, SD_TO_ERR);
238 retval = STATUS_TIMEDOUT;
240 retval = STATUS_FAIL;
242 rtsx_clear_sd_error(chip);
244 TRACE_RET(chip, retval);
247 if (rsp_type == SD_RSP_TYPE_R0)
248 return STATUS_SUCCESS;
250 ptr = rtsx_get_cmd_data(chip) + 1;
252 if ((ptr[0] & 0xC0) != 0) {
253 sd_set_err_code(chip, SD_STS_ERR);
254 TRACE_RET(chip, STATUS_FAIL);
257 if (!(rsp_type & SD_NO_CHECK_CRC7)) {
258 if (ptr[stat_idx] & SD_CRC7_ERR) {
259 if (cmd_idx == WRITE_MULTIPLE_BLOCK) {
260 sd_set_err_code(chip, SD_CRC_ERR);
261 TRACE_RET(chip, STATUS_FAIL);
263 if (rty_cnt < SD_MAX_RETRY_COUNT) {
268 sd_set_err_code(chip, SD_CRC_ERR);
269 TRACE_RET(chip, STATUS_FAIL);
274 if ((rsp_type == SD_RSP_TYPE_R1) || (rsp_type == SD_RSP_TYPE_R1b)) {
275 if ((cmd_idx != SEND_RELATIVE_ADDR) && (cmd_idx != SEND_IF_COND)) {
276 if (cmd_idx != STOP_TRANSMISSION) {
278 TRACE_RET(chip, STATUS_FAIL);
281 #ifdef SUPPORT_SD_LOCK
287 RTSX_DEBUGP("ptr[1]: 0x%02x\n", ptr[1]);
288 TRACE_RET(chip, STATUS_FAIL);
291 RTSX_DEBUGP("ptr[2]: 0x%02x\n", ptr[2]);
292 TRACE_RET(chip, STATUS_FAIL);
295 RTSX_DEBUGP("ptr[3]: 0x%02x\n", ptr[3]);
296 TRACE_RET(chip, STATUS_FAIL);
299 sd_card->sd_data_buf_ready = 1;
301 sd_card->sd_data_buf_ready = 0;
307 memcpy(rsp, ptr, rsp_len);
309 return STATUS_SUCCESS;
312 static int sd_read_data(struct rtsx_chip *chip,
313 u8 trans_mode, u8 *cmd, int cmd_len, u16 byte_cnt,
314 u16 blk_cnt, u8 bus_width, u8 *buf, int buf_len,
317 struct sd_info *sd_card = &(chip->sd_card);
321 sd_clr_err_code(chip);
327 TRACE_RET(chip, STATUS_FAIL);
333 RTSX_DEBUGP("SD/MMC CMD %d\n", cmd[0] - 0x40);
334 for (i = 0; i < (cmd_len < 6 ? cmd_len : 6); i++) {
335 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD0 + i, 0xFF, cmd[i]);
338 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF, (u8)byte_cnt);
339 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_H, 0xFF, (u8)(byte_cnt >> 8));
340 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L, 0xFF, (u8)blk_cnt);
341 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H, 0xFF, (u8)(blk_cnt >> 8));
343 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG1, 0x03, bus_width);
345 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF,
346 SD_CALCULATE_CRC7 | SD_CHECK_CRC16 | SD_NO_WAIT_BUSY_END |
347 SD_CHECK_CRC7 | SD_RSP_LEN_6);
348 if (trans_mode != SD_TM_AUTO_TUNING) {
349 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 0x01, PINGPONG_BUFFER);
351 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF, trans_mode | SD_TRANSFER_START);
352 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER, SD_TRANSFER_END, SD_TRANSFER_END);
354 retval = rtsx_send_cmd(chip, SD_CARD, timeout);
356 if (retval == -ETIMEDOUT) {
357 sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
358 SD_RSP_TYPE_R1, NULL, 0);
361 TRACE_RET(chip, STATUS_FAIL);
364 if (buf && buf_len) {
365 retval = rtsx_read_ppbuf(chip, buf, buf_len);
366 if (retval != STATUS_SUCCESS) {
367 TRACE_RET(chip, STATUS_FAIL);
371 return STATUS_SUCCESS;
374 static int sd_write_data(struct rtsx_chip *chip, u8 trans_mode,
375 u8 *cmd, int cmd_len, u16 byte_cnt, u16 blk_cnt, u8 bus_width,
376 u8 *buf, int buf_len, int timeout)
378 struct sd_info *sd_card = &(chip->sd_card);
382 sd_clr_err_code(chip);
388 /* This function can't write data more than one page */
389 TRACE_RET(chip, STATUS_FAIL);
392 if (buf && buf_len) {
393 retval = rtsx_write_ppbuf(chip, buf, buf_len);
394 if (retval != STATUS_SUCCESS) {
395 TRACE_RET(chip, STATUS_FAIL);
402 RTSX_DEBUGP("SD/MMC CMD %d\n", cmd[0] - 0x40);
403 for (i = 0; i < (cmd_len < 6 ? cmd_len : 6); i++) {
404 rtsx_add_cmd(chip, WRITE_REG_CMD,
405 REG_SD_CMD0 + i, 0xFF, cmd[i]);
408 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF, (u8)byte_cnt);
409 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_H, 0xFF, (u8)(byte_cnt >> 8));
410 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L, 0xFF, (u8)blk_cnt);
411 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H, 0xFF, (u8)(blk_cnt >> 8));
413 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG1, 0x03, bus_width);
415 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF,
416 SD_CALCULATE_CRC7 | SD_CHECK_CRC16 | SD_NO_WAIT_BUSY_END |
417 SD_CHECK_CRC7 | SD_RSP_LEN_6);
419 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF, trans_mode | SD_TRANSFER_START);
420 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER, SD_TRANSFER_END, SD_TRANSFER_END);
422 retval = rtsx_send_cmd(chip, SD_CARD, timeout);
424 if (retval == -ETIMEDOUT) {
425 sd_send_cmd_get_rsp(chip, SEND_STATUS,
426 sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
429 TRACE_RET(chip, STATUS_FAIL);
432 return STATUS_SUCCESS;
435 static int sd_check_csd(struct rtsx_chip *chip, char check_wp)
437 struct sd_info *sd_card = &(chip->sd_card);
440 u8 csd_ver, trans_speed;
443 for (i = 0; i < 6; i++) {
444 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
445 sd_set_err_code(chip, SD_NO_CARD);
446 TRACE_RET(chip, STATUS_FAIL);
449 retval = sd_send_cmd_get_rsp(chip, SEND_CSD, sd_card->sd_addr, SD_RSP_TYPE_R2, rsp, 16);
450 if (retval == STATUS_SUCCESS)
455 TRACE_RET(chip, STATUS_FAIL);
458 memcpy(sd_card->raw_csd, rsp + 1, 15);
460 if (CHECK_PID(chip, 0x5209)) {
461 RTSX_READ_REG(chip, REG_SD_CMD5, sd_card->raw_csd + 15);
464 RTSX_DEBUGP("CSD Response:\n");
465 RTSX_DUMP(sd_card->raw_csd, 16);
467 csd_ver = (rsp[1] & 0xc0) >> 6;
468 RTSX_DEBUGP("csd_ver = %d\n", csd_ver);
470 trans_speed = rsp[4];
471 if ((trans_speed & 0x07) == 0x02) {
472 if ((trans_speed & 0xf8) >= 0x30) {
473 if (chip->asic_code) {
474 sd_card->sd_clock = 47;
476 sd_card->sd_clock = CLK_50;
478 } else if ((trans_speed & 0xf8) == 0x28) {
479 if (chip->asic_code) {
480 sd_card->sd_clock = 39;
482 sd_card->sd_clock = CLK_40;
484 } else if ((trans_speed & 0xf8) == 0x20) {
485 if (chip->asic_code) {
486 sd_card->sd_clock = 29;
488 sd_card->sd_clock = CLK_30;
490 } else if ((trans_speed & 0xf8) >= 0x10) {
491 if (chip->asic_code) {
492 sd_card->sd_clock = 23;
494 sd_card->sd_clock = CLK_20;
496 } else if ((trans_speed & 0x08) >= 0x08) {
497 if (chip->asic_code) {
498 sd_card->sd_clock = 19;
500 sd_card->sd_clock = CLK_20;
503 TRACE_RET(chip, STATUS_FAIL);
506 TRACE_RET(chip, STATUS_FAIL);
509 if (CHK_MMC_SECTOR_MODE(sd_card)) {
510 sd_card->capacity = 0;
512 if ((!CHK_SD_HCXC(sd_card)) || (csd_ver == 0)) {
513 u8 blk_size, c_size_mult;
515 blk_size = rsp[6] & 0x0F;
516 c_size = ((u16)(rsp[7] & 0x03) << 10)
518 + ((u16)(rsp[9] & 0xC0) >> 6);
519 c_size_mult = (u8)((rsp[10] & 0x03) << 1);
520 c_size_mult += (rsp[11] & 0x80) >> 7;
521 sd_card->capacity = (((u32)(c_size + 1)) * (1 << (c_size_mult + 2))) << (blk_size - 9);
523 u32 total_sector = 0;
524 total_sector = (((u32)rsp[8] & 0x3f) << 16) |
525 ((u32)rsp[9] << 8) | (u32)rsp[10];
526 sd_card->capacity = (total_sector + 1) << 10;
531 if (rsp[15] & 0x30) {
532 chip->card_wp |= SD_CARD;
534 RTSX_DEBUGP("CSD WP Status: 0x%x\n", rsp[15]);
537 return STATUS_SUCCESS;
540 static int sd_set_sample_push_timing(struct rtsx_chip *chip)
542 struct sd_info *sd_card = &(chip->sd_card);
544 if (CHECK_PID(chip, 0x5209)) {
545 if (CHK_SD_SDR104(sd_card) || CHK_SD_SDR50(sd_card)) {
546 RTSX_WRITE_REG(chip, SD_CFG1, 0x0C | SD_ASYNC_FIFO_NOT_RST,
547 SD_30_MODE | SD_ASYNC_FIFO_NOT_RST);
548 RTSX_WRITE_REG(chip, CLK_CTL, CLK_LOW_FREQ, CLK_LOW_FREQ);
549 RTSX_WRITE_REG(chip, CARD_CLK_SOURCE, 0xFF,
550 CRC_VAR_CLK0 | SD30_FIX_CLK | SAMPLE_VAR_CLK1);
551 RTSX_WRITE_REG(chip, CLK_CTL, CLK_LOW_FREQ, 0);
552 } else if (CHK_SD_DDR50(sd_card) || CHK_MMC_DDR52(sd_card)) {
553 RTSX_WRITE_REG(chip, SD_CFG1, 0x0C | SD_ASYNC_FIFO_NOT_RST,
554 SD_DDR_MODE | SD_ASYNC_FIFO_NOT_RST);
555 RTSX_WRITE_REG(chip, CLK_CTL, CLK_LOW_FREQ, CLK_LOW_FREQ);
556 RTSX_WRITE_REG(chip, CARD_CLK_SOURCE, 0xFF,
557 CRC_VAR_CLK0 | SD30_FIX_CLK | SAMPLE_VAR_CLK1);
558 RTSX_WRITE_REG(chip, CLK_CTL, CLK_LOW_FREQ, 0);
559 RTSX_WRITE_REG(chip, SD_PUSH_POINT_CTL, DDR_VAR_TX_CMD_DAT,
561 RTSX_WRITE_REG(chip, SD_SAMPLE_POINT_CTL, DDR_VAR_RX_DAT | DDR_VAR_RX_CMD,
562 DDR_VAR_RX_DAT | DDR_VAR_RX_CMD);
566 RTSX_WRITE_REG(chip, SD_CFG1, 0x0C, SD_20_MODE);
567 RTSX_WRITE_REG(chip, CLK_CTL, CLK_LOW_FREQ, CLK_LOW_FREQ);
568 RTSX_WRITE_REG(chip, CARD_CLK_SOURCE, 0xFF,
569 CRC_FIX_CLK | SD30_VAR_CLK0 | SAMPLE_VAR_CLK1);
570 RTSX_WRITE_REG(chip, CLK_CTL, CLK_LOW_FREQ, 0);
572 if ((chip->sd_ctl & SD_PUSH_POINT_CTL_MASK) == SD_PUSH_POINT_AUTO) {
573 val = SD20_TX_NEG_EDGE;
574 } else if ((chip->sd_ctl & SD_PUSH_POINT_CTL_MASK) == SD_PUSH_POINT_DELAY) {
575 val = SD20_TX_14_AHEAD;
577 val = SD20_TX_NEG_EDGE;
579 RTSX_WRITE_REG(chip, SD_PUSH_POINT_CTL, SD20_TX_SEL_MASK, val);
581 if ((chip->sd_ctl & SD_SAMPLE_POINT_CTL_MASK) == SD_SAMPLE_POINT_AUTO) {
582 if (chip->asic_code) {
583 if (CHK_SD_HS(sd_card) || CHK_MMC_52M(sd_card)) {
584 val = SD20_RX_14_DELAY;
586 val = SD20_RX_POS_EDGE;
589 val = SD20_RX_14_DELAY;
591 } else if ((chip->sd_ctl & SD_SAMPLE_POINT_CTL_MASK) == SD_SAMPLE_POINT_DELAY) {
592 val = SD20_RX_14_DELAY;
594 val = SD20_RX_POS_EDGE;
596 RTSX_WRITE_REG(chip, SD_SAMPLE_POINT_CTL, SD20_RX_SEL_MASK, val);
601 if ((chip->sd_ctl & SD_PUSH_POINT_CTL_MASK) == SD_PUSH_POINT_DELAY) {
605 if ((chip->sd_ctl & SD_SAMPLE_POINT_CTL_MASK) == SD_SAMPLE_POINT_AUTO) {
606 if (chip->asic_code) {
607 if (CHK_SD_HS(sd_card) || CHK_MMC_52M(sd_card)) {
621 } else if ((chip->sd_ctl & SD_SAMPLE_POINT_CTL_MASK) == SD_SAMPLE_POINT_DELAY) {
629 RTSX_WRITE_REG(chip, REG_SD_CFG1, 0x1C, val);
632 return STATUS_SUCCESS;
635 static void sd_choose_proper_clock(struct rtsx_chip *chip)
637 struct sd_info *sd_card = &(chip->sd_card);
639 if (CHK_SD_SDR104(sd_card)) {
640 if (chip->asic_code) {
641 sd_card->sd_clock = chip->asic_sd_sdr104_clk;
643 sd_card->sd_clock = chip->fpga_sd_sdr104_clk;
645 } else if (CHK_SD_DDR50(sd_card)) {
646 if (chip->asic_code) {
647 sd_card->sd_clock = chip->asic_sd_ddr50_clk;
649 sd_card->sd_clock = chip->fpga_sd_ddr50_clk;
651 } else if (CHK_SD_SDR50(sd_card)) {
652 if (chip->asic_code) {
653 sd_card->sd_clock = chip->asic_sd_sdr50_clk;
655 sd_card->sd_clock = chip->fpga_sd_sdr50_clk;
657 } else if (CHK_SD_HS(sd_card)) {
658 if (chip->asic_code) {
659 sd_card->sd_clock = chip->asic_sd_hs_clk;
661 sd_card->sd_clock = chip->fpga_sd_hs_clk;
663 } else if (CHK_MMC_52M(sd_card) || CHK_MMC_DDR52(sd_card)) {
664 if (chip->asic_code) {
665 sd_card->sd_clock = chip->asic_mmc_52m_clk;
667 sd_card->sd_clock = chip->fpga_mmc_52m_clk;
669 } else if (CHK_MMC_26M(sd_card)) {
670 if (chip->asic_code) {
671 sd_card->sd_clock = 48;
673 sd_card->sd_clock = CLK_50;
678 static int sd_set_clock_divider(struct rtsx_chip *chip, u8 clk_div)
680 u8 mask = 0, val = 0;
682 if (CHECK_PID(chip, 0x5209)) {
683 mask = SD_CLK_DIVIDE_MASK;
687 if (clk_div == SD_CLK_DIVIDE_0) {
689 } else if (clk_div == SD_CLK_DIVIDE_128) {
691 } else if (clk_div == SD_CLK_DIVIDE_256) {
696 RTSX_WRITE_REG(chip, REG_SD_CFG1, mask, val);
698 return STATUS_SUCCESS;
701 static int sd_set_init_para(struct rtsx_chip *chip)
703 struct sd_info *sd_card = &(chip->sd_card);
706 retval = sd_set_sample_push_timing(chip);
707 if (retval != STATUS_SUCCESS) {
708 TRACE_RET(chip, STATUS_FAIL);
711 sd_choose_proper_clock(chip);
713 retval = switch_clock(chip, sd_card->sd_clock);
714 if (retval != STATUS_SUCCESS) {
715 TRACE_RET(chip, STATUS_FAIL);
718 return STATUS_SUCCESS;
721 int sd_select_card(struct rtsx_chip *chip, int select)
723 struct sd_info *sd_card = &(chip->sd_card);
725 u8 cmd_idx, cmd_type;
729 cmd_idx = SELECT_CARD;
730 cmd_type = SD_RSP_TYPE_R1;
731 addr = sd_card->sd_addr;
733 cmd_idx = DESELECT_CARD;
734 cmd_type = SD_RSP_TYPE_R0;
738 retval = sd_send_cmd_get_rsp(chip, cmd_idx, addr, cmd_type, NULL, 0);
739 if (retval != STATUS_SUCCESS) {
740 TRACE_RET(chip, STATUS_FAIL);
743 return STATUS_SUCCESS;
746 #ifdef SUPPORT_SD_LOCK
747 static int sd_update_lock_status(struct rtsx_chip *chip)
749 struct sd_info *sd_card = &(chip->sd_card);
753 retval = sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr, SD_RSP_TYPE_R1, rsp, 5);
754 if (retval != STATUS_SUCCESS) {
755 TRACE_RET(chip, STATUS_FAIL);
759 sd_card->sd_lock_status |= SD_LOCKED;
761 sd_card->sd_lock_status &= ~SD_LOCKED;
764 RTSX_DEBUGP("sd_card->sd_lock_status = 0x%x\n", sd_card->sd_lock_status);
767 TRACE_RET(chip, STATUS_FAIL);
770 return STATUS_SUCCESS;
774 static int sd_wait_state_data_ready(struct rtsx_chip *chip, u8 state, u8 data_ready, int polling_cnt)
776 struct sd_info *sd_card = &(chip->sd_card);
780 for (i = 0; i < polling_cnt; i++) {
781 retval = sd_send_cmd_get_rsp(chip, SEND_STATUS,
782 sd_card->sd_addr, SD_RSP_TYPE_R1, rsp, 5);
783 if (retval != STATUS_SUCCESS) {
784 TRACE_RET(chip, STATUS_FAIL);
787 if (((rsp[3] & 0x1E) == state) && ((rsp[3] & 0x01) == data_ready)) {
788 return STATUS_SUCCESS;
792 TRACE_RET(chip, STATUS_FAIL);
795 static int sd_change_bank_voltage(struct rtsx_chip *chip, u8 voltage)
799 if (voltage == SD_IO_3V3) {
800 if (chip->asic_code) {
801 retval = rtsx_write_phy_register(chip, 0x08, 0x4FC0 | chip->phy_voltage);
802 if (retval != STATUS_SUCCESS) {
803 TRACE_RET(chip, STATUS_FAIL);
806 RTSX_WRITE_REG(chip, SD_PAD_CTL, SD_IO_USING_1V8, 0);
808 } else if (voltage == SD_IO_1V8) {
809 if (chip->asic_code) {
810 retval = rtsx_write_phy_register(chip, 0x08, 0x4C40 | chip->phy_voltage);
811 if (retval != STATUS_SUCCESS) {
812 TRACE_RET(chip, STATUS_FAIL);
815 RTSX_WRITE_REG(chip, SD_PAD_CTL, SD_IO_USING_1V8, SD_IO_USING_1V8);
818 TRACE_RET(chip, STATUS_FAIL);
821 return STATUS_SUCCESS;
824 static int sd_voltage_switch(struct rtsx_chip *chip)
829 RTSX_WRITE_REG(chip, SD_BUS_STAT, SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP, SD_CLK_TOGGLE_EN);
831 retval = sd_send_cmd_get_rsp(chip, VOLTAGE_SWITCH, 0, SD_RSP_TYPE_R1, NULL, 0);
832 if (retval != STATUS_SUCCESS) {
833 TRACE_RET(chip, STATUS_FAIL);
836 udelay(chip->sd_voltage_switch_delay);
838 RTSX_READ_REG(chip, SD_BUS_STAT, &stat);
839 if (stat & (SD_CMD_STATUS | SD_DAT3_STATUS | SD_DAT2_STATUS |
840 SD_DAT1_STATUS | SD_DAT0_STATUS)) {
841 TRACE_RET(chip, STATUS_FAIL);
844 RTSX_WRITE_REG(chip, SD_BUS_STAT, 0xFF, SD_CLK_FORCE_STOP);
845 retval = sd_change_bank_voltage(chip, SD_IO_1V8);
846 if (retval != STATUS_SUCCESS) {
847 TRACE_RET(chip, STATUS_FAIL);
851 RTSX_WRITE_REG(chip, SD_BUS_STAT, 0xFF, SD_CLK_TOGGLE_EN);
854 RTSX_READ_REG(chip, SD_BUS_STAT, &stat);
855 if ((stat & (SD_CMD_STATUS | SD_DAT3_STATUS | SD_DAT2_STATUS |
856 SD_DAT1_STATUS | SD_DAT0_STATUS)) !=
857 (SD_CMD_STATUS | SD_DAT3_STATUS | SD_DAT2_STATUS |
858 SD_DAT1_STATUS | SD_DAT0_STATUS)) {
859 RTSX_DEBUGP("SD_BUS_STAT: 0x%x\n", stat);
860 rtsx_write_register(chip, SD_BUS_STAT, SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP, 0);
861 rtsx_write_register(chip, CARD_CLK_EN, 0xFF, 0);
862 TRACE_RET(chip, STATUS_FAIL);
865 RTSX_WRITE_REG(chip, SD_BUS_STAT, SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP, 0);
867 return STATUS_SUCCESS;
870 static int sd_reset_dcm(struct rtsx_chip *chip, u8 tune_dir)
872 if (tune_dir == TUNE_RX) {
873 RTSX_WRITE_REG(chip, DCM_DRP_CTL, 0xFF, DCM_RESET | DCM_RX);
874 RTSX_WRITE_REG(chip, DCM_DRP_CTL, 0xFF, DCM_RX);
876 RTSX_WRITE_REG(chip, DCM_DRP_CTL, 0xFF, DCM_RESET | DCM_TX);
877 RTSX_WRITE_REG(chip, DCM_DRP_CTL, 0xFF, DCM_TX);
880 return STATUS_SUCCESS;
883 static int sd_change_phase(struct rtsx_chip *chip, u8 sample_point, u8 tune_dir)
885 struct sd_info *sd_card = &(chip->sd_card);
886 u16 SD_VP_CTL, SD_DCMPS_CTL;
891 RTSX_DEBUGP("sd_change_phase (sample_point = %d, tune_dir = %d)\n",
892 sample_point, tune_dir);
894 if (tune_dir == TUNE_RX) {
895 SD_VP_CTL = SD_VPRX_CTL;
896 SD_DCMPS_CTL = SD_DCMPS_RX_CTL;
897 if (CHK_SD_DDR50(sd_card)) {
901 SD_VP_CTL = SD_VPTX_CTL;
902 SD_DCMPS_CTL = SD_DCMPS_TX_CTL;
905 if (chip->asic_code) {
906 RTSX_WRITE_REG(chip, CLK_CTL, CHANGE_CLK, CHANGE_CLK);
907 RTSX_WRITE_REG(chip, SD_VP_CTL, 0x1F, sample_point);
908 RTSX_WRITE_REG(chip, SD_VPCLK0_CTL, PHASE_NOT_RESET, 0);
909 RTSX_WRITE_REG(chip, SD_VPCLK0_CTL, PHASE_NOT_RESET, PHASE_NOT_RESET);
910 RTSX_WRITE_REG(chip, CLK_CTL, CHANGE_CLK, 0);
912 #ifdef CONFIG_RTS_PSTOR_DEBUG
913 rtsx_read_register(chip, SD_VP_CTL, &val);
914 RTSX_DEBUGP("SD_VP_CTL: 0x%x\n", val);
915 rtsx_read_register(chip, SD_DCMPS_CTL, &val);
916 RTSX_DEBUGP("SD_DCMPS_CTL: 0x%x\n", val);
920 RTSX_WRITE_REG(chip, SD_VP_CTL, PHASE_CHANGE, PHASE_CHANGE);
922 RTSX_WRITE_REG(chip, SD_VP_CTL, 0xFF,
923 PHASE_CHANGE | PHASE_NOT_RESET | sample_point);
925 RTSX_WRITE_REG(chip, CLK_CTL, CHANGE_CLK, CHANGE_CLK);
927 RTSX_WRITE_REG(chip, SD_VP_CTL, 0xFF,
928 PHASE_NOT_RESET | sample_point);
933 rtsx_add_cmd(chip, WRITE_REG_CMD, SD_DCMPS_CTL, DCMPS_CHANGE, DCMPS_CHANGE);
934 rtsx_add_cmd(chip, CHECK_REG_CMD, SD_DCMPS_CTL, DCMPS_CHANGE_DONE, DCMPS_CHANGE_DONE);
935 retval = rtsx_send_cmd(chip, SD_CARD, 100);
936 if (retval != STATUS_SUCCESS) {
937 TRACE_GOTO(chip, Fail);
940 val = *rtsx_get_cmd_data(chip);
941 if (val & DCMPS_ERROR) {
942 TRACE_GOTO(chip, Fail);
944 if ((val & DCMPS_CURRENT_PHASE) != sample_point) {
945 TRACE_GOTO(chip, Fail);
947 RTSX_WRITE_REG(chip, SD_DCMPS_CTL, DCMPS_CHANGE, 0);
949 RTSX_WRITE_REG(chip, SD_VP_CTL, PHASE_CHANGE, 0);
951 RTSX_WRITE_REG(chip, CLK_CTL, CHANGE_CLK, 0);
956 RTSX_WRITE_REG(chip, SD_CFG1, SD_ASYNC_FIFO_NOT_RST, 0);
958 return STATUS_SUCCESS;
961 #ifdef CONFIG_RTS_PSTOR_DEBUG
962 rtsx_read_register(chip, SD_VP_CTL, &val);
963 RTSX_DEBUGP("SD_VP_CTL: 0x%x\n", val);
964 rtsx_read_register(chip, SD_DCMPS_CTL, &val);
965 RTSX_DEBUGP("SD_DCMPS_CTL: 0x%x\n", val);
968 rtsx_write_register(chip, SD_DCMPS_CTL, DCMPS_CHANGE, 0);
969 rtsx_write_register(chip, SD_VP_CTL, PHASE_CHANGE, 0);
971 sd_reset_dcm(chip, tune_dir);
975 static int sd_check_spec(struct rtsx_chip *chip, u8 bus_width)
977 struct sd_info *sd_card = &(chip->sd_card);
981 retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
982 if (retval != STATUS_SUCCESS) {
983 TRACE_RET(chip, STATUS_FAIL);
986 cmd[0] = 0x40 | SEND_SCR;
992 retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd, 5, 8, 1, bus_width, buf, 8, 250);
993 if (retval != STATUS_SUCCESS) {
994 rtsx_clear_sd_error(chip);
995 TRACE_RET(chip, STATUS_FAIL);
998 memcpy(sd_card->raw_scr, buf, 8);
1000 if ((buf[0] & 0x0F) == 0) {
1001 TRACE_RET(chip, STATUS_FAIL);
1004 return STATUS_SUCCESS;
1007 static int sd_query_switch_result(struct rtsx_chip *chip, u8 func_group, u8 func_to_switch,
1008 u8 *buf, int buf_len)
1010 u8 support_mask = 0, query_switch = 0, switch_busy = 0;
1011 int support_offset = 0, query_switch_offset = 0, check_busy_offset = 0;
1013 if (func_group == SD_FUNC_GROUP_1) {
1014 support_offset = FUNCTION_GROUP1_SUPPORT_OFFSET;
1015 query_switch_offset = FUNCTION_GROUP1_QUERY_SWITCH_OFFSET;
1016 check_busy_offset = FUNCTION_GROUP1_CHECK_BUSY_OFFSET;
1018 switch (func_to_switch) {
1020 support_mask = HS_SUPPORT_MASK;
1021 query_switch = HS_QUERY_SWITCH_OK;
1022 switch_busy = HS_SWITCH_BUSY;
1026 support_mask = SDR50_SUPPORT_MASK;
1027 query_switch = SDR50_QUERY_SWITCH_OK;
1028 switch_busy = SDR50_SWITCH_BUSY;
1031 case SDR104_SUPPORT:
1032 support_mask = SDR104_SUPPORT_MASK;
1033 query_switch = SDR104_QUERY_SWITCH_OK;
1034 switch_busy = SDR104_SWITCH_BUSY;
1038 support_mask = DDR50_SUPPORT_MASK;
1039 query_switch = DDR50_QUERY_SWITCH_OK;
1040 switch_busy = DDR50_SWITCH_BUSY;
1044 TRACE_RET(chip, STATUS_FAIL);
1046 } else if (func_group == SD_FUNC_GROUP_3) {
1047 support_offset = FUNCTION_GROUP3_SUPPORT_OFFSET;
1048 query_switch_offset = FUNCTION_GROUP3_QUERY_SWITCH_OFFSET;
1049 check_busy_offset = FUNCTION_GROUP3_CHECK_BUSY_OFFSET;
1051 switch (func_to_switch) {
1052 case DRIVING_TYPE_A:
1053 support_mask = DRIVING_TYPE_A_MASK;
1054 query_switch = TYPE_A_QUERY_SWITCH_OK;
1055 switch_busy = TYPE_A_SWITCH_BUSY;
1058 case DRIVING_TYPE_C:
1059 support_mask = DRIVING_TYPE_C_MASK;
1060 query_switch = TYPE_C_QUERY_SWITCH_OK;
1061 switch_busy = TYPE_C_SWITCH_BUSY;
1064 case DRIVING_TYPE_D:
1065 support_mask = DRIVING_TYPE_D_MASK;
1066 query_switch = TYPE_D_QUERY_SWITCH_OK;
1067 switch_busy = TYPE_D_SWITCH_BUSY;
1071 TRACE_RET(chip, STATUS_FAIL);
1073 } else if (func_group == SD_FUNC_GROUP_4) {
1074 support_offset = FUNCTION_GROUP4_SUPPORT_OFFSET;
1075 query_switch_offset = FUNCTION_GROUP4_QUERY_SWITCH_OFFSET;
1076 check_busy_offset = FUNCTION_GROUP4_CHECK_BUSY_OFFSET;
1078 switch (func_to_switch) {
1079 case CURRENT_LIMIT_400:
1080 support_mask = CURRENT_LIMIT_400_MASK;
1081 query_switch = CURRENT_LIMIT_400_QUERY_SWITCH_OK;
1082 switch_busy = CURRENT_LIMIT_400_SWITCH_BUSY;
1085 case CURRENT_LIMIT_600:
1086 support_mask = CURRENT_LIMIT_600_MASK;
1087 query_switch = CURRENT_LIMIT_600_QUERY_SWITCH_OK;
1088 switch_busy = CURRENT_LIMIT_600_SWITCH_BUSY;
1091 case CURRENT_LIMIT_800:
1092 support_mask = CURRENT_LIMIT_800_MASK;
1093 query_switch = CURRENT_LIMIT_800_QUERY_SWITCH_OK;
1094 switch_busy = CURRENT_LIMIT_800_SWITCH_BUSY;
1098 TRACE_RET(chip, STATUS_FAIL);
1101 TRACE_RET(chip, STATUS_FAIL);
1104 if (func_group == SD_FUNC_GROUP_1) {
1105 if (!(buf[support_offset] & support_mask) ||
1106 ((buf[query_switch_offset] & 0x0F) != query_switch)) {
1107 TRACE_RET(chip, STATUS_FAIL);
1111 /* Check 'Busy Status' */
1112 if ((buf[DATA_STRUCTURE_VER_OFFSET] == 0x01) &&
1113 ((buf[check_busy_offset] & switch_busy) == switch_busy)) {
1114 TRACE_RET(chip, STATUS_FAIL);
1117 return STATUS_SUCCESS;
1120 static int sd_check_switch_mode(struct rtsx_chip *chip, u8 mode,
1121 u8 func_group, u8 func_to_switch, u8 bus_width)
1123 struct sd_info *sd_card = &(chip->sd_card);
1127 RTSX_DEBUGP("sd_check_switch_mode (mode = %d, func_group = %d, func_to_switch = %d)\n",
1128 mode, func_group, func_to_switch);
1130 cmd[0] = 0x40 | SWITCH;
1133 if (func_group == SD_FUNC_GROUP_1) {
1136 cmd[4] = 0xF0 + func_to_switch;
1137 } else if (func_group == SD_FUNC_GROUP_3) {
1139 cmd[3] = 0xF0 + func_to_switch;
1141 } else if (func_group == SD_FUNC_GROUP_4) {
1143 cmd[3] = 0x0F + (func_to_switch << 4);
1146 cmd[1] = SD_CHECK_MODE;
1152 retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd, 5, 64, 1, bus_width, buf, 64, 250);
1153 if (retval != STATUS_SUCCESS) {
1154 rtsx_clear_sd_error(chip);
1155 TRACE_RET(chip, STATUS_FAIL);
1160 if (func_group == NO_ARGUMENT) {
1161 sd_card->func_group1_mask = buf[0x0D];
1162 sd_card->func_group2_mask = buf[0x0B];
1163 sd_card->func_group3_mask = buf[0x09];
1164 sd_card->func_group4_mask = buf[0x07];
1166 RTSX_DEBUGP("func_group1_mask = 0x%02x\n", buf[0x0D]);
1167 RTSX_DEBUGP("func_group2_mask = 0x%02x\n", buf[0x0B]);
1168 RTSX_DEBUGP("func_group3_mask = 0x%02x\n", buf[0x09]);
1169 RTSX_DEBUGP("func_group4_mask = 0x%02x\n", buf[0x07]);
1171 /* Maximum current consumption, check whether current is acceptable;
1172 * bit[511:496] = 0x0000 means some error happaned.
1174 u16 cc = ((u16)buf[0] << 8) | buf[1];
1175 RTSX_DEBUGP("Maximum current consumption: %dmA\n", cc);
1176 if ((cc == 0) || (cc > 800)) {
1177 TRACE_RET(chip, STATUS_FAIL);
1179 retval = sd_query_switch_result(chip, func_group, func_to_switch, buf, 64);
1180 if (retval != STATUS_SUCCESS) {
1181 TRACE_RET(chip, STATUS_FAIL);
1184 if ((cc > 400) || (func_to_switch > CURRENT_LIMIT_400)) {
1185 RTSX_WRITE_REG(chip, OCPPARA2, SD_OCP_THD_MASK, chip->sd_800mA_ocp_thd);
1186 RTSX_WRITE_REG(chip, CARD_PWR_CTL, PMOS_STRG_MASK, PMOS_STRG_800mA);
1190 return STATUS_SUCCESS;
1193 static u8 downgrade_switch_mode(u8 func_group, u8 func_to_switch)
1195 if (func_group == SD_FUNC_GROUP_1) {
1196 if (func_to_switch > HS_SUPPORT) {
1199 } else if (func_group == SD_FUNC_GROUP_4) {
1200 if (func_to_switch > CURRENT_LIMIT_200) {
1205 return func_to_switch;
1208 static int sd_check_switch(struct rtsx_chip *chip,
1209 u8 func_group, u8 func_to_switch, u8 bus_width)
1213 int switch_good = 0;
1215 for (i = 0; i < 3; i++) {
1216 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
1217 sd_set_err_code(chip, SD_NO_CARD);
1218 TRACE_RET(chip, STATUS_FAIL);
1221 retval = sd_check_switch_mode(chip, SD_CHECK_MODE, func_group,
1222 func_to_switch, bus_width);
1223 if (retval == STATUS_SUCCESS) {
1226 retval = sd_check_switch_mode(chip, SD_SWITCH_MODE,
1227 func_group, func_to_switch, bus_width);
1228 if (retval == STATUS_SUCCESS) {
1233 RTSX_READ_REG(chip, SD_STAT1, &stat);
1234 if (stat & SD_CRC16_ERR) {
1235 RTSX_DEBUGP("SD CRC16 error when switching mode\n");
1236 TRACE_RET(chip, STATUS_FAIL);
1240 func_to_switch = downgrade_switch_mode(func_group, func_to_switch);
1246 TRACE_RET(chip, STATUS_FAIL);
1249 return STATUS_SUCCESS;
1252 static int sd_switch_function(struct rtsx_chip *chip, u8 bus_width)
1254 struct sd_info *sd_card = &(chip->sd_card);
1257 u8 func_to_switch = 0;
1259 /* Get supported functions */
1260 retval = sd_check_switch_mode(chip, SD_CHECK_MODE,
1261 NO_ARGUMENT, NO_ARGUMENT, bus_width);
1262 if (retval != STATUS_SUCCESS) {
1263 TRACE_RET(chip, STATUS_FAIL);
1266 sd_card->func_group1_mask &= ~(sd_card->sd_switch_fail);
1268 /* Function Group 1: Access Mode */
1269 for (i = 0; i < 4; i++) {
1270 switch ((u8)(chip->sd_speed_prior >> (i*8))) {
1271 case SDR104_SUPPORT:
1272 if ((sd_card->func_group1_mask & SDR104_SUPPORT_MASK)
1273 && chip->sdr104_en) {
1274 func_to_switch = SDR104_SUPPORT;
1279 if ((sd_card->func_group1_mask & DDR50_SUPPORT_MASK)
1280 && chip->ddr50_en) {
1281 func_to_switch = DDR50_SUPPORT;
1286 if ((sd_card->func_group1_mask & SDR50_SUPPORT_MASK)
1287 && chip->sdr50_en) {
1288 func_to_switch = SDR50_SUPPORT;
1293 if (sd_card->func_group1_mask & HS_SUPPORT_MASK) {
1294 func_to_switch = HS_SUPPORT;
1303 if (func_to_switch) {
1307 RTSX_DEBUGP("SD_FUNC_GROUP_1: func_to_switch = 0x%02x", func_to_switch);
1309 #ifdef SUPPORT_SD_LOCK
1310 if ((sd_card->sd_lock_status & SD_SDR_RST)
1311 && (DDR50_SUPPORT == func_to_switch)
1312 && (sd_card->func_group1_mask & SDR50_SUPPORT_MASK)) {
1313 func_to_switch = SDR50_SUPPORT;
1314 RTSX_DEBUGP("Using SDR50 instead of DDR50 for SD Lock\n");
1318 if (func_to_switch) {
1319 retval = sd_check_switch(chip, SD_FUNC_GROUP_1, func_to_switch, bus_width);
1320 if (retval != STATUS_SUCCESS) {
1321 if (func_to_switch == SDR104_SUPPORT) {
1322 sd_card->sd_switch_fail = SDR104_SUPPORT_MASK;
1323 } else if (func_to_switch == DDR50_SUPPORT) {
1324 sd_card->sd_switch_fail =
1325 SDR104_SUPPORT_MASK | DDR50_SUPPORT_MASK;
1326 } else if (func_to_switch == SDR50_SUPPORT) {
1327 sd_card->sd_switch_fail =
1328 SDR104_SUPPORT_MASK | DDR50_SUPPORT_MASK |
1331 TRACE_RET(chip, STATUS_FAIL);
1334 if (func_to_switch == SDR104_SUPPORT) {
1335 SET_SD_SDR104(sd_card);
1336 } else if (func_to_switch == DDR50_SUPPORT) {
1337 SET_SD_DDR50(sd_card);
1338 } else if (func_to_switch == SDR50_SUPPORT) {
1339 SET_SD_SDR50(sd_card);
1345 if (CHK_SD_DDR50(sd_card)) {
1346 RTSX_WRITE_REG(chip, SD_PUSH_POINT_CTL, 0x06, 0x04);
1347 retval = sd_set_sample_push_timing(chip);
1348 if (retval != STATUS_SUCCESS) {
1349 TRACE_RET(chip, STATUS_FAIL);
1353 if (!func_to_switch || (func_to_switch == HS_SUPPORT)) {
1354 /* Do not try to switch current limit if the card doesn't
1355 * support UHS mode or we don't want it to support UHS mode
1357 return STATUS_SUCCESS;
1360 /* Function Group 4: Current Limit */
1361 func_to_switch = 0xFF;
1363 for (i = 0; i < 4; i++) {
1364 switch ((u8)(chip->sd_current_prior >> (i*8))) {
1365 case CURRENT_LIMIT_800:
1366 if (sd_card->func_group4_mask & CURRENT_LIMIT_800_MASK) {
1367 func_to_switch = CURRENT_LIMIT_800;
1371 case CURRENT_LIMIT_600:
1372 if (sd_card->func_group4_mask & CURRENT_LIMIT_600_MASK) {
1373 func_to_switch = CURRENT_LIMIT_600;
1377 case CURRENT_LIMIT_400:
1378 if (sd_card->func_group4_mask & CURRENT_LIMIT_400_MASK) {
1379 func_to_switch = CURRENT_LIMIT_400;
1383 case CURRENT_LIMIT_200:
1384 if (sd_card->func_group4_mask & CURRENT_LIMIT_200_MASK) {
1385 func_to_switch = CURRENT_LIMIT_200;
1393 if (func_to_switch != 0xFF) {
1398 RTSX_DEBUGP("SD_FUNC_GROUP_4: func_to_switch = 0x%02x", func_to_switch);
1400 if (func_to_switch <= CURRENT_LIMIT_800) {
1401 retval = sd_check_switch(chip, SD_FUNC_GROUP_4, func_to_switch, bus_width);
1402 if (retval != STATUS_SUCCESS) {
1403 if (sd_check_err_code(chip, SD_NO_CARD)) {
1404 TRACE_RET(chip, STATUS_FAIL);
1407 RTSX_DEBUGP("Switch current limit finished! (%d)\n", retval);
1410 if (CHK_SD_DDR50(sd_card)) {
1411 RTSX_WRITE_REG(chip, SD_PUSH_POINT_CTL, 0x06, 0);
1414 return STATUS_SUCCESS;
1417 static int sd_wait_data_idle(struct rtsx_chip *chip)
1419 int retval = STATUS_TIMEDOUT;
1423 for (i = 0; i < 100; i++) {
1424 RTSX_READ_REG(chip, SD_DATA_STATE, &val);
1425 if (val & SD_DATA_IDLE) {
1426 retval = STATUS_SUCCESS;
1431 RTSX_DEBUGP("SD_DATA_STATE: 0x%02x\n", val);
1436 static int sd_sdr_tuning_rx_cmd(struct rtsx_chip *chip, u8 sample_point)
1441 retval = sd_change_phase(chip, sample_point, TUNE_RX);
1442 if (retval != STATUS_SUCCESS) {
1443 TRACE_RET(chip, STATUS_FAIL);
1446 cmd[0] = 0x40 | SEND_TUNING_PATTERN;
1452 retval = sd_read_data(chip, SD_TM_AUTO_TUNING,
1453 cmd, 5, 0x40, 1, SD_BUS_WIDTH_4, NULL, 0, 100);
1454 if (retval != STATUS_SUCCESS) {
1455 (void)sd_wait_data_idle(chip);
1457 rtsx_clear_sd_error(chip);
1458 TRACE_RET(chip, STATUS_FAIL);
1461 return STATUS_SUCCESS;
1464 static int sd_ddr_tuning_rx_cmd(struct rtsx_chip *chip, u8 sample_point)
1466 struct sd_info *sd_card = &(chip->sd_card);
1470 retval = sd_change_phase(chip, sample_point, TUNE_RX);
1471 if (retval != STATUS_SUCCESS) {
1472 TRACE_RET(chip, STATUS_FAIL);
1475 RTSX_DEBUGP("sd ddr tuning rx\n");
1477 retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
1478 if (retval != STATUS_SUCCESS) {
1479 TRACE_RET(chip, STATUS_FAIL);
1482 cmd[0] = 0x40 | SD_STATUS;
1488 retval = sd_read_data(chip, SD_TM_NORMAL_READ,
1489 cmd, 5, 64, 1, SD_BUS_WIDTH_4, NULL, 0, 100);
1490 if (retval != STATUS_SUCCESS) {
1491 (void)sd_wait_data_idle(chip);
1493 rtsx_clear_sd_error(chip);
1494 TRACE_RET(chip, STATUS_FAIL);
1497 return STATUS_SUCCESS;
1500 static int mmc_ddr_tunning_rx_cmd(struct rtsx_chip *chip, u8 sample_point)
1502 struct sd_info *sd_card = &(chip->sd_card);
1504 u8 cmd[5], bus_width;
1506 if (CHK_MMC_8BIT(sd_card)) {
1507 bus_width = SD_BUS_WIDTH_8;
1508 } else if (CHK_MMC_4BIT(sd_card)) {
1509 bus_width = SD_BUS_WIDTH_4;
1511 bus_width = SD_BUS_WIDTH_1;
1514 retval = sd_change_phase(chip, sample_point, TUNE_RX);
1515 if (retval != STATUS_SUCCESS) {
1516 TRACE_RET(chip, STATUS_FAIL);
1519 RTSX_DEBUGP("mmc ddr tuning rx\n");
1521 cmd[0] = 0x40 | SEND_EXT_CSD;
1527 retval = sd_read_data(chip, SD_TM_NORMAL_READ,
1528 cmd, 5, 0x200, 1, bus_width, NULL, 0, 100);
1529 if (retval != STATUS_SUCCESS) {
1530 (void)sd_wait_data_idle(chip);
1532 rtsx_clear_sd_error(chip);
1533 TRACE_RET(chip, STATUS_FAIL);
1536 return STATUS_SUCCESS;
1539 static int sd_sdr_tuning_tx_cmd(struct rtsx_chip *chip, u8 sample_point)
1541 struct sd_info *sd_card = &(chip->sd_card);
1544 retval = sd_change_phase(chip, sample_point, TUNE_TX);
1545 if (retval != STATUS_SUCCESS) {
1546 TRACE_RET(chip, STATUS_FAIL);
1549 RTSX_WRITE_REG(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, SD_RSP_80CLK_TIMEOUT_EN);
1551 retval = sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
1552 SD_RSP_TYPE_R1, NULL, 0);
1553 if (retval != STATUS_SUCCESS) {
1554 if (sd_check_err_code(chip, SD_RSP_TIMEOUT)) {
1555 rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, 0);
1556 TRACE_RET(chip, STATUS_FAIL);
1560 RTSX_WRITE_REG(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, 0);
1562 return STATUS_SUCCESS;
1565 static int sd_ddr_tuning_tx_cmd(struct rtsx_chip *chip, u8 sample_point)
1567 struct sd_info *sd_card = &(chip->sd_card);
1569 u8 cmd[5], bus_width;
1571 retval = sd_change_phase(chip, sample_point, TUNE_TX);
1572 if (retval != STATUS_SUCCESS) {
1573 TRACE_RET(chip, STATUS_FAIL);
1576 if (CHK_SD(sd_card)) {
1577 bus_width = SD_BUS_WIDTH_4;
1579 if (CHK_MMC_8BIT(sd_card)) {
1580 bus_width = SD_BUS_WIDTH_8;
1581 } else if (CHK_MMC_4BIT(sd_card)) {
1582 bus_width = SD_BUS_WIDTH_4;
1584 bus_width = SD_BUS_WIDTH_1;
1588 retval = sd_wait_state_data_ready(chip, 0x08, 1, 1000);
1589 if (retval != STATUS_SUCCESS) {
1590 TRACE_RET(chip, STATUS_FAIL);
1593 RTSX_WRITE_REG(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, SD_RSP_80CLK_TIMEOUT_EN);
1595 cmd[0] = 0x40 | PROGRAM_CSD;
1601 retval = sd_write_data(chip, SD_TM_AUTO_WRITE_2,
1602 cmd, 5, 16, 1, bus_width, sd_card->raw_csd, 16, 100);
1603 if (retval != STATUS_SUCCESS) {
1604 rtsx_clear_sd_error(chip);
1605 rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, 0);
1606 TRACE_RET(chip, STATUS_FAIL);
1609 RTSX_WRITE_REG(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, 0);
1611 sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
1613 return STATUS_SUCCESS;
1616 static u8 sd_search_final_phase(struct rtsx_chip *chip, u32 phase_map, u8 tune_dir)
1618 struct sd_info *sd_card = &(chip->sd_card);
1619 struct timing_phase_path path[MAX_PHASE + 1];
1620 int i, j, cont_path_cnt;
1621 int new_block, max_len, final_path_idx;
1622 u8 final_phase = 0xFF;
1624 if (phase_map == 0xFFFFFFFF) {
1625 if (tune_dir == TUNE_RX) {
1626 final_phase = (u8)chip->sd_default_rx_phase;
1628 final_phase = (u8)chip->sd_default_tx_phase;
1637 for (i = 0; i < MAX_PHASE + 1; i++) {
1638 if (phase_map & (1 << i)) {
1641 j = cont_path_cnt++;
1649 if (cont_path_cnt) {
1650 int idx = cont_path_cnt - 1;
1651 path[idx].len = path[idx].end - path[idx].start + 1;
1652 path[idx].mid = path[idx].start + path[idx].len / 2;
1657 if (cont_path_cnt == 0) {
1658 RTSX_DEBUGP("No continuous phase path\n");
1661 int idx = cont_path_cnt - 1;
1662 path[idx].len = path[idx].end - path[idx].start + 1;
1663 path[idx].mid = path[idx].start + path[idx].len / 2;
1666 if ((path[0].start == 0) && (path[cont_path_cnt - 1].end == MAX_PHASE)) {
1667 path[0].start = path[cont_path_cnt - 1].start - MAX_PHASE - 1;
1668 path[0].len += path[cont_path_cnt - 1].len;
1669 path[0].mid = path[0].start + path[0].len / 2;
1670 if (path[0].mid < 0) {
1671 path[0].mid += MAX_PHASE + 1;
1679 for (i = 0; i < cont_path_cnt; i++) {
1680 if (path[i].len > max_len) {
1681 max_len = path[i].len;
1682 final_phase = (u8)path[i].mid;
1686 RTSX_DEBUGP("path[%d].start = %d\n", i, path[i].start);
1687 RTSX_DEBUGP("path[%d].end = %d\n", i, path[i].end);
1688 RTSX_DEBUGP("path[%d].len = %d\n", i, path[i].len);
1689 RTSX_DEBUGP("path[%d].mid = %d\n", i, path[i].mid);
1693 if (tune_dir == TUNE_TX) {
1694 if (CHK_SD_SDR104(sd_card)) {
1696 int temp_mid = (max_len - 16) / 2;
1697 int temp_final_phase =
1698 path[final_path_idx].end - (max_len - (6 + temp_mid));
1700 if (temp_final_phase < 0) {
1701 final_phase = (u8)(temp_final_phase + MAX_PHASE + 1);
1703 final_phase = (u8)temp_final_phase;
1706 } else if (CHK_SD_SDR50(sd_card)) {
1708 int temp_mid = (max_len - 13) / 2;
1709 int temp_final_phase =
1710 path[final_path_idx].end - (max_len - (3 + temp_mid));
1712 if (temp_final_phase < 0) {
1713 final_phase = (u8)(temp_final_phase + MAX_PHASE + 1);
1715 final_phase = (u8)temp_final_phase;
1722 RTSX_DEBUGP("Final chosen phase: %d\n", final_phase);
1726 static int sd_tuning_rx(struct rtsx_chip *chip)
1728 struct sd_info *sd_card = &(chip->sd_card);
1731 u32 raw_phase_map[3], phase_map;
1733 int (*tuning_cmd)(struct rtsx_chip *chip, u8 sample_point);
1735 if (CHK_SD(sd_card)) {
1736 if (CHK_SD_DDR50(sd_card)) {
1737 tuning_cmd = sd_ddr_tuning_rx_cmd;
1739 tuning_cmd = sd_sdr_tuning_rx_cmd;
1742 if (CHK_MMC_DDR52(sd_card)) {
1743 tuning_cmd = mmc_ddr_tunning_rx_cmd;
1745 TRACE_RET(chip, STATUS_FAIL);
1749 for (i = 0; i < 3; i++) {
1750 raw_phase_map[i] = 0;
1751 for (j = MAX_PHASE; j >= 0; j--) {
1752 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
1753 sd_set_err_code(chip, SD_NO_CARD);
1754 TRACE_RET(chip, STATUS_FAIL);
1757 retval = tuning_cmd(chip, (u8)j);
1758 if (retval == STATUS_SUCCESS) {
1759 raw_phase_map[i] |= 1 << j;
1764 phase_map = raw_phase_map[0] & raw_phase_map[1] & raw_phase_map[2];
1765 for (i = 0; i < 3; i++) {
1766 RTSX_DEBUGP("RX raw_phase_map[%d] = 0x%08x\n", i, raw_phase_map[i]);
1768 RTSX_DEBUGP("RX phase_map = 0x%08x\n", phase_map);
1770 final_phase = sd_search_final_phase(chip, phase_map, TUNE_RX);
1771 if (final_phase == 0xFF) {
1772 TRACE_RET(chip, STATUS_FAIL);
1775 retval = sd_change_phase(chip, final_phase, TUNE_RX);
1776 if (retval != STATUS_SUCCESS) {
1777 TRACE_RET(chip, STATUS_FAIL);
1780 return STATUS_SUCCESS;
1783 static int sd_ddr_pre_tuning_tx(struct rtsx_chip *chip)
1785 struct sd_info *sd_card = &(chip->sd_card);
1791 RTSX_WRITE_REG(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, SD_RSP_80CLK_TIMEOUT_EN);
1794 for (i = MAX_PHASE; i >= 0; i--) {
1795 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
1796 sd_set_err_code(chip, SD_NO_CARD);
1797 rtsx_write_register(chip, SD_CFG3,
1798 SD_RSP_80CLK_TIMEOUT_EN, 0);
1799 TRACE_RET(chip, STATUS_FAIL);
1802 retval = sd_change_phase(chip, (u8)i, TUNE_TX);
1803 if (retval != STATUS_SUCCESS) {
1807 retval = sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
1808 SD_RSP_TYPE_R1, NULL, 0);
1809 if ((retval == STATUS_SUCCESS) || !sd_check_err_code(chip, SD_RSP_TIMEOUT)) {
1810 phase_map |= 1 << i;
1814 RTSX_WRITE_REG(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, 0);
1816 RTSX_DEBUGP("DDR TX pre tune phase_map = 0x%08x\n", phase_map);
1818 final_phase = sd_search_final_phase(chip, phase_map, TUNE_TX);
1819 if (final_phase == 0xFF) {
1820 TRACE_RET(chip, STATUS_FAIL);
1823 retval = sd_change_phase(chip, final_phase, TUNE_TX);
1824 if (retval != STATUS_SUCCESS) {
1825 TRACE_RET(chip, STATUS_FAIL);
1828 RTSX_DEBUGP("DDR TX pre tune phase: %d\n", (int)final_phase);
1830 return STATUS_SUCCESS;
1833 static int sd_tuning_tx(struct rtsx_chip *chip)
1835 struct sd_info *sd_card = &(chip->sd_card);
1838 u32 raw_phase_map[3], phase_map;
1840 int (*tuning_cmd)(struct rtsx_chip *chip, u8 sample_point);
1842 if (CHK_SD(sd_card)) {
1843 if (CHK_SD_DDR50(sd_card)) {
1844 tuning_cmd = sd_ddr_tuning_tx_cmd;
1846 tuning_cmd = sd_sdr_tuning_tx_cmd;
1849 if (CHK_MMC_DDR52(sd_card)) {
1850 tuning_cmd = sd_ddr_tuning_tx_cmd;
1852 TRACE_RET(chip, STATUS_FAIL);
1856 for (i = 0; i < 3; i++) {
1857 raw_phase_map[i] = 0;
1858 for (j = MAX_PHASE; j >= 0; j--) {
1859 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
1860 sd_set_err_code(chip, SD_NO_CARD);
1861 rtsx_write_register(chip, SD_CFG3,
1862 SD_RSP_80CLK_TIMEOUT_EN, 0);
1863 TRACE_RET(chip, STATUS_FAIL);
1866 retval = tuning_cmd(chip, (u8)j);
1867 if (retval == STATUS_SUCCESS) {
1868 raw_phase_map[i] |= 1 << j;
1873 phase_map = raw_phase_map[0] & raw_phase_map[1] & raw_phase_map[2];
1874 for (i = 0; i < 3; i++) {
1875 RTSX_DEBUGP("TX raw_phase_map[%d] = 0x%08x\n", i, raw_phase_map[i]);
1877 RTSX_DEBUGP("TX phase_map = 0x%08x\n", phase_map);
1879 final_phase = sd_search_final_phase(chip, phase_map, TUNE_TX);
1880 if (final_phase == 0xFF) {
1881 TRACE_RET(chip, STATUS_FAIL);
1884 retval = sd_change_phase(chip, final_phase, TUNE_TX);
1885 if (retval != STATUS_SUCCESS) {
1886 TRACE_RET(chip, STATUS_FAIL);
1889 return STATUS_SUCCESS;
1892 static int sd_sdr_tuning(struct rtsx_chip *chip)
1896 retval = sd_tuning_tx(chip);
1897 if (retval != STATUS_SUCCESS) {
1898 TRACE_RET(chip, STATUS_FAIL);
1901 retval = sd_tuning_rx(chip);
1902 if (retval != STATUS_SUCCESS) {
1903 TRACE_RET(chip, STATUS_FAIL);
1906 return STATUS_SUCCESS;
1909 static int sd_ddr_tuning(struct rtsx_chip *chip)
1913 if (!(chip->sd_ctl & SD_DDR_TX_PHASE_SET_BY_USER)) {
1914 retval = sd_ddr_pre_tuning_tx(chip);
1915 if (retval != STATUS_SUCCESS) {
1916 TRACE_RET(chip, STATUS_FAIL);
1919 retval = sd_change_phase(chip, (u8)chip->sd_ddr_tx_phase, TUNE_TX);
1920 if (retval != STATUS_SUCCESS) {
1921 TRACE_RET(chip, STATUS_FAIL);
1925 retval = sd_tuning_rx(chip);
1926 if (retval != STATUS_SUCCESS) {
1927 TRACE_RET(chip, STATUS_FAIL);
1930 if (!(chip->sd_ctl & SD_DDR_TX_PHASE_SET_BY_USER)) {
1931 retval = sd_tuning_tx(chip);
1932 if (retval != STATUS_SUCCESS) {
1933 TRACE_RET(chip, STATUS_FAIL);
1937 return STATUS_SUCCESS;
1940 static int mmc_ddr_tuning(struct rtsx_chip *chip)
1944 if (!(chip->sd_ctl & MMC_DDR_TX_PHASE_SET_BY_USER)) {
1945 retval = sd_ddr_pre_tuning_tx(chip);
1946 if (retval != STATUS_SUCCESS) {
1947 TRACE_RET(chip, STATUS_FAIL);
1950 retval = sd_change_phase(chip, (u8)chip->mmc_ddr_tx_phase, TUNE_TX);
1951 if (retval != STATUS_SUCCESS) {
1952 TRACE_RET(chip, STATUS_FAIL);
1956 retval = sd_tuning_rx(chip);
1957 if (retval != STATUS_SUCCESS) {
1958 TRACE_RET(chip, STATUS_FAIL);
1961 if (!(chip->sd_ctl & MMC_DDR_TX_PHASE_SET_BY_USER)) {
1962 retval = sd_tuning_tx(chip);
1963 if (retval != STATUS_SUCCESS) {
1964 TRACE_RET(chip, STATUS_FAIL);
1968 return STATUS_SUCCESS;
1971 int sd_switch_clock(struct rtsx_chip *chip)
1973 struct sd_info *sd_card = &(chip->sd_card);
1977 retval = select_card(chip, SD_CARD);
1978 if (retval != STATUS_SUCCESS) {
1979 TRACE_RET(chip, STATUS_FAIL);
1982 if (CHECK_PID(chip, 0x5209) &&
1983 (CHK_SD30_SPEED(sd_card) || CHK_MMC_DDR52(sd_card))) {
1984 if (sd_card->need_retune && (sd_card->sd_clock != chip->cur_clk)) {
1986 sd_card->need_retune = 0;
1990 retval = switch_clock(chip, sd_card->sd_clock);
1991 if (retval != STATUS_SUCCESS) {
1992 TRACE_RET(chip, STATUS_FAIL);
1996 if (CHK_SD(sd_card)) {
1997 if (CHK_SD_DDR50(sd_card)) {
1998 retval = sd_ddr_tuning(chip);
2000 retval = sd_sdr_tuning(chip);
2003 if (CHK_MMC_DDR52(sd_card)) {
2004 retval = mmc_ddr_tuning(chip);
2008 if (retval != STATUS_SUCCESS) {
2009 TRACE_RET(chip, STATUS_FAIL);
2013 return STATUS_SUCCESS;
2016 static int sd_prepare_reset(struct rtsx_chip *chip)
2018 struct sd_info *sd_card = &(chip->sd_card);
2021 if (chip->asic_code) {
2022 sd_card->sd_clock = 29;
2024 sd_card->sd_clock = CLK_30;
2027 sd_card->sd_type = 0;
2028 sd_card->seq_mode = 0;
2029 sd_card->sd_data_buf_ready = 0;
2030 sd_card->capacity = 0;
2032 #ifdef SUPPORT_SD_LOCK
2033 sd_card->sd_lock_status = 0;
2034 sd_card->sd_erase_status = 0;
2037 chip->capacity[chip->card2lun[SD_CARD]] = 0;
2040 retval = sd_set_init_para(chip);
2041 if (retval != STATUS_SUCCESS) {
2042 TRACE_RET(chip, retval);
2045 if (CHECK_PID(chip, 0x5209)) {
2046 RTSX_WRITE_REG(chip, REG_SD_CFG1, 0xFF,
2047 SD_CLK_DIVIDE_128 | SD_20_MODE | SD_BUS_WIDTH_1);
2048 RTSX_WRITE_REG(chip, SD_SAMPLE_POINT_CTL, 0xFF, SD20_RX_POS_EDGE);
2049 RTSX_WRITE_REG(chip, SD_PUSH_POINT_CTL, 0xFF, 0);
2051 RTSX_WRITE_REG(chip, REG_SD_CFG1, 0xFF, 0x40);
2054 RTSX_WRITE_REG(chip, CARD_STOP, SD_STOP | SD_CLR_ERR, SD_STOP | SD_CLR_ERR);
2056 retval = select_card(chip, SD_CARD);
2057 if (retval != STATUS_SUCCESS) {
2058 TRACE_RET(chip, STATUS_FAIL);
2061 return STATUS_SUCCESS;
2064 static int sd_pull_ctl_disable(struct rtsx_chip *chip)
2066 if (CHECK_PID(chip, 0x5209)) {
2067 RTSX_WRITE_REG(chip, CARD_PULL_CTL1, 0xFF, 0x55);
2068 RTSX_WRITE_REG(chip, CARD_PULL_CTL2, 0xFF, 0x55);
2069 RTSX_WRITE_REG(chip, CARD_PULL_CTL3, 0xFF, 0xD5);
2070 } else if (CHECK_PID(chip, 0x5208)) {
2071 RTSX_WRITE_REG(chip, CARD_PULL_CTL1, 0xFF,
2072 XD_D3_PD | SD_D7_PD | SD_CLK_PD | SD_D5_PD);
2073 RTSX_WRITE_REG(chip, CARD_PULL_CTL2, 0xFF,
2074 SD_D6_PD | SD_D0_PD | SD_D1_PD | XD_D5_PD);
2075 RTSX_WRITE_REG(chip, CARD_PULL_CTL3, 0xFF,
2076 SD_D4_PD | XD_CE_PD | XD_CLE_PD | XD_CD_PU);
2077 RTSX_WRITE_REG(chip, CARD_PULL_CTL4, 0xFF,
2078 XD_RDY_PD | SD_D3_PD | SD_D2_PD | XD_ALE_PD);
2079 RTSX_WRITE_REG(chip, CARD_PULL_CTL5, 0xFF,
2080 MS_INS_PU | SD_WP_PD | SD_CD_PU | SD_CMD_PD);
2081 RTSX_WRITE_REG(chip, CARD_PULL_CTL6, 0xFF, MS_D5_PD | MS_D4_PD);
2082 } else if (CHECK_PID(chip, 0x5288)) {
2083 if (CHECK_BARO_PKG(chip, QFN)) {
2084 RTSX_WRITE_REG(chip, CARD_PULL_CTL1, 0xFF, 0x55);
2085 RTSX_WRITE_REG(chip, CARD_PULL_CTL2, 0xFF, 0x55);
2086 RTSX_WRITE_REG(chip, CARD_PULL_CTL3, 0xFF, 0x4B);
2087 RTSX_WRITE_REG(chip, CARD_PULL_CTL4, 0xFF, 0x69);
2091 return STATUS_SUCCESS;
2094 int sd_pull_ctl_enable(struct rtsx_chip *chip)
2098 rtsx_init_cmd(chip);
2100 if (CHECK_PID(chip, 0x5209)) {
2101 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0xAA);
2102 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0xAA);
2103 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0xE9);
2104 } else if (CHECK_PID(chip, 0x5208)) {
2105 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF,
2106 XD_D3_PD | SD_DAT7_PU | SD_CLK_NP | SD_D5_PU);
2107 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF,
2108 SD_D6_PU | SD_D0_PU | SD_D1_PU | XD_D5_PD);
2109 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF,
2110 SD_D4_PU | XD_CE_PD | XD_CLE_PD | XD_CD_PU);
2111 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF,
2112 XD_RDY_PD | SD_D3_PU | SD_D2_PU | XD_ALE_PD);
2113 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF,
2114 MS_INS_PU | SD_WP_PU | SD_CD_PU | SD_CMD_PU);
2115 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, MS_D5_PD | MS_D4_PD);
2116 } else if (CHECK_PID(chip, 0x5288)) {
2117 if (CHECK_BARO_PKG(chip, QFN)) {
2118 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0xA8);
2119 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x5A);
2120 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0x95);
2121 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0xAA);
2125 retval = rtsx_send_cmd(chip, SD_CARD, 100);
2127 TRACE_RET(chip, STATUS_FAIL);
2130 return STATUS_SUCCESS;
2133 static int sd_init_power(struct rtsx_chip *chip)
2137 if (CHECK_PID(chip, 0x5209)) {
2138 RTSX_WRITE_REG(chip, PWR_GATE_CTRL, LDO3318_PWR_MASK, LDO_OFF);
2141 retval = sd_power_off_card3v3(chip);
2142 if (retval != STATUS_SUCCESS) {
2143 TRACE_RET(chip, STATUS_FAIL);
2146 if (!chip->ft2_fast_mode) {
2150 retval = enable_card_clock(chip, SD_CARD);
2151 if (retval != STATUS_SUCCESS) {
2152 TRACE_RET(chip, STATUS_FAIL);
2155 if (chip->asic_code) {
2156 retval = sd_pull_ctl_enable(chip);
2157 if (retval != STATUS_SUCCESS) {
2158 TRACE_RET(chip, STATUS_FAIL);
2161 RTSX_WRITE_REG(chip, FPGA_PULL_CTL, FPGA_SD_PULL_CTL_BIT | 0x20, 0);
2164 if (chip->ft2_fast_mode) {
2165 if (CHECK_PID(chip, 0x5209)) {
2166 RTSX_WRITE_REG(chip, PWR_GATE_CTRL, LDO3318_PWR_MASK, LDO_ON);
2169 retval = card_power_on(chip, SD_CARD);
2170 if (retval != STATUS_SUCCESS) {
2171 TRACE_RET(chip, STATUS_FAIL);
2176 if (chip->ocp_stat & (SD_OC_NOW | SD_OC_EVER)) {
2177 RTSX_DEBUGP("Over current, OCPSTAT is 0x%x\n", chip->ocp_stat);
2178 TRACE_RET(chip, STATUS_FAIL);
2183 RTSX_WRITE_REG(chip, CARD_OE, SD_OUTPUT_EN, SD_OUTPUT_EN);
2185 return STATUS_SUCCESS;
2188 static int sd_dummy_clock(struct rtsx_chip *chip)
2190 if (CHECK_PID(chip, 0x5209)) {
2191 RTSX_WRITE_REG(chip, SD_BUS_STAT, SD_CLK_TOGGLE_EN, SD_CLK_TOGGLE_EN);
2193 RTSX_WRITE_REG(chip, SD_BUS_STAT, SD_CLK_TOGGLE_EN, 0x00);
2195 RTSX_WRITE_REG(chip, REG_SD_CFG3, 0x01, 0x01);
2197 RTSX_WRITE_REG(chip, REG_SD_CFG3, 0x01, 0);
2200 return STATUS_SUCCESS;
2203 static int sd_read_lba0(struct rtsx_chip *chip)
2205 struct sd_info *sd_card = &(chip->sd_card);
2207 u8 cmd[5], bus_width;
2209 cmd[0] = 0x40 | READ_SINGLE_BLOCK;
2215 if (CHK_SD(sd_card)) {
2216 bus_width = SD_BUS_WIDTH_4;
2218 if (CHK_MMC_8BIT(sd_card)) {
2219 bus_width = SD_BUS_WIDTH_8;
2220 } else if (CHK_MMC_4BIT(sd_card)) {
2221 bus_width = SD_BUS_WIDTH_4;
2223 bus_width = SD_BUS_WIDTH_1;
2227 retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd,
2228 5, 512, 1, bus_width, NULL, 0, 100);
2229 if (retval != STATUS_SUCCESS) {
2230 rtsx_clear_sd_error(chip);
2231 TRACE_RET(chip, STATUS_FAIL);
2234 return STATUS_SUCCESS;
2237 static int sd_check_wp_state(struct rtsx_chip *chip)
2239 struct sd_info *sd_card = &(chip->sd_card);
2245 retval = sd_send_cmd_get_rsp(chip, APP_CMD,
2246 sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
2247 if (retval != STATUS_SUCCESS) {
2248 TRACE_RET(chip, STATUS_FAIL);
2251 cmd[0] = 0x40 | SD_STATUS;
2257 retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd, 5, 64, 1, SD_BUS_WIDTH_4, buf, 64, 250);
2258 if (retval != STATUS_SUCCESS) {
2259 rtsx_clear_sd_error(chip);
2261 sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
2262 TRACE_RET(chip, STATUS_FAIL);
2265 RTSX_DEBUGP("ACMD13:\n");
2268 sd_card_type = ((u16)buf[2] << 8) | buf[3];
2269 RTSX_DEBUGP("sd_card_type = 0x%04x\n", sd_card_type);
2270 if ((sd_card_type == 0x0001) || (sd_card_type == 0x0002)) {
2271 /* ROM card or OTP */
2272 chip->card_wp |= SD_CARD;
2275 /* Check SD Machanical Write-Protect Switch */
2276 val = rtsx_readl(chip, RTSX_BIPR);
2277 if (val & SD_WRITE_PROTECT) {
2278 chip->card_wp |= SD_CARD;
2281 return STATUS_SUCCESS;
2284 static int reset_sd(struct rtsx_chip *chip)
2286 struct sd_info *sd_card = &(chip->sd_card);
2287 int retval, i = 0, j = 0, k = 0, hi_cap_flow = 0;
2288 int sd_dont_switch = 0;
2289 int support_1v8 = 0;
2292 u8 switch_bus_width;
2305 #ifdef SUPPORT_SD_LOCK
2306 if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON)
2307 goto SD_UNLOCK_ENTRY;
2310 retval = sd_prepare_reset(chip);
2311 if (retval != STATUS_SUCCESS) {
2312 TRACE_RET(chip, STATUS_FAIL);
2315 retval = sd_dummy_clock(chip);
2316 if (retval != STATUS_SUCCESS) {
2317 TRACE_RET(chip, STATUS_FAIL);
2320 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip) && try_sdio) {
2323 for (; rty_cnt < chip->sdio_retry_cnt; rty_cnt++) {
2324 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
2325 sd_set_err_code(chip, SD_NO_CARD);
2326 TRACE_RET(chip, STATUS_FAIL);
2329 retval = sd_send_cmd_get_rsp(chip, IO_SEND_OP_COND, 0, SD_RSP_TYPE_R4, rsp, 5);
2330 if (retval == STATUS_SUCCESS) {
2331 int func_num = (rsp[1] >> 4) & 0x07;
2333 RTSX_DEBUGP("SD_IO card (Function number: %d)!\n", func_num);
2335 TRACE_RET(chip, STATUS_FAIL);
2341 sd_init_power(chip);
2343 sd_dummy_clock(chip);
2346 RTSX_DEBUGP("Normal card!\n");
2349 /* Start Initialization Process of SD Card */
2351 retval = sd_send_cmd_get_rsp(chip, GO_IDLE_STATE, 0, SD_RSP_TYPE_R0, NULL, 0);
2352 if (retval != STATUS_SUCCESS) {
2353 TRACE_RET(chip, STATUS_FAIL);
2358 retval = sd_send_cmd_get_rsp(chip, SEND_IF_COND, 0x000001AA, SD_RSP_TYPE_R7, rsp, 5);
2359 if (retval == STATUS_SUCCESS) {
2360 if ((rsp[4] == 0xAA) && ((rsp[3] & 0x0f) == 0x01)) {
2362 if (CHECK_PID(chip, 0x5209)) {
2364 voltage = SUPPORT_VOLTAGE |
2365 SUPPORT_HIGH_AND_EXTENDED_CAPACITY;
2367 voltage = SUPPORT_VOLTAGE |
2368 SUPPORT_HIGH_AND_EXTENDED_CAPACITY |
2369 SUPPORT_MAX_POWER_PERMANCE | SUPPORT_1V8;
2372 voltage = SUPPORT_VOLTAGE | 0x40000000;
2378 voltage = SUPPORT_VOLTAGE;
2380 retval = sd_send_cmd_get_rsp(chip, GO_IDLE_STATE, 0, SD_RSP_TYPE_R0, NULL, 0);
2381 if (retval != STATUS_SUCCESS) {
2382 TRACE_RET(chip, STATUS_FAIL);
2389 retval = sd_send_cmd_get_rsp(chip, APP_CMD, 0, SD_RSP_TYPE_R1, NULL, 0);
2390 if (retval != STATUS_SUCCESS) {
2391 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
2392 sd_set_err_code(chip, SD_NO_CARD);
2393 TRACE_RET(chip, STATUS_FAIL);
2400 TRACE_RET(chip, STATUS_FAIL);
2404 retval = sd_send_cmd_get_rsp(chip, SD_APP_OP_COND, voltage, SD_RSP_TYPE_R3, rsp, 5);
2405 if (retval != STATUS_SUCCESS) {
2410 TRACE_RET(chip, STATUS_FAIL);
2416 } while (!(rsp[1] & 0x80) && (i < 255));
2419 TRACE_RET(chip, STATUS_FAIL);
2423 if (rsp[1] & 0x40) {
2424 SET_SD_HCXC(sd_card);
2426 CLR_SD_HCXC(sd_card);
2428 if (CHECK_PID(chip, 0x5209) && CHK_SD_HCXC(sd_card) && !sd20_mode) {
2429 support_1v8 = (rsp[1] & 0x01) ? 1 : 0;
2434 CLR_SD_HCXC(sd_card);
2437 RTSX_DEBUGP("support_1v8 = %d\n", support_1v8);
2440 retval = sd_voltage_switch(chip);
2441 if (retval != STATUS_SUCCESS) {
2442 TRACE_RET(chip, STATUS_FAIL);
2446 retval = sd_send_cmd_get_rsp(chip, ALL_SEND_CID, 0, SD_RSP_TYPE_R2, NULL, 0);
2447 if (retval != STATUS_SUCCESS) {
2448 TRACE_RET(chip, STATUS_FAIL);
2451 for (i = 0; i < 3; i++) {
2452 retval = sd_send_cmd_get_rsp(chip, SEND_RELATIVE_ADDR, 0, SD_RSP_TYPE_R6, rsp, 5);
2453 if (retval != STATUS_SUCCESS) {
2454 TRACE_RET(chip, STATUS_FAIL);
2457 sd_card->sd_addr = (u32)rsp[1] << 24;
2458 sd_card->sd_addr += (u32)rsp[2] << 16;
2460 if (sd_card->sd_addr) {
2465 retval = sd_check_csd(chip, 1);
2466 if (retval != STATUS_SUCCESS) {
2467 TRACE_RET(chip, STATUS_FAIL);
2470 retval = sd_select_card(chip, 1);
2471 if (retval != STATUS_SUCCESS) {
2472 TRACE_RET(chip, STATUS_FAIL);
2475 #ifdef SUPPORT_SD_LOCK
2477 retval = sd_update_lock_status(chip);
2478 if (retval != STATUS_SUCCESS) {
2479 TRACE_RET(chip, STATUS_FAIL);
2482 if (sd_card->sd_lock_status & SD_LOCKED) {
2483 sd_card->sd_lock_status |= (SD_LOCK_1BIT_MODE | SD_PWD_EXIST);
2484 return STATUS_SUCCESS;
2485 } else if (!(sd_card->sd_lock_status & SD_UNLOCK_POW_ON)) {
2486 sd_card->sd_lock_status &= ~SD_PWD_EXIST;
2490 retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
2491 if (retval != STATUS_SUCCESS) {
2492 TRACE_RET(chip, STATUS_FAIL);
2494 retval = sd_send_cmd_get_rsp(chip, SET_CLR_CARD_DETECT, 0, SD_RSP_TYPE_R1, NULL, 0);
2495 if (retval != STATUS_SUCCESS) {
2496 TRACE_RET(chip, STATUS_FAIL);
2500 retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
2501 if (retval != STATUS_SUCCESS) {
2502 TRACE_RET(chip, STATUS_FAIL);
2504 retval = sd_send_cmd_get_rsp(chip, SET_BUS_WIDTH, 2, SD_RSP_TYPE_R1, NULL, 0);
2505 if (retval != STATUS_SUCCESS) {
2506 TRACE_RET(chip, STATUS_FAIL);
2509 switch_bus_width = SD_BUS_WIDTH_4;
2511 switch_bus_width = SD_BUS_WIDTH_1;
2514 retval = sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200, SD_RSP_TYPE_R1, NULL, 0);
2515 if (retval != STATUS_SUCCESS) {
2516 TRACE_RET(chip, STATUS_FAIL);
2519 retval = sd_set_clock_divider(chip, SD_CLK_DIVIDE_0);
2520 if (retval != STATUS_SUCCESS) {
2521 TRACE_RET(chip, STATUS_FAIL);
2524 if (!(sd_card->raw_csd[4] & 0x40))
2527 if (!sd_dont_switch) {
2529 /* Set sd_switch_fail here, because we needn't
2530 * switch to UHS mode
2532 sd_card->sd_switch_fail = SDR104_SUPPORT_MASK |
2533 DDR50_SUPPORT_MASK | SDR50_SUPPORT_MASK;
2536 /* Check the card whether follow SD1.1 spec or higher */
2537 retval = sd_check_spec(chip, switch_bus_width);
2538 if (retval == STATUS_SUCCESS) {
2539 retval = sd_switch_function(chip, switch_bus_width);
2540 if (retval != STATUS_SUCCESS) {
2541 if (CHECK_PID(chip, 0x5209)) {
2542 sd_change_bank_voltage(chip, SD_IO_3V3);
2544 sd_init_power(chip);
2552 if (CHECK_PID(chip, 0x5209)) {
2553 sd_change_bank_voltage(chip, SD_IO_3V3);
2555 sd_init_power(chip);
2565 retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
2566 if (retval != STATUS_SUCCESS) {
2567 TRACE_RET(chip, STATUS_FAIL);
2569 retval = sd_send_cmd_get_rsp(chip, SET_BUS_WIDTH, 2, SD_RSP_TYPE_R1, NULL, 0);
2570 if (retval != STATUS_SUCCESS) {
2571 TRACE_RET(chip, STATUS_FAIL);
2575 #ifdef SUPPORT_SD_LOCK
2576 sd_card->sd_lock_status &= ~SD_LOCK_1BIT_MODE;
2579 if (!sd20_mode && CHK_SD30_SPEED(sd_card)) {
2582 RTSX_WRITE_REG(chip, SD30_DRIVE_SEL, 0x07, chip->sd30_drive_sel_1v8);
2584 retval = sd_set_init_para(chip);
2585 if (retval != STATUS_SUCCESS) {
2586 TRACE_RET(chip, STATUS_FAIL);
2589 if (CHK_SD_DDR50(sd_card)) {
2590 retval = sd_ddr_tuning(chip);
2592 retval = sd_sdr_tuning(chip);
2595 if (retval != STATUS_SUCCESS) {
2597 TRACE_RET(chip, STATUS_FAIL);
2599 retval = sd_init_power(chip);
2600 if (retval != STATUS_SUCCESS) {
2601 TRACE_RET(chip, STATUS_FAIL);
2609 sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
2611 if (CHK_SD_DDR50(sd_card)) {
2612 retval = sd_wait_state_data_ready(chip, 0x08, 1, 1000);
2613 if (retval != STATUS_SUCCESS) {
2619 retval = sd_read_lba0(chip);
2620 if (retval != STATUS_SUCCESS) {
2622 TRACE_RET(chip, STATUS_FAIL);
2624 retval = sd_init_power(chip);
2625 if (retval != STATUS_SUCCESS) {
2626 TRACE_RET(chip, STATUS_FAIL);
2636 retval = sd_check_wp_state(chip);
2637 if (retval != STATUS_SUCCESS) {
2638 TRACE_RET(chip, STATUS_FAIL);
2641 chip->card_bus_width[chip->card2lun[SD_CARD]] = 4;
2643 #ifdef SUPPORT_SD_LOCK
2644 if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON) {
2645 RTSX_WRITE_REG(chip, REG_SD_BLOCK_CNT_H, 0xFF, 0x02);
2646 RTSX_WRITE_REG(chip, REG_SD_BLOCK_CNT_L, 0xFF, 0x00);
2650 return STATUS_SUCCESS;
2654 static int mmc_test_switch_bus(struct rtsx_chip *chip, u8 width)
2656 struct sd_info *sd_card = &(chip->sd_card);
2658 u8 buf[8] = {0}, bus_width, *ptr;
2662 retval = sd_send_cmd_get_rsp(chip, BUSTEST_W, 0, SD_RSP_TYPE_R1, NULL, 0);
2663 if (retval != STATUS_SUCCESS) {
2664 TRACE_RET(chip, STATUS_FAIL);
2667 if (width == MMC_8BIT_BUS) {
2672 bus_width = SD_BUS_WIDTH_8;
2677 bus_width = SD_BUS_WIDTH_4;
2680 if (!CHECK_PID(chip, 0x5209)) {
2681 RTSX_WRITE_REG(chip, REG_SD_CFG3, 0x02, 0x02);
2684 retval = sd_write_data(chip, SD_TM_AUTO_WRITE_3,
2685 NULL, 0, byte_cnt, 1, bus_width, buf, len, 100);
2686 if (retval != STATUS_SUCCESS) {
2687 if (CHECK_PID(chip, 0x5209)) {
2688 u8 val1 = 0, val2 = 0;
2689 rtsx_read_register(chip, REG_SD_STAT1, &val1);
2690 rtsx_read_register(chip, REG_SD_STAT2, &val2);
2691 rtsx_clear_sd_error(chip);
2692 if ((val1 & 0xE0) || val2) {
2693 TRACE_RET(chip, STATUS_FAIL);
2696 rtsx_clear_sd_error(chip);
2697 rtsx_write_register(chip, REG_SD_CFG3, 0x02, 0);
2698 TRACE_RET(chip, STATUS_FAIL);
2702 if (!CHECK_PID(chip, 0x5209)) {
2703 RTSX_WRITE_REG(chip, REG_SD_CFG3, 0x02, 0);
2706 RTSX_DEBUGP("SD/MMC CMD %d\n", BUSTEST_R);
2708 rtsx_init_cmd(chip);
2710 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD0, 0xFF, 0x40 | BUSTEST_R);
2712 if (width == MMC_8BIT_BUS) {
2713 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF, 0x08);
2715 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF, 0x04);
2718 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L, 0xFF, 1);
2719 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H, 0xFF, 0);
2721 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF,
2722 SD_CALCULATE_CRC7 | SD_NO_CHECK_CRC16 | SD_NO_WAIT_BUSY_END |
2723 SD_CHECK_CRC7 | SD_RSP_LEN_6);
2724 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 0x01, PINGPONG_BUFFER);
2725 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF, SD_TM_NORMAL_READ | SD_TRANSFER_START);
2726 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER, SD_TRANSFER_END, SD_TRANSFER_END);
2728 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2, 0, 0);
2729 if (width == MMC_8BIT_BUS) {
2730 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + 1, 0, 0);
2733 retval = rtsx_send_cmd(chip, SD_CARD, 100);
2735 rtsx_clear_sd_error(chip);
2736 TRACE_RET(chip, STATUS_FAIL);
2739 ptr = rtsx_get_cmd_data(chip) + 1;
2741 if (width == MMC_8BIT_BUS) {
2742 RTSX_DEBUGP("BUSTEST_R [8bits]: 0x%02x 0x%02x\n", ptr[0], ptr[1]);
2743 if ((ptr[0] == 0xAA) && (ptr[1] == 0x55)) {
2747 if (CHK_MMC_DDR52(sd_card)) {
2752 retval = sd_send_cmd_get_rsp(chip, SWITCH, arg, SD_RSP_TYPE_R1b, rsp, 5);
2753 if ((retval == STATUS_SUCCESS) && !(rsp[4] & MMC_SWITCH_ERR)) {
2754 return STATUS_SUCCESS;
2758 RTSX_DEBUGP("BUSTEST_R [4bits]: 0x%02x\n", ptr[0]);
2759 if (ptr[0] == 0xA5) {
2763 if (CHK_MMC_DDR52(sd_card)) {
2768 retval = sd_send_cmd_get_rsp(chip, SWITCH, arg, SD_RSP_TYPE_R1b, rsp, 5);
2769 if ((retval == STATUS_SUCCESS) && !(rsp[4] & MMC_SWITCH_ERR)) {
2770 return STATUS_SUCCESS;
2775 TRACE_RET(chip, STATUS_FAIL);
2779 static int mmc_switch_timing_bus(struct rtsx_chip *chip, int switch_ddr)
2781 struct sd_info *sd_card = &(chip->sd_card);
2783 u8 *ptr, card_type, card_type_mask = 0;
2785 CLR_MMC_HS(sd_card);
2787 RTSX_DEBUGP("SD/MMC CMD %d\n", SEND_EXT_CSD);
2789 rtsx_init_cmd(chip);
2791 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD0, 0xFF, 0x40 | SEND_EXT_CSD);
2792 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD1, 0xFF, 0);
2793 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD2, 0xFF, 0);
2794 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD3, 0xFF, 0);
2795 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD4, 0xFF, 0);
2797 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF, 0);
2798 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_H, 0xFF, 2);
2799 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L, 0xFF, 1);
2800 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H, 0xFF, 0);
2802 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF,
2803 SD_CALCULATE_CRC7 | SD_CHECK_CRC16 | SD_NO_WAIT_BUSY_END |
2804 SD_CHECK_CRC7 | SD_RSP_LEN_6);
2805 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 0x01, PINGPONG_BUFFER);
2806 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF, SD_TM_NORMAL_READ | SD_TRANSFER_START);
2807 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER, SD_TRANSFER_END, SD_TRANSFER_END);
2809 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + 196, 0xFF, 0);
2810 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + 212, 0xFF, 0);
2811 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + 213, 0xFF, 0);
2812 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + 214, 0xFF, 0);
2813 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + 215, 0xFF, 0);
2815 retval = rtsx_send_cmd(chip, SD_CARD, 1000);
2817 if (retval == -ETIMEDOUT) {
2818 rtsx_clear_sd_error(chip);
2819 sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
2820 SD_RSP_TYPE_R1, NULL, 0);
2822 TRACE_RET(chip, STATUS_FAIL);
2825 ptr = rtsx_get_cmd_data(chip);
2826 if (ptr[0] & SD_TRANSFER_ERR) {
2827 sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
2828 TRACE_RET(chip, STATUS_FAIL);
2831 if (CHK_MMC_SECTOR_MODE(sd_card)) {
2832 sd_card->capacity = ((u32)ptr[5] << 24) | ((u32)ptr[4] << 16) |
2833 ((u32)ptr[3] << 8) | ((u32)ptr[2]);
2836 if (CHECK_PID(chip, 0x5209)) {
2837 #ifdef SUPPORT_SD_LOCK
2838 if (!(sd_card->sd_lock_status & SD_SDR_RST) &&
2839 (chip->sd_ctl & SUPPORT_MMC_DDR_MODE)) {
2840 card_type_mask = 0x07;
2842 card_type_mask = 0x03;
2845 if (chip->sd_ctl & SUPPORT_MMC_DDR_MODE) {
2846 card_type_mask = 0x07;
2848 card_type_mask = 0x03;
2852 card_type_mask = 0x03;
2854 card_type = ptr[1] & card_type_mask;
2858 if (card_type & 0x04) {
2860 SET_MMC_DDR52(sd_card);
2862 SET_MMC_52M(sd_card);
2864 } else if (card_type & 0x02) {
2865 SET_MMC_52M(sd_card);
2867 SET_MMC_26M(sd_card);
2870 retval = sd_send_cmd_get_rsp(chip, SWITCH,
2871 0x03B90100, SD_RSP_TYPE_R1b, rsp, 5);
2872 if ((retval != STATUS_SUCCESS) || (rsp[4] & MMC_SWITCH_ERR)) {
2873 CLR_MMC_HS(sd_card);
2877 sd_choose_proper_clock(chip);
2878 retval = switch_clock(chip, sd_card->sd_clock);
2879 if (retval != STATUS_SUCCESS) {
2880 TRACE_RET(chip, STATUS_FAIL);
2883 if (mmc_test_switch_bus(chip, MMC_8BIT_BUS) == STATUS_SUCCESS) {
2884 SET_MMC_8BIT(sd_card);
2885 chip->card_bus_width[chip->card2lun[SD_CARD]] = 8;
2886 #ifdef SUPPORT_SD_LOCK
2887 sd_card->sd_lock_status &= ~SD_LOCK_1BIT_MODE;
2889 } else if (mmc_test_switch_bus(chip, MMC_4BIT_BUS) == STATUS_SUCCESS) {
2890 SET_MMC_4BIT(sd_card);
2891 chip->card_bus_width[chip->card2lun[SD_CARD]] = 4;
2892 #ifdef SUPPORT_SD_LOCK
2893 sd_card->sd_lock_status &= ~SD_LOCK_1BIT_MODE;
2896 CLR_MMC_8BIT(sd_card);
2897 CLR_MMC_4BIT(sd_card);
2900 return STATUS_SUCCESS;
2904 static int reset_mmc(struct rtsx_chip *chip)
2906 struct sd_info *sd_card = &(chip->sd_card);
2907 int retval, i = 0, j = 0, k = 0;
2913 #ifdef SUPPORT_SD_LOCK
2914 if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON)
2915 goto MMC_UNLOCK_ENTRY;
2920 retval = sd_prepare_reset(chip);
2921 if (retval != STATUS_SUCCESS) {
2922 TRACE_RET(chip, retval);
2928 retval = sd_send_cmd_get_rsp(chip, GO_IDLE_STATE, 0, SD_RSP_TYPE_R0, NULL, 0);
2929 if (retval != STATUS_SUCCESS) {
2930 TRACE_RET(chip, STATUS_FAIL);
2934 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
2935 sd_set_err_code(chip, SD_NO_CARD);
2936 TRACE_RET(chip, STATUS_FAIL);
2939 retval = sd_send_cmd_get_rsp(chip, SEND_OP_COND,
2940 (SUPPORT_VOLTAGE|0x40000000), SD_RSP_TYPE_R3, rsp, 5);
2941 if (retval != STATUS_SUCCESS) {
2942 if (sd_check_err_code(chip, SD_BUSY) || sd_check_err_code(chip, SD_TO_ERR)) {
2945 sd_clr_err_code(chip);
2948 TRACE_RET(chip, STATUS_FAIL);
2953 sd_clr_err_code(chip);
2956 TRACE_RET(chip, STATUS_FAIL);
2963 } while (!(rsp[1] & 0x80) && (i < 255));
2966 TRACE_RET(chip, STATUS_FAIL);
2969 if ((rsp[1] & 0x60) == 0x40) {
2970 SET_MMC_SECTOR_MODE(sd_card);
2972 CLR_MMC_SECTOR_MODE(sd_card);
2975 retval = sd_send_cmd_get_rsp(chip, ALL_SEND_CID, 0, SD_RSP_TYPE_R2, NULL, 0);
2976 if (retval != STATUS_SUCCESS) {
2977 TRACE_RET(chip, STATUS_FAIL);
2980 sd_card->sd_addr = 0x00100000;
2981 retval = sd_send_cmd_get_rsp(chip, SET_RELATIVE_ADDR, sd_card->sd_addr, SD_RSP_TYPE_R6, rsp, 5);
2982 if (retval != STATUS_SUCCESS) {
2983 TRACE_RET(chip, STATUS_FAIL);
2986 retval = sd_check_csd(chip, 1);
2987 if (retval != STATUS_SUCCESS) {
2988 TRACE_RET(chip, STATUS_FAIL);
2991 spec_ver = (sd_card->raw_csd[0] & 0x3C) >> 2;
2993 retval = sd_select_card(chip, 1);
2994 if (retval != STATUS_SUCCESS) {
2995 TRACE_RET(chip, STATUS_FAIL);
2998 retval = sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200, SD_RSP_TYPE_R1, NULL, 0);
2999 if (retval != STATUS_SUCCESS) {
3000 TRACE_RET(chip, STATUS_FAIL);
3003 #ifdef SUPPORT_SD_LOCK
3005 retval = sd_update_lock_status(chip);
3006 if (retval != STATUS_SUCCESS) {
3007 TRACE_RET(chip, STATUS_FAIL);
3011 retval = sd_set_clock_divider(chip, SD_CLK_DIVIDE_0);
3012 if (retval != STATUS_SUCCESS) {
3013 TRACE_RET(chip, STATUS_FAIL);
3016 chip->card_bus_width[chip->card2lun[SD_CARD]] = 1;
3018 if (!sd_card->mmc_dont_switch_bus) {
3019 if (spec_ver == 4) {
3020 (void)mmc_switch_timing_bus(chip, switch_ddr);
3023 if (CHK_MMC_SECTOR_MODE(sd_card) && (sd_card->capacity == 0)) {
3024 TRACE_RET(chip, STATUS_FAIL);
3027 if (switch_ddr && CHK_MMC_DDR52(sd_card)) {
3028 retval = sd_set_init_para(chip);
3029 if (retval != STATUS_SUCCESS) {
3030 TRACE_RET(chip, STATUS_FAIL);
3033 retval = mmc_ddr_tuning(chip);
3034 if (retval != STATUS_SUCCESS) {
3035 retval = sd_init_power(chip);
3036 if (retval != STATUS_SUCCESS) {
3037 TRACE_RET(chip, STATUS_FAIL);
3040 goto DDR_TUNING_FAIL;
3043 retval = sd_wait_state_data_ready(chip, 0x08, 1, 1000);
3044 if (retval == STATUS_SUCCESS) {
3045 retval = sd_read_lba0(chip);
3046 if (retval != STATUS_SUCCESS) {
3047 retval = sd_init_power(chip);
3048 if (retval != STATUS_SUCCESS) {
3049 TRACE_RET(chip, STATUS_FAIL);
3052 goto DDR_TUNING_FAIL;
3058 #ifdef SUPPORT_SD_LOCK
3059 if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON) {
3060 RTSX_WRITE_REG(chip, REG_SD_BLOCK_CNT_H, 0xFF, 0x02);
3061 RTSX_WRITE_REG(chip, REG_SD_BLOCK_CNT_L, 0xFF, 0x00);
3065 temp = rtsx_readl(chip, RTSX_BIPR);
3066 if (temp & SD_WRITE_PROTECT) {
3067 chip->card_wp |= SD_CARD;
3070 return STATUS_SUCCESS;
3073 int reset_sd_card(struct rtsx_chip *chip)
3075 struct sd_info *sd_card = &(chip->sd_card);
3078 sd_init_reg_addr(chip);
3080 memset(sd_card, 0, sizeof(struct sd_info));
3081 chip->capacity[chip->card2lun[SD_CARD]] = 0;
3083 retval = enable_card_clock(chip, SD_CARD);
3084 if (retval != STATUS_SUCCESS) {
3085 TRACE_RET(chip, STATUS_FAIL);
3088 if (chip->ignore_sd && CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) {
3089 if (chip->asic_code) {
3090 retval = sd_pull_ctl_enable(chip);
3091 if (retval != STATUS_SUCCESS) {
3092 TRACE_RET(chip, STATUS_FAIL);
3095 retval = rtsx_write_register(chip, FPGA_PULL_CTL,
3096 FPGA_SD_PULL_CTL_BIT | 0x20, 0);
3097 if (retval != STATUS_SUCCESS) {
3098 TRACE_RET(chip, STATUS_FAIL);
3101 retval = card_share_mode(chip, SD_CARD);
3102 if (retval != STATUS_SUCCESS) {
3103 TRACE_RET(chip, STATUS_FAIL);
3107 TRACE_RET(chip, STATUS_FAIL);
3110 retval = sd_init_power(chip);
3111 if (retval != STATUS_SUCCESS) {
3112 TRACE_RET(chip, STATUS_FAIL);
3115 if (chip->sd_ctl & RESET_MMC_FIRST) {
3116 retval = reset_mmc(chip);
3117 if ((retval != STATUS_SUCCESS) && !sd_check_err_code(chip, SD_NO_CARD)) {
3118 retval = reset_sd(chip);
3119 if (retval != STATUS_SUCCESS) {
3120 if (CHECK_PID(chip, 0x5209)) {
3121 retval = sd_change_bank_voltage(chip, SD_IO_3V3);
3122 if (retval != STATUS_SUCCESS) {
3123 TRACE_RET(chip, STATUS_FAIL);
3129 retval = reset_sd(chip);
3130 if (retval != STATUS_SUCCESS) {
3131 if (sd_check_err_code(chip, SD_NO_CARD)) {
3132 TRACE_RET(chip, STATUS_FAIL);
3135 if (CHECK_PID(chip, 0x5209)) {
3136 retval = sd_change_bank_voltage(chip, SD_IO_3V3);
3137 if (retval != STATUS_SUCCESS) {
3138 TRACE_RET(chip, STATUS_FAIL);
3143 retval = reset_mmc(chip);
3148 if (retval != STATUS_SUCCESS) {
3149 TRACE_RET(chip, STATUS_FAIL);
3152 retval = sd_set_clock_divider(chip, SD_CLK_DIVIDE_0);
3153 if (retval != STATUS_SUCCESS) {
3154 TRACE_RET(chip, STATUS_FAIL);
3156 RTSX_WRITE_REG(chip, REG_SD_BYTE_CNT_L, 0xFF, 0);
3157 RTSX_WRITE_REG(chip, REG_SD_BYTE_CNT_H, 0xFF, 2);
3159 chip->capacity[chip->card2lun[SD_CARD]] = sd_card->capacity;
3161 retval = sd_set_init_para(chip);
3162 if (retval != STATUS_SUCCESS) {
3163 TRACE_RET(chip, STATUS_FAIL);
3166 RTSX_DEBUGP("sd_card->sd_type = 0x%x\n", sd_card->sd_type);
3168 return STATUS_SUCCESS;
3171 static int reset_mmc_only(struct rtsx_chip *chip)
3173 struct sd_info *sd_card = &(chip->sd_card);
3176 sd_card->sd_type = 0;
3177 sd_card->seq_mode = 0;
3178 sd_card->sd_data_buf_ready = 0;
3179 sd_card->capacity = 0;
3180 sd_card->sd_switch_fail = 0;
3182 #ifdef SUPPORT_SD_LOCK
3183 sd_card->sd_lock_status = 0;
3184 sd_card->sd_erase_status = 0;
3187 chip->capacity[chip->card2lun[SD_CARD]] = sd_card->capacity = 0;
3189 retval = enable_card_clock(chip, SD_CARD);
3190 if (retval != STATUS_SUCCESS) {
3191 TRACE_RET(chip, STATUS_FAIL);
3194 retval = sd_init_power(chip);
3195 if (retval != STATUS_SUCCESS) {
3196 TRACE_RET(chip, STATUS_FAIL);
3199 retval = reset_mmc(chip);
3200 if (retval != STATUS_SUCCESS) {
3201 TRACE_RET(chip, STATUS_FAIL);
3204 retval = sd_set_clock_divider(chip, SD_CLK_DIVIDE_0);
3205 if (retval != STATUS_SUCCESS) {
3206 TRACE_RET(chip, STATUS_FAIL);
3208 RTSX_WRITE_REG(chip, REG_SD_BYTE_CNT_L, 0xFF, 0);
3209 RTSX_WRITE_REG(chip, REG_SD_BYTE_CNT_H, 0xFF, 2);
3211 chip->capacity[chip->card2lun[SD_CARD]] = sd_card->capacity;
3213 retval = sd_set_init_para(chip);
3214 if (retval != STATUS_SUCCESS) {
3215 TRACE_RET(chip, STATUS_FAIL);
3218 RTSX_DEBUGP("In reset_mmc_only, sd_card->sd_type = 0x%x\n", sd_card->sd_type);
3220 return STATUS_SUCCESS;
3223 #define WAIT_DATA_READY_RTY_CNT 255
3225 static int wait_data_buf_ready(struct rtsx_chip *chip)
3227 struct sd_info *sd_card = &(chip->sd_card);
3230 for (i = 0; i < WAIT_DATA_READY_RTY_CNT; i++) {
3231 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
3232 sd_set_err_code(chip, SD_NO_CARD);
3233 TRACE_RET(chip, STATUS_FAIL);
3236 sd_card->sd_data_buf_ready = 0;
3238 retval = sd_send_cmd_get_rsp(chip, SEND_STATUS,
3239 sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
3240 if (retval != STATUS_SUCCESS) {
3241 TRACE_RET(chip, STATUS_FAIL);
3244 if (sd_card->sd_data_buf_ready) {
3245 return sd_send_cmd_get_rsp(chip, SEND_STATUS,
3246 sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
3250 sd_set_err_code(chip, SD_TO_ERR);
3252 TRACE_RET(chip, STATUS_FAIL);
3255 void sd_stop_seq_mode(struct rtsx_chip *chip)
3257 struct sd_info *sd_card = &(chip->sd_card);
3260 if (sd_card->seq_mode) {
3261 retval = sd_switch_clock(chip);
3262 if (retval != STATUS_SUCCESS) {
3266 retval = sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION, 0,
3267 SD_RSP_TYPE_R1b, NULL, 0);
3268 if (retval != STATUS_SUCCESS) {
3269 sd_set_err_code(chip, SD_STS_ERR);
3271 retval = sd_wait_state_data_ready(chip, 0x08, 1, 1000);
3272 if (retval != STATUS_SUCCESS) {
3273 sd_set_err_code(chip, SD_STS_ERR);
3275 sd_card->seq_mode = 0;
3277 rtsx_write_register(chip, RBCTL, RB_FLUSH, RB_FLUSH);
3281 static inline int sd_auto_tune_clock(struct rtsx_chip *chip)
3283 struct sd_info *sd_card = &(chip->sd_card);
3286 if (chip->asic_code) {
3287 if (sd_card->sd_clock > 30) {
3288 sd_card->sd_clock -= 20;
3291 switch (sd_card->sd_clock) {
3293 sd_card->sd_clock = CLK_150;
3297 sd_card->sd_clock = CLK_120;
3301 sd_card->sd_clock = CLK_100;
3305 sd_card->sd_clock = CLK_80;
3309 sd_card->sd_clock = CLK_60;
3313 sd_card->sd_clock = CLK_50;
3321 retval = sd_switch_clock(chip);
3322 if (retval != STATUS_SUCCESS) {
3323 TRACE_RET(chip, STATUS_FAIL);
3326 return STATUS_SUCCESS;
3329 int sd_rw(struct scsi_cmnd *srb, struct rtsx_chip *chip, u32 start_sector, u16 sector_cnt)
3331 struct sd_info *sd_card = &(chip->sd_card);
3336 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
3337 RTSX_DEBUGP("sd_rw: Read %d %s from 0x%x\n", sector_cnt,
3338 (sector_cnt > 1) ? "sectors" : "sector", start_sector);
3340 RTSX_DEBUGP("sd_rw: Write %d %s to 0x%x\n", sector_cnt,
3341 (sector_cnt > 1) ? "sectors" : "sector", start_sector);
3344 sd_card->cleanup_counter = 0;
3346 if (!(chip->card_ready & SD_CARD)) {
3347 sd_card->seq_mode = 0;
3349 retval = reset_sd_card(chip);
3350 if (retval == STATUS_SUCCESS) {
3351 chip->card_ready |= SD_CARD;
3352 chip->card_fail &= ~SD_CARD;
3354 chip->card_ready &= ~SD_CARD;
3355 chip->card_fail |= SD_CARD;
3356 chip->capacity[chip->card2lun[SD_CARD]] = 0;
3357 chip->rw_need_retry = 1;
3358 TRACE_RET(chip, STATUS_FAIL);
3362 if (!CHK_SD_HCXC(sd_card) && !CHK_MMC_SECTOR_MODE(sd_card)) {
3363 data_addr = start_sector << 9;
3365 data_addr = start_sector;
3368 sd_clr_err_code(chip);
3370 retval = sd_switch_clock(chip);
3371 if (retval != STATUS_SUCCESS) {
3372 sd_set_err_code(chip, SD_IO_ERR);
3373 TRACE_GOTO(chip, RW_FAIL);
3376 if (sd_card->seq_mode && ((sd_card->pre_dir != srb->sc_data_direction)
3377 || ((sd_card->pre_sec_addr + sd_card->pre_sec_cnt) != start_sector))) {
3378 if ((sd_card->pre_sec_cnt < 0x80)
3379 && (sd_card->pre_dir == DMA_FROM_DEVICE)
3380 && !CHK_SD30_SPEED(sd_card)
3381 && !CHK_SD_HS(sd_card)
3382 && !CHK_MMC_HS(sd_card)) {
3383 sd_send_cmd_get_rsp(chip, SEND_STATUS,
3384 sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
3387 retval = sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION,
3388 0, SD_RSP_TYPE_R1b, NULL, 0);
3389 if (retval != STATUS_SUCCESS) {
3390 chip->rw_need_retry = 1;
3391 sd_set_err_code(chip, SD_STS_ERR);
3392 TRACE_GOTO(chip, RW_FAIL);
3395 sd_card->seq_mode = 0;
3397 retval = rtsx_write_register(chip, RBCTL, RB_FLUSH, RB_FLUSH);
3398 if (retval != STATUS_SUCCESS) {
3399 sd_set_err_code(chip, SD_IO_ERR);
3400 TRACE_GOTO(chip, RW_FAIL);
3403 if ((sd_card->pre_sec_cnt < 0x80)
3404 && !CHK_SD30_SPEED(sd_card)
3405 && !CHK_SD_HS(sd_card)
3406 && !CHK_MMC_HS(sd_card)) {
3407 sd_send_cmd_get_rsp(chip, SEND_STATUS,
3408 sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
3412 rtsx_init_cmd(chip);
3414 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF, 0x00);
3415 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_H, 0xFF, 0x02);
3416 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L, 0xFF, (u8)sector_cnt);
3417 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H, 0xFF, (u8)(sector_cnt >> 8));
3419 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 0x01, RING_BUFFER);
3421 if (CHK_MMC_8BIT(sd_card)) {
3422 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_8);
3423 } else if (CHK_MMC_4BIT(sd_card) || CHK_SD(sd_card)) {
3424 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_4);
3426 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_1);
3429 if (sd_card->seq_mode) {
3430 cfg2 = SD_NO_CALCULATE_CRC7 | SD_CHECK_CRC16 | SD_NO_WAIT_BUSY_END |
3431 SD_NO_CHECK_CRC7 | SD_RSP_LEN_0;
3432 if (CHECK_PID(chip, 0x5209)) {
3433 if (!CHK_SD30_SPEED(sd_card)) {
3434 cfg2 |= SD_NO_CHECK_WAIT_CRC_TO;
3437 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF, cfg2);
3439 trans_dma_enable(srb->sc_data_direction, chip, sector_cnt * 512, DMA_512);
3441 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
3442 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF,
3443 SD_TM_AUTO_READ_3 | SD_TRANSFER_START);
3445 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF,
3446 SD_TM_AUTO_WRITE_3 | SD_TRANSFER_START);
3449 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER, SD_TRANSFER_END, SD_TRANSFER_END);
3451 rtsx_send_cmd_no_wait(chip);
3453 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
3454 RTSX_DEBUGP("SD/MMC CMD %d\n", READ_MULTIPLE_BLOCK);
3455 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD0, 0xFF,
3456 0x40 | READ_MULTIPLE_BLOCK);
3457 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD1, 0xFF, (u8)(data_addr >> 24));
3458 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD2, 0xFF, (u8)(data_addr >> 16));
3459 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD3, 0xFF, (u8)(data_addr >> 8));
3460 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD4, 0xFF, (u8)data_addr);
3462 cfg2 = SD_CALCULATE_CRC7 | SD_CHECK_CRC16 | SD_NO_WAIT_BUSY_END |
3463 SD_CHECK_CRC7 | SD_RSP_LEN_6;
3464 if (CHECK_PID(chip, 0x5209)) {
3465 if (!CHK_SD30_SPEED(sd_card)) {
3466 cfg2 |= SD_NO_CHECK_WAIT_CRC_TO;
3469 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF, cfg2);
3471 trans_dma_enable(srb->sc_data_direction, chip, sector_cnt * 512, DMA_512);
3473 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF,
3474 SD_TM_AUTO_READ_2 | SD_TRANSFER_START);
3475 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER,
3476 SD_TRANSFER_END, SD_TRANSFER_END);
3478 rtsx_send_cmd_no_wait(chip);
3480 retval = rtsx_send_cmd(chip, SD_CARD, 50);
3482 rtsx_clear_sd_error(chip);
3484 chip->rw_need_retry = 1;
3485 sd_set_err_code(chip, SD_TO_ERR);
3486 TRACE_GOTO(chip, RW_FAIL);
3489 retval = wait_data_buf_ready(chip);
3490 if (retval != STATUS_SUCCESS) {
3491 chip->rw_need_retry = 1;
3492 sd_set_err_code(chip, SD_TO_ERR);
3493 TRACE_GOTO(chip, RW_FAIL);
3496 retval = sd_send_cmd_get_rsp(chip, WRITE_MULTIPLE_BLOCK,
3497 data_addr, SD_RSP_TYPE_R1, NULL, 0);
3498 if (retval != STATUS_SUCCESS) {
3499 chip->rw_need_retry = 1;
3500 TRACE_GOTO(chip, RW_FAIL);
3503 rtsx_init_cmd(chip);
3505 cfg2 = SD_NO_CALCULATE_CRC7 | SD_CHECK_CRC16 | SD_NO_WAIT_BUSY_END |
3506 SD_NO_CHECK_CRC7 | SD_RSP_LEN_0;
3507 if (CHECK_PID(chip, 0x5209)) {
3508 if (!CHK_SD30_SPEED(sd_card)) {
3509 cfg2 |= SD_NO_CHECK_WAIT_CRC_TO;
3512 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF, cfg2);
3514 trans_dma_enable(srb->sc_data_direction, chip, sector_cnt * 512, DMA_512);
3516 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF,
3517 SD_TM_AUTO_WRITE_3 | SD_TRANSFER_START);
3518 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER,
3519 SD_TRANSFER_END, SD_TRANSFER_END);
3521 rtsx_send_cmd_no_wait(chip);
3524 sd_card->seq_mode = 1;
3527 retval = rtsx_transfer_data(chip, SD_CARD, scsi_sglist(srb), scsi_bufflen(srb),
3528 scsi_sg_count(srb), srb->sc_data_direction, chip->sd_timeout);
3533 sd_card->seq_mode = 0;
3535 if (retval == -ETIMEDOUT) {
3536 err = STATUS_TIMEDOUT;
3541 rtsx_read_register(chip, REG_SD_STAT1, &stat);
3542 rtsx_clear_sd_error(chip);
3543 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
3544 chip->rw_need_retry = 0;
3545 RTSX_DEBUGP("No card exist, exit sd_rw\n");
3546 TRACE_RET(chip, STATUS_FAIL);
3549 chip->rw_need_retry = 1;
3551 retval = sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION, 0, SD_RSP_TYPE_R1b, NULL, 0);
3552 if (retval != STATUS_SUCCESS) {
3553 sd_set_err_code(chip, SD_STS_ERR);
3554 TRACE_GOTO(chip, RW_FAIL);
3557 if (stat & (SD_CRC7_ERR | SD_CRC16_ERR | SD_CRC_WRITE_ERR)) {
3558 RTSX_DEBUGP("SD CRC error, tune clock!\n");
3559 sd_set_err_code(chip, SD_CRC_ERR);
3560 TRACE_GOTO(chip, RW_FAIL);
3563 if (err == STATUS_TIMEDOUT) {
3564 sd_set_err_code(chip, SD_TO_ERR);
3565 TRACE_GOTO(chip, RW_FAIL);
3568 TRACE_RET(chip, err);
3571 sd_card->pre_sec_addr = start_sector;
3572 sd_card->pre_sec_cnt = sector_cnt;
3573 sd_card->pre_dir = srb->sc_data_direction;
3575 return STATUS_SUCCESS;
3578 sd_card->seq_mode = 0;
3580 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
3581 chip->rw_need_retry = 0;
3582 RTSX_DEBUGP("No card exist, exit sd_rw\n");
3583 TRACE_RET(chip, STATUS_FAIL);
3586 if (sd_check_err_code(chip, SD_CRC_ERR)) {
3587 if (CHK_MMC_4BIT(sd_card) || CHK_MMC_8BIT(sd_card)) {
3588 sd_card->mmc_dont_switch_bus = 1;
3589 reset_mmc_only(chip);
3590 sd_card->mmc_dont_switch_bus = 0;
3592 sd_card->need_retune = 1;
3593 sd_auto_tune_clock(chip);
3595 } else if (sd_check_err_code(chip, SD_TO_ERR | SD_STS_ERR)) {
3596 retval = reset_sd_card(chip);
3597 if (retval != STATUS_SUCCESS) {
3598 chip->card_ready &= ~SD_CARD;
3599 chip->card_fail |= SD_CARD;
3600 chip->capacity[chip->card2lun[SD_CARD]] = 0;
3604 TRACE_RET(chip, STATUS_FAIL);
3608 int soft_reset_sd_card(struct rtsx_chip *chip)
3610 return reset_sd(chip);
3613 int ext_sd_send_cmd_get_rsp(struct rtsx_chip *chip, u8 cmd_idx,
3614 u32 arg, u8 rsp_type, u8 *rsp, int rsp_len, int special_check)
3623 RTSX_DEBUGP("EXT SD/MMC CMD %d\n", cmd_idx);
3625 if (rsp_type == SD_RSP_TYPE_R1b) {
3631 rtsx_init_cmd(chip);
3633 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD0, 0xFF, 0x40 | cmd_idx);
3634 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD1, 0xFF, (u8)(arg >> 24));
3635 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD2, 0xFF, (u8)(arg >> 16));
3636 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD3, 0xFF, (u8)(arg >> 8));
3637 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD4, 0xFF, (u8)arg);
3639 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF, rsp_type);
3640 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE,
3641 0x01, PINGPONG_BUFFER);
3642 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER,
3643 0xFF, SD_TM_CMD_RSP | SD_TRANSFER_START);
3644 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER, SD_TRANSFER_END, SD_TRANSFER_END);
3646 if (rsp_type == SD_RSP_TYPE_R2) {
3647 for (reg_addr = PPBUF_BASE2; reg_addr < PPBUF_BASE2 + 16; reg_addr++) {
3648 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0, 0);
3651 } else if (rsp_type != SD_RSP_TYPE_R0) {
3652 for (reg_addr = REG_SD_CMD0; reg_addr <= REG_SD_CMD4; reg_addr++) {
3653 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0, 0);
3657 rtsx_add_cmd(chip, READ_REG_CMD, REG_SD_CMD5, 0, 0);
3659 rtsx_add_cmd(chip, READ_REG_CMD, REG_SD_STAT1, 0, 0);
3661 retval = rtsx_send_cmd(chip, SD_CARD, timeout);
3663 if (retval == -ETIMEDOUT) {
3664 rtsx_clear_sd_error(chip);
3666 if (rsp_type & SD_WAIT_BUSY_END) {
3667 retval = sd_check_data0_status(chip);
3668 if (retval != STATUS_SUCCESS) {
3669 TRACE_RET(chip, retval);
3672 sd_set_err_code(chip, SD_TO_ERR);
3675 TRACE_RET(chip, STATUS_FAIL);
3678 if (rsp_type == SD_RSP_TYPE_R0) {
3679 return STATUS_SUCCESS;
3682 ptr = rtsx_get_cmd_data(chip) + 1;
3684 if ((ptr[0] & 0xC0) != 0) {
3685 sd_set_err_code(chip, SD_STS_ERR);
3686 TRACE_RET(chip, STATUS_FAIL);
3689 if (!(rsp_type & SD_NO_CHECK_CRC7)) {
3690 if (ptr[stat_idx] & SD_CRC7_ERR) {
3691 if (cmd_idx == WRITE_MULTIPLE_BLOCK) {
3692 sd_set_err_code(chip, SD_CRC_ERR);
3693 TRACE_RET(chip, STATUS_FAIL);
3695 if (rty_cnt < SD_MAX_RETRY_COUNT) {
3700 sd_set_err_code(chip, SD_CRC_ERR);
3701 TRACE_RET(chip, STATUS_FAIL);
3706 if ((cmd_idx == SELECT_CARD) || (cmd_idx == APP_CMD) ||
3707 (cmd_idx == SEND_STATUS) || (cmd_idx == STOP_TRANSMISSION)) {
3708 if ((cmd_idx != STOP_TRANSMISSION) && (special_check == 0)) {
3709 if (ptr[1] & 0x80) {
3710 TRACE_RET(chip, STATUS_FAIL);
3713 #ifdef SUPPORT_SD_LOCK
3719 TRACE_RET(chip, STATUS_FAIL);
3721 if (ptr[2] & 0xF8) {
3722 TRACE_RET(chip, STATUS_FAIL);
3725 if (cmd_idx == SELECT_CARD) {
3726 if (rsp_type == SD_RSP_TYPE_R2) {
3727 if ((ptr[3] & 0x1E) != 0x04) {
3728 TRACE_RET(chip, STATUS_FAIL);
3730 } else if (rsp_type == SD_RSP_TYPE_R2) {
3731 if ((ptr[3] & 0x1E) != 0x03) {
3732 TRACE_RET(chip, STATUS_FAIL);
3738 if (rsp && rsp_len) {
3739 memcpy(rsp, ptr, rsp_len);
3742 return STATUS_SUCCESS;
3745 int ext_sd_get_rsp(struct rtsx_chip *chip, int len, u8 *rsp, u8 rsp_type)
3747 int retval, rsp_len;
3750 if (rsp_type == SD_RSP_TYPE_R0) {
3751 return STATUS_SUCCESS;
3754 rtsx_init_cmd(chip);
3756 if (rsp_type == SD_RSP_TYPE_R2) {
3757 for (reg_addr = PPBUF_BASE2; reg_addr < PPBUF_BASE2 + 16; reg_addr++) {
3758 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0xFF, 0);
3761 } else if (rsp_type != SD_RSP_TYPE_R0) {
3762 for (reg_addr = REG_SD_CMD0; reg_addr <= REG_SD_CMD4; reg_addr++) {
3763 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0xFF, 0);
3767 rtsx_add_cmd(chip, READ_REG_CMD, REG_SD_CMD5, 0xFF, 0);
3769 retval = rtsx_send_cmd(chip, SD_CARD, 100);
3770 if (retval != STATUS_SUCCESS) {
3771 TRACE_RET(chip, STATUS_FAIL);
3775 int min_len = (rsp_len < len) ? rsp_len : len;
3777 memcpy(rsp, rtsx_get_cmd_data(chip), min_len);
3779 RTSX_DEBUGP("min_len = %d\n", min_len);
3780 RTSX_DEBUGP("Response in cmd buf: 0x%x 0x%x 0x%x 0x%x\n",
3781 rsp[0], rsp[1], rsp[2], rsp[3]);
3784 return STATUS_SUCCESS;
3787 int sd_pass_thru_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3789 struct sd_info *sd_card = &(chip->sd_card);
3790 unsigned int lun = SCSI_LUN(srb);
3813 sd_card->pre_cmd_err = 0;
3815 if (!(CHK_BIT(chip->lun_mc, lun))) {
3816 SET_BIT(chip->lun_mc, lun);
3817 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
3818 TRACE_RET(chip, TRANSPORT_FAILED);
3821 if ((0x53 != srb->cmnd[2]) || (0x44 != srb->cmnd[3]) || (0x20 != srb->cmnd[4]) ||
3822 (0x43 != srb->cmnd[5]) || (0x61 != srb->cmnd[6]) ||
3823 (0x72 != srb->cmnd[7]) || (0x64 != srb->cmnd[8])) {
3824 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3825 TRACE_RET(chip, TRANSPORT_FAILED);
3828 switch (srb->cmnd[1] & 0x0F) {
3830 sd_card->sd_pass_thru_en = 0;
3834 sd_card->sd_pass_thru_en = 1;
3838 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3839 TRACE_RET(chip, TRANSPORT_FAILED);
3842 buf[5] = (1 == CHK_SD(sd_card)) ? 0x01 : 0x02;
3843 if (chip->card_wp & SD_CARD) {
3847 buf[6] = (u8)(sd_card->sd_addr >> 16);
3848 buf[7] = (u8)(sd_card->sd_addr >> 24);
3850 buf[15] = chip->max_lun;
3852 len = min(18, (int)scsi_bufflen(srb));
3853 rtsx_stor_set_xfer_buf(buf, len, srb);
3855 return TRANSPORT_GOOD;
3858 static inline int get_rsp_type(struct scsi_cmnd *srb, u8 *rsp_type, int *rsp_len)
3860 if (!rsp_type || !rsp_len) {
3864 switch (srb->cmnd[10]) {
3866 *rsp_type = SD_RSP_TYPE_R0;
3871 *rsp_type = SD_RSP_TYPE_R1;
3876 *rsp_type = SD_RSP_TYPE_R1b;
3881 *rsp_type = SD_RSP_TYPE_R2;
3886 *rsp_type = SD_RSP_TYPE_R3;
3894 return STATUS_SUCCESS;
3897 int sd_execute_no_data(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3899 struct sd_info *sd_card = &(chip->sd_card);
3900 unsigned int lun = SCSI_LUN(srb);
3901 int retval, rsp_len;
3902 u8 cmd_idx, rsp_type;
3903 u8 standby = 0, acmd = 0;
3906 if (!sd_card->sd_pass_thru_en) {
3907 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3908 TRACE_RET(chip, TRANSPORT_FAILED);
3911 retval = sd_switch_clock(chip);
3912 if (retval != STATUS_SUCCESS) {
3913 TRACE_RET(chip, TRANSPORT_FAILED);
3916 if (sd_card->pre_cmd_err) {
3917 sd_card->pre_cmd_err = 0;
3918 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
3919 TRACE_RET(chip, TRANSPORT_FAILED);
3922 cmd_idx = srb->cmnd[2] & 0x3F;
3923 if (srb->cmnd[1] & 0x02) {
3926 if (srb->cmnd[1] & 0x01) {
3930 arg = ((u32)srb->cmnd[3] << 24) | ((u32)srb->cmnd[4] << 16) |
3931 ((u32)srb->cmnd[5] << 8) | srb->cmnd[6];
3933 retval = get_rsp_type(srb, &rsp_type, &rsp_len);
3934 if (retval != STATUS_SUCCESS) {
3935 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3936 TRACE_RET(chip, TRANSPORT_FAILED);
3938 sd_card->last_rsp_type = rsp_type;
3940 retval = sd_switch_clock(chip);
3941 if (retval != STATUS_SUCCESS) {
3942 TRACE_RET(chip, TRANSPORT_FAILED);
3945 #ifdef SUPPORT_SD_LOCK
3946 if ((sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) == 0) {
3947 if (CHK_MMC_8BIT(sd_card)) {
3948 retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_8);
3949 if (retval != STATUS_SUCCESS) {
3950 TRACE_RET(chip, TRANSPORT_FAILED);
3952 } else if (CHK_SD(sd_card) || CHK_MMC_4BIT(sd_card)) {
3953 retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_4);
3954 if (retval != STATUS_SUCCESS) {
3955 TRACE_RET(chip, TRANSPORT_FAILED);
3960 retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_4);
3961 if (retval != STATUS_SUCCESS) {
3962 TRACE_RET(chip, TRANSPORT_FAILED);
3967 retval = sd_select_card(chip, 0);
3968 if (retval != STATUS_SUCCESS) {
3969 TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
3974 retval = ext_sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
3975 SD_RSP_TYPE_R1, NULL, 0, 0);
3976 if (retval != STATUS_SUCCESS) {
3977 TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
3981 retval = ext_sd_send_cmd_get_rsp(chip, cmd_idx, arg, rsp_type,
3982 sd_card->rsp, rsp_len, 0);
3983 if (retval != STATUS_SUCCESS) {
3984 TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
3988 retval = sd_select_card(chip, 1);
3989 if (retval != STATUS_SUCCESS) {
3990 TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
3994 #ifdef SUPPORT_SD_LOCK
3995 retval = sd_update_lock_status(chip);
3996 if (retval != STATUS_SUCCESS) {
3997 TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
4001 scsi_set_resid(srb, 0);
4002 return TRANSPORT_GOOD;
4004 SD_Execute_Cmd_Failed:
4005 sd_card->pre_cmd_err = 1;
4006 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
4007 release_sd_card(chip);
4008 do_reset_sd_card(chip);
4009 if (!(chip->card_ready & SD_CARD)) {
4010 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
4013 TRACE_RET(chip, TRANSPORT_FAILED);
4016 int sd_execute_read_data(struct scsi_cmnd *srb, struct rtsx_chip *chip)
4018 struct sd_info *sd_card = &(chip->sd_card);
4019 unsigned int lun = SCSI_LUN(srb);
4020 int retval, rsp_len, i;
4021 int cmd13_checkbit = 0, read_err = 0;
4022 u8 cmd_idx, rsp_type, bus_width;
4023 u8 send_cmd12 = 0, standby = 0, acmd = 0;
4026 if (!sd_card->sd_pass_thru_en) {
4027 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4028 TRACE_RET(chip, TRANSPORT_FAILED);
4031 if (sd_card->pre_cmd_err) {
4032 sd_card->pre_cmd_err = 0;
4033 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
4034 TRACE_RET(chip, TRANSPORT_FAILED);
4037 retval = sd_switch_clock(chip);
4038 if (retval != STATUS_SUCCESS) {
4039 TRACE_RET(chip, TRANSPORT_FAILED);
4042 cmd_idx = srb->cmnd[2] & 0x3F;
4043 if (srb->cmnd[1] & 0x04) {
4046 if (srb->cmnd[1] & 0x02) {
4049 if (srb->cmnd[1] & 0x01) {
4053 data_len = ((u32)srb->cmnd[7] << 16) | ((u32)srb->cmnd[8] << 8) | srb->cmnd[9];
4055 retval = get_rsp_type(srb, &rsp_type, &rsp_len);
4056 if (retval != STATUS_SUCCESS) {
4057 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4058 TRACE_RET(chip, TRANSPORT_FAILED);
4060 sd_card->last_rsp_type = rsp_type;
4062 retval = sd_switch_clock(chip);
4063 if (retval != STATUS_SUCCESS) {
4064 TRACE_RET(chip, TRANSPORT_FAILED);
4067 #ifdef SUPPORT_SD_LOCK
4068 if ((sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) == 0) {
4069 if (CHK_MMC_8BIT(sd_card)) {
4070 bus_width = SD_BUS_WIDTH_8;
4071 } else if (CHK_SD(sd_card) || CHK_MMC_4BIT(sd_card)) {
4072 bus_width = SD_BUS_WIDTH_4;
4074 bus_width = SD_BUS_WIDTH_1;
4077 bus_width = SD_BUS_WIDTH_4;
4079 RTSX_DEBUGP("bus_width = %d\n", bus_width);
4081 bus_width = SD_BUS_WIDTH_4;
4084 if (data_len < 512) {
4085 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len,
4086 SD_RSP_TYPE_R1, NULL, 0, 0);
4087 if (retval != STATUS_SUCCESS) {
4088 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
4093 retval = sd_select_card(chip, 0);
4094 if (retval != STATUS_SUCCESS) {
4095 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
4100 retval = ext_sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
4101 SD_RSP_TYPE_R1, NULL, 0, 0);
4102 if (retval != STATUS_SUCCESS) {
4103 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
4107 if (data_len <= 512) {
4110 u16 byte_cnt, blk_cnt;
4113 byte_cnt = ((u16)(srb->cmnd[8] & 0x03) << 8) | srb->cmnd[9];
4116 cmd[0] = 0x40 | cmd_idx;
4117 cmd[1] = srb->cmnd[3];
4118 cmd[2] = srb->cmnd[4];
4119 cmd[3] = srb->cmnd[5];
4120 cmd[4] = srb->cmnd[6];
4122 buf = (u8 *)kmalloc(data_len, GFP_KERNEL);
4124 TRACE_RET(chip, TRANSPORT_ERROR);
4127 retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd, 5, byte_cnt,
4128 blk_cnt, bus_width, buf, data_len, 2000);
4129 if (retval != STATUS_SUCCESS) {
4132 rtsx_clear_sd_error(chip);
4133 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
4136 min_len = min(data_len, scsi_bufflen(srb));
4137 rtsx_stor_set_xfer_buf(buf, min_len, srb);
4140 } else if (!(data_len & 0x1FF)) {
4141 rtsx_init_cmd(chip);
4143 trans_dma_enable(DMA_FROM_DEVICE, chip, data_len, DMA_512);
4145 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_H, 0xFF, 0x02);
4146 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF, 0x00);
4147 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H,
4148 0xFF, (srb->cmnd[7] & 0xFE) >> 1);
4149 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L,
4150 0xFF, (u8)((data_len & 0x0001FE00) >> 9));
4152 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD0, 0xFF, 0x40 | cmd_idx);
4153 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD1, 0xFF, srb->cmnd[3]);
4154 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD2, 0xFF, srb->cmnd[4]);
4155 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD3, 0xFF, srb->cmnd[5]);
4156 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD4, 0xFF, srb->cmnd[6]);
4158 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG1, 0x03, bus_width);
4159 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF, rsp_type);
4161 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER,
4162 0xFF, SD_TM_AUTO_READ_2 | SD_TRANSFER_START);
4163 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER, SD_TRANSFER_END, SD_TRANSFER_END);
4165 rtsx_send_cmd_no_wait(chip);
4167 retval = rtsx_transfer_data(chip, SD_CARD, scsi_sglist(srb), scsi_bufflen(srb),
4168 scsi_sg_count(srb), DMA_FROM_DEVICE, 10000);
4171 rtsx_clear_sd_error(chip);
4172 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
4176 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
4179 retval = ext_sd_get_rsp(chip, rsp_len, sd_card->rsp, rsp_type);
4180 if (retval != STATUS_SUCCESS) {
4181 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
4185 retval = sd_select_card(chip, 1);
4186 if (retval != STATUS_SUCCESS) {
4187 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
4192 retval = ext_sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION,
4193 0, SD_RSP_TYPE_R1b, NULL, 0, 0);
4194 if (retval != STATUS_SUCCESS) {
4195 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
4199 if (data_len < 512) {
4200 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200,
4201 SD_RSP_TYPE_R1, NULL, 0, 0);
4202 if (retval != STATUS_SUCCESS) {
4203 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
4206 retval = rtsx_write_register(chip, SD_BYTE_CNT_H, 0xFF, 0x02);
4207 if (retval != STATUS_SUCCESS) {
4208 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
4210 retval = rtsx_write_register(chip, SD_BYTE_CNT_L, 0xFF, 0x00);
4211 if (retval != STATUS_SUCCESS) {
4212 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
4216 if ((srb->cmnd[1] & 0x02) || (srb->cmnd[1] & 0x04)) {
4220 for (i = 0; i < 3; i++) {
4221 retval = ext_sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
4222 SD_RSP_TYPE_R1, NULL, 0, cmd13_checkbit);
4223 if (retval == STATUS_SUCCESS) {
4227 if (retval != STATUS_SUCCESS) {
4228 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
4231 scsi_set_resid(srb, 0);
4232 return TRANSPORT_GOOD;
4234 SD_Execute_Read_Cmd_Failed:
4235 sd_card->pre_cmd_err = 1;
4236 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
4238 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
4240 release_sd_card(chip);
4241 do_reset_sd_card(chip);
4242 if (!(chip->card_ready & SD_CARD)) {
4243 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
4246 TRACE_RET(chip, TRANSPORT_FAILED);
4249 int sd_execute_write_data(struct scsi_cmnd *srb, struct rtsx_chip *chip)
4251 struct sd_info *sd_card = &(chip->sd_card);
4252 unsigned int lun = SCSI_LUN(srb);
4253 int retval, rsp_len, i;
4254 int cmd13_checkbit = 0, write_err = 0;
4255 u8 cmd_idx, rsp_type;
4256 u8 send_cmd12 = 0, standby = 0, acmd = 0;
4258 #ifdef SUPPORT_SD_LOCK
4259 int lock_cmd_fail = 0;
4260 u8 sd_lock_state = 0;
4261 u8 lock_cmd_type = 0;
4264 if (!sd_card->sd_pass_thru_en) {
4265 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4266 TRACE_RET(chip, TRANSPORT_FAILED);
4269 if (sd_card->pre_cmd_err) {
4270 sd_card->pre_cmd_err = 0;
4271 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
4272 TRACE_RET(chip, TRANSPORT_FAILED);
4275 retval = sd_switch_clock(chip);
4276 if (retval != STATUS_SUCCESS) {
4277 TRACE_RET(chip, TRANSPORT_FAILED);
4280 cmd_idx = srb->cmnd[2] & 0x3F;
4281 if (srb->cmnd[1] & 0x04) {
4284 if (srb->cmnd[1] & 0x02) {
4287 if (srb->cmnd[1] & 0x01) {
4291 data_len = ((u32)srb->cmnd[7] << 16) | ((u32)srb->cmnd[8] << 8) | srb->cmnd[9];
4292 arg = ((u32)srb->cmnd[3] << 24) | ((u32)srb->cmnd[4] << 16) |
4293 ((u32)srb->cmnd[5] << 8) | srb->cmnd[6];
4295 #ifdef SUPPORT_SD_LOCK
4296 if (cmd_idx == LOCK_UNLOCK) {
4297 sd_lock_state = sd_card->sd_lock_status;
4298 sd_lock_state &= SD_LOCKED;
4302 retval = get_rsp_type(srb, &rsp_type, &rsp_len);
4303 if (retval != STATUS_SUCCESS) {
4304 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4305 TRACE_RET(chip, TRANSPORT_FAILED);
4307 sd_card->last_rsp_type = rsp_type;
4309 retval = sd_switch_clock(chip);
4310 if (retval != STATUS_SUCCESS) {
4311 TRACE_RET(chip, TRANSPORT_FAILED);
4314 #ifdef SUPPORT_SD_LOCK
4315 if ((sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) == 0) {
4316 if (CHK_MMC_8BIT(sd_card)) {
4317 retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_8);
4318 if (retval != STATUS_SUCCESS) {
4319 TRACE_RET(chip, TRANSPORT_FAILED);
4321 } else if (CHK_SD(sd_card) || CHK_MMC_4BIT(sd_card)) {
4322 retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_4);
4323 if (retval != STATUS_SUCCESS) {
4324 TRACE_RET(chip, TRANSPORT_FAILED);
4329 retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_4);
4330 if (retval != STATUS_SUCCESS) {
4331 TRACE_RET(chip, TRANSPORT_FAILED);
4335 if (data_len < 512) {
4336 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len,
4337 SD_RSP_TYPE_R1, NULL, 0, 0);
4338 if (retval != STATUS_SUCCESS) {
4339 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4344 retval = sd_select_card(chip, 0);
4345 if (retval != STATUS_SUCCESS) {
4346 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4351 retval = ext_sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
4352 SD_RSP_TYPE_R1, NULL, 0, 0);
4353 if (retval != STATUS_SUCCESS) {
4354 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4358 retval = ext_sd_send_cmd_get_rsp(chip, cmd_idx, arg, rsp_type,
4359 sd_card->rsp, rsp_len, 0);
4360 if (retval != STATUS_SUCCESS) {
4361 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4364 if (data_len <= 512) {
4368 buf = (u8 *)kmalloc(data_len, GFP_KERNEL);
4370 TRACE_RET(chip, TRANSPORT_ERROR);
4373 rtsx_stor_get_xfer_buf(buf, data_len, srb);
4375 #ifdef SUPPORT_SD_LOCK
4376 if (cmd_idx == LOCK_UNLOCK) {
4377 lock_cmd_type = buf[0] & 0x0F;
4381 if (data_len > 256) {
4382 rtsx_init_cmd(chip);
4383 for (i = 0; i < 256; i++) {
4384 rtsx_add_cmd(chip, WRITE_REG_CMD,
4385 PPBUF_BASE2 + i, 0xFF, buf[i]);
4387 retval = rtsx_send_cmd(chip, 0, 250);
4388 if (retval != STATUS_SUCCESS) {
4390 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4393 rtsx_init_cmd(chip);
4394 for (i = 256; i < data_len; i++) {
4395 rtsx_add_cmd(chip, WRITE_REG_CMD,
4396 PPBUF_BASE2 + i, 0xFF, buf[i]);
4398 retval = rtsx_send_cmd(chip, 0, 250);
4399 if (retval != STATUS_SUCCESS) {
4401 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4404 rtsx_init_cmd(chip);
4405 for (i = 0; i < data_len; i++) {
4406 rtsx_add_cmd(chip, WRITE_REG_CMD,
4407 PPBUF_BASE2 + i, 0xFF, buf[i]);
4409 retval = rtsx_send_cmd(chip, 0, 250);
4410 if (retval != STATUS_SUCCESS) {
4412 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4418 rtsx_init_cmd(chip);
4420 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_H, 0xFF, srb->cmnd[8] & 0x03);
4421 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF, srb->cmnd[9]);
4422 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H, 0xFF, 0x00);
4423 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L, 0xFF, 0x01);
4424 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 0x01, PINGPONG_BUFFER);
4426 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF,
4427 SD_TM_AUTO_WRITE_3 | SD_TRANSFER_START);
4428 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER, SD_TRANSFER_END, SD_TRANSFER_END);
4430 retval = rtsx_send_cmd(chip, SD_CARD, 250);
4431 } else if (!(data_len & 0x1FF)) {
4432 rtsx_init_cmd(chip);
4434 trans_dma_enable(DMA_TO_DEVICE, chip, data_len, DMA_512);
4436 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_H, 0xFF, 0x02);
4437 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF, 0x00);
4438 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H,
4439 0xFF, (srb->cmnd[7] & 0xFE) >> 1);
4440 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L,
4441 0xFF, (u8)((data_len & 0x0001FE00) >> 9));
4443 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF, SD_TM_AUTO_WRITE_3 | SD_TRANSFER_START);
4444 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER, SD_TRANSFER_END, SD_TRANSFER_END);
4446 rtsx_send_cmd_no_wait(chip);
4448 retval = rtsx_transfer_data(chip, SD_CARD, scsi_sglist(srb), scsi_bufflen(srb),
4449 scsi_sg_count(srb), DMA_TO_DEVICE, 10000);
4452 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4457 rtsx_clear_sd_error(chip);
4458 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4461 #ifdef SUPPORT_SD_LOCK
4462 if (cmd_idx == LOCK_UNLOCK) {
4463 if (lock_cmd_type == SD_ERASE) {
4464 sd_card->sd_erase_status = SD_UNDER_ERASING;
4465 scsi_set_resid(srb, 0);
4466 return TRANSPORT_GOOD;
4469 rtsx_init_cmd(chip);
4470 if (CHECK_PID(chip, 0x5209)) {
4471 rtsx_add_cmd(chip, CHECK_REG_CMD, SD_BUS_STAT, SD_DAT0_STATUS, SD_DAT0_STATUS);
4473 rtsx_add_cmd(chip, CHECK_REG_CMD, 0xFD30, 0x02, 0x02);
4475 rtsx_send_cmd(chip, SD_CARD, 250);
4477 retval = sd_update_lock_status(chip);
4478 if (retval != STATUS_SUCCESS) {
4479 RTSX_DEBUGP("Lock command fail!\n");
4483 #endif /* SUPPORT_SD_LOCK */
4486 retval = sd_select_card(chip, 1);
4487 if (retval != STATUS_SUCCESS) {
4488 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4493 retval = ext_sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION,
4494 0, SD_RSP_TYPE_R1b, NULL, 0, 0);
4495 if (retval != STATUS_SUCCESS) {
4496 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4500 if (data_len < 512) {
4501 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200,
4502 SD_RSP_TYPE_R1, NULL, 0, 0);
4503 if (retval != STATUS_SUCCESS) {
4504 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4507 retval = rtsx_write_register(chip, SD_BYTE_CNT_H, 0xFF, 0x02);
4508 if (retval != STATUS_SUCCESS) {
4509 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4511 rtsx_write_register(chip, SD_BYTE_CNT_L, 0xFF, 0x00);
4512 if (retval != STATUS_SUCCESS) {
4513 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4517 if ((srb->cmnd[1] & 0x02) || (srb->cmnd[1] & 0x04)) {
4521 for (i = 0; i < 3; i++) {
4522 retval = ext_sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
4523 SD_RSP_TYPE_R1, NULL, 0, cmd13_checkbit);
4524 if (retval == STATUS_SUCCESS) {
4528 if (retval != STATUS_SUCCESS) {
4529 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4532 #ifdef SUPPORT_SD_LOCK
4533 if (cmd_idx == LOCK_UNLOCK) {
4534 if (!lock_cmd_fail) {
4535 RTSX_DEBUGP("lock_cmd_type = 0x%x\n", lock_cmd_type);
4536 if (lock_cmd_type & SD_CLR_PWD) {
4537 sd_card->sd_lock_status &= ~SD_PWD_EXIST;
4539 if (lock_cmd_type & SD_SET_PWD) {
4540 sd_card->sd_lock_status |= SD_PWD_EXIST;
4544 RTSX_DEBUGP("sd_lock_state = 0x%x, sd_card->sd_lock_status = 0x%x\n",
4545 sd_lock_state, sd_card->sd_lock_status);
4546 if (sd_lock_state ^ (sd_card->sd_lock_status & SD_LOCKED)) {
4547 sd_card->sd_lock_notify = 1;
4548 if (sd_lock_state) {
4549 if (sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) {
4550 sd_card->sd_lock_status |= (SD_UNLOCK_POW_ON | SD_SDR_RST);
4551 if (CHK_SD(sd_card)) {
4552 retval = reset_sd(chip);
4553 if (retval != STATUS_SUCCESS) {
4554 sd_card->sd_lock_status &= ~(SD_UNLOCK_POW_ON | SD_SDR_RST);
4555 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
4559 sd_card->sd_lock_status &= ~(SD_UNLOCK_POW_ON | SD_SDR_RST);
4565 if (lock_cmd_fail) {
4566 scsi_set_resid(srb, 0);
4567 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
4568 TRACE_RET(chip, TRANSPORT_FAILED);
4570 #endif /* SUPPORT_SD_LOCK */
4572 scsi_set_resid(srb, 0);
4573 return TRANSPORT_GOOD;
4575 SD_Execute_Write_Cmd_Failed:
4576 sd_card->pre_cmd_err = 1;
4577 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
4579 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
4581 release_sd_card(chip);
4582 do_reset_sd_card(chip);
4583 if (!(chip->card_ready & SD_CARD)) {
4584 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
4587 TRACE_RET(chip, TRANSPORT_FAILED);
4590 int sd_get_cmd_rsp(struct scsi_cmnd *srb, struct rtsx_chip *chip)
4592 struct sd_info *sd_card = &(chip->sd_card);
4593 unsigned int lun = SCSI_LUN(srb);
4597 if (!sd_card->sd_pass_thru_en) {
4598 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4599 TRACE_RET(chip, TRANSPORT_FAILED);
4602 if (sd_card->pre_cmd_err) {
4603 sd_card->pre_cmd_err = 0;
4604 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
4605 TRACE_RET(chip, TRANSPORT_FAILED);
4608 data_len = ((u16)srb->cmnd[7] << 8) | srb->cmnd[8];
4610 if (sd_card->last_rsp_type == SD_RSP_TYPE_R0) {
4611 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4612 TRACE_RET(chip, TRANSPORT_FAILED);
4613 } else if (sd_card->last_rsp_type == SD_RSP_TYPE_R2) {
4614 count = (data_len < 17) ? data_len : 17;
4616 count = (data_len < 6) ? data_len : 6;
4618 rtsx_stor_set_xfer_buf(sd_card->rsp, count, srb);
4620 RTSX_DEBUGP("Response length: %d\n", data_len);
4621 RTSX_DEBUGP("Response: 0x%x 0x%x 0x%x 0x%x\n",
4622 sd_card->rsp[0], sd_card->rsp[1], sd_card->rsp[2], sd_card->rsp[3]);
4624 scsi_set_resid(srb, 0);
4625 return TRANSPORT_GOOD;
4628 int sd_hw_rst(struct scsi_cmnd *srb, struct rtsx_chip *chip)
4630 struct sd_info *sd_card = &(chip->sd_card);
4631 unsigned int lun = SCSI_LUN(srb);
4634 if (!sd_card->sd_pass_thru_en) {
4635 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4636 TRACE_RET(chip, TRANSPORT_FAILED);
4639 if (sd_card->pre_cmd_err) {
4640 sd_card->pre_cmd_err = 0;
4641 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
4642 TRACE_RET(chip, TRANSPORT_FAILED);
4645 if ((0x53 != srb->cmnd[2]) || (0x44 != srb->cmnd[3]) || (0x20 != srb->cmnd[4]) ||
4646 (0x43 != srb->cmnd[5]) || (0x61 != srb->cmnd[6]) ||
4647 (0x72 != srb->cmnd[7]) || (0x64 != srb->cmnd[8])) {
4648 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4649 TRACE_RET(chip, TRANSPORT_FAILED);
4652 switch (srb->cmnd[1] & 0x0F) {
4654 #ifdef SUPPORT_SD_LOCK
4655 if (0x64 == srb->cmnd[9]) {
4656 sd_card->sd_lock_status |= SD_SDR_RST;
4659 retval = reset_sd_card(chip);
4660 if (retval != STATUS_SUCCESS) {
4661 #ifdef SUPPORT_SD_LOCK
4662 sd_card->sd_lock_status &= ~SD_SDR_RST;
4664 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
4665 sd_card->pre_cmd_err = 1;
4666 TRACE_RET(chip, TRANSPORT_FAILED);
4668 #ifdef SUPPORT_SD_LOCK
4669 sd_card->sd_lock_status &= ~SD_SDR_RST;
4674 retval = soft_reset_sd_card(chip);
4675 if (retval != STATUS_SUCCESS) {
4676 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
4677 sd_card->pre_cmd_err = 1;
4678 TRACE_RET(chip, TRANSPORT_FAILED);
4683 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4684 TRACE_RET(chip, TRANSPORT_FAILED);
4687 scsi_set_resid(srb, 0);
4688 return TRANSPORT_GOOD;
4692 void sd_cleanup_work(struct rtsx_chip *chip)
4694 struct sd_info *sd_card = &(chip->sd_card);
4696 if (sd_card->seq_mode) {
4697 RTSX_DEBUGP("SD: stop transmission\n");
4698 sd_stop_seq_mode(chip);
4699 sd_card->cleanup_counter = 0;
4703 int sd_power_off_card3v3(struct rtsx_chip *chip)
4707 retval = disable_card_clock(chip, SD_CARD);
4708 if (retval != STATUS_SUCCESS) {
4709 TRACE_RET(chip, STATUS_FAIL);
4712 RTSX_WRITE_REG(chip, CARD_OE, SD_OUTPUT_EN, 0);
4714 if (!chip->ft2_fast_mode) {
4715 retval = card_power_off(chip, SD_CARD);
4716 if (retval != STATUS_SUCCESS) {
4717 TRACE_RET(chip, STATUS_FAIL);
4723 if (chip->asic_code) {
4724 retval = sd_pull_ctl_disable(chip);
4725 if (retval != STATUS_SUCCESS) {
4726 TRACE_RET(chip, STATUS_FAIL);
4729 RTSX_WRITE_REG(chip, FPGA_PULL_CTL,
4730 FPGA_SD_PULL_CTL_BIT | 0x20, FPGA_SD_PULL_CTL_BIT);
4733 return STATUS_SUCCESS;
4736 int release_sd_card(struct rtsx_chip *chip)
4738 struct sd_info *sd_card = &(chip->sd_card);
4741 RTSX_DEBUGP("release_sd_card\n");
4743 chip->card_ready &= ~SD_CARD;
4744 chip->card_fail &= ~SD_CARD;
4745 chip->card_wp &= ~SD_CARD;
4750 #ifdef SUPPORT_SD_LOCK
4751 sd_card->sd_lock_status = 0;
4752 sd_card->sd_erase_status = 0;
4755 memset(sd_card->raw_csd, 0, 16);
4756 memset(sd_card->raw_scr, 0, 8);
4758 retval = sd_power_off_card3v3(chip);
4759 if (retval != STATUS_SUCCESS) {
4760 TRACE_RET(chip, STATUS_FAIL);
4763 if (CHECK_PID(chip, 0x5209)) {
4764 retval = sd_change_bank_voltage(chip, SD_IO_3V3);
4765 if (retval != STATUS_SUCCESS) {
4766 TRACE_RET(chip, STATUS_FAIL);
4769 if (CHK_SD30_SPEED(sd_card)) {
4770 RTSX_WRITE_REG(chip, SD30_DRIVE_SEL, 0x07, chip->sd30_drive_sel_3v3);
4773 RTSX_WRITE_REG(chip, OCPPARA2, SD_OCP_THD_MASK, chip->sd_400mA_ocp_thd);
4776 return STATUS_SUCCESS;