1
2
3
4
5
6
7
8
9
10
11
12#include <linux/blkdev.h>
13#include <linux/kthread.h>
14#include <linux/sched.h>
15
16#include "rtsx.h"
17#include "sd.h"
18
19#define SD_MAX_RETRY_COUNT 3
20
21static u16 REG_SD_CFG1;
22static u16 REG_SD_CFG2;
23static u16 REG_SD_CFG3;
24static u16 REG_SD_STAT1;
25static u16 REG_SD_STAT2;
26static u16 REG_SD_BUS_STAT;
27static u16 REG_SD_PAD_CTL;
28static u16 REG_SD_SAMPLE_POINT_CTL;
29static u16 REG_SD_PUSH_POINT_CTL;
30static u16 REG_SD_CMD0;
31static u16 REG_SD_CMD1;
32static u16 REG_SD_CMD2;
33static u16 REG_SD_CMD3;
34static u16 REG_SD_CMD4;
35static u16 REG_SD_CMD5;
36static u16 REG_SD_BYTE_CNT_L;
37static u16 REG_SD_BYTE_CNT_H;
38static u16 REG_SD_BLOCK_CNT_L;
39static u16 REG_SD_BLOCK_CNT_H;
40static u16 REG_SD_TRANSFER;
41static u16 REG_SD_VPCLK0_CTL;
42static u16 REG_SD_VPCLK1_CTL;
43static u16 REG_SD_DCMPS0_CTL;
44static u16 REG_SD_DCMPS1_CTL;
45
46static inline void sd_set_err_code(struct rtsx_chip *chip, u8 err_code)
47{
48 struct sd_info *sd_card = &chip->sd_card;
49
50 sd_card->err_code |= err_code;
51}
52
53static inline void sd_clr_err_code(struct rtsx_chip *chip)
54{
55 struct sd_info *sd_card = &chip->sd_card;
56
57 sd_card->err_code = 0;
58}
59
60static inline int sd_check_err_code(struct rtsx_chip *chip, u8 err_code)
61{
62 struct sd_info *sd_card = &chip->sd_card;
63
64 return sd_card->err_code & err_code;
65}
66
67static void sd_init_reg_addr(struct rtsx_chip *chip)
68{
69 REG_SD_CFG1 = 0xFD31;
70 REG_SD_CFG2 = 0xFD33;
71 REG_SD_CFG3 = 0xFD3E;
72 REG_SD_STAT1 = 0xFD30;
73 REG_SD_STAT2 = 0;
74 REG_SD_BUS_STAT = 0;
75 REG_SD_PAD_CTL = 0;
76 REG_SD_SAMPLE_POINT_CTL = 0;
77 REG_SD_PUSH_POINT_CTL = 0;
78 REG_SD_CMD0 = 0xFD34;
79 REG_SD_CMD1 = 0xFD35;
80 REG_SD_CMD2 = 0xFD36;
81 REG_SD_CMD3 = 0xFD37;
82 REG_SD_CMD4 = 0xFD38;
83 REG_SD_CMD5 = 0xFD5A;
84 REG_SD_BYTE_CNT_L = 0xFD39;
85 REG_SD_BYTE_CNT_H = 0xFD3A;
86 REG_SD_BLOCK_CNT_L = 0xFD3B;
87 REG_SD_BLOCK_CNT_H = 0xFD3C;
88 REG_SD_TRANSFER = 0xFD32;
89 REG_SD_VPCLK0_CTL = 0;
90 REG_SD_VPCLK1_CTL = 0;
91 REG_SD_DCMPS0_CTL = 0;
92 REG_SD_DCMPS1_CTL = 0;
93}
94
95static int sd_check_data0_status(struct rtsx_chip *chip)
96{
97 int retval;
98 u8 stat;
99
100 retval = rtsx_read_register(chip, REG_SD_STAT1, &stat);
101 if (retval)
102 return retval;
103
104 if (!(stat & SD_DAT0_STATUS)) {
105 sd_set_err_code(chip, SD_BUSY);
106 return STATUS_FAIL;
107 }
108
109 return STATUS_SUCCESS;
110}
111
112static int sd_send_cmd_get_rsp(struct rtsx_chip *chip, u8 cmd_idx,
113 u32 arg, u8 rsp_type, u8 *rsp, int rsp_len)
114{
115 struct sd_info *sd_card = &chip->sd_card;
116 int retval;
117 int timeout = 100;
118 u16 reg_addr;
119 u8 *ptr;
120 int stat_idx = 0;
121 int rty_cnt = 0;
122
123 sd_clr_err_code(chip);
124
125 dev_dbg(rtsx_dev(chip), "SD/MMC CMD %d, arg = 0x%08x\n", cmd_idx, arg);
126
127 if (rsp_type == SD_RSP_TYPE_R1b)
128 timeout = 3000;
129
130RTY_SEND_CMD:
131
132 rtsx_init_cmd(chip);
133
134 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD0, 0xFF, 0x40 | cmd_idx);
135 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD1, 0xFF, (u8)(arg >> 24));
136 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD2, 0xFF, (u8)(arg >> 16));
137 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD3, 0xFF, (u8)(arg >> 8));
138 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD4, 0xFF, (u8)arg);
139
140 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF, rsp_type);
141 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE,
142 0x01, PINGPONG_BUFFER);
143 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER,
144 0xFF, SD_TM_CMD_RSP | SD_TRANSFER_START);
145 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER,
146 SD_TRANSFER_END | SD_STAT_IDLE, SD_TRANSFER_END |
147 SD_STAT_IDLE);
148
149 if (rsp_type == SD_RSP_TYPE_R2) {
150 for (reg_addr = PPBUF_BASE2; reg_addr < PPBUF_BASE2 + 16;
151 reg_addr++)
152 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0, 0);
153
154 stat_idx = 16;
155 } else if (rsp_type != SD_RSP_TYPE_R0) {
156 for (reg_addr = REG_SD_CMD0; reg_addr <= REG_SD_CMD4;
157 reg_addr++)
158 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0, 0);
159
160 stat_idx = 5;
161 }
162
163 rtsx_add_cmd(chip, READ_REG_CMD, REG_SD_STAT1, 0, 0);
164
165 retval = rtsx_send_cmd(chip, SD_CARD, timeout);
166 if (retval < 0) {
167 u8 val;
168
169 rtsx_read_register(chip, REG_SD_STAT1, &val);
170 dev_dbg(rtsx_dev(chip), "SD_STAT1: 0x%x\n", val);
171
172 rtsx_read_register(chip, REG_SD_CFG3, &val);
173 dev_dbg(rtsx_dev(chip), "SD_CFG3: 0x%x\n", val);
174
175 if (retval == -ETIMEDOUT) {
176 if (rsp_type & SD_WAIT_BUSY_END) {
177 retval = sd_check_data0_status(chip);
178 if (retval != STATUS_SUCCESS) {
179 rtsx_clear_sd_error(chip);
180 return retval;
181 }
182 } else {
183 sd_set_err_code(chip, SD_TO_ERR);
184 }
185 retval = STATUS_TIMEDOUT;
186 } else {
187 retval = STATUS_FAIL;
188 }
189 rtsx_clear_sd_error(chip);
190
191 return retval;
192 }
193
194 if (rsp_type == SD_RSP_TYPE_R0)
195 return STATUS_SUCCESS;
196
197 ptr = rtsx_get_cmd_data(chip) + 1;
198
199 if ((ptr[0] & 0xC0) != 0) {
200 sd_set_err_code(chip, SD_STS_ERR);
201 return STATUS_FAIL;
202 }
203
204 if (!(rsp_type & SD_NO_CHECK_CRC7)) {
205 if (ptr[stat_idx] & SD_CRC7_ERR) {
206 if (cmd_idx == WRITE_MULTIPLE_BLOCK) {
207 sd_set_err_code(chip, SD_CRC_ERR);
208 return STATUS_FAIL;
209 }
210 if (rty_cnt < SD_MAX_RETRY_COUNT) {
211 wait_timeout(20);
212 rty_cnt++;
213 goto RTY_SEND_CMD;
214 } else {
215 sd_set_err_code(chip, SD_CRC_ERR);
216 return STATUS_FAIL;
217 }
218 }
219 }
220
221 if ((rsp_type == SD_RSP_TYPE_R1) || (rsp_type == SD_RSP_TYPE_R1b)) {
222 if ((cmd_idx != SEND_RELATIVE_ADDR) &&
223 (cmd_idx != SEND_IF_COND)) {
224 if (cmd_idx != STOP_TRANSMISSION) {
225 if (ptr[1] & 0x80)
226 return STATUS_FAIL;
227 }
228#ifdef SUPPORT_SD_LOCK
229 if (ptr[1] & 0x7D) {
230#else
231 if (ptr[1] & 0x7F) {
232#endif
233 dev_dbg(rtsx_dev(chip), "ptr[1]: 0x%02x\n",
234 ptr[1]);
235 return STATUS_FAIL;
236 }
237 if (ptr[2] & 0xFF) {
238 dev_dbg(rtsx_dev(chip), "ptr[2]: 0x%02x\n",
239 ptr[2]);
240 return STATUS_FAIL;
241 }
242 if (ptr[3] & 0x80) {
243 dev_dbg(rtsx_dev(chip), "ptr[3]: 0x%02x\n",
244 ptr[3]);
245 return STATUS_FAIL;
246 }
247 if (ptr[3] & 0x01)
248 sd_card->sd_data_buf_ready = 1;
249 else
250 sd_card->sd_data_buf_ready = 0;
251 }
252 }
253
254 if (rsp && rsp_len)
255 memcpy(rsp, ptr, rsp_len);
256
257 return STATUS_SUCCESS;
258}
259
260static int sd_read_data(struct rtsx_chip *chip,
261 u8 trans_mode, u8 *cmd, int cmd_len, u16 byte_cnt,
262 u16 blk_cnt, u8 bus_width, u8 *buf, int buf_len,
263 int timeout)
264{
265 struct sd_info *sd_card = &chip->sd_card;
266 int retval;
267 int i;
268
269 sd_clr_err_code(chip);
270
271 if (!buf)
272 buf_len = 0;
273
274 if (buf_len > 512)
275 return STATUS_FAIL;
276
277 rtsx_init_cmd(chip);
278
279 if (cmd_len) {
280 dev_dbg(rtsx_dev(chip), "SD/MMC CMD %d\n", cmd[0] - 0x40);
281 for (i = 0; i < (min(cmd_len, 6)); i++)
282 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD0 + i,
283 0xFF, cmd[i]);
284 }
285 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF,
286 (u8)byte_cnt);
287 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_H, 0xFF,
288 (u8)(byte_cnt >> 8));
289 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L, 0xFF,
290 (u8)blk_cnt);
291 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H, 0xFF,
292 (u8)(blk_cnt >> 8));
293
294 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG1, 0x03, bus_width);
295
296 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF,
297 SD_CALCULATE_CRC7 | SD_CHECK_CRC16 | SD_NO_WAIT_BUSY_END |
298 SD_CHECK_CRC7 | SD_RSP_LEN_6);
299 if (trans_mode != SD_TM_AUTO_TUNING)
300 rtsx_add_cmd(chip, WRITE_REG_CMD,
301 CARD_DATA_SOURCE, 0x01, PINGPONG_BUFFER);
302
303 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF,
304 trans_mode | SD_TRANSFER_START);
305 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER, SD_TRANSFER_END,
306 SD_TRANSFER_END);
307
308 retval = rtsx_send_cmd(chip, SD_CARD, timeout);
309 if (retval < 0) {
310 if (retval == -ETIMEDOUT) {
311 sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
312 SD_RSP_TYPE_R1, NULL, 0);
313 }
314
315 return STATUS_FAIL;
316 }
317
318 if (buf && buf_len) {
319 retval = rtsx_read_ppbuf(chip, buf, buf_len);
320 if (retval != STATUS_SUCCESS)
321 return STATUS_FAIL;
322 }
323
324 return STATUS_SUCCESS;
325}
326
327static int sd_write_data(struct rtsx_chip *chip, u8 trans_mode,
328 u8 *cmd, int cmd_len, u16 byte_cnt, u16 blk_cnt,
329 u8 bus_width, u8 *buf, int buf_len, int timeout)
330{
331 struct sd_info *sd_card = &chip->sd_card;
332 int retval;
333 int i;
334
335 sd_clr_err_code(chip);
336
337 if (!buf)
338 buf_len = 0;
339
340 if (buf_len > 512) {
341
342 return STATUS_FAIL;
343 }
344
345 if (buf && buf_len) {
346 retval = rtsx_write_ppbuf(chip, buf, buf_len);
347 if (retval != STATUS_SUCCESS)
348 return STATUS_FAIL;
349 }
350
351 rtsx_init_cmd(chip);
352
353 if (cmd_len) {
354 dev_dbg(rtsx_dev(chip), "SD/MMC CMD %d\n", cmd[0] - 0x40);
355 for (i = 0; i < (min(cmd_len, 6)); i++) {
356 rtsx_add_cmd(chip, WRITE_REG_CMD,
357 REG_SD_CMD0 + i, 0xFF, cmd[i]);
358 }
359 }
360 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF,
361 (u8)byte_cnt);
362 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_H, 0xFF,
363 (u8)(byte_cnt >> 8));
364 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L, 0xFF,
365 (u8)blk_cnt);
366 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H, 0xFF,
367 (u8)(blk_cnt >> 8));
368
369 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG1, 0x03, bus_width);
370
371 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF,
372 SD_CALCULATE_CRC7 | SD_CHECK_CRC16 | SD_NO_WAIT_BUSY_END |
373 SD_CHECK_CRC7 | SD_RSP_LEN_6);
374
375 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF,
376 trans_mode | SD_TRANSFER_START);
377 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER, SD_TRANSFER_END,
378 SD_TRANSFER_END);
379
380 retval = rtsx_send_cmd(chip, SD_CARD, timeout);
381 if (retval < 0) {
382 if (retval == -ETIMEDOUT) {
383 sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
384 SD_RSP_TYPE_R1, NULL, 0);
385 }
386
387 return STATUS_FAIL;
388 }
389
390 return STATUS_SUCCESS;
391}
392
393static int sd_check_csd(struct rtsx_chip *chip, char check_wp)
394{
395 struct sd_info *sd_card = &chip->sd_card;
396 int retval;
397 int i;
398 u8 csd_ver, trans_speed;
399 u8 rsp[16];
400
401 for (i = 0; i < 6; i++) {
402 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
403 sd_set_err_code(chip, SD_NO_CARD);
404 return STATUS_FAIL;
405 }
406
407 retval = sd_send_cmd_get_rsp(chip, SEND_CSD, sd_card->sd_addr,
408 SD_RSP_TYPE_R2, rsp, 16);
409 if (retval == STATUS_SUCCESS)
410 break;
411 }
412
413 if (i == 6)
414 return STATUS_FAIL;
415
416 memcpy(sd_card->raw_csd, rsp + 1, 15);
417
418 dev_dbg(rtsx_dev(chip), "CSD Response:\n");
419 dev_dbg(rtsx_dev(chip), "%*ph\n", 16, sd_card->raw_csd);
420
421 csd_ver = (rsp[1] & 0xc0) >> 6;
422 dev_dbg(rtsx_dev(chip), "csd_ver = %d\n", csd_ver);
423
424 trans_speed = rsp[4];
425 if ((trans_speed & 0x07) == 0x02) {
426 if ((trans_speed & 0xf8) >= 0x30) {
427 if (chip->asic_code)
428 sd_card->sd_clock = 47;
429 else
430 sd_card->sd_clock = CLK_50;
431
432 } else if ((trans_speed & 0xf8) == 0x28) {
433 if (chip->asic_code)
434 sd_card->sd_clock = 39;
435 else
436 sd_card->sd_clock = CLK_40;
437
438 } else if ((trans_speed & 0xf8) == 0x20) {
439 if (chip->asic_code)
440 sd_card->sd_clock = 29;
441 else
442 sd_card->sd_clock = CLK_30;
443
444 } else if ((trans_speed & 0xf8) >= 0x10) {
445 if (chip->asic_code)
446 sd_card->sd_clock = 23;
447 else
448 sd_card->sd_clock = CLK_20;
449
450 } else if ((trans_speed & 0x08) >= 0x08) {
451 if (chip->asic_code)
452 sd_card->sd_clock = 19;
453 else
454 sd_card->sd_clock = CLK_20;
455 } else {
456 return STATUS_FAIL;
457 }
458 } else {
459 return STATUS_FAIL;
460 }
461
462 if (CHK_MMC_SECTOR_MODE(sd_card)) {
463 sd_card->capacity = 0;
464 } else {
465 if ((!CHK_SD_HCXC(sd_card)) || (csd_ver == 0)) {
466 u8 blk_size, c_size_mult;
467 u16 c_size;
468
469 blk_size = rsp[6] & 0x0F;
470 c_size = ((u16)(rsp[7] & 0x03) << 10)
471 + ((u16)rsp[8] << 2)
472 + ((u16)(rsp[9] & 0xC0) >> 6);
473 c_size_mult = (u8)((rsp[10] & 0x03) << 1);
474 c_size_mult += (rsp[11] & 0x80) >> 7;
475 sd_card->capacity = (((u32)(c_size + 1)) *
476 (1 << (c_size_mult + 2)))
477 << (blk_size - 9);
478 } else {
479 u32 total_sector = 0;
480
481 total_sector = (((u32)rsp[8] & 0x3f) << 16) |
482 ((u32)rsp[9] << 8) | (u32)rsp[10];
483 sd_card->capacity = (total_sector + 1) << 10;
484 }
485 }
486
487 if (check_wp) {
488 if (rsp[15] & 0x30)
489 chip->card_wp |= SD_CARD;
490
491 dev_dbg(rtsx_dev(chip), "CSD WP Status: 0x%x\n", rsp[15]);
492 }
493
494 return STATUS_SUCCESS;
495}
496
497static int sd_set_sample_push_timing(struct rtsx_chip *chip)
498{
499 int retval;
500 struct sd_info *sd_card = &chip->sd_card;
501 u8 val = 0;
502
503 if ((chip->sd_ctl & SD_PUSH_POINT_CTL_MASK) == SD_PUSH_POINT_DELAY)
504 val |= 0x10;
505
506 if ((chip->sd_ctl & SD_SAMPLE_POINT_CTL_MASK) == SD_SAMPLE_POINT_AUTO) {
507 if (chip->asic_code) {
508 if (CHK_SD_HS(sd_card) || CHK_MMC_52M(sd_card)) {
509 if (val & 0x10)
510 val |= 0x04;
511 else
512 val |= 0x08;
513 }
514 } else {
515 if (val & 0x10)
516 val |= 0x04;
517 else
518 val |= 0x08;
519 }
520 } else if ((chip->sd_ctl & SD_SAMPLE_POINT_CTL_MASK) ==
521 SD_SAMPLE_POINT_DELAY) {
522 if (val & 0x10)
523 val |= 0x04;
524 else
525 val |= 0x08;
526 }
527
528 retval = rtsx_write_register(chip, REG_SD_CFG1, 0x1C, val);
529 if (retval)
530 return retval;
531
532 return STATUS_SUCCESS;
533}
534
535static void sd_choose_proper_clock(struct rtsx_chip *chip)
536{
537 struct sd_info *sd_card = &chip->sd_card;
538
539 if (CHK_SD_SDR104(sd_card)) {
540 if (chip->asic_code)
541 sd_card->sd_clock = chip->asic_sd_sdr104_clk;
542 else
543 sd_card->sd_clock = chip->fpga_sd_sdr104_clk;
544
545 } else if (CHK_SD_DDR50(sd_card)) {
546 if (chip->asic_code)
547 sd_card->sd_clock = chip->asic_sd_ddr50_clk;
548 else
549 sd_card->sd_clock = chip->fpga_sd_ddr50_clk;
550
551 } else if (CHK_SD_SDR50(sd_card)) {
552 if (chip->asic_code)
553 sd_card->sd_clock = chip->asic_sd_sdr50_clk;
554 else
555 sd_card->sd_clock = chip->fpga_sd_sdr50_clk;
556
557 } else if (CHK_SD_HS(sd_card)) {
558 if (chip->asic_code)
559 sd_card->sd_clock = chip->asic_sd_hs_clk;
560 else
561 sd_card->sd_clock = chip->fpga_sd_hs_clk;
562
563 } else if (CHK_MMC_52M(sd_card) || CHK_MMC_DDR52(sd_card)) {
564 if (chip->asic_code)
565 sd_card->sd_clock = chip->asic_mmc_52m_clk;
566 else
567 sd_card->sd_clock = chip->fpga_mmc_52m_clk;
568
569 } else if (CHK_MMC_26M(sd_card)) {
570 if (chip->asic_code)
571 sd_card->sd_clock = 48;
572 else
573 sd_card->sd_clock = CLK_50;
574 }
575}
576
577static int sd_set_clock_divider(struct rtsx_chip *chip, u8 clk_div)
578{
579 int retval;
580 u8 mask = 0, val = 0;
581
582 mask = 0x60;
583 if (clk_div == SD_CLK_DIVIDE_0)
584 val = 0x00;
585 else if (clk_div == SD_CLK_DIVIDE_128)
586 val = 0x40;
587 else if (clk_div == SD_CLK_DIVIDE_256)
588 val = 0x20;
589
590 retval = rtsx_write_register(chip, REG_SD_CFG1, mask, val);
591 if (retval)
592 return retval;
593
594 return STATUS_SUCCESS;
595}
596
597static int sd_set_init_para(struct rtsx_chip *chip)
598{
599 struct sd_info *sd_card = &chip->sd_card;
600 int retval;
601
602 retval = sd_set_sample_push_timing(chip);
603 if (retval != STATUS_SUCCESS)
604 return STATUS_FAIL;
605
606 sd_choose_proper_clock(chip);
607
608 retval = switch_clock(chip, sd_card->sd_clock);
609 if (retval != STATUS_SUCCESS)
610 return STATUS_FAIL;
611
612 return STATUS_SUCCESS;
613}
614
615int sd_select_card(struct rtsx_chip *chip, int select)
616{
617 struct sd_info *sd_card = &chip->sd_card;
618 int retval;
619 u8 cmd_idx, cmd_type;
620 u32 addr;
621
622 if (select) {
623 cmd_idx = SELECT_CARD;
624 cmd_type = SD_RSP_TYPE_R1;
625 addr = sd_card->sd_addr;
626 } else {
627 cmd_idx = DESELECT_CARD;
628 cmd_type = SD_RSP_TYPE_R0;
629 addr = 0;
630 }
631
632 retval = sd_send_cmd_get_rsp(chip, cmd_idx, addr, cmd_type, NULL, 0);
633 if (retval != STATUS_SUCCESS)
634 return STATUS_FAIL;
635
636 return STATUS_SUCCESS;
637}
638
639#ifdef SUPPORT_SD_LOCK
640static int sd_update_lock_status(struct rtsx_chip *chip)
641{
642 struct sd_info *sd_card = &chip->sd_card;
643 int retval;
644 u8 rsp[5];
645
646 retval = sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
647 SD_RSP_TYPE_R1, rsp, 5);
648 if (retval != STATUS_SUCCESS)
649 return STATUS_FAIL;
650
651 if (rsp[1] & 0x02)
652 sd_card->sd_lock_status |= SD_LOCKED;
653 else
654 sd_card->sd_lock_status &= ~SD_LOCKED;
655
656 dev_dbg(rtsx_dev(chip), "sd_card->sd_lock_status = 0x%x\n",
657 sd_card->sd_lock_status);
658
659 if (rsp[1] & 0x01)
660 return STATUS_FAIL;
661
662 return STATUS_SUCCESS;
663}
664#endif
665
666static int sd_wait_state_data_ready(struct rtsx_chip *chip, u8 state,
667 u8 data_ready, int polling_cnt)
668{
669 struct sd_info *sd_card = &chip->sd_card;
670 int retval, i;
671 u8 rsp[5];
672
673 for (i = 0; i < polling_cnt; i++) {
674 retval = sd_send_cmd_get_rsp(chip, SEND_STATUS,
675 sd_card->sd_addr, SD_RSP_TYPE_R1,
676 rsp, 5);
677 if (retval != STATUS_SUCCESS)
678 return STATUS_FAIL;
679
680 if (((rsp[3] & 0x1E) == state) &&
681 ((rsp[3] & 0x01) == data_ready))
682 return STATUS_SUCCESS;
683 }
684
685 return STATUS_FAIL;
686}
687
688static int sd_change_bank_voltage(struct rtsx_chip *chip, u8 voltage)
689{
690 int retval;
691
692 if (voltage == SD_IO_3V3) {
693 if (chip->asic_code) {
694 retval = rtsx_write_phy_register(chip, 0x08,
695 0x4FC0 |
696 chip->phy_voltage);
697 if (retval != STATUS_SUCCESS)
698 return STATUS_FAIL;
699 } else {
700 retval = rtsx_write_register(chip, SD_PAD_CTL,
701 SD_IO_USING_1V8, 0);
702 if (retval)
703 return retval;
704 }
705 } else if (voltage == SD_IO_1V8) {
706 if (chip->asic_code) {
707 retval = rtsx_write_phy_register(chip, 0x08,
708 0x4C40 |
709 chip->phy_voltage);
710 if (retval != STATUS_SUCCESS)
711 return STATUS_FAIL;
712 } else {
713 retval = rtsx_write_register(chip, SD_PAD_CTL,
714 SD_IO_USING_1V8,
715 SD_IO_USING_1V8);
716 if (retval)
717 return retval;
718 }
719 } else {
720 return STATUS_FAIL;
721 }
722
723 return STATUS_SUCCESS;
724}
725
726static int sd_voltage_switch(struct rtsx_chip *chip)
727{
728 int retval;
729 u8 stat;
730
731 retval = rtsx_write_register(chip, SD_BUS_STAT,
732 SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP,
733 SD_CLK_TOGGLE_EN);
734 if (retval)
735 return retval;
736
737 retval = sd_send_cmd_get_rsp(chip, VOLTAGE_SWITCH, 0, SD_RSP_TYPE_R1,
738 NULL, 0);
739 if (retval != STATUS_SUCCESS)
740 return STATUS_FAIL;
741
742 udelay(chip->sd_voltage_switch_delay);
743
744 retval = rtsx_read_register(chip, SD_BUS_STAT, &stat);
745 if (retval)
746 return retval;
747 if (stat & (SD_CMD_STATUS | SD_DAT3_STATUS | SD_DAT2_STATUS |
748 SD_DAT1_STATUS | SD_DAT0_STATUS)) {
749 return STATUS_FAIL;
750 }
751
752 retval = rtsx_write_register(chip, SD_BUS_STAT, 0xFF,
753 SD_CLK_FORCE_STOP);
754 if (retval)
755 return retval;
756 retval = sd_change_bank_voltage(chip, SD_IO_1V8);
757 if (retval != STATUS_SUCCESS)
758 return STATUS_FAIL;
759
760 wait_timeout(50);
761
762 retval = rtsx_write_register(chip, SD_BUS_STAT, 0xFF,
763 SD_CLK_TOGGLE_EN);
764 if (retval)
765 return retval;
766 wait_timeout(10);
767
768 retval = rtsx_read_register(chip, SD_BUS_STAT, &stat);
769 if (retval)
770 return retval;
771 if ((stat & (SD_CMD_STATUS | SD_DAT3_STATUS | SD_DAT2_STATUS |
772 SD_DAT1_STATUS | SD_DAT0_STATUS)) !=
773 (SD_CMD_STATUS | SD_DAT3_STATUS | SD_DAT2_STATUS |
774 SD_DAT1_STATUS | SD_DAT0_STATUS)) {
775 dev_dbg(rtsx_dev(chip), "SD_BUS_STAT: 0x%x\n", stat);
776 rtsx_write_register(chip, SD_BUS_STAT, SD_CLK_TOGGLE_EN |
777 SD_CLK_FORCE_STOP, 0);
778 rtsx_write_register(chip, CARD_CLK_EN, 0xFF, 0);
779 return STATUS_FAIL;
780 }
781
782 retval = rtsx_write_register(chip, SD_BUS_STAT,
783 SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP, 0);
784 if (retval)
785 return retval;
786
787 return STATUS_SUCCESS;
788}
789
790static int sd_reset_dcm(struct rtsx_chip *chip, u8 tune_dir)
791{
792 int retval;
793
794 if (tune_dir == TUNE_RX) {
795 retval = rtsx_write_register(chip, DCM_DRP_CTL, 0xFF,
796 DCM_RESET | DCM_RX);
797 if (retval)
798 return retval;
799 retval = rtsx_write_register(chip, DCM_DRP_CTL, 0xFF, DCM_RX);
800 if (retval)
801 return retval;
802 } else {
803 retval = rtsx_write_register(chip, DCM_DRP_CTL, 0xFF,
804 DCM_RESET | DCM_TX);
805 if (retval)
806 return retval;
807 retval = rtsx_write_register(chip, DCM_DRP_CTL, 0xFF, DCM_TX);
808 if (retval)
809 return retval;
810 }
811
812 return STATUS_SUCCESS;
813}
814
815static int sd_change_phase(struct rtsx_chip *chip, u8 sample_point, u8 tune_dir)
816{
817 struct sd_info *sd_card = &chip->sd_card;
818 u16 SD_VP_CTL, SD_DCMPS_CTL;
819 u8 val;
820 int retval;
821 bool ddr_rx = false;
822
823 dev_dbg(rtsx_dev(chip), "%s (sample_point = %d, tune_dir = %d)\n",
824 __func__, sample_point, tune_dir);
825
826 if (tune_dir == TUNE_RX) {
827 SD_VP_CTL = SD_VPRX_CTL;
828 SD_DCMPS_CTL = SD_DCMPS_RX_CTL;
829 if (CHK_SD_DDR50(sd_card))
830 ddr_rx = true;
831 } else {
832 SD_VP_CTL = SD_VPTX_CTL;
833 SD_DCMPS_CTL = SD_DCMPS_TX_CTL;
834 }
835
836 if (chip->asic_code) {
837 retval = rtsx_write_register(chip, CLK_CTL, CHANGE_CLK,
838 CHANGE_CLK);
839 if (retval)
840 return retval;
841 retval = rtsx_write_register(chip, SD_VP_CTL, 0x1F,
842 sample_point);
843 if (retval)
844 return retval;
845 retval = rtsx_write_register(chip, SD_VPCLK0_CTL,
846 PHASE_NOT_RESET, 0);
847 if (retval)
848 return retval;
849 retval = rtsx_write_register(chip, SD_VPCLK0_CTL,
850 PHASE_NOT_RESET, PHASE_NOT_RESET);
851 if (retval)
852 return retval;
853 retval = rtsx_write_register(chip, CLK_CTL, CHANGE_CLK, 0);
854 if (retval)
855 return retval;
856 } else {
857 rtsx_read_register(chip, SD_VP_CTL, &val);
858 dev_dbg(rtsx_dev(chip), "SD_VP_CTL: 0x%x\n", val);
859 rtsx_read_register(chip, SD_DCMPS_CTL, &val);
860 dev_dbg(rtsx_dev(chip), "SD_DCMPS_CTL: 0x%x\n", val);
861
862 if (ddr_rx) {
863 retval = rtsx_write_register(chip, SD_VP_CTL,
864 PHASE_CHANGE,
865 PHASE_CHANGE);
866 if (retval)
867 return retval;
868 udelay(50);
869 retval = rtsx_write_register(chip, SD_VP_CTL, 0xFF,
870 PHASE_CHANGE |
871 PHASE_NOT_RESET |
872 sample_point);
873 if (retval)
874 return retval;
875 } else {
876 retval = rtsx_write_register(chip, CLK_CTL,
877 CHANGE_CLK, CHANGE_CLK);
878 if (retval)
879 return retval;
880 udelay(50);
881 retval = rtsx_write_register(chip, SD_VP_CTL, 0xFF,
882 PHASE_NOT_RESET |
883 sample_point);
884 if (retval)
885 return retval;
886 }
887 udelay(100);
888
889 rtsx_init_cmd(chip);
890 rtsx_add_cmd(chip, WRITE_REG_CMD, SD_DCMPS_CTL, DCMPS_CHANGE,
891 DCMPS_CHANGE);
892 rtsx_add_cmd(chip, CHECK_REG_CMD, SD_DCMPS_CTL,
893 DCMPS_CHANGE_DONE, DCMPS_CHANGE_DONE);
894 retval = rtsx_send_cmd(chip, SD_CARD, 100);
895 if (retval != STATUS_SUCCESS)
896 goto fail;
897
898 val = *rtsx_get_cmd_data(chip);
899 if (val & DCMPS_ERROR)
900 goto fail;
901
902 if ((val & DCMPS_CURRENT_PHASE) != sample_point)
903 goto fail;
904
905 retval = rtsx_write_register(chip, SD_DCMPS_CTL,
906 DCMPS_CHANGE, 0);
907 if (retval)
908 return retval;
909 if (ddr_rx) {
910 retval = rtsx_write_register(chip, SD_VP_CTL,
911 PHASE_CHANGE, 0);
912 if (retval)
913 return retval;
914 } else {
915 retval = rtsx_write_register(chip, CLK_CTL,
916 CHANGE_CLK, 0);
917 if (retval)
918 return retval;
919 }
920
921 udelay(50);
922 }
923
924 retval = rtsx_write_register(chip, SD_CFG1, SD_ASYNC_FIFO_NOT_RST, 0);
925 if (retval)
926 return retval;
927
928 return STATUS_SUCCESS;
929
930fail:
931 rtsx_read_register(chip, SD_VP_CTL, &val);
932 dev_dbg(rtsx_dev(chip), "SD_VP_CTL: 0x%x\n", val);
933 rtsx_read_register(chip, SD_DCMPS_CTL, &val);
934 dev_dbg(rtsx_dev(chip), "SD_DCMPS_CTL: 0x%x\n", val);
935
936 rtsx_write_register(chip, SD_DCMPS_CTL, DCMPS_CHANGE, 0);
937 rtsx_write_register(chip, SD_VP_CTL, PHASE_CHANGE, 0);
938 mdelay(10);
939 sd_reset_dcm(chip, tune_dir);
940 return STATUS_FAIL;
941}
942
943static int sd_check_spec(struct rtsx_chip *chip, u8 bus_width)
944{
945 struct sd_info *sd_card = &chip->sd_card;
946 int retval;
947 u8 cmd[5], buf[8];
948
949 retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
950 SD_RSP_TYPE_R1, NULL, 0);
951 if (retval != STATUS_SUCCESS)
952 return STATUS_FAIL;
953
954 cmd[0] = 0x40 | SEND_SCR;
955 cmd[1] = 0;
956 cmd[2] = 0;
957 cmd[3] = 0;
958 cmd[4] = 0;
959
960 retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd, 5, 8, 1, bus_width,
961 buf, 8, 250);
962 if (retval != STATUS_SUCCESS) {
963 rtsx_clear_sd_error(chip);
964 return STATUS_FAIL;
965 }
966
967 memcpy(sd_card->raw_scr, buf, 8);
968
969 if ((buf[0] & 0x0F) == 0)
970 return STATUS_FAIL;
971
972 return STATUS_SUCCESS;
973}
974
975static int sd_query_switch_result(struct rtsx_chip *chip, u8 func_group,
976 u8 func_to_switch, u8 *buf, int buf_len)
977{
978 u8 support_mask = 0, query_switch = 0, switch_busy = 0;
979 int support_offset = 0, query_switch_offset = 0, check_busy_offset = 0;
980
981 if (func_group == SD_FUNC_GROUP_1) {
982 support_offset = FUNCTION_GROUP1_SUPPORT_OFFSET;
983 query_switch_offset = FUNCTION_GROUP1_QUERY_SWITCH_OFFSET;
984 check_busy_offset = FUNCTION_GROUP1_CHECK_BUSY_OFFSET;
985
986 switch (func_to_switch) {
987 case HS_SUPPORT:
988 support_mask = HS_SUPPORT_MASK;
989 query_switch = HS_QUERY_SWITCH_OK;
990 switch_busy = HS_SWITCH_BUSY;
991 break;
992
993 case SDR50_SUPPORT:
994 support_mask = SDR50_SUPPORT_MASK;
995 query_switch = SDR50_QUERY_SWITCH_OK;
996 switch_busy = SDR50_SWITCH_BUSY;
997 break;
998
999 case SDR104_SUPPORT:
1000 support_mask = SDR104_SUPPORT_MASK;
1001 query_switch = SDR104_QUERY_SWITCH_OK;
1002 switch_busy = SDR104_SWITCH_BUSY;
1003 break;
1004
1005 case DDR50_SUPPORT:
1006 support_mask = DDR50_SUPPORT_MASK;
1007 query_switch = DDR50_QUERY_SWITCH_OK;
1008 switch_busy = DDR50_SWITCH_BUSY;
1009 break;
1010
1011 default:
1012 return STATUS_FAIL;
1013 }
1014 } else if (func_group == SD_FUNC_GROUP_3) {
1015 support_offset = FUNCTION_GROUP3_SUPPORT_OFFSET;
1016 query_switch_offset = FUNCTION_GROUP3_QUERY_SWITCH_OFFSET;
1017 check_busy_offset = FUNCTION_GROUP3_CHECK_BUSY_OFFSET;
1018
1019 switch (func_to_switch) {
1020 case DRIVING_TYPE_A:
1021 support_mask = DRIVING_TYPE_A_MASK;
1022 query_switch = TYPE_A_QUERY_SWITCH_OK;
1023 switch_busy = TYPE_A_SWITCH_BUSY;
1024 break;
1025
1026 case DRIVING_TYPE_C:
1027 support_mask = DRIVING_TYPE_C_MASK;
1028 query_switch = TYPE_C_QUERY_SWITCH_OK;
1029 switch_busy = TYPE_C_SWITCH_BUSY;
1030 break;
1031
1032 case DRIVING_TYPE_D:
1033 support_mask = DRIVING_TYPE_D_MASK;
1034 query_switch = TYPE_D_QUERY_SWITCH_OK;
1035 switch_busy = TYPE_D_SWITCH_BUSY;
1036 break;
1037
1038 default:
1039 return STATUS_FAIL;
1040 }
1041 } else if (func_group == SD_FUNC_GROUP_4) {
1042 support_offset = FUNCTION_GROUP4_SUPPORT_OFFSET;
1043 query_switch_offset = FUNCTION_GROUP4_QUERY_SWITCH_OFFSET;
1044 check_busy_offset = FUNCTION_GROUP4_CHECK_BUSY_OFFSET;
1045
1046 switch (func_to_switch) {
1047 case CURRENT_LIMIT_400:
1048 support_mask = CURRENT_LIMIT_400_MASK;
1049 query_switch = CURRENT_LIMIT_400_QUERY_SWITCH_OK;
1050 switch_busy = CURRENT_LIMIT_400_SWITCH_BUSY;
1051 break;
1052
1053 case CURRENT_LIMIT_600:
1054 support_mask = CURRENT_LIMIT_600_MASK;
1055 query_switch = CURRENT_LIMIT_600_QUERY_SWITCH_OK;
1056 switch_busy = CURRENT_LIMIT_600_SWITCH_BUSY;
1057 break;
1058
1059 case CURRENT_LIMIT_800:
1060 support_mask = CURRENT_LIMIT_800_MASK;
1061 query_switch = CURRENT_LIMIT_800_QUERY_SWITCH_OK;
1062 switch_busy = CURRENT_LIMIT_800_SWITCH_BUSY;
1063 break;
1064
1065 default:
1066 return STATUS_FAIL;
1067 }
1068 } else {
1069 return STATUS_FAIL;
1070 }
1071
1072 if (func_group == SD_FUNC_GROUP_1) {
1073 if (!(buf[support_offset] & support_mask) ||
1074 ((buf[query_switch_offset] & 0x0F) != query_switch)) {
1075 return STATUS_FAIL;
1076 }
1077 }
1078
1079
1080 if ((buf[DATA_STRUCTURE_VER_OFFSET] == 0x01) &&
1081 ((buf[check_busy_offset] & switch_busy) == switch_busy)) {
1082 return STATUS_FAIL;
1083 }
1084
1085 return STATUS_SUCCESS;
1086}
1087
1088static int sd_check_switch_mode(struct rtsx_chip *chip, u8 mode, u8 func_group,
1089 u8 func_to_switch, u8 bus_width)
1090{
1091 struct sd_info *sd_card = &chip->sd_card;
1092 int retval;
1093 u8 cmd[5], buf[64];
1094
1095 dev_dbg(rtsx_dev(chip), "%s (mode = %d, func_group = %d, func_to_switch = %d)\n",
1096 __func__, mode, func_group, func_to_switch);
1097
1098 cmd[0] = 0x40 | SWITCH;
1099 cmd[1] = mode;
1100
1101 if (func_group == SD_FUNC_GROUP_1) {
1102 cmd[2] = 0xFF;
1103 cmd[3] = 0xFF;
1104 cmd[4] = 0xF0 + func_to_switch;
1105 } else if (func_group == SD_FUNC_GROUP_3) {
1106 cmd[2] = 0xFF;
1107 cmd[3] = 0xF0 + func_to_switch;
1108 cmd[4] = 0xFF;
1109 } else if (func_group == SD_FUNC_GROUP_4) {
1110 cmd[2] = 0xFF;
1111 cmd[3] = 0x0F + (func_to_switch << 4);
1112 cmd[4] = 0xFF;
1113 } else {
1114 cmd[1] = SD_CHECK_MODE;
1115 cmd[2] = 0xFF;
1116 cmd[3] = 0xFF;
1117 cmd[4] = 0xFF;
1118 }
1119
1120 retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd, 5, 64, 1, bus_width,
1121 buf, 64, 250);
1122 if (retval != STATUS_SUCCESS) {
1123 rtsx_clear_sd_error(chip);
1124 return STATUS_FAIL;
1125 }
1126
1127 dev_dbg(rtsx_dev(chip), "%*ph\n", 64, buf);
1128
1129 if (func_group == NO_ARGUMENT) {
1130 sd_card->func_group1_mask = buf[0x0D];
1131 sd_card->func_group2_mask = buf[0x0B];
1132 sd_card->func_group3_mask = buf[0x09];
1133 sd_card->func_group4_mask = buf[0x07];
1134
1135 dev_dbg(rtsx_dev(chip), "func_group1_mask = 0x%02x\n",
1136 buf[0x0D]);
1137 dev_dbg(rtsx_dev(chip), "func_group2_mask = 0x%02x\n",
1138 buf[0x0B]);
1139 dev_dbg(rtsx_dev(chip), "func_group3_mask = 0x%02x\n",
1140 buf[0x09]);
1141 dev_dbg(rtsx_dev(chip), "func_group4_mask = 0x%02x\n",
1142 buf[0x07]);
1143 } else {
1144
1145
1146
1147 u16 cc = ((u16)buf[0] << 8) | buf[1];
1148
1149 dev_dbg(rtsx_dev(chip), "Maximum current consumption: %dmA\n",
1150 cc);
1151 if ((cc == 0) || (cc > 800))
1152 return STATUS_FAIL;
1153
1154 retval = sd_query_switch_result(chip, func_group,
1155 func_to_switch, buf, 64);
1156 if (retval != STATUS_SUCCESS)
1157 return STATUS_FAIL;
1158
1159 if ((cc > 400) || (func_to_switch > CURRENT_LIMIT_400)) {
1160 retval = rtsx_write_register(chip, OCPPARA2,
1161 SD_OCP_THD_MASK,
1162 chip->sd_800mA_ocp_thd);
1163 if (retval)
1164 return retval;
1165 retval = rtsx_write_register(chip, CARD_PWR_CTL,
1166 PMOS_STRG_MASK,
1167 PMOS_STRG_800mA);
1168 if (retval)
1169 return retval;
1170 }
1171 }
1172
1173 return STATUS_SUCCESS;
1174}
1175
1176static u8 downgrade_switch_mode(u8 func_group, u8 func_to_switch)
1177{
1178 if (func_group == SD_FUNC_GROUP_1) {
1179 if (func_to_switch > HS_SUPPORT)
1180 func_to_switch--;
1181
1182 } else if (func_group == SD_FUNC_GROUP_4) {
1183 if (func_to_switch > CURRENT_LIMIT_200)
1184 func_to_switch--;
1185 }
1186
1187 return func_to_switch;
1188}
1189
1190static int sd_check_switch(struct rtsx_chip *chip,
1191 u8 func_group, u8 func_to_switch, u8 bus_width)
1192{
1193 int retval;
1194 int i;
1195 bool switch_good = false;
1196
1197 for (i = 0; i < 3; i++) {
1198 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
1199 sd_set_err_code(chip, SD_NO_CARD);
1200 return STATUS_FAIL;
1201 }
1202
1203 retval = sd_check_switch_mode(chip, SD_CHECK_MODE, func_group,
1204 func_to_switch, bus_width);
1205 if (retval == STATUS_SUCCESS) {
1206 u8 stat;
1207
1208 retval = sd_check_switch_mode(chip, SD_SWITCH_MODE,
1209 func_group,
1210 func_to_switch,
1211 bus_width);
1212 if (retval == STATUS_SUCCESS) {
1213 switch_good = true;
1214 break;
1215 }
1216
1217 retval = rtsx_read_register(chip, SD_STAT1, &stat);
1218 if (retval)
1219 return retval;
1220 if (stat & SD_CRC16_ERR) {
1221 dev_dbg(rtsx_dev(chip), "SD CRC16 error when switching mode\n");
1222 return STATUS_FAIL;
1223 }
1224 }
1225
1226 func_to_switch = downgrade_switch_mode(func_group,
1227 func_to_switch);
1228
1229 wait_timeout(20);
1230 }
1231
1232 if (!switch_good)
1233 return STATUS_FAIL;
1234
1235 return STATUS_SUCCESS;
1236}
1237
1238static int sd_switch_function(struct rtsx_chip *chip, u8 bus_width)
1239{
1240 struct sd_info *sd_card = &chip->sd_card;
1241 int retval;
1242 int i;
1243 u8 func_to_switch = 0;
1244
1245
1246 retval = sd_check_switch_mode(chip, SD_CHECK_MODE, NO_ARGUMENT,
1247 NO_ARGUMENT, bus_width);
1248 if (retval != STATUS_SUCCESS)
1249 return STATUS_FAIL;
1250
1251 sd_card->func_group1_mask &= ~(sd_card->sd_switch_fail);
1252
1253
1254 for (i = 0; i < 4; i++) {
1255 switch ((u8)(chip->sd_speed_prior >> (i * 8))) {
1256 case SDR104_SUPPORT:
1257 if ((sd_card->func_group1_mask & SDR104_SUPPORT_MASK) &&
1258 chip->sdr104_en) {
1259 func_to_switch = SDR104_SUPPORT;
1260 }
1261 break;
1262
1263 case DDR50_SUPPORT:
1264 if ((sd_card->func_group1_mask & DDR50_SUPPORT_MASK) &&
1265 chip->ddr50_en) {
1266 func_to_switch = DDR50_SUPPORT;
1267 }
1268 break;
1269
1270 case SDR50_SUPPORT:
1271 if ((sd_card->func_group1_mask & SDR50_SUPPORT_MASK) &&
1272 chip->sdr50_en) {
1273 func_to_switch = SDR50_SUPPORT;
1274 }
1275 break;
1276
1277 case HS_SUPPORT:
1278 if (sd_card->func_group1_mask & HS_SUPPORT_MASK)
1279 func_to_switch = HS_SUPPORT;
1280
1281 break;
1282
1283 default:
1284 continue;
1285 }
1286
1287 if (func_to_switch)
1288 break;
1289 }
1290 dev_dbg(rtsx_dev(chip), "SD_FUNC_GROUP_1: func_to_switch = 0x%02x",
1291 func_to_switch);
1292
1293#ifdef SUPPORT_SD_LOCK
1294 if ((sd_card->sd_lock_status & SD_SDR_RST) &&
1295 (func_to_switch == DDR50_SUPPORT) &&
1296 (sd_card->func_group1_mask & SDR50_SUPPORT_MASK)) {
1297 func_to_switch = SDR50_SUPPORT;
1298 dev_dbg(rtsx_dev(chip), "Using SDR50 instead of DDR50 for SD Lock\n");
1299 }
1300#endif
1301
1302 if (func_to_switch) {
1303 retval = sd_check_switch(chip, SD_FUNC_GROUP_1, func_to_switch,
1304 bus_width);
1305 if (retval != STATUS_SUCCESS) {
1306 if (func_to_switch == SDR104_SUPPORT) {
1307 sd_card->sd_switch_fail = SDR104_SUPPORT_MASK;
1308 } else if (func_to_switch == DDR50_SUPPORT) {
1309 sd_card->sd_switch_fail = SDR104_SUPPORT_MASK |
1310 DDR50_SUPPORT_MASK;
1311 } else if (func_to_switch == SDR50_SUPPORT) {
1312 sd_card->sd_switch_fail = SDR104_SUPPORT_MASK |
1313 DDR50_SUPPORT_MASK | SDR50_SUPPORT_MASK;
1314 }
1315 return STATUS_FAIL;
1316 }
1317
1318 if (func_to_switch == SDR104_SUPPORT)
1319 SET_SD_SDR104(sd_card);
1320 else if (func_to_switch == DDR50_SUPPORT)
1321 SET_SD_DDR50(sd_card);
1322 else if (func_to_switch == SDR50_SUPPORT)
1323 SET_SD_SDR50(sd_card);
1324 else
1325 SET_SD_HS(sd_card);
1326 }
1327
1328 if (CHK_SD_DDR50(sd_card)) {
1329 retval = rtsx_write_register(chip, SD_PUSH_POINT_CTL, 0x06,
1330 0x04);
1331 if (retval)
1332 return retval;
1333 retval = sd_set_sample_push_timing(chip);
1334 if (retval != STATUS_SUCCESS)
1335 return STATUS_FAIL;
1336 }
1337
1338 if (!func_to_switch || (func_to_switch == HS_SUPPORT)) {
1339
1340
1341
1342 return STATUS_SUCCESS;
1343 }
1344
1345
1346 func_to_switch = 0xFF;
1347
1348 for (i = 0; i < 4; i++) {
1349 switch ((u8)(chip->sd_current_prior >> (i * 8))) {
1350 case CURRENT_LIMIT_800:
1351 if (sd_card->func_group4_mask & CURRENT_LIMIT_800_MASK)
1352 func_to_switch = CURRENT_LIMIT_800;
1353
1354 break;
1355
1356 case CURRENT_LIMIT_600:
1357 if (sd_card->func_group4_mask & CURRENT_LIMIT_600_MASK)
1358 func_to_switch = CURRENT_LIMIT_600;
1359
1360 break;
1361
1362 case CURRENT_LIMIT_400:
1363 if (sd_card->func_group4_mask & CURRENT_LIMIT_400_MASK)
1364 func_to_switch = CURRENT_LIMIT_400;
1365
1366 break;
1367
1368 case CURRENT_LIMIT_200:
1369 if (sd_card->func_group4_mask & CURRENT_LIMIT_200_MASK)
1370 func_to_switch = CURRENT_LIMIT_200;
1371
1372 break;
1373
1374 default:
1375 continue;
1376 }
1377
1378 if (func_to_switch != 0xFF)
1379 break;
1380 }
1381
1382 dev_dbg(rtsx_dev(chip), "SD_FUNC_GROUP_4: func_to_switch = 0x%02x",
1383 func_to_switch);
1384
1385 if (func_to_switch <= CURRENT_LIMIT_800) {
1386 retval = sd_check_switch(chip, SD_FUNC_GROUP_4, func_to_switch,
1387 bus_width);
1388 if (retval != STATUS_SUCCESS) {
1389 if (sd_check_err_code(chip, SD_NO_CARD))
1390 return STATUS_FAIL;
1391 }
1392 dev_dbg(rtsx_dev(chip), "Switch current limit finished! (%d)\n",
1393 retval);
1394 }
1395
1396 if (CHK_SD_DDR50(sd_card)) {
1397 retval = rtsx_write_register(chip, SD_PUSH_POINT_CTL, 0x06, 0);
1398 if (retval)
1399 return retval;
1400 }
1401
1402 return STATUS_SUCCESS;
1403}
1404
1405static int sd_wait_data_idle(struct rtsx_chip *chip)
1406{
1407 int retval = STATUS_TIMEDOUT;
1408 int i;
1409 u8 val = 0;
1410
1411 for (i = 0; i < 100; i++) {
1412 retval = rtsx_read_register(chip, SD_DATA_STATE, &val);
1413 if (retval)
1414 return retval;
1415 if (val & SD_DATA_IDLE) {
1416 retval = STATUS_SUCCESS;
1417 break;
1418 }
1419 udelay(100);
1420 }
1421 dev_dbg(rtsx_dev(chip), "SD_DATA_STATE: 0x%02x\n", val);
1422
1423 return retval;
1424}
1425
1426static int sd_sdr_tuning_rx_cmd(struct rtsx_chip *chip, u8 sample_point)
1427{
1428 int retval;
1429 u8 cmd[5];
1430
1431 retval = sd_change_phase(chip, sample_point, TUNE_RX);
1432 if (retval != STATUS_SUCCESS)
1433 return STATUS_FAIL;
1434
1435 cmd[0] = 0x40 | SEND_TUNING_PATTERN;
1436 cmd[1] = 0;
1437 cmd[2] = 0;
1438 cmd[3] = 0;
1439 cmd[4] = 0;
1440
1441 retval = sd_read_data(chip, SD_TM_AUTO_TUNING, cmd, 5, 0x40, 1,
1442 SD_BUS_WIDTH_4, NULL, 0, 100);
1443 if (retval != STATUS_SUCCESS) {
1444 (void)sd_wait_data_idle(chip);
1445
1446 rtsx_clear_sd_error(chip);
1447 return STATUS_FAIL;
1448 }
1449
1450 return STATUS_SUCCESS;
1451}
1452
1453static int sd_ddr_tuning_rx_cmd(struct rtsx_chip *chip, u8 sample_point)
1454{
1455 struct sd_info *sd_card = &chip->sd_card;
1456 int retval;
1457 u8 cmd[5];
1458
1459 retval = sd_change_phase(chip, sample_point, TUNE_RX);
1460 if (retval != STATUS_SUCCESS)
1461 return STATUS_FAIL;
1462
1463 dev_dbg(rtsx_dev(chip), "sd ddr tuning rx\n");
1464
1465 retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
1466 SD_RSP_TYPE_R1, NULL, 0);
1467 if (retval != STATUS_SUCCESS)
1468 return STATUS_FAIL;
1469
1470 cmd[0] = 0x40 | SD_STATUS;
1471 cmd[1] = 0;
1472 cmd[2] = 0;
1473 cmd[3] = 0;
1474 cmd[4] = 0;
1475
1476 retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd, 5, 64, 1,
1477 SD_BUS_WIDTH_4, NULL, 0, 100);
1478 if (retval != STATUS_SUCCESS) {
1479 (void)sd_wait_data_idle(chip);
1480
1481 rtsx_clear_sd_error(chip);
1482 return STATUS_FAIL;
1483 }
1484
1485 return STATUS_SUCCESS;
1486}
1487
1488static int mmc_ddr_tuning_rx_cmd(struct rtsx_chip *chip, u8 sample_point)
1489{
1490 struct sd_info *sd_card = &chip->sd_card;
1491 int retval;
1492 u8 cmd[5], bus_width;
1493
1494 if (CHK_MMC_8BIT(sd_card))
1495 bus_width = SD_BUS_WIDTH_8;
1496 else if (CHK_MMC_4BIT(sd_card))
1497 bus_width = SD_BUS_WIDTH_4;
1498 else
1499 bus_width = SD_BUS_WIDTH_1;
1500
1501 retval = sd_change_phase(chip, sample_point, TUNE_RX);
1502 if (retval != STATUS_SUCCESS)
1503 return STATUS_FAIL;
1504
1505 dev_dbg(rtsx_dev(chip), "mmc ddr tuning rx\n");
1506
1507 cmd[0] = 0x40 | SEND_EXT_CSD;
1508 cmd[1] = 0;
1509 cmd[2] = 0;
1510 cmd[3] = 0;
1511 cmd[4] = 0;
1512
1513 retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd, 5, 0x200, 1,
1514 bus_width, NULL, 0, 100);
1515 if (retval != STATUS_SUCCESS) {
1516 (void)sd_wait_data_idle(chip);
1517
1518 rtsx_clear_sd_error(chip);
1519 return STATUS_FAIL;
1520 }
1521
1522 return STATUS_SUCCESS;
1523}
1524
1525static int sd_sdr_tuning_tx_cmd(struct rtsx_chip *chip, u8 sample_point)
1526{
1527 struct sd_info *sd_card = &chip->sd_card;
1528 int retval;
1529
1530 retval = sd_change_phase(chip, sample_point, TUNE_TX);
1531 if (retval != STATUS_SUCCESS)
1532 return STATUS_FAIL;
1533
1534 retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN,
1535 SD_RSP_80CLK_TIMEOUT_EN);
1536 if (retval)
1537 return retval;
1538
1539 retval = sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
1540 SD_RSP_TYPE_R1, NULL, 0);
1541 if (retval != STATUS_SUCCESS) {
1542 if (sd_check_err_code(chip, SD_RSP_TIMEOUT)) {
1543 rtsx_write_register(chip, SD_CFG3,
1544 SD_RSP_80CLK_TIMEOUT_EN, 0);
1545 return STATUS_FAIL;
1546 }
1547 }
1548
1549 retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN,
1550 0);
1551 if (retval)
1552 return retval;
1553
1554 return STATUS_SUCCESS;
1555}
1556
1557static int sd_ddr_tuning_tx_cmd(struct rtsx_chip *chip, u8 sample_point)
1558{
1559 struct sd_info *sd_card = &chip->sd_card;
1560 int retval;
1561 u8 cmd[5], bus_width;
1562
1563 retval = sd_change_phase(chip, sample_point, TUNE_TX);
1564 if (retval != STATUS_SUCCESS)
1565 return STATUS_FAIL;
1566
1567 if (CHK_SD(sd_card)) {
1568 bus_width = SD_BUS_WIDTH_4;
1569 } else {
1570 if (CHK_MMC_8BIT(sd_card))
1571 bus_width = SD_BUS_WIDTH_8;
1572 else if (CHK_MMC_4BIT(sd_card))
1573 bus_width = SD_BUS_WIDTH_4;
1574 else
1575 bus_width = SD_BUS_WIDTH_1;
1576 }
1577
1578 retval = sd_wait_state_data_ready(chip, 0x08, 1, 1000);
1579 if (retval != STATUS_SUCCESS)
1580 return STATUS_FAIL;
1581
1582 retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN,
1583 SD_RSP_80CLK_TIMEOUT_EN);
1584 if (retval)
1585 return retval;
1586
1587 cmd[0] = 0x40 | PROGRAM_CSD;
1588 cmd[1] = 0;
1589 cmd[2] = 0;
1590 cmd[3] = 0;
1591 cmd[4] = 0;
1592
1593 retval = sd_write_data(chip, SD_TM_AUTO_WRITE_2, cmd, 5, 16, 1,
1594 bus_width, sd_card->raw_csd, 16, 100);
1595 if (retval != STATUS_SUCCESS) {
1596 rtsx_clear_sd_error(chip);
1597 rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, 0);
1598 return STATUS_FAIL;
1599 }
1600
1601 retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN,
1602 0);
1603 if (retval)
1604 return retval;
1605
1606 sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr, SD_RSP_TYPE_R1,
1607 NULL, 0);
1608
1609 return STATUS_SUCCESS;
1610}
1611
1612static u8 sd_search_final_phase(struct rtsx_chip *chip, u32 phase_map,
1613 u8 tune_dir)
1614{
1615 struct sd_info *sd_card = &chip->sd_card;
1616 struct timing_phase_path path[MAX_PHASE + 1];
1617 int i, j, cont_path_cnt;
1618 bool new_block;
1619 int max_len, final_path_idx;
1620 u8 final_phase = 0xFF;
1621
1622 if (phase_map == 0xFFFFFFFF) {
1623 if (tune_dir == TUNE_RX)
1624 final_phase = (u8)chip->sd_default_rx_phase;
1625 else
1626 final_phase = (u8)chip->sd_default_tx_phase;
1627
1628 goto search_finish;
1629 }
1630
1631 cont_path_cnt = 0;
1632 new_block = true;
1633 j = 0;
1634 for (i = 0; i < MAX_PHASE + 1; i++) {
1635 if (phase_map & (1 << i)) {
1636 if (new_block) {
1637 new_block = false;
1638 j = cont_path_cnt++;
1639 path[j].start = i;
1640 path[j].end = i;
1641 } else {
1642 path[j].end = i;
1643 }
1644 } else {
1645 new_block = true;
1646 if (cont_path_cnt) {
1647 int idx = cont_path_cnt - 1;
1648
1649 path[idx].len = path[idx].end -
1650 path[idx].start + 1;
1651 path[idx].mid = path[idx].start +
1652 path[idx].len / 2;
1653 }
1654 }
1655 }
1656
1657 if (cont_path_cnt == 0) {
1658 dev_dbg(rtsx_dev(chip), "No continuous phase path\n");
1659 goto search_finish;
1660 } else {
1661 int idx = cont_path_cnt - 1;
1662
1663 path[idx].len = path[idx].end - path[idx].start + 1;
1664 path[idx].mid = path[idx].start + path[idx].len / 2;
1665 }
1666
1667 if ((path[0].start == 0) &&
1668 (path[cont_path_cnt - 1].end == MAX_PHASE)) {
1669 path[0].start = path[cont_path_cnt - 1].start - MAX_PHASE - 1;
1670 path[0].len += path[cont_path_cnt - 1].len;
1671 path[0].mid = path[0].start + path[0].len / 2;
1672 if (path[0].mid < 0)
1673 path[0].mid += MAX_PHASE + 1;
1674
1675 cont_path_cnt--;
1676 }
1677
1678 max_len = 0;
1679 final_phase = 0;
1680 final_path_idx = 0;
1681 for (i = 0; i < cont_path_cnt; i++) {
1682 if (path[i].len > max_len) {
1683 max_len = path[i].len;
1684 final_phase = (u8)path[i].mid;
1685 final_path_idx = i;
1686 }
1687
1688 dev_dbg(rtsx_dev(chip), "path[%d].start = %d\n",
1689 i, path[i].start);
1690 dev_dbg(rtsx_dev(chip), "path[%d].end = %d\n", i, path[i].end);
1691 dev_dbg(rtsx_dev(chip), "path[%d].len = %d\n", i, path[i].len);
1692 dev_dbg(rtsx_dev(chip), "path[%d].mid = %d\n", i, path[i].mid);
1693 dev_dbg(rtsx_dev(chip), "\n");
1694 }
1695
1696 if (tune_dir == TUNE_TX) {
1697 if (CHK_SD_SDR104(sd_card)) {
1698 if (max_len > 15) {
1699 int temp_mid = (max_len - 16) / 2;
1700 int temp_final_phase =
1701 path[final_path_idx].end -
1702 (max_len - (6 + temp_mid));
1703
1704 if (temp_final_phase < 0)
1705 final_phase = (u8)(temp_final_phase +
1706 MAX_PHASE + 1);
1707 else
1708 final_phase = (u8)temp_final_phase;
1709 }
1710 } else if (CHK_SD_SDR50(sd_card)) {
1711 if (max_len > 12) {
1712 int temp_mid = (max_len - 13) / 2;
1713 int temp_final_phase =
1714 path[final_path_idx].end -
1715 (max_len - (3 + temp_mid));
1716
1717 if (temp_final_phase < 0)
1718 final_phase = (u8)(temp_final_phase +
1719 MAX_PHASE + 1);
1720 else
1721 final_phase = (u8)temp_final_phase;
1722 }
1723 }
1724 }
1725
1726search_finish:
1727 dev_dbg(rtsx_dev(chip), "Final chosen phase: %d\n", final_phase);
1728 return final_phase;
1729}
1730
1731static int sd_tuning_rx(struct rtsx_chip *chip)
1732{
1733 struct sd_info *sd_card = &chip->sd_card;
1734 int retval;
1735 int i, j;
1736 u32 raw_phase_map[3], phase_map;
1737 u8 final_phase;
1738 int (*tuning_cmd)(struct rtsx_chip *chip, u8 sample_point);
1739
1740 if (CHK_SD(sd_card)) {
1741 if (CHK_SD_DDR50(sd_card))
1742 tuning_cmd = sd_ddr_tuning_rx_cmd;
1743 else
1744 tuning_cmd = sd_sdr_tuning_rx_cmd;
1745
1746 } else {
1747 if (CHK_MMC_DDR52(sd_card))
1748 tuning_cmd = mmc_ddr_tuning_rx_cmd;
1749 else
1750 return STATUS_FAIL;
1751 }
1752
1753 for (i = 0; i < 3; i++) {
1754 raw_phase_map[i] = 0;
1755 for (j = MAX_PHASE; j >= 0; j--) {
1756 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
1757 sd_set_err_code(chip, SD_NO_CARD);
1758 return STATUS_FAIL;
1759 }
1760
1761 retval = tuning_cmd(chip, (u8)j);
1762 if (retval == STATUS_SUCCESS)
1763 raw_phase_map[i] |= 1 << j;
1764 }
1765 }
1766
1767 phase_map = raw_phase_map[0] & raw_phase_map[1] & raw_phase_map[2];
1768 for (i = 0; i < 3; i++)
1769 dev_dbg(rtsx_dev(chip), "RX raw_phase_map[%d] = 0x%08x\n",
1770 i, raw_phase_map[i]);
1771
1772 dev_dbg(rtsx_dev(chip), "RX phase_map = 0x%08x\n", phase_map);
1773
1774 final_phase = sd_search_final_phase(chip, phase_map, TUNE_RX);
1775 if (final_phase == 0xFF)
1776 return STATUS_FAIL;
1777
1778 retval = sd_change_phase(chip, final_phase, TUNE_RX);
1779 if (retval != STATUS_SUCCESS)
1780 return STATUS_FAIL;
1781
1782 return STATUS_SUCCESS;
1783}
1784
1785static int sd_ddr_pre_tuning_tx(struct rtsx_chip *chip)
1786{
1787 struct sd_info *sd_card = &chip->sd_card;
1788 int retval;
1789 int i;
1790 u32 phase_map;
1791 u8 final_phase;
1792
1793 retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN,
1794 SD_RSP_80CLK_TIMEOUT_EN);
1795 if (retval)
1796 return retval;
1797
1798 phase_map = 0;
1799 for (i = MAX_PHASE; i >= 0; i--) {
1800 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
1801 sd_set_err_code(chip, SD_NO_CARD);
1802 rtsx_write_register(chip, SD_CFG3,
1803 SD_RSP_80CLK_TIMEOUT_EN, 0);
1804 return STATUS_FAIL;
1805 }
1806
1807 retval = sd_change_phase(chip, (u8)i, TUNE_TX);
1808 if (retval != STATUS_SUCCESS)
1809 continue;
1810
1811 retval = sd_send_cmd_get_rsp(chip, SEND_STATUS,
1812 sd_card->sd_addr, SD_RSP_TYPE_R1,
1813 NULL, 0);
1814 if ((retval == STATUS_SUCCESS) ||
1815 !sd_check_err_code(chip, SD_RSP_TIMEOUT))
1816 phase_map |= 1 << i;
1817 }
1818
1819 retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN,
1820 0);
1821 if (retval)
1822 return retval;
1823
1824 dev_dbg(rtsx_dev(chip), "DDR TX pre tune phase_map = 0x%08x\n",
1825 phase_map);
1826
1827 final_phase = sd_search_final_phase(chip, phase_map, TUNE_TX);
1828 if (final_phase == 0xFF)
1829 return STATUS_FAIL;
1830
1831 retval = sd_change_phase(chip, final_phase, TUNE_TX);
1832 if (retval != STATUS_SUCCESS)
1833 return STATUS_FAIL;
1834
1835 dev_dbg(rtsx_dev(chip), "DDR TX pre tune phase: %d\n",
1836 (int)final_phase);
1837
1838 return STATUS_SUCCESS;
1839}
1840
1841static int sd_tuning_tx(struct rtsx_chip *chip)
1842{
1843 struct sd_info *sd_card = &chip->sd_card;
1844 int retval;
1845 int i, j;
1846 u32 raw_phase_map[3], phase_map;
1847 u8 final_phase;
1848 int (*tuning_cmd)(struct rtsx_chip *chip, u8 sample_point);
1849
1850 if (CHK_SD(sd_card)) {
1851 if (CHK_SD_DDR50(sd_card))
1852 tuning_cmd = sd_ddr_tuning_tx_cmd;
1853 else
1854 tuning_cmd = sd_sdr_tuning_tx_cmd;
1855
1856 } else {
1857 if (CHK_MMC_DDR52(sd_card))
1858 tuning_cmd = sd_ddr_tuning_tx_cmd;
1859 else
1860 return STATUS_FAIL;
1861 }
1862
1863 for (i = 0; i < 3; i++) {
1864 raw_phase_map[i] = 0;
1865 for (j = MAX_PHASE; j >= 0; j--) {
1866 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
1867 sd_set_err_code(chip, SD_NO_CARD);
1868 rtsx_write_register(chip, SD_CFG3,
1869 SD_RSP_80CLK_TIMEOUT_EN, 0);
1870 return STATUS_FAIL;
1871 }
1872
1873 retval = tuning_cmd(chip, (u8)j);
1874 if (retval == STATUS_SUCCESS)
1875 raw_phase_map[i] |= 1 << j;
1876 }
1877 }
1878
1879 phase_map = raw_phase_map[0] & raw_phase_map[1] & raw_phase_map[2];
1880 for (i = 0; i < 3; i++)
1881 dev_dbg(rtsx_dev(chip), "TX raw_phase_map[%d] = 0x%08x\n",
1882 i, raw_phase_map[i]);
1883
1884 dev_dbg(rtsx_dev(chip), "TX phase_map = 0x%08x\n", phase_map);
1885
1886 final_phase = sd_search_final_phase(chip, phase_map, TUNE_TX);
1887 if (final_phase == 0xFF)
1888 return STATUS_FAIL;
1889
1890 retval = sd_change_phase(chip, final_phase, TUNE_TX);
1891 if (retval != STATUS_SUCCESS)
1892 return STATUS_FAIL;
1893
1894 return STATUS_SUCCESS;
1895}
1896
1897static int sd_sdr_tuning(struct rtsx_chip *chip)
1898{
1899 int retval;
1900
1901 retval = sd_tuning_tx(chip);
1902 if (retval != STATUS_SUCCESS)
1903 return STATUS_FAIL;
1904
1905 retval = sd_tuning_rx(chip);
1906 if (retval != STATUS_SUCCESS)
1907 return STATUS_FAIL;
1908
1909 return STATUS_SUCCESS;
1910}
1911
1912static int sd_ddr_tuning(struct rtsx_chip *chip)
1913{
1914 int retval;
1915
1916 if (!(chip->sd_ctl & SD_DDR_TX_PHASE_SET_BY_USER)) {
1917 retval = sd_ddr_pre_tuning_tx(chip);
1918 if (retval != STATUS_SUCCESS)
1919 return STATUS_FAIL;
1920 } else {
1921 retval = sd_change_phase(chip, (u8)chip->sd_ddr_tx_phase,
1922 TUNE_TX);
1923 if (retval != STATUS_SUCCESS)
1924 return STATUS_FAIL;
1925 }
1926
1927 retval = sd_tuning_rx(chip);
1928 if (retval != STATUS_SUCCESS)
1929 return STATUS_FAIL;
1930
1931 if (!(chip->sd_ctl & SD_DDR_TX_PHASE_SET_BY_USER)) {
1932 retval = sd_tuning_tx(chip);
1933 if (retval != STATUS_SUCCESS)
1934 return STATUS_FAIL;
1935 }
1936
1937 return STATUS_SUCCESS;
1938}
1939
1940static int mmc_ddr_tuning(struct rtsx_chip *chip)
1941{
1942 int retval;
1943
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 return STATUS_FAIL;
1948 } else {
1949 retval = sd_change_phase(chip, (u8)chip->mmc_ddr_tx_phase,
1950 TUNE_TX);
1951 if (retval != STATUS_SUCCESS)
1952 return STATUS_FAIL;
1953 }
1954
1955 retval = sd_tuning_rx(chip);
1956 if (retval != STATUS_SUCCESS)
1957 return STATUS_FAIL;
1958
1959 if (!(chip->sd_ctl & MMC_DDR_TX_PHASE_SET_BY_USER)) {
1960 retval = sd_tuning_tx(chip);
1961 if (retval != STATUS_SUCCESS)
1962 return STATUS_FAIL;
1963 }
1964
1965 return STATUS_SUCCESS;
1966}
1967
1968int sd_switch_clock(struct rtsx_chip *chip)
1969{
1970 struct sd_info *sd_card = &chip->sd_card;
1971 int retval;
1972 int re_tuning = 0;
1973
1974 retval = select_card(chip, SD_CARD);
1975 if (retval != STATUS_SUCCESS)
1976 return STATUS_FAIL;
1977
1978 retval = switch_clock(chip, sd_card->sd_clock);
1979 if (retval != STATUS_SUCCESS)
1980 return STATUS_FAIL;
1981
1982 if (re_tuning) {
1983 if (CHK_SD(sd_card)) {
1984 if (CHK_SD_DDR50(sd_card))
1985 retval = sd_ddr_tuning(chip);
1986 else
1987 retval = sd_sdr_tuning(chip);
1988 } else {
1989 if (CHK_MMC_DDR52(sd_card))
1990 retval = mmc_ddr_tuning(chip);
1991 }
1992
1993 if (retval != STATUS_SUCCESS)
1994 return STATUS_FAIL;
1995 }
1996
1997 return STATUS_SUCCESS;
1998}
1999
2000static int sd_prepare_reset(struct rtsx_chip *chip)
2001{
2002 struct sd_info *sd_card = &chip->sd_card;
2003 int retval;
2004
2005 if (chip->asic_code)
2006 sd_card->sd_clock = 29;
2007 else
2008 sd_card->sd_clock = CLK_30;
2009
2010 sd_card->sd_type = 0;
2011 sd_card->seq_mode = 0;
2012 sd_card->sd_data_buf_ready = 0;
2013 sd_card->capacity = 0;
2014
2015#ifdef SUPPORT_SD_LOCK
2016 sd_card->sd_lock_status = 0;
2017 sd_card->sd_erase_status = 0;
2018#endif
2019
2020 chip->capacity[chip->card2lun[SD_CARD]] = 0;
2021 chip->sd_io = 0;
2022
2023 retval = sd_set_init_para(chip);
2024 if (retval != STATUS_SUCCESS)
2025 return retval;
2026
2027 retval = rtsx_write_register(chip, REG_SD_CFG1, 0xFF, 0x40);
2028 if (retval)
2029 return retval;
2030
2031 retval = rtsx_write_register(chip, CARD_STOP, SD_STOP | SD_CLR_ERR,
2032 SD_STOP | SD_CLR_ERR);
2033 if (retval)
2034 return retval;
2035
2036 retval = select_card(chip, SD_CARD);
2037 if (retval != STATUS_SUCCESS)
2038 return STATUS_FAIL;
2039
2040 return STATUS_SUCCESS;
2041}
2042
2043static int sd_pull_ctl_disable(struct rtsx_chip *chip)
2044{
2045 int retval;
2046
2047 if (CHECK_PID(chip, 0x5208)) {
2048 retval = rtsx_write_register(chip, CARD_PULL_CTL1, 0xFF,
2049 XD_D3_PD | SD_D7_PD | SD_CLK_PD |
2050 SD_D5_PD);
2051 if (retval)
2052 return retval;
2053 retval = rtsx_write_register(chip, CARD_PULL_CTL2, 0xFF,
2054 SD_D6_PD | SD_D0_PD | SD_D1_PD |
2055 XD_D5_PD);
2056 if (retval)
2057 return retval;
2058 retval = rtsx_write_register(chip, CARD_PULL_CTL3, 0xFF,
2059 SD_D4_PD | XD_CE_PD | XD_CLE_PD |
2060 XD_CD_PU);
2061 if (retval)
2062 return retval;
2063 retval = rtsx_write_register(chip, CARD_PULL_CTL4, 0xFF,
2064 XD_RDY_PD | SD_D3_PD | SD_D2_PD |
2065 XD_ALE_PD);
2066 if (retval)
2067 return retval;
2068 retval = rtsx_write_register(chip, CARD_PULL_CTL5, 0xFF,
2069 MS_INS_PU | SD_WP_PD | SD_CD_PU |
2070 SD_CMD_PD);
2071 if (retval)
2072 return retval;
2073 retval = rtsx_write_register(chip, CARD_PULL_CTL6, 0xFF,
2074 MS_D5_PD | MS_D4_PD);
2075 if (retval)
2076 return retval;
2077 } else if (CHECK_PID(chip, 0x5288)) {
2078 if (CHECK_BARO_PKG(chip, QFN)) {
2079 retval = rtsx_write_register(chip, CARD_PULL_CTL1,
2080 0xFF, 0x55);
2081 if (retval)
2082 return retval;
2083 retval = rtsx_write_register(chip, CARD_PULL_CTL2,
2084 0xFF, 0x55);
2085 if (retval)
2086 return retval;
2087 retval = rtsx_write_register(chip, CARD_PULL_CTL3,
2088 0xFF, 0x4B);
2089 if (retval)
2090 return retval;
2091 retval = rtsx_write_register(chip, CARD_PULL_CTL4,
2092 0xFF, 0x69);
2093 if (retval)
2094 return retval;
2095 }
2096 }
2097
2098 return STATUS_SUCCESS;
2099}
2100
2101int sd_pull_ctl_enable(struct rtsx_chip *chip)
2102{
2103 int retval;
2104
2105 rtsx_init_cmd(chip);
2106
2107 if (CHECK_PID(chip, 0x5208)) {
2108 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF,
2109 XD_D3_PD | SD_DAT7_PU | SD_CLK_NP | SD_D5_PU);
2110 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF,
2111 SD_D6_PU | SD_D0_PU | SD_D1_PU | XD_D5_PD);
2112 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF,
2113 SD_D4_PU | XD_CE_PD | XD_CLE_PD | XD_CD_PU);
2114 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF,
2115 XD_RDY_PD | SD_D3_PU | SD_D2_PU | XD_ALE_PD);
2116 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF,
2117 MS_INS_PU | SD_WP_PU | SD_CD_PU | SD_CMD_PU);
2118 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF,
2119 MS_D5_PD | MS_D4_PD);
2120 } else if (CHECK_PID(chip, 0x5288)) {
2121 if (CHECK_BARO_PKG(chip, QFN)) {
2122 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF,
2123 0xA8);
2124 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF,
2125 0x5A);
2126 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF,
2127 0x95);
2128 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF,
2129 0xAA);
2130 }
2131 }
2132
2133 retval = rtsx_send_cmd(chip, SD_CARD, 100);
2134 if (retval < 0)
2135 return STATUS_FAIL;
2136
2137 return STATUS_SUCCESS;
2138}
2139
2140static int sd_init_power(struct rtsx_chip *chip)
2141{
2142 int retval;
2143
2144 retval = sd_power_off_card3v3(chip);
2145 if (retval != STATUS_SUCCESS)
2146 return STATUS_FAIL;
2147
2148 if (!chip->ft2_fast_mode)
2149 wait_timeout(250);
2150
2151 retval = enable_card_clock(chip, SD_CARD);
2152 if (retval != STATUS_SUCCESS)
2153 return STATUS_FAIL;
2154
2155 if (chip->asic_code) {
2156 retval = sd_pull_ctl_enable(chip);
2157 if (retval != STATUS_SUCCESS)
2158 return STATUS_FAIL;
2159 } else {
2160 retval = rtsx_write_register(chip, FPGA_PULL_CTL,
2161 FPGA_SD_PULL_CTL_BIT | 0x20, 0);
2162 if (retval)
2163 return retval;
2164 }
2165
2166 if (!chip->ft2_fast_mode) {
2167 retval = card_power_on(chip, SD_CARD);
2168 if (retval != STATUS_SUCCESS)
2169 return STATUS_FAIL;
2170
2171 wait_timeout(260);
2172
2173#ifdef SUPPORT_OCP
2174 if (chip->ocp_stat & (SD_OC_NOW | SD_OC_EVER)) {
2175 dev_dbg(rtsx_dev(chip), "Over current, OCPSTAT is 0x%x\n",
2176 chip->ocp_stat);
2177 return STATUS_FAIL;
2178 }
2179#endif
2180 }
2181
2182 retval = rtsx_write_register(chip, CARD_OE, SD_OUTPUT_EN,
2183 SD_OUTPUT_EN);
2184 if (retval)
2185 return retval;
2186
2187 return STATUS_SUCCESS;
2188}
2189
2190static int sd_dummy_clock(struct rtsx_chip *chip)
2191{
2192 int retval;
2193
2194 retval = rtsx_write_register(chip, REG_SD_CFG3, 0x01, 0x01);
2195 if (retval)
2196 return retval;
2197 wait_timeout(5);
2198 retval = rtsx_write_register(chip, REG_SD_CFG3, 0x01, 0);
2199 if (retval)
2200 return retval;
2201
2202 return STATUS_SUCCESS;
2203}
2204
2205static int sd_read_lba0(struct rtsx_chip *chip)
2206{
2207 struct sd_info *sd_card = &chip->sd_card;
2208 int retval;
2209 u8 cmd[5], bus_width;
2210
2211 cmd[0] = 0x40 | READ_SINGLE_BLOCK;
2212 cmd[1] = 0;
2213 cmd[2] = 0;
2214 cmd[3] = 0;
2215 cmd[4] = 0;
2216
2217 if (CHK_SD(sd_card)) {
2218 bus_width = SD_BUS_WIDTH_4;
2219 } else {
2220 if (CHK_MMC_8BIT(sd_card))
2221 bus_width = SD_BUS_WIDTH_8;
2222 else if (CHK_MMC_4BIT(sd_card))
2223 bus_width = SD_BUS_WIDTH_4;
2224 else
2225 bus_width = SD_BUS_WIDTH_1;
2226 }
2227
2228 retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd, 5, 512, 1,
2229 bus_width, NULL, 0, 100);
2230 if (retval != STATUS_SUCCESS) {
2231 rtsx_clear_sd_error(chip);
2232 return STATUS_FAIL;
2233 }
2234
2235 return STATUS_SUCCESS;
2236}
2237
2238static int sd_check_wp_state(struct rtsx_chip *chip)
2239{
2240 struct sd_info *sd_card = &chip->sd_card;
2241 int retval;
2242 u32 val;
2243 u16 sd_card_type;
2244 u8 cmd[5], buf[64];
2245
2246 retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
2247 SD_RSP_TYPE_R1, NULL, 0);
2248 if (retval != STATUS_SUCCESS)
2249 return STATUS_FAIL;
2250
2251 cmd[0] = 0x40 | SD_STATUS;
2252 cmd[1] = 0;
2253 cmd[2] = 0;
2254 cmd[3] = 0;
2255 cmd[4] = 0;
2256
2257 retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd, 5, 64, 1,
2258 SD_BUS_WIDTH_4, buf, 64, 250);
2259 if (retval != STATUS_SUCCESS) {
2260 rtsx_clear_sd_error(chip);
2261
2262 sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
2263 SD_RSP_TYPE_R1, NULL, 0);
2264 return STATUS_FAIL;
2265 }
2266
2267 dev_dbg(rtsx_dev(chip), "ACMD13:\n");
2268 dev_dbg(rtsx_dev(chip), "%*ph\n", 64, buf);
2269
2270 sd_card_type = ((u16)buf[2] << 8) | buf[3];
2271 dev_dbg(rtsx_dev(chip), "sd_card_type = 0x%04x\n", sd_card_type);
2272 if ((sd_card_type == 0x0001) || (sd_card_type == 0x0002)) {
2273
2274 chip->card_wp |= SD_CARD;
2275 }
2276
2277
2278 val = rtsx_readl(chip, RTSX_BIPR);
2279 if (val & SD_WRITE_PROTECT)
2280 chip->card_wp |= SD_CARD;
2281
2282 return STATUS_SUCCESS;
2283}
2284
2285static int reset_sd(struct rtsx_chip *chip)
2286{
2287 struct sd_info *sd_card = &chip->sd_card;
2288 bool hi_cap_flow = false;
2289 int retval, i = 0, j = 0, k = 0;
2290 bool sd_dont_switch = false;
2291 bool support_1v8 = false;
2292 bool try_sdio = true;
2293 u8 rsp[16];
2294 u8 switch_bus_width;
2295 u32 voltage = 0;
2296 bool sd20_mode = false;
2297
2298 SET_SD(sd_card);
2299
2300switch_fail:
2301
2302 i = 0;
2303 j = 0;
2304 k = 0;
2305 hi_cap_flow = false;
2306
2307#ifdef SUPPORT_SD_LOCK
2308 if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON)
2309 goto SD_UNLOCK_ENTRY;
2310#endif
2311
2312 retval = sd_prepare_reset(chip);
2313 if (retval != STATUS_SUCCESS)
2314 goto status_fail;
2315
2316 retval = sd_dummy_clock(chip);
2317 if (retval != STATUS_SUCCESS)
2318 goto status_fail;
2319
2320 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip) && try_sdio) {
2321 int rty_cnt = 0;
2322
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 goto status_fail;
2327 }
2328
2329 retval = sd_send_cmd_get_rsp(chip, IO_SEND_OP_COND, 0,
2330 SD_RSP_TYPE_R4, rsp, 5);
2331 if (retval == STATUS_SUCCESS) {
2332 int func_num = (rsp[1] >> 4) & 0x07;
2333
2334 if (func_num) {
2335 dev_dbg(rtsx_dev(chip), "SD_IO card (Function number: %d)!\n",
2336 func_num);
2337 chip->sd_io = 1;
2338 goto status_fail;
2339 }
2340
2341 break;
2342 }
2343
2344 sd_init_power(chip);
2345
2346 sd_dummy_clock(chip);
2347 }
2348
2349 dev_dbg(rtsx_dev(chip), "Normal card!\n");
2350 }
2351
2352
2353RTY_SD_RST:
2354 retval = sd_send_cmd_get_rsp(chip, GO_IDLE_STATE, 0, SD_RSP_TYPE_R0,
2355 NULL, 0);
2356 if (retval != STATUS_SUCCESS)
2357 goto status_fail;
2358
2359 wait_timeout(20);
2360
2361 retval = sd_send_cmd_get_rsp(chip, SEND_IF_COND, 0x000001AA,
2362 SD_RSP_TYPE_R7, rsp, 5);
2363 if (retval == STATUS_SUCCESS) {
2364 if ((rsp[4] == 0xAA) && ((rsp[3] & 0x0f) == 0x01)) {
2365 hi_cap_flow = true;
2366 voltage = SUPPORT_VOLTAGE | 0x40000000;
2367 }
2368 }
2369
2370 if (!hi_cap_flow) {
2371 voltage = SUPPORT_VOLTAGE;
2372
2373 retval = sd_send_cmd_get_rsp(chip, GO_IDLE_STATE, 0,
2374 SD_RSP_TYPE_R0, NULL, 0);
2375 if (retval != STATUS_SUCCESS)
2376 goto status_fail;
2377
2378 wait_timeout(20);
2379 }
2380
2381 do {
2382 retval = sd_send_cmd_get_rsp(chip, APP_CMD, 0, SD_RSP_TYPE_R1,
2383 NULL, 0);
2384 if (retval != STATUS_SUCCESS) {
2385 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
2386 sd_set_err_code(chip, SD_NO_CARD);
2387 goto status_fail;
2388 }
2389
2390 j++;
2391 if (j < 3)
2392 goto RTY_SD_RST;
2393 else
2394 goto status_fail;
2395 }
2396
2397 retval = sd_send_cmd_get_rsp(chip, SD_APP_OP_COND, voltage,
2398 SD_RSP_TYPE_R3, rsp, 5);
2399 if (retval != STATUS_SUCCESS) {
2400 k++;
2401 if (k < 3)
2402 goto RTY_SD_RST;
2403 else
2404 goto status_fail;
2405 }
2406
2407 i++;
2408 wait_timeout(20);
2409 } while (!(rsp[1] & 0x80) && (i < 255));
2410
2411 if (i == 255)
2412 goto status_fail;
2413
2414 if (hi_cap_flow) {
2415 if (rsp[1] & 0x40)
2416 SET_SD_HCXC(sd_card);
2417 else
2418 CLR_SD_HCXC(sd_card);
2419
2420 support_1v8 = false;
2421 } else {
2422 CLR_SD_HCXC(sd_card);
2423 support_1v8 = false;
2424 }
2425 dev_dbg(rtsx_dev(chip), "support_1v8 = %d\n", support_1v8);
2426
2427 if (support_1v8) {
2428 retval = sd_voltage_switch(chip);
2429 if (retval != STATUS_SUCCESS)
2430 goto status_fail;
2431 }
2432
2433 retval = sd_send_cmd_get_rsp(chip, ALL_SEND_CID, 0, SD_RSP_TYPE_R2,
2434 NULL, 0);
2435 if (retval != STATUS_SUCCESS)
2436 goto status_fail;
2437
2438 for (i = 0; i < 3; i++) {
2439 retval = sd_send_cmd_get_rsp(chip, SEND_RELATIVE_ADDR, 0,
2440 SD_RSP_TYPE_R6, rsp, 5);
2441 if (retval != STATUS_SUCCESS)
2442 goto status_fail;
2443
2444 sd_card->sd_addr = (u32)rsp[1] << 24;
2445 sd_card->sd_addr += (u32)rsp[2] << 16;
2446
2447 if (sd_card->sd_addr)
2448 break;
2449 }
2450
2451 retval = sd_check_csd(chip, 1);
2452 if (retval != STATUS_SUCCESS)
2453 goto status_fail;
2454
2455 retval = sd_select_card(chip, 1);
2456 if (retval != STATUS_SUCCESS)
2457 goto status_fail;
2458
2459#ifdef SUPPORT_SD_LOCK
2460SD_UNLOCK_ENTRY:
2461 retval = sd_update_lock_status(chip);
2462 if (retval != STATUS_SUCCESS)
2463 goto status_fail;
2464
2465 if (sd_card->sd_lock_status & SD_LOCKED) {
2466 sd_card->sd_lock_status |= (SD_LOCK_1BIT_MODE | SD_PWD_EXIST);
2467 return STATUS_SUCCESS;
2468 } else if (!(sd_card->sd_lock_status & SD_UNLOCK_POW_ON)) {
2469 sd_card->sd_lock_status &= ~SD_PWD_EXIST;
2470 }
2471#endif
2472
2473 retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
2474 SD_RSP_TYPE_R1, NULL, 0);
2475 if (retval != STATUS_SUCCESS)
2476 goto status_fail;
2477
2478 retval = sd_send_cmd_get_rsp(chip, SET_CLR_CARD_DETECT, 0,
2479 SD_RSP_TYPE_R1, NULL, 0);
2480 if (retval != STATUS_SUCCESS)
2481 goto status_fail;
2482
2483 if (support_1v8) {
2484 retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
2485 SD_RSP_TYPE_R1, NULL, 0);
2486 if (retval != STATUS_SUCCESS)
2487 goto status_fail;
2488
2489 retval = sd_send_cmd_get_rsp(chip, SET_BUS_WIDTH, 2,
2490 SD_RSP_TYPE_R1, NULL, 0);
2491 if (retval != STATUS_SUCCESS)
2492 goto status_fail;
2493
2494 switch_bus_width = SD_BUS_WIDTH_4;
2495 } else {
2496 switch_bus_width = SD_BUS_WIDTH_1;
2497 }
2498
2499 retval = sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200, SD_RSP_TYPE_R1,
2500 NULL, 0);
2501 if (retval != STATUS_SUCCESS)
2502 goto status_fail;
2503
2504 retval = sd_set_clock_divider(chip, SD_CLK_DIVIDE_0);
2505 if (retval != STATUS_SUCCESS)
2506 goto status_fail;
2507
2508 if (!(sd_card->raw_csd[4] & 0x40))
2509 sd_dont_switch = true;
2510
2511 if (!sd_dont_switch) {
2512 if (sd20_mode) {
2513
2514
2515
2516 sd_card->sd_switch_fail = SDR104_SUPPORT_MASK |
2517 DDR50_SUPPORT_MASK | SDR50_SUPPORT_MASK;
2518 }
2519
2520
2521 retval = sd_check_spec(chip, switch_bus_width);
2522 if (retval == STATUS_SUCCESS) {
2523 retval = sd_switch_function(chip, switch_bus_width);
2524 if (retval != STATUS_SUCCESS) {
2525 sd_init_power(chip);
2526 sd_dont_switch = true;
2527 try_sdio = false;
2528
2529 goto switch_fail;
2530 }
2531 } else {
2532 if (support_1v8) {
2533 sd_init_power(chip);
2534 sd_dont_switch = true;
2535 try_sdio = false;
2536
2537 goto switch_fail;
2538 }
2539 }
2540 }
2541
2542 if (!support_1v8) {
2543 retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
2544 SD_RSP_TYPE_R1, NULL, 0);
2545 if (retval != STATUS_SUCCESS)
2546 goto status_fail;
2547
2548 retval = sd_send_cmd_get_rsp(chip, SET_BUS_WIDTH, 2,
2549 SD_RSP_TYPE_R1, NULL, 0);
2550 if (retval != STATUS_SUCCESS)
2551 goto status_fail;
2552 }
2553
2554#ifdef SUPPORT_SD_LOCK
2555 sd_card->sd_lock_status &= ~SD_LOCK_1BIT_MODE;
2556#endif
2557
2558 if (!sd20_mode && CHK_SD30_SPEED(sd_card)) {
2559 int read_lba0 = 1;
2560
2561 retval = rtsx_write_register(chip, SD30_DRIVE_SEL, 0x07,
2562 chip->sd30_drive_sel_1v8);
2563 if (retval)
2564 return retval;
2565
2566 retval = sd_set_init_para(chip);
2567 if (retval != STATUS_SUCCESS)
2568 goto status_fail;
2569
2570 if (CHK_SD_DDR50(sd_card))
2571 retval = sd_ddr_tuning(chip);
2572 else
2573 retval = sd_sdr_tuning(chip);
2574
2575 if (retval != STATUS_SUCCESS) {
2576 if (sd20_mode) {
2577 goto status_fail;
2578 } else {
2579 retval = sd_init_power(chip);
2580 if (retval != STATUS_SUCCESS)
2581 goto status_fail;
2582
2583 try_sdio = false;
2584 sd20_mode = true;
2585 goto switch_fail;
2586 }
2587 }
2588
2589 sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
2590 SD_RSP_TYPE_R1, NULL, 0);
2591
2592 if (CHK_SD_DDR50(sd_card)) {
2593 retval = sd_wait_state_data_ready(chip, 0x08, 1, 1000);
2594 if (retval != STATUS_SUCCESS)
2595 read_lba0 = 0;
2596 }
2597
2598 if (read_lba0) {
2599 retval = sd_read_lba0(chip);
2600 if (retval != STATUS_SUCCESS) {
2601 if (sd20_mode) {
2602 goto status_fail;
2603 } else {
2604 retval = sd_init_power(chip);
2605 if (retval != STATUS_SUCCESS)
2606 goto status_fail;
2607
2608 try_sdio = false;
2609 sd20_mode = true;
2610 goto switch_fail;
2611 }
2612 }
2613 }
2614 }
2615
2616 retval = sd_check_wp_state(chip);
2617 if (retval != STATUS_SUCCESS)
2618 goto status_fail;
2619
2620 chip->card_bus_width[chip->card2lun[SD_CARD]] = 4;
2621
2622#ifdef SUPPORT_SD_LOCK
2623 if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON) {
2624 retval = rtsx_write_register(chip, REG_SD_BLOCK_CNT_H, 0xFF,
2625 0x02);
2626 if (retval)
2627 return retval;
2628 retval = rtsx_write_register(chip, REG_SD_BLOCK_CNT_L, 0xFF,
2629 0x00);
2630 if (retval)
2631 return retval;
2632 }
2633#endif
2634
2635 return STATUS_SUCCESS;
2636
2637status_fail:
2638 return STATUS_FAIL;
2639}
2640
2641static int mmc_test_switch_bus(struct rtsx_chip *chip, u8 width)
2642{
2643 struct sd_info *sd_card = &chip->sd_card;
2644 int retval;
2645 u8 buf[8] = {0}, bus_width, *ptr;
2646 u16 byte_cnt;
2647 int len;
2648
2649 retval = sd_send_cmd_get_rsp(chip, BUSTEST_W, 0, SD_RSP_TYPE_R1, NULL,
2650 0);
2651 if (retval != STATUS_SUCCESS)
2652 return SWITCH_FAIL;
2653
2654 if (width == MMC_8BIT_BUS) {
2655 buf[0] = 0x55;
2656 buf[1] = 0xAA;
2657 len = 8;
2658 byte_cnt = 8;
2659 bus_width = SD_BUS_WIDTH_8;
2660 } else {
2661 buf[0] = 0x5A;
2662 len = 4;
2663 byte_cnt = 4;
2664 bus_width = SD_BUS_WIDTH_4;
2665 }
2666
2667 retval = rtsx_write_register(chip, REG_SD_CFG3, 0x02, 0x02);
2668 if (retval != STATUS_SUCCESS)
2669 return SWITCH_ERR;
2670
2671 retval = sd_write_data(chip, SD_TM_AUTO_WRITE_3, NULL, 0, byte_cnt, 1,
2672 bus_width, buf, len, 100);
2673 if (retval != STATUS_SUCCESS) {
2674 rtsx_clear_sd_error(chip);
2675 rtsx_write_register(chip, REG_SD_CFG3, 0x02, 0);
2676 return SWITCH_ERR;
2677 }
2678
2679 retval = rtsx_write_register(chip, REG_SD_CFG3, 0x02, 0);
2680 if (retval != STATUS_SUCCESS)
2681 return SWITCH_ERR;
2682
2683 dev_dbg(rtsx_dev(chip), "SD/MMC CMD %d\n", BUSTEST_R);
2684
2685 rtsx_init_cmd(chip);
2686
2687 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD0, 0xFF, 0x40 | BUSTEST_R);
2688
2689 if (width == MMC_8BIT_BUS)
2690 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L,
2691 0xFF, 0x08);
2692 else
2693 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L,
2694 0xFF, 0x04);
2695
2696 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L, 0xFF, 1);
2697 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H, 0xFF, 0);
2698
2699 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF, SD_CALCULATE_CRC7 |
2700 SD_NO_CHECK_CRC16 | SD_NO_WAIT_BUSY_END |
2701 SD_CHECK_CRC7 | SD_RSP_LEN_6);
2702 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 0x01,
2703 PINGPONG_BUFFER);
2704 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF,
2705 SD_TM_NORMAL_READ | SD_TRANSFER_START);
2706 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER, SD_TRANSFER_END,
2707 SD_TRANSFER_END);
2708
2709 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2, 0, 0);
2710 if (width == MMC_8BIT_BUS)
2711 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + 1, 0, 0);
2712
2713 retval = rtsx_send_cmd(chip, SD_CARD, 100);
2714 if (retval < 0) {
2715 rtsx_clear_sd_error(chip);
2716 return SWITCH_ERR;
2717 }
2718
2719 ptr = rtsx_get_cmd_data(chip) + 1;
2720
2721 if (width == MMC_8BIT_BUS) {
2722 dev_dbg(rtsx_dev(chip), "BUSTEST_R [8bits]: 0x%02x 0x%02x\n",
2723 ptr[0], ptr[1]);
2724 if ((ptr[0] == 0xAA) && (ptr[1] == 0x55)) {
2725 u8 rsp[5];
2726 u32 arg;
2727
2728 if (CHK_MMC_DDR52(sd_card))
2729 arg = 0x03B70600;
2730 else
2731 arg = 0x03B70200;
2732
2733 retval = sd_send_cmd_get_rsp(chip, SWITCH, arg,
2734 SD_RSP_TYPE_R1b, rsp, 5);
2735 if ((retval == STATUS_SUCCESS) &&
2736 !(rsp[4] & MMC_SWITCH_ERR))
2737 return SWITCH_SUCCESS;
2738 }
2739 } else {
2740 dev_dbg(rtsx_dev(chip), "BUSTEST_R [4bits]: 0x%02x\n", ptr[0]);
2741 if (ptr[0] == 0xA5) {
2742 u8 rsp[5];
2743 u32 arg;
2744
2745 if (CHK_MMC_DDR52(sd_card))
2746 arg = 0x03B70500;
2747 else
2748 arg = 0x03B70100;
2749
2750 retval = sd_send_cmd_get_rsp(chip, SWITCH, arg,
2751 SD_RSP_TYPE_R1b, rsp, 5);
2752 if ((retval == STATUS_SUCCESS) &&
2753 !(rsp[4] & MMC_SWITCH_ERR))
2754 return SWITCH_SUCCESS;
2755 }
2756 }
2757
2758 return SWITCH_FAIL;
2759}
2760
2761static int mmc_switch_timing_bus(struct rtsx_chip *chip, bool switch_ddr)
2762{
2763 struct sd_info *sd_card = &chip->sd_card;
2764 int retval;
2765 u8 *ptr, card_type, card_type_mask = 0;
2766
2767 CLR_MMC_HS(sd_card);
2768
2769 dev_dbg(rtsx_dev(chip), "SD/MMC CMD %d\n", SEND_EXT_CSD);
2770
2771 rtsx_init_cmd(chip);
2772
2773 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD0, 0xFF,
2774 0x40 | SEND_EXT_CSD);
2775 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD1, 0xFF, 0);
2776 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD2, 0xFF, 0);
2777 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD3, 0xFF, 0);
2778 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD4, 0xFF, 0);
2779
2780 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF, 0);
2781 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_H, 0xFF, 2);
2782 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L, 0xFF, 1);
2783 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H, 0xFF, 0);
2784
2785 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF,
2786 SD_CALCULATE_CRC7 | SD_CHECK_CRC16 | SD_NO_WAIT_BUSY_END |
2787 SD_CHECK_CRC7 | SD_RSP_LEN_6);
2788 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 0x01,
2789 PINGPONG_BUFFER);
2790 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF,
2791 SD_TM_NORMAL_READ | SD_TRANSFER_START);
2792 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER, SD_TRANSFER_END,
2793 SD_TRANSFER_END);
2794
2795 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + 196, 0xFF, 0);
2796 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + 212, 0xFF, 0);
2797 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + 213, 0xFF, 0);
2798 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + 214, 0xFF, 0);
2799 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + 215, 0xFF, 0);
2800
2801 retval = rtsx_send_cmd(chip, SD_CARD, 1000);
2802 if (retval < 0) {
2803 if (retval == -ETIMEDOUT) {
2804 rtsx_clear_sd_error(chip);
2805 sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
2806 SD_RSP_TYPE_R1, NULL, 0);
2807 }
2808 return STATUS_FAIL;
2809 }
2810
2811 ptr = rtsx_get_cmd_data(chip);
2812 if (ptr[0] & SD_TRANSFER_ERR) {
2813 sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
2814 SD_RSP_TYPE_R1, NULL, 0);
2815 return STATUS_FAIL;
2816 }
2817
2818 if (CHK_MMC_SECTOR_MODE(sd_card)) {
2819 sd_card->capacity = ((u32)ptr[5] << 24) | ((u32)ptr[4] << 16) |
2820 ((u32)ptr[3] << 8) | ((u32)ptr[2]);
2821 }
2822
2823 card_type_mask = 0x03;
2824 card_type = ptr[1] & card_type_mask;
2825 if (card_type) {
2826 u8 rsp[5];
2827
2828 if (card_type & 0x04) {
2829 if (switch_ddr)
2830 SET_MMC_DDR52(sd_card);
2831 else
2832 SET_MMC_52M(sd_card);
2833 } else if (card_type & 0x02) {
2834 SET_MMC_52M(sd_card);
2835 } else {
2836 SET_MMC_26M(sd_card);
2837 }
2838
2839 retval = sd_send_cmd_get_rsp(chip, SWITCH, 0x03B90100,
2840 SD_RSP_TYPE_R1b, rsp, 5);
2841 if ((retval != STATUS_SUCCESS) || (rsp[4] & MMC_SWITCH_ERR))
2842 CLR_MMC_HS(sd_card);
2843 }
2844
2845 sd_choose_proper_clock(chip);
2846 retval = switch_clock(chip, sd_card->sd_clock);
2847 if (retval != STATUS_SUCCESS)
2848 return STATUS_FAIL;
2849
2850
2851 retval = mmc_test_switch_bus(chip, MMC_8BIT_BUS);
2852 if (retval == SWITCH_SUCCESS) {
2853 SET_MMC_8BIT(sd_card);
2854 chip->card_bus_width[chip->card2lun[SD_CARD]] = 8;
2855#ifdef SUPPORT_SD_LOCK
2856 sd_card->sd_lock_status &= ~SD_LOCK_1BIT_MODE;
2857#endif
2858 } else if (retval == SWITCH_FAIL) {
2859 retval = mmc_test_switch_bus(chip, MMC_4BIT_BUS);
2860 if (retval == SWITCH_SUCCESS) {
2861 SET_MMC_4BIT(sd_card);
2862 chip->card_bus_width[chip->card2lun[SD_CARD]] = 4;
2863#ifdef SUPPORT_SD_LOCK
2864 sd_card->sd_lock_status &= ~SD_LOCK_1BIT_MODE;
2865#endif
2866 } else if (retval == SWITCH_FAIL) {
2867 CLR_MMC_8BIT(sd_card);
2868 CLR_MMC_4BIT(sd_card);
2869 } else {
2870 return STATUS_FAIL;
2871 }
2872 } else {
2873 return STATUS_FAIL;
2874 }
2875
2876 return STATUS_SUCCESS;
2877}
2878
2879static int reset_mmc(struct rtsx_chip *chip)
2880{
2881 struct sd_info *sd_card = &chip->sd_card;
2882 int retval, i = 0, j = 0, k = 0;
2883 bool switch_ddr = true;
2884 u8 rsp[16];
2885 u8 spec_ver = 0;
2886 u32 temp;
2887
2888#ifdef SUPPORT_SD_LOCK
2889 if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON)
2890 goto MMC_UNLOCK_ENTRY;
2891#endif
2892
2893switch_fail:
2894 retval = sd_prepare_reset(chip);
2895 if (retval != STATUS_SUCCESS)
2896 return retval;
2897
2898 SET_MMC(sd_card);
2899
2900RTY_MMC_RST:
2901 retval = sd_send_cmd_get_rsp(chip, GO_IDLE_STATE, 0, SD_RSP_TYPE_R0,
2902 NULL, 0);
2903 if (retval != STATUS_SUCCESS)
2904 return STATUS_FAIL;
2905
2906 do {
2907 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
2908 sd_set_err_code(chip, SD_NO_CARD);
2909 return STATUS_FAIL;
2910 }
2911
2912 retval = sd_send_cmd_get_rsp(chip, SEND_OP_COND,
2913 (SUPPORT_VOLTAGE | 0x40000000),
2914 SD_RSP_TYPE_R3, rsp, 5);
2915 if (retval != STATUS_SUCCESS) {
2916 if (sd_check_err_code(chip, SD_BUSY) ||
2917 sd_check_err_code(chip, SD_TO_ERR)) {
2918 k++;
2919 if (k < 20) {
2920 sd_clr_err_code(chip);
2921 goto RTY_MMC_RST;
2922 } else {
2923 return STATUS_FAIL;
2924 }
2925 } else {
2926 j++;
2927 if (j < 100) {
2928 sd_clr_err_code(chip);
2929 goto RTY_MMC_RST;
2930 } else {
2931 return STATUS_FAIL;
2932 }
2933 }
2934 }
2935
2936 wait_timeout(20);
2937 i++;
2938 } while (!(rsp[1] & 0x80) && (i < 255));
2939
2940 if (i == 255)
2941 return STATUS_FAIL;
2942
2943 if ((rsp[1] & 0x60) == 0x40)
2944 SET_MMC_SECTOR_MODE(sd_card);
2945 else
2946 CLR_MMC_SECTOR_MODE(sd_card);
2947
2948 retval = sd_send_cmd_get_rsp(chip, ALL_SEND_CID, 0, SD_RSP_TYPE_R2,
2949 NULL, 0);
2950 if (retval != STATUS_SUCCESS)
2951 return STATUS_FAIL;
2952
2953 sd_card->sd_addr = 0x00100000;
2954 retval = sd_send_cmd_get_rsp(chip, SET_RELATIVE_ADDR, sd_card->sd_addr,
2955 SD_RSP_TYPE_R6, rsp, 5);
2956 if (retval != STATUS_SUCCESS)
2957 return STATUS_FAIL;
2958
2959 retval = sd_check_csd(chip, 1);
2960 if (retval != STATUS_SUCCESS)
2961 return STATUS_FAIL;
2962
2963 spec_ver = (sd_card->raw_csd[0] & 0x3C) >> 2;
2964
2965 retval = sd_select_card(chip, 1);
2966 if (retval != STATUS_SUCCESS)
2967 return STATUS_FAIL;
2968
2969 retval = sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200, SD_RSP_TYPE_R1,
2970 NULL, 0);
2971 if (retval != STATUS_SUCCESS)
2972 return STATUS_FAIL;
2973
2974#ifdef SUPPORT_SD_LOCK
2975MMC_UNLOCK_ENTRY:
2976 retval = sd_update_lock_status(chip);
2977 if (retval != STATUS_SUCCESS)
2978 return STATUS_FAIL;
2979#endif
2980
2981 retval = sd_set_clock_divider(chip, SD_CLK_DIVIDE_0);
2982 if (retval != STATUS_SUCCESS)
2983 return STATUS_FAIL;
2984
2985 chip->card_bus_width[chip->card2lun[SD_CARD]] = 1;
2986
2987 if (!sd_card->mmc_dont_switch_bus) {
2988 if (spec_ver == 4) {
2989
2990 retval = mmc_switch_timing_bus(chip, switch_ddr);
2991 if (retval != STATUS_SUCCESS) {
2992 retval = sd_init_power(chip);
2993 if (retval != STATUS_SUCCESS)
2994 return STATUS_FAIL;
2995 sd_card->mmc_dont_switch_bus = 1;
2996 goto switch_fail;
2997 }
2998 }
2999
3000 if (CHK_MMC_SECTOR_MODE(sd_card) && (sd_card->capacity == 0))
3001 return STATUS_FAIL;
3002
3003 if (switch_ddr && CHK_MMC_DDR52(sd_card)) {
3004 retval = sd_set_init_para(chip);
3005 if (retval != STATUS_SUCCESS)
3006 return STATUS_FAIL;
3007
3008 retval = mmc_ddr_tuning(chip);
3009 if (retval != STATUS_SUCCESS) {
3010 retval = sd_init_power(chip);
3011 if (retval != STATUS_SUCCESS)
3012 return STATUS_FAIL;
3013
3014 switch_ddr = false;
3015 goto switch_fail;
3016 }
3017
3018 retval = sd_wait_state_data_ready(chip, 0x08, 1, 1000);
3019 if (retval == STATUS_SUCCESS) {
3020 retval = sd_read_lba0(chip);
3021 if (retval != STATUS_SUCCESS) {
3022 retval = sd_init_power(chip);
3023 if (retval != STATUS_SUCCESS)
3024 return STATUS_FAIL;
3025
3026 switch_ddr = false;
3027 goto switch_fail;
3028 }
3029 }
3030 }
3031 }
3032
3033#ifdef SUPPORT_SD_LOCK
3034 if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON) {
3035 retval = rtsx_write_register(chip, REG_SD_BLOCK_CNT_H, 0xFF,
3036 0x02);
3037 if (retval)
3038 return retval;
3039 retval = rtsx_write_register(chip, REG_SD_BLOCK_CNT_L, 0xFF,
3040 0x00);
3041 if (retval)
3042 return retval;
3043 }
3044#endif
3045
3046 temp = rtsx_readl(chip, RTSX_BIPR);
3047 if (temp & SD_WRITE_PROTECT)
3048 chip->card_wp |= SD_CARD;
3049
3050 return STATUS_SUCCESS;
3051}
3052
3053int reset_sd_card(struct rtsx_chip *chip)
3054{
3055 struct sd_info *sd_card = &chip->sd_card;
3056 int retval;
3057
3058 sd_init_reg_addr(chip);
3059
3060 memset(sd_card, 0, sizeof(struct sd_info));
3061 chip->capacity[chip->card2lun[SD_CARD]] = 0;
3062
3063 retval = enable_card_clock(chip, SD_CARD);
3064 if (retval != STATUS_SUCCESS)
3065 return STATUS_FAIL;
3066
3067 if (chip->ignore_sd && CHK_SDIO_EXIST(chip) &&
3068 !CHK_SDIO_IGNORED(chip)) {
3069 if (chip->asic_code) {
3070 retval = sd_pull_ctl_enable(chip);
3071 if (retval != STATUS_SUCCESS)
3072 return STATUS_FAIL;
3073 } else {
3074 retval = rtsx_write_register(chip, FPGA_PULL_CTL,
3075 FPGA_SD_PULL_CTL_BIT |
3076 0x20, 0);
3077 if (retval != STATUS_SUCCESS)
3078 return STATUS_FAIL;
3079 }
3080 retval = card_share_mode(chip, SD_CARD);
3081 if (retval != STATUS_SUCCESS)
3082 return STATUS_FAIL;
3083
3084 chip->sd_io = 1;
3085 return STATUS_FAIL;
3086 }
3087
3088 retval = sd_init_power(chip);
3089 if (retval != STATUS_SUCCESS)
3090 return STATUS_FAIL;
3091
3092 if (chip->sd_ctl & RESET_MMC_FIRST) {
3093 retval = reset_mmc(chip);
3094 if (retval != STATUS_SUCCESS) {
3095 if (sd_check_err_code(chip, SD_NO_CARD))
3096 return STATUS_FAIL;
3097
3098 retval = reset_sd(chip);
3099 if (retval != STATUS_SUCCESS)
3100 return STATUS_FAIL;
3101 }
3102 } else {
3103 retval = reset_sd(chip);
3104 if (retval != STATUS_SUCCESS) {
3105 if (sd_check_err_code(chip, SD_NO_CARD))
3106 return STATUS_FAIL;
3107
3108 if (chip->sd_io)
3109 return STATUS_FAIL;
3110 retval = reset_mmc(chip);
3111 if (retval != STATUS_SUCCESS)
3112 return STATUS_FAIL;
3113 }
3114 }
3115
3116 retval = sd_set_clock_divider(chip, SD_CLK_DIVIDE_0);
3117 if (retval != STATUS_SUCCESS)
3118 return STATUS_FAIL;
3119
3120 retval = rtsx_write_register(chip, REG_SD_BYTE_CNT_L, 0xFF, 0);
3121 if (retval)
3122 return retval;
3123 retval = rtsx_write_register(chip, REG_SD_BYTE_CNT_H, 0xFF, 2);
3124 if (retval)
3125 return retval;
3126
3127 chip->capacity[chip->card2lun[SD_CARD]] = sd_card->capacity;
3128
3129 retval = sd_set_init_para(chip);
3130 if (retval != STATUS_SUCCESS)
3131 return STATUS_FAIL;
3132
3133 dev_dbg(rtsx_dev(chip), "sd_card->sd_type = 0x%x\n", sd_card->sd_type);
3134
3135 return STATUS_SUCCESS;
3136}
3137
3138static int reset_mmc_only(struct rtsx_chip *chip)
3139{
3140 struct sd_info *sd_card = &chip->sd_card;
3141 int retval;
3142
3143 sd_card->sd_type = 0;
3144 sd_card->seq_mode = 0;
3145 sd_card->sd_data_buf_ready = 0;
3146 sd_card->capacity = 0;
3147 sd_card->sd_switch_fail = 0;
3148
3149#ifdef SUPPORT_SD_LOCK
3150 sd_card->sd_lock_status = 0;
3151 sd_card->sd_erase_status = 0;
3152#endif
3153
3154 chip->capacity[chip->card2lun[SD_CARD]] = sd_card->capacity = 0;
3155
3156 retval = enable_card_clock(chip, SD_CARD);
3157 if (retval != STATUS_SUCCESS)
3158 return STATUS_FAIL;
3159
3160 retval = sd_init_power(chip);
3161 if (retval != STATUS_SUCCESS)
3162 return STATUS_FAIL;
3163
3164 retval = reset_mmc(chip);
3165 if (retval != STATUS_SUCCESS)
3166 return STATUS_FAIL;
3167
3168 retval = sd_set_clock_divider(chip, SD_CLK_DIVIDE_0);
3169 if (retval != STATUS_SUCCESS)
3170 return STATUS_FAIL;
3171
3172 retval = rtsx_write_register(chip, REG_SD_BYTE_CNT_L, 0xFF, 0);
3173 if (retval)
3174 return retval;
3175 retval = rtsx_write_register(chip, REG_SD_BYTE_CNT_H, 0xFF, 2);
3176 if (retval)
3177 return retval;
3178
3179 chip->capacity[chip->card2lun[SD_CARD]] = sd_card->capacity;
3180
3181 retval = sd_set_init_para(chip);
3182 if (retval != STATUS_SUCCESS)
3183 return STATUS_FAIL;
3184
3185 dev_dbg(rtsx_dev(chip), "In %s, sd_card->sd_type = 0x%x\n",
3186 __func__, sd_card->sd_type);
3187
3188 return STATUS_SUCCESS;
3189}
3190
3191#define WAIT_DATA_READY_RTY_CNT 255
3192
3193static int wait_data_buf_ready(struct rtsx_chip *chip)
3194{
3195 struct sd_info *sd_card = &chip->sd_card;
3196 int i, retval;
3197
3198 for (i = 0; i < WAIT_DATA_READY_RTY_CNT; i++) {
3199 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
3200 sd_set_err_code(chip, SD_NO_CARD);
3201 return STATUS_FAIL;
3202 }
3203
3204 sd_card->sd_data_buf_ready = 0;
3205
3206 retval = sd_send_cmd_get_rsp(chip, SEND_STATUS,
3207 sd_card->sd_addr, SD_RSP_TYPE_R1,
3208 NULL, 0);
3209 if (retval != STATUS_SUCCESS)
3210 return STATUS_FAIL;
3211
3212 if (sd_card->sd_data_buf_ready) {
3213 return sd_send_cmd_get_rsp(chip, SEND_STATUS,
3214 sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0);
3215 }
3216 }
3217
3218 sd_set_err_code(chip, SD_TO_ERR);
3219
3220 return STATUS_FAIL;
3221}
3222
3223void sd_stop_seq_mode(struct rtsx_chip *chip)
3224{
3225 struct sd_info *sd_card = &chip->sd_card;
3226 int retval;
3227
3228 if (sd_card->seq_mode) {
3229 retval = sd_switch_clock(chip);
3230 if (retval != STATUS_SUCCESS)
3231 return;
3232
3233 retval = sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION, 0,
3234 SD_RSP_TYPE_R1b, NULL, 0);
3235 if (retval != STATUS_SUCCESS)
3236 sd_set_err_code(chip, SD_STS_ERR);
3237
3238 retval = sd_wait_state_data_ready(chip, 0x08, 1, 1000);
3239 if (retval != STATUS_SUCCESS)
3240 sd_set_err_code(chip, SD_STS_ERR);
3241
3242 sd_card->seq_mode = 0;
3243
3244 rtsx_write_register(chip, RBCTL, RB_FLUSH, RB_FLUSH);
3245 }
3246}
3247
3248static inline int sd_auto_tune_clock(struct rtsx_chip *chip)
3249{
3250 struct sd_info *sd_card = &chip->sd_card;
3251 int retval;
3252
3253 if (chip->asic_code) {
3254 if (sd_card->sd_clock > 30)
3255 sd_card->sd_clock -= 20;
3256 } else {
3257 switch (sd_card->sd_clock) {
3258 case CLK_200:
3259 sd_card->sd_clock = CLK_150;
3260 break;
3261
3262 case CLK_150:
3263 sd_card->sd_clock = CLK_120;
3264 break;
3265
3266 case CLK_120:
3267 sd_card->sd_clock = CLK_100;
3268 break;
3269
3270 case CLK_100:
3271 sd_card->sd_clock = CLK_80;
3272 break;
3273
3274 case CLK_80:
3275 sd_card->sd_clock = CLK_60;
3276 break;
3277
3278 case CLK_60:
3279 sd_card->sd_clock = CLK_50;
3280 break;
3281
3282 default:
3283 break;
3284 }
3285 }
3286
3287 retval = sd_switch_clock(chip);
3288 if (retval != STATUS_SUCCESS)
3289 return STATUS_FAIL;
3290
3291 return STATUS_SUCCESS;
3292}
3293
3294int sd_rw(struct scsi_cmnd *srb, struct rtsx_chip *chip, u32 start_sector,
3295 u16 sector_cnt)
3296{
3297 struct sd_info *sd_card = &chip->sd_card;
3298 u32 data_addr;
3299 u8 cfg2;
3300 int retval;
3301
3302 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
3303 dev_dbg(rtsx_dev(chip), "%s: Read %d %s from 0x%x\n", __func__,
3304 sector_cnt, (sector_cnt > 1) ? "sectors" : "sector",
3305 start_sector);
3306 } else {
3307 dev_dbg(rtsx_dev(chip), "%s: Write %d %s to 0x%x\n", __func__,
3308 sector_cnt, (sector_cnt > 1) ? "sectors" : "sector",
3309 start_sector);
3310 }
3311
3312 sd_card->cleanup_counter = 0;
3313
3314 if (!(chip->card_ready & SD_CARD)) {
3315 sd_card->seq_mode = 0;
3316
3317 retval = reset_sd_card(chip);
3318 if (retval == STATUS_SUCCESS) {
3319 chip->card_ready |= SD_CARD;
3320 chip->card_fail &= ~SD_CARD;
3321 } else {
3322 chip->card_ready &= ~SD_CARD;
3323 chip->card_fail |= SD_CARD;
3324 chip->capacity[chip->card2lun[SD_CARD]] = 0;
3325 chip->rw_need_retry = 1;
3326 return STATUS_FAIL;
3327 }
3328 }
3329
3330 if (!CHK_SD_HCXC(sd_card) && !CHK_MMC_SECTOR_MODE(sd_card))
3331 data_addr = start_sector << 9;
3332 else
3333 data_addr = start_sector;
3334
3335 sd_clr_err_code(chip);
3336
3337 retval = sd_switch_clock(chip);
3338 if (retval != STATUS_SUCCESS) {
3339 sd_set_err_code(chip, SD_IO_ERR);
3340 goto RW_FAIL;
3341 }
3342
3343 if (sd_card->seq_mode &&
3344 ((sd_card->pre_dir != srb->sc_data_direction) ||
3345 ((sd_card->pre_sec_addr + sd_card->pre_sec_cnt) !=
3346 start_sector))) {
3347 if ((sd_card->pre_sec_cnt < 0x80) &&
3348 (sd_card->pre_dir == DMA_FROM_DEVICE) &&
3349 !CHK_SD30_SPEED(sd_card) &&
3350 !CHK_SD_HS(sd_card) &&
3351 !CHK_MMC_HS(sd_card)) {
3352 sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
3353 SD_RSP_TYPE_R1, NULL, 0);
3354 }
3355
3356 retval = sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION, 0,
3357 SD_RSP_TYPE_R1b, NULL, 0);
3358 if (retval != STATUS_SUCCESS) {
3359 chip->rw_need_retry = 1;
3360 sd_set_err_code(chip, SD_STS_ERR);
3361 goto RW_FAIL;
3362 }
3363
3364 sd_card->seq_mode = 0;
3365
3366 retval = rtsx_write_register(chip, RBCTL, RB_FLUSH, RB_FLUSH);
3367 if (retval != STATUS_SUCCESS) {
3368 sd_set_err_code(chip, SD_IO_ERR);
3369 goto RW_FAIL;
3370 }
3371
3372 if ((sd_card->pre_sec_cnt < 0x80) &&
3373 !CHK_SD30_SPEED(sd_card) &&
3374 !CHK_SD_HS(sd_card) &&
3375 !CHK_MMC_HS(sd_card)) {
3376 sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
3377 SD_RSP_TYPE_R1, NULL, 0);
3378 }
3379 }
3380
3381 rtsx_init_cmd(chip);
3382
3383 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF, 0x00);
3384 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_H, 0xFF, 0x02);
3385 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L, 0xFF,
3386 (u8)sector_cnt);
3387 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H, 0xFF,
3388 (u8)(sector_cnt >> 8));
3389
3390 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 0x01, RING_BUFFER);
3391
3392 if (CHK_MMC_8BIT(sd_card))
3393 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG1,
3394 0x03, SD_BUS_WIDTH_8);
3395 else if (CHK_MMC_4BIT(sd_card) || CHK_SD(sd_card))
3396 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG1,
3397 0x03, SD_BUS_WIDTH_4);
3398 else
3399 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG1,
3400 0x03, SD_BUS_WIDTH_1);
3401
3402 if (sd_card->seq_mode) {
3403 cfg2 = SD_NO_CALCULATE_CRC7 | SD_CHECK_CRC16 |
3404 SD_NO_WAIT_BUSY_END | SD_NO_CHECK_CRC7 |
3405 SD_RSP_LEN_0;
3406 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF, cfg2);
3407
3408 trans_dma_enable(srb->sc_data_direction, chip, sector_cnt * 512,
3409 DMA_512);
3410
3411 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
3412 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF,
3413 SD_TM_AUTO_READ_3 | SD_TRANSFER_START);
3414 } else {
3415 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF,
3416 SD_TM_AUTO_WRITE_3 | SD_TRANSFER_START);
3417 }
3418
3419 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER,
3420 SD_TRANSFER_END, SD_TRANSFER_END);
3421
3422 rtsx_send_cmd_no_wait(chip);
3423 } else {
3424 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
3425 dev_dbg(rtsx_dev(chip), "SD/MMC CMD %d\n",
3426 READ_MULTIPLE_BLOCK);
3427 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD0, 0xFF,
3428 0x40 | READ_MULTIPLE_BLOCK);
3429 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD1, 0xFF,
3430 (u8)(data_addr >> 24));
3431 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD2, 0xFF,
3432 (u8)(data_addr >> 16));
3433 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD3, 0xFF,
3434 (u8)(data_addr >> 8));
3435 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD4, 0xFF,
3436 (u8)data_addr);
3437
3438 cfg2 = SD_CALCULATE_CRC7 | SD_CHECK_CRC16 |
3439 SD_NO_WAIT_BUSY_END | SD_CHECK_CRC7 |
3440 SD_RSP_LEN_6;
3441 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF,
3442 cfg2);
3443
3444 trans_dma_enable(srb->sc_data_direction, chip,
3445 sector_cnt * 512, DMA_512);
3446
3447 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF,
3448 SD_TM_AUTO_READ_2 | SD_TRANSFER_START);
3449 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER,
3450 SD_TRANSFER_END, SD_TRANSFER_END);
3451
3452 rtsx_send_cmd_no_wait(chip);
3453 } else {
3454 retval = rtsx_send_cmd(chip, SD_CARD, 50);
3455 if (retval < 0) {
3456 rtsx_clear_sd_error(chip);
3457
3458 chip->rw_need_retry = 1;
3459 sd_set_err_code(chip, SD_TO_ERR);
3460 goto RW_FAIL;
3461 }
3462
3463 retval = wait_data_buf_ready(chip);
3464 if (retval != STATUS_SUCCESS) {
3465 chip->rw_need_retry = 1;
3466 sd_set_err_code(chip, SD_TO_ERR);
3467 goto RW_FAIL;
3468 }
3469
3470 retval = sd_send_cmd_get_rsp(chip, WRITE_MULTIPLE_BLOCK,
3471 data_addr, SD_RSP_TYPE_R1,
3472 NULL, 0);
3473 if (retval != STATUS_SUCCESS) {
3474 chip->rw_need_retry = 1;
3475 goto RW_FAIL;
3476 }
3477
3478 rtsx_init_cmd(chip);
3479
3480 cfg2 = SD_NO_CALCULATE_CRC7 | SD_CHECK_CRC16 |
3481 SD_NO_WAIT_BUSY_END |
3482 SD_NO_CHECK_CRC7 | SD_RSP_LEN_0;
3483 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF,
3484 cfg2);
3485
3486 trans_dma_enable(srb->sc_data_direction, chip,
3487 sector_cnt * 512, DMA_512);
3488
3489 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF,
3490 SD_TM_AUTO_WRITE_3 | SD_TRANSFER_START);
3491 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER,
3492 SD_TRANSFER_END, SD_TRANSFER_END);
3493
3494 rtsx_send_cmd_no_wait(chip);
3495 }
3496
3497 sd_card->seq_mode = 1;
3498 }
3499
3500 retval = rtsx_transfer_data(chip, SD_CARD, scsi_sglist(srb),
3501 scsi_bufflen(srb), scsi_sg_count(srb),
3502 srb->sc_data_direction, chip->sd_timeout);
3503 if (retval < 0) {
3504 u8 stat = 0;
3505 int err;
3506
3507 sd_card->seq_mode = 0;
3508
3509 if (retval == -ETIMEDOUT)
3510 err = STATUS_TIMEDOUT;
3511 else
3512 err = STATUS_FAIL;
3513
3514 rtsx_read_register(chip, REG_SD_STAT1, &stat);
3515 rtsx_clear_sd_error(chip);
3516 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
3517 chip->rw_need_retry = 0;
3518 dev_dbg(rtsx_dev(chip), "No card exist, exit %s\n",
3519 __func__);
3520 return STATUS_FAIL;
3521 }
3522
3523 chip->rw_need_retry = 1;
3524
3525 retval = sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION, 0,
3526 SD_RSP_TYPE_R1b, NULL, 0);
3527 if (retval != STATUS_SUCCESS) {
3528 sd_set_err_code(chip, SD_STS_ERR);
3529 goto RW_FAIL;
3530 }
3531
3532 if (stat & (SD_CRC7_ERR | SD_CRC16_ERR | SD_CRC_WRITE_ERR)) {
3533 dev_dbg(rtsx_dev(chip), "SD CRC error, tune clock!\n");
3534 sd_set_err_code(chip, SD_CRC_ERR);
3535 goto RW_FAIL;
3536 }
3537
3538 if (err == STATUS_TIMEDOUT) {
3539 sd_set_err_code(chip, SD_TO_ERR);
3540 goto RW_FAIL;
3541 }
3542
3543 return err;
3544 }
3545
3546 sd_card->pre_sec_addr = start_sector;
3547 sd_card->pre_sec_cnt = sector_cnt;
3548 sd_card->pre_dir = srb->sc_data_direction;
3549
3550 return STATUS_SUCCESS;
3551
3552RW_FAIL:
3553 sd_card->seq_mode = 0;
3554
3555 if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
3556 chip->rw_need_retry = 0;
3557 dev_dbg(rtsx_dev(chip), "No card exist, exit %s\n", __func__);
3558 return STATUS_FAIL;
3559 }
3560
3561 if (sd_check_err_code(chip, SD_CRC_ERR)) {
3562 if (CHK_MMC_4BIT(sd_card) || CHK_MMC_8BIT(sd_card)) {
3563 sd_card->mmc_dont_switch_bus = 1;
3564 reset_mmc_only(chip);
3565 sd_card->mmc_dont_switch_bus = 0;
3566 } else {
3567 sd_card->need_retune = 1;
3568 sd_auto_tune_clock(chip);
3569 }
3570 } else if (sd_check_err_code(chip, SD_TO_ERR | SD_STS_ERR)) {
3571 retval = reset_sd_card(chip);
3572 if (retval != STATUS_SUCCESS) {
3573 chip->card_ready &= ~SD_CARD;
3574 chip->card_fail |= SD_CARD;
3575 chip->capacity[chip->card2lun[SD_CARD]] = 0;
3576 }
3577 }
3578
3579 return STATUS_FAIL;
3580}
3581
3582#ifdef SUPPORT_CPRM
3583int ext_sd_send_cmd_get_rsp(struct rtsx_chip *chip, u8 cmd_idx, u32 arg,
3584 u8 rsp_type, u8 *rsp, int rsp_len,
3585 bool special_check)
3586{
3587 int retval;
3588 int timeout = 100;
3589 u16 reg_addr;
3590 u8 *ptr;
3591 int stat_idx = 0;
3592 int rty_cnt = 0;
3593
3594 dev_dbg(rtsx_dev(chip), "EXT SD/MMC CMD %d\n", cmd_idx);
3595
3596 if (rsp_type == SD_RSP_TYPE_R1b)
3597 timeout = 3000;
3598
3599RTY_SEND_CMD:
3600
3601 rtsx_init_cmd(chip);
3602
3603 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD0, 0xFF, 0x40 | cmd_idx);
3604 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD1, 0xFF, (u8)(arg >> 24));
3605 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD2, 0xFF, (u8)(arg >> 16));
3606 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD3, 0xFF, (u8)(arg >> 8));
3607 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD4, 0xFF, (u8)arg);
3608
3609 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF, rsp_type);
3610 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE,
3611 0x01, PINGPONG_BUFFER);
3612 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER,
3613 0xFF, SD_TM_CMD_RSP | SD_TRANSFER_START);
3614 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER, SD_TRANSFER_END,
3615 SD_TRANSFER_END);
3616
3617 if (rsp_type == SD_RSP_TYPE_R2) {
3618 for (reg_addr = PPBUF_BASE2; reg_addr < PPBUF_BASE2 + 16;
3619 reg_addr++)
3620 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0, 0);
3621
3622 stat_idx = 17;
3623 } else if (rsp_type != SD_RSP_TYPE_R0) {
3624 for (reg_addr = REG_SD_CMD0; reg_addr <= REG_SD_CMD4;
3625 reg_addr++)
3626 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0, 0);
3627
3628 stat_idx = 6;
3629 }
3630 rtsx_add_cmd(chip, READ_REG_CMD, REG_SD_CMD5, 0, 0);
3631
3632 rtsx_add_cmd(chip, READ_REG_CMD, REG_SD_STAT1, 0, 0);
3633
3634 retval = rtsx_send_cmd(chip, SD_CARD, timeout);
3635 if (retval < 0) {
3636 if (retval == -ETIMEDOUT) {
3637 rtsx_clear_sd_error(chip);
3638
3639 if (rsp_type & SD_WAIT_BUSY_END) {
3640 retval = sd_check_data0_status(chip);
3641 if (retval != STATUS_SUCCESS)
3642 return retval;
3643 } else {
3644 sd_set_err_code(chip, SD_TO_ERR);
3645 }
3646 }
3647 return STATUS_FAIL;
3648 }
3649
3650 if (rsp_type == SD_RSP_TYPE_R0)
3651 return STATUS_SUCCESS;
3652
3653 ptr = rtsx_get_cmd_data(chip) + 1;
3654
3655 if ((ptr[0] & 0xC0) != 0) {
3656 sd_set_err_code(chip, SD_STS_ERR);
3657 return STATUS_FAIL;
3658 }
3659
3660 if (!(rsp_type & SD_NO_CHECK_CRC7)) {
3661 if (ptr[stat_idx] & SD_CRC7_ERR) {
3662 if (cmd_idx == WRITE_MULTIPLE_BLOCK) {
3663 sd_set_err_code(chip, SD_CRC_ERR);
3664 return STATUS_FAIL;
3665 }
3666 if (rty_cnt < SD_MAX_RETRY_COUNT) {
3667 wait_timeout(20);
3668 rty_cnt++;
3669 goto RTY_SEND_CMD;
3670 } else {
3671 sd_set_err_code(chip, SD_CRC_ERR);
3672 return STATUS_FAIL;
3673 }
3674 }
3675 }
3676
3677 if ((cmd_idx == SELECT_CARD) || (cmd_idx == APP_CMD) ||
3678 (cmd_idx == SEND_STATUS) || (cmd_idx == STOP_TRANSMISSION)) {
3679 if ((cmd_idx != STOP_TRANSMISSION) && !special_check) {
3680 if (ptr[1] & 0x80)
3681 return STATUS_FAIL;
3682 }
3683#ifdef SUPPORT_SD_LOCK
3684 if (ptr[1] & 0x7D) {
3685#else
3686 if (ptr[1] & 0x7F) {
3687#endif
3688 return STATUS_FAIL;
3689 }
3690 if (ptr[2] & 0xF8)
3691 return STATUS_FAIL;
3692
3693 if (cmd_idx == SELECT_CARD) {
3694 if (rsp_type == SD_RSP_TYPE_R2) {
3695 if ((ptr[3] & 0x1E) != 0x04)
3696 return STATUS_FAIL;
3697 }
3698 }
3699 }
3700
3701 if (rsp && rsp_len)
3702 memcpy(rsp, ptr, rsp_len);
3703
3704 return STATUS_SUCCESS;
3705}
3706
3707int ext_sd_get_rsp(struct rtsx_chip *chip, int len, u8 *rsp, u8 rsp_type)
3708{
3709 int retval, rsp_len;
3710 u16 reg_addr;
3711
3712 if (rsp_type == SD_RSP_TYPE_R0)
3713 return STATUS_SUCCESS;
3714
3715 rtsx_init_cmd(chip);
3716
3717 if (rsp_type == SD_RSP_TYPE_R2) {
3718 for (reg_addr = PPBUF_BASE2; reg_addr < PPBUF_BASE2 + 16;
3719 reg_addr++)
3720 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0xFF, 0);
3721
3722 rsp_len = 17;
3723 } else if (rsp_type != SD_RSP_TYPE_R0) {
3724 for (reg_addr = REG_SD_CMD0; reg_addr <= REG_SD_CMD4;
3725 reg_addr++)
3726 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0xFF, 0);
3727
3728 rsp_len = 6;
3729 }
3730 rtsx_add_cmd(chip, READ_REG_CMD, REG_SD_CMD5, 0xFF, 0);
3731
3732 retval = rtsx_send_cmd(chip, SD_CARD, 100);
3733 if (retval != STATUS_SUCCESS)
3734 return STATUS_FAIL;
3735
3736 if (rsp) {
3737 int min_len = (rsp_len < len) ? rsp_len : len;
3738
3739 memcpy(rsp, rtsx_get_cmd_data(chip), min_len);
3740
3741 dev_dbg(rtsx_dev(chip), "min_len = %d\n", min_len);
3742 dev_dbg(rtsx_dev(chip), "Response in cmd buf: 0x%x 0x%x 0x%x 0x%x\n",
3743 rsp[0], rsp[1], rsp[2], rsp[3]);
3744 }
3745
3746 return STATUS_SUCCESS;
3747}
3748
3749int sd_pass_thru_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3750{
3751 struct sd_info *sd_card = &chip->sd_card;
3752 unsigned int lun = SCSI_LUN(srb);
3753 int len;
3754 u8 buf[18] = {
3755 0x00,
3756 0x00,
3757 0x00,
3758 0x0E,
3759 0x00,
3760 0x00,
3761 0x00,
3762 0x00,
3763 0x53,
3764 0x44,
3765 0x20,
3766 0x43,
3767 0x61,
3768 0x72,
3769 0x64,
3770 0x00,
3771 0x00,
3772 0x00,
3773 };
3774
3775 sd_card->pre_cmd_err = 0;
3776
3777 if (!(CHK_BIT(chip->lun_mc, lun))) {
3778 SET_BIT(chip->lun_mc, lun);
3779 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
3780 return TRANSPORT_FAILED;
3781 }
3782
3783 if ((srb->cmnd[2] != 0x53) || (srb->cmnd[3] != 0x44) ||
3784 (srb->cmnd[4] != 0x20) || (srb->cmnd[5] != 0x43) ||
3785 (srb->cmnd[6] != 0x61) || (srb->cmnd[7] != 0x72) ||
3786 (srb->cmnd[8] != 0x64)) {
3787 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3788 return TRANSPORT_FAILED;
3789 }
3790
3791 switch (srb->cmnd[1] & 0x0F) {
3792 case 0:
3793 sd_card->sd_pass_thru_en = 0;
3794 break;
3795
3796 case 1:
3797 sd_card->sd_pass_thru_en = 1;
3798 break;
3799
3800 default:
3801 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3802 return TRANSPORT_FAILED;
3803 }
3804
3805 buf[5] = (CHK_SD(sd_card) == 1) ? 0x01 : 0x02;
3806 if (chip->card_wp & SD_CARD)
3807 buf[5] |= 0x80;
3808
3809 buf[6] = (u8)(sd_card->sd_addr >> 16);
3810 buf[7] = (u8)(sd_card->sd_addr >> 24);
3811
3812 buf[15] = chip->max_lun;
3813
3814 len = min_t(int, 18, scsi_bufflen(srb));
3815 rtsx_stor_set_xfer_buf(buf, len, srb);
3816
3817 return TRANSPORT_GOOD;
3818}
3819
3820static inline int get_rsp_type(struct scsi_cmnd *srb, u8 *rsp_type,
3821 int *rsp_len)
3822{
3823 if (!rsp_type || !rsp_len)
3824 return STATUS_FAIL;
3825
3826 switch (srb->cmnd[10]) {
3827 case 0x03:
3828 *rsp_type = SD_RSP_TYPE_R0;
3829 *rsp_len = 0;
3830 break;
3831
3832 case 0x04:
3833 *rsp_type = SD_RSP_TYPE_R1;
3834 *rsp_len = 6;
3835 break;
3836
3837 case 0x05:
3838 *rsp_type = SD_RSP_TYPE_R1b;
3839 *rsp_len = 6;
3840 break;
3841
3842 case 0x06:
3843 *rsp_type = SD_RSP_TYPE_R2;
3844 *rsp_len = 17;
3845 break;
3846
3847 case 0x07:
3848 *rsp_type = SD_RSP_TYPE_R3;
3849 *rsp_len = 6;
3850 break;
3851
3852 default:
3853 return STATUS_FAIL;
3854 }
3855
3856 return STATUS_SUCCESS;
3857}
3858
3859int sd_execute_no_data(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3860{
3861 struct sd_info *sd_card = &chip->sd_card;
3862 unsigned int lun = SCSI_LUN(srb);
3863 int retval, rsp_len;
3864 u8 cmd_idx, rsp_type;
3865 bool standby = false, acmd = false;
3866 u32 arg;
3867
3868 if (!sd_card->sd_pass_thru_en) {
3869 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3870 return TRANSPORT_FAILED;
3871 }
3872
3873 retval = sd_switch_clock(chip);
3874 if (retval != STATUS_SUCCESS)
3875 return TRANSPORT_FAILED;
3876
3877 if (sd_card->pre_cmd_err) {
3878 sd_card->pre_cmd_err = 0;
3879 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
3880 return TRANSPORT_FAILED;
3881 }
3882
3883 cmd_idx = srb->cmnd[2] & 0x3F;
3884 if (srb->cmnd[1] & 0x02)
3885 standby = true;
3886
3887 if (srb->cmnd[1] & 0x01)
3888 acmd = true;
3889
3890 arg = ((u32)srb->cmnd[3] << 24) | ((u32)srb->cmnd[4] << 16) |
3891 ((u32)srb->cmnd[5] << 8) | srb->cmnd[6];
3892
3893 retval = get_rsp_type(srb, &rsp_type, &rsp_len);
3894 if (retval != STATUS_SUCCESS) {
3895 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3896 return TRANSPORT_FAILED;
3897 }
3898 sd_card->last_rsp_type = rsp_type;
3899
3900 retval = sd_switch_clock(chip);
3901 if (retval != STATUS_SUCCESS)
3902 return TRANSPORT_FAILED;
3903
3904#ifdef SUPPORT_SD_LOCK
3905 if ((sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) == 0) {
3906 if (CHK_MMC_8BIT(sd_card)) {
3907 retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03,
3908 SD_BUS_WIDTH_8);
3909 if (retval != STATUS_SUCCESS)
3910 return TRANSPORT_FAILED;
3911
3912 } else if (CHK_SD(sd_card) || CHK_MMC_4BIT(sd_card)) {
3913 retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03,
3914 SD_BUS_WIDTH_4);
3915 if (retval != STATUS_SUCCESS)
3916 return TRANSPORT_FAILED;
3917 }
3918 }
3919#else
3920 retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_4);
3921 if (retval != STATUS_SUCCESS)
3922 return TRANSPORT_FAILED;
3923#endif
3924
3925 if (standby) {
3926 retval = sd_select_card(chip, 0);
3927 if (retval != STATUS_SUCCESS)
3928 goto sd_execute_cmd_failed;
3929 }
3930
3931 if (acmd) {
3932 retval = ext_sd_send_cmd_get_rsp(chip, APP_CMD,
3933 sd_card->sd_addr,
3934 SD_RSP_TYPE_R1, NULL, 0,
3935 false);
3936 if (retval != STATUS_SUCCESS)
3937 goto sd_execute_cmd_failed;
3938 }
3939
3940 retval = ext_sd_send_cmd_get_rsp(chip, cmd_idx, arg, rsp_type,
3941 sd_card->rsp, rsp_len, false);
3942 if (retval != STATUS_SUCCESS)
3943 goto sd_execute_cmd_failed;
3944
3945 if (standby) {
3946 retval = sd_select_card(chip, 1);
3947 if (retval != STATUS_SUCCESS)
3948 goto sd_execute_cmd_failed;
3949 }
3950
3951#ifdef SUPPORT_SD_LOCK
3952 retval = sd_update_lock_status(chip);
3953 if (retval != STATUS_SUCCESS)
3954 goto sd_execute_cmd_failed;
3955#endif
3956
3957 scsi_set_resid(srb, 0);
3958 return TRANSPORT_GOOD;
3959
3960sd_execute_cmd_failed:
3961 sd_card->pre_cmd_err = 1;
3962 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
3963 release_sd_card(chip);
3964 do_reset_sd_card(chip);
3965 if (!(chip->card_ready & SD_CARD))
3966 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3967
3968 return TRANSPORT_FAILED;
3969}
3970
3971int sd_execute_read_data(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3972{
3973 struct sd_info *sd_card = &chip->sd_card;
3974 unsigned int lun = SCSI_LUN(srb);
3975 int retval, rsp_len, i;
3976 bool read_err = false, cmd13_checkbit = false;
3977 u8 cmd_idx, rsp_type, bus_width;
3978 bool standby = false, send_cmd12 = false, acmd = false;
3979 u32 data_len;
3980
3981 if (!sd_card->sd_pass_thru_en) {
3982 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3983 return TRANSPORT_FAILED;
3984 }
3985
3986 if (sd_card->pre_cmd_err) {
3987 sd_card->pre_cmd_err = 0;
3988 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
3989 return TRANSPORT_FAILED;
3990 }
3991
3992 retval = sd_switch_clock(chip);
3993 if (retval != STATUS_SUCCESS)
3994 return TRANSPORT_FAILED;
3995
3996 cmd_idx = srb->cmnd[2] & 0x3F;
3997 if (srb->cmnd[1] & 0x04)
3998 send_cmd12 = true;
3999
4000 if (srb->cmnd[1] & 0x02)
4001 standby = true;
4002
4003 if (srb->cmnd[1] & 0x01)
4004 acmd = true;
4005
4006 data_len = ((u32)srb->cmnd[7] << 16) | ((u32)srb->cmnd[8]
4007 << 8) | srb->cmnd[9];
4008
4009 retval = get_rsp_type(srb, &rsp_type, &rsp_len);
4010 if (retval != STATUS_SUCCESS) {
4011 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4012 return TRANSPORT_FAILED;
4013 }
4014 sd_card->last_rsp_type = rsp_type;
4015
4016 retval = sd_switch_clock(chip);
4017 if (retval != STATUS_SUCCESS)
4018 return TRANSPORT_FAILED;
4019
4020#ifdef SUPPORT_SD_LOCK
4021 if ((sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) == 0) {
4022 if (CHK_MMC_8BIT(sd_card))
4023 bus_width = SD_BUS_WIDTH_8;
4024 else if (CHK_SD(sd_card) || CHK_MMC_4BIT(sd_card))
4025 bus_width = SD_BUS_WIDTH_4;
4026 else
4027 bus_width = SD_BUS_WIDTH_1;
4028 } else {
4029 bus_width = SD_BUS_WIDTH_4;
4030 }
4031 dev_dbg(rtsx_dev(chip), "bus_width = %d\n", bus_width);
4032#else
4033 bus_width = SD_BUS_WIDTH_4;
4034#endif
4035
4036 if (data_len < 512) {
4037 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len,
4038 SD_RSP_TYPE_R1, NULL, 0,
4039 false);
4040 if (retval != STATUS_SUCCESS)
4041 goto sd_execute_read_cmd_failed;
4042 }
4043
4044 if (standby) {
4045 retval = sd_select_card(chip, 0);
4046 if (retval != STATUS_SUCCESS)
4047 goto sd_execute_read_cmd_failed;
4048 }
4049
4050 if (acmd) {
4051 retval = ext_sd_send_cmd_get_rsp(chip, APP_CMD,
4052 sd_card->sd_addr,
4053 SD_RSP_TYPE_R1, NULL, 0,
4054 false);
4055 if (retval != STATUS_SUCCESS)
4056 goto sd_execute_read_cmd_failed;
4057 }
4058
4059 if (data_len <= 512) {
4060 int min_len;
4061 u8 *buf;
4062 u16 byte_cnt, blk_cnt;
4063 u8 cmd[5];
4064
4065 byte_cnt = ((u16)(srb->cmnd[8] & 0x03) << 8) | srb->cmnd[9];
4066 blk_cnt = 1;
4067
4068 cmd[0] = 0x40 | cmd_idx;
4069 cmd[1] = srb->cmnd[3];
4070 cmd[2] = srb->cmnd[4];
4071 cmd[3] = srb->cmnd[5];
4072 cmd[4] = srb->cmnd[6];
4073
4074 buf = kmalloc(data_len, GFP_KERNEL);
4075 if (!buf)
4076 return TRANSPORT_ERROR;
4077
4078 retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd, 5, byte_cnt,
4079 blk_cnt, bus_width, buf, data_len, 2000);
4080 if (retval != STATUS_SUCCESS) {
4081 read_err = true;
4082 kfree(buf);
4083 rtsx_clear_sd_error(chip);
4084 goto sd_execute_read_cmd_failed;
4085 }
4086
4087 min_len = min(data_len, scsi_bufflen(srb));
4088 rtsx_stor_set_xfer_buf(buf, min_len, srb);
4089
4090 kfree(buf);
4091 } else if (!(data_len & 0x1FF)) {
4092 rtsx_init_cmd(chip);
4093
4094 trans_dma_enable(DMA_FROM_DEVICE, chip, data_len, DMA_512);
4095
4096 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_H, 0xFF,
4097 0x02);
4098 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF,
4099 0x00);
4100 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H,
4101 0xFF, (srb->cmnd[7] & 0xFE) >> 1);
4102 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L,
4103 0xFF, (u8)((data_len & 0x0001FE00) >> 9));
4104
4105 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD0, 0xFF,
4106 0x40 | cmd_idx);
4107 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD1, 0xFF,
4108 srb->cmnd[3]);
4109 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD2, 0xFF,
4110 srb->cmnd[4]);
4111 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD3, 0xFF,
4112 srb->cmnd[5]);
4113 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CMD4, 0xFF,
4114 srb->cmnd[6]);
4115
4116 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG1, 0x03, bus_width);
4117 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_CFG2, 0xFF, rsp_type);
4118
4119 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER,
4120 0xFF, SD_TM_AUTO_READ_2 | SD_TRANSFER_START);
4121 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER,
4122 SD_TRANSFER_END, SD_TRANSFER_END);
4123
4124 rtsx_send_cmd_no_wait(chip);
4125
4126 retval = rtsx_transfer_data(chip, SD_CARD, scsi_sglist(srb),
4127 scsi_bufflen(srb),
4128 scsi_sg_count(srb),
4129 DMA_FROM_DEVICE, 10000);
4130 if (retval < 0) {
4131 read_err = true;
4132 rtsx_clear_sd_error(chip);
4133 goto sd_execute_read_cmd_failed;
4134 }
4135
4136 } else {
4137 goto sd_execute_read_cmd_failed;
4138 }
4139
4140 retval = ext_sd_get_rsp(chip, rsp_len, sd_card->rsp, rsp_type);
4141 if (retval != STATUS_SUCCESS)
4142 goto sd_execute_read_cmd_failed;
4143
4144 if (standby) {
4145 retval = sd_select_card(chip, 1);
4146 if (retval != STATUS_SUCCESS)
4147 goto sd_execute_read_cmd_failed;
4148 }
4149
4150 if (send_cmd12) {
4151 retval = ext_sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION, 0,
4152 SD_RSP_TYPE_R1b, NULL, 0,
4153 false);
4154 if (retval != STATUS_SUCCESS)
4155 goto sd_execute_read_cmd_failed;
4156 }
4157
4158 if (data_len < 512) {
4159 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200,
4160 SD_RSP_TYPE_R1, NULL, 0,
4161 false);
4162 if (retval != STATUS_SUCCESS)
4163 goto sd_execute_read_cmd_failed;
4164
4165 retval = rtsx_write_register(chip, SD_BYTE_CNT_H, 0xFF, 0x02);
4166 if (retval != STATUS_SUCCESS)
4167 goto sd_execute_read_cmd_failed;
4168
4169 retval = rtsx_write_register(chip, SD_BYTE_CNT_L, 0xFF, 0x00);
4170 if (retval != STATUS_SUCCESS)
4171 goto sd_execute_read_cmd_failed;
4172 }
4173
4174 if ((srb->cmnd[1] & 0x02) || (srb->cmnd[1] & 0x04))
4175 cmd13_checkbit = true;
4176
4177 for (i = 0; i < 3; i++) {
4178 retval = ext_sd_send_cmd_get_rsp(chip, SEND_STATUS,
4179 sd_card->sd_addr,
4180 SD_RSP_TYPE_R1, NULL, 0,
4181 cmd13_checkbit);
4182 if (retval == STATUS_SUCCESS)
4183 break;
4184 }
4185 if (retval != STATUS_SUCCESS)
4186 goto sd_execute_read_cmd_failed;
4187
4188 scsi_set_resid(srb, 0);
4189 return TRANSPORT_GOOD;
4190
4191sd_execute_read_cmd_failed:
4192 sd_card->pre_cmd_err = 1;
4193 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
4194 if (read_err)
4195 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
4196
4197 release_sd_card(chip);
4198 do_reset_sd_card(chip);
4199 if (!(chip->card_ready & SD_CARD))
4200 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
4201
4202 return TRANSPORT_FAILED;
4203}
4204
4205int sd_execute_write_data(struct scsi_cmnd *srb, struct rtsx_chip *chip)
4206{
4207 struct sd_info *sd_card = &chip->sd_card;
4208 unsigned int lun = SCSI_LUN(srb);
4209 int retval, rsp_len, i;
4210 bool write_err = false, cmd13_checkbit = false;
4211 u8 cmd_idx, rsp_type;
4212 bool standby = false, send_cmd12 = false, acmd = false;
4213 u32 data_len, arg;
4214#ifdef SUPPORT_SD_LOCK
4215 int lock_cmd_fail = 0;
4216 u8 sd_lock_state = 0;
4217 u8 lock_cmd_type = 0;
4218#endif
4219
4220 if (!sd_card->sd_pass_thru_en) {
4221 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4222 return TRANSPORT_FAILED;
4223 }
4224
4225 if (sd_card->pre_cmd_err) {
4226 sd_card->pre_cmd_err = 0;
4227 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
4228 return TRANSPORT_FAILED;
4229 }
4230
4231 retval = sd_switch_clock(chip);
4232 if (retval != STATUS_SUCCESS)
4233 return TRANSPORT_FAILED;
4234
4235 cmd_idx = srb->cmnd[2] & 0x3F;
4236 if (srb->cmnd[1] & 0x04)
4237 send_cmd12 = true;
4238
4239 if (srb->cmnd[1] & 0x02)
4240 standby = true;
4241
4242 if (srb->cmnd[1] & 0x01)
4243 acmd = true;
4244
4245 data_len = ((u32)srb->cmnd[7] << 16) | ((u32)srb->cmnd[8]
4246 << 8) | srb->cmnd[9];
4247 arg = ((u32)srb->cmnd[3] << 24) | ((u32)srb->cmnd[4] << 16) |
4248 ((u32)srb->cmnd[5] << 8) | srb->cmnd[6];
4249
4250#ifdef SUPPORT_SD_LOCK
4251 if (cmd_idx == LOCK_UNLOCK) {
4252 sd_lock_state = sd_card->sd_lock_status;
4253 sd_lock_state &= SD_LOCKED;
4254 }
4255#endif
4256
4257 retval = get_rsp_type(srb, &rsp_type, &rsp_len);
4258 if (retval != STATUS_SUCCESS) {
4259 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4260 return TRANSPORT_FAILED;
4261 }
4262 sd_card->last_rsp_type = rsp_type;
4263
4264 retval = sd_switch_clock(chip);
4265 if (retval != STATUS_SUCCESS)
4266 return TRANSPORT_FAILED;
4267
4268#ifdef SUPPORT_SD_LOCK
4269 if ((sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) == 0) {
4270 if (CHK_MMC_8BIT(sd_card)) {
4271 retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03,
4272 SD_BUS_WIDTH_8);
4273 if (retval != STATUS_SUCCESS)
4274 return TRANSPORT_FAILED;
4275
4276 } else if (CHK_SD(sd_card) || CHK_MMC_4BIT(sd_card)) {
4277 retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03,
4278 SD_BUS_WIDTH_4);
4279 if (retval != STATUS_SUCCESS)
4280 return TRANSPORT_FAILED;
4281 }
4282 }
4283#else
4284 retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_4);
4285 if (retval != STATUS_SUCCESS)
4286 return TRANSPORT_FAILED;
4287#endif
4288
4289 if (data_len < 512) {
4290 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len,
4291 SD_RSP_TYPE_R1, NULL, 0,
4292 false);
4293 if (retval != STATUS_SUCCESS)
4294 goto sd_execute_write_cmd_failed;
4295 }
4296
4297 if (standby) {
4298 retval = sd_select_card(chip, 0);
4299 if (retval != STATUS_SUCCESS)
4300 goto sd_execute_write_cmd_failed;
4301 }
4302
4303 if (acmd) {
4304 retval = ext_sd_send_cmd_get_rsp(chip, APP_CMD,
4305 sd_card->sd_addr,
4306 SD_RSP_TYPE_R1, NULL, 0,
4307 false);
4308 if (retval != STATUS_SUCCESS)
4309 goto sd_execute_write_cmd_failed;
4310 }
4311
4312 retval = ext_sd_send_cmd_get_rsp(chip, cmd_idx, arg, rsp_type,
4313 sd_card->rsp, rsp_len, false);
4314 if (retval != STATUS_SUCCESS)
4315 goto sd_execute_write_cmd_failed;
4316
4317 if (data_len <= 512) {
4318 u16 i;
4319 u8 *buf;
4320
4321 buf = kmalloc(data_len, GFP_KERNEL);
4322 if (!buf)
4323 return TRANSPORT_ERROR;
4324
4325 rtsx_stor_get_xfer_buf(buf, data_len, srb);
4326
4327#ifdef SUPPORT_SD_LOCK
4328 if (cmd_idx == LOCK_UNLOCK)
4329 lock_cmd_type = buf[0] & 0x0F;
4330#endif
4331
4332 if (data_len > 256) {
4333 rtsx_init_cmd(chip);
4334 for (i = 0; i < 256; i++) {
4335 rtsx_add_cmd(chip, WRITE_REG_CMD,
4336 PPBUF_BASE2 + i, 0xFF, buf[i]);
4337 }
4338 retval = rtsx_send_cmd(chip, 0, 250);
4339 if (retval != STATUS_SUCCESS) {
4340 kfree(buf);
4341 goto sd_execute_write_cmd_failed;
4342 }
4343
4344 rtsx_init_cmd(chip);
4345 for (i = 256; i < data_len; i++) {
4346 rtsx_add_cmd(chip, WRITE_REG_CMD,
4347 PPBUF_BASE2 + i, 0xFF, buf[i]);
4348 }
4349 retval = rtsx_send_cmd(chip, 0, 250);
4350 if (retval != STATUS_SUCCESS) {
4351 kfree(buf);
4352 goto sd_execute_write_cmd_failed;
4353 }
4354 } else {
4355 rtsx_init_cmd(chip);
4356 for (i = 0; i < data_len; i++) {
4357 rtsx_add_cmd(chip, WRITE_REG_CMD,
4358 PPBUF_BASE2 + i, 0xFF, buf[i]);
4359 }
4360 retval = rtsx_send_cmd(chip, 0, 250);
4361 if (retval != STATUS_SUCCESS) {
4362 kfree(buf);
4363 goto sd_execute_write_cmd_failed;
4364 }
4365 }
4366
4367 kfree(buf);
4368
4369 rtsx_init_cmd(chip);
4370
4371 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_H, 0xFF,
4372 srb->cmnd[8] & 0x03);
4373 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF,
4374 srb->cmnd[9]);
4375 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H, 0xFF,
4376 0x00);
4377 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L, 0xFF,
4378 0x01);
4379 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 0x01,
4380 PINGPONG_BUFFER);
4381
4382 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF,
4383 SD_TM_AUTO_WRITE_3 | SD_TRANSFER_START);
4384 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER,
4385 SD_TRANSFER_END, SD_TRANSFER_END);
4386
4387 retval = rtsx_send_cmd(chip, SD_CARD, 250);
4388 } else if (!(data_len & 0x1FF)) {
4389 rtsx_init_cmd(chip);
4390
4391 trans_dma_enable(DMA_TO_DEVICE, chip, data_len, DMA_512);
4392
4393 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_H, 0xFF,
4394 0x02);
4395 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BYTE_CNT_L, 0xFF,
4396 0x00);
4397 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_H,
4398 0xFF, (srb->cmnd[7] & 0xFE) >> 1);
4399 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_BLOCK_CNT_L,
4400 0xFF, (u8)((data_len & 0x0001FE00) >> 9));
4401
4402 rtsx_add_cmd(chip, WRITE_REG_CMD, REG_SD_TRANSFER, 0xFF,
4403 SD_TM_AUTO_WRITE_3 | SD_TRANSFER_START);
4404 rtsx_add_cmd(chip, CHECK_REG_CMD, REG_SD_TRANSFER,
4405 SD_TRANSFER_END, SD_TRANSFER_END);
4406
4407 rtsx_send_cmd_no_wait(chip);
4408
4409 retval = rtsx_transfer_data(chip, SD_CARD, scsi_sglist(srb),
4410 scsi_bufflen(srb),
4411 scsi_sg_count(srb),
4412 DMA_TO_DEVICE, 10000);
4413
4414 } else {
4415 goto sd_execute_write_cmd_failed;
4416 }
4417
4418 if (retval < 0) {
4419 write_err = true;
4420 rtsx_clear_sd_error(chip);
4421 goto sd_execute_write_cmd_failed;
4422 }
4423
4424#ifdef SUPPORT_SD_LOCK
4425 if (cmd_idx == LOCK_UNLOCK) {
4426 if (lock_cmd_type == SD_ERASE) {
4427 sd_card->sd_erase_status = SD_UNDER_ERASING;
4428 scsi_set_resid(srb, 0);
4429 return TRANSPORT_GOOD;
4430 }
4431
4432 rtsx_init_cmd(chip);
4433 rtsx_add_cmd(chip, CHECK_REG_CMD, 0xFD30, 0x02, 0x02);
4434
4435 retval = rtsx_send_cmd(chip, SD_CARD, 250);
4436 if (retval < 0) {
4437 write_err = true;
4438 rtsx_clear_sd_error(chip);
4439 goto sd_execute_write_cmd_failed;
4440 }
4441
4442 retval = sd_update_lock_status(chip);
4443 if (retval != STATUS_SUCCESS) {
4444 dev_dbg(rtsx_dev(chip), "Lock command fail!\n");
4445 lock_cmd_fail = 1;
4446 }
4447 }
4448#endif
4449
4450 if (standby) {
4451 retval = sd_select_card(chip, 1);
4452 if (retval != STATUS_SUCCESS)
4453 goto sd_execute_write_cmd_failed;
4454 }
4455
4456 if (send_cmd12) {
4457 retval = ext_sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION, 0,
4458 SD_RSP_TYPE_R1b, NULL, 0,
4459 false);
4460 if (retval != STATUS_SUCCESS)
4461 goto sd_execute_write_cmd_failed;
4462 }
4463
4464 if (data_len < 512) {
4465 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200,
4466 SD_RSP_TYPE_R1, NULL, 0,
4467 false);
4468 if (retval != STATUS_SUCCESS)
4469 goto sd_execute_write_cmd_failed;
4470
4471 retval = rtsx_write_register(chip, SD_BYTE_CNT_H, 0xFF, 0x02);
4472 if (retval != STATUS_SUCCESS)
4473 goto sd_execute_write_cmd_failed;
4474
4475 retval = rtsx_write_register(chip, SD_BYTE_CNT_L, 0xFF, 0x00);
4476 if (retval != STATUS_SUCCESS)
4477 goto sd_execute_write_cmd_failed;
4478 }
4479
4480 if ((srb->cmnd[1] & 0x02) || (srb->cmnd[1] & 0x04))
4481 cmd13_checkbit = true;
4482
4483 for (i = 0; i < 3; i++) {
4484 retval = ext_sd_send_cmd_get_rsp(chip, SEND_STATUS,
4485 sd_card->sd_addr,
4486 SD_RSP_TYPE_R1, NULL, 0,
4487 cmd13_checkbit);
4488 if (retval == STATUS_SUCCESS)
4489 break;
4490 }
4491 if (retval != STATUS_SUCCESS)
4492 goto sd_execute_write_cmd_failed;
4493
4494#ifdef SUPPORT_SD_LOCK
4495 if (cmd_idx == LOCK_UNLOCK) {
4496 if (!lock_cmd_fail) {
4497 dev_dbg(rtsx_dev(chip), "lock_cmd_type = 0x%x\n",
4498 lock_cmd_type);
4499 if (lock_cmd_type & SD_CLR_PWD)
4500 sd_card->sd_lock_status &= ~SD_PWD_EXIST;
4501
4502 if (lock_cmd_type & SD_SET_PWD)
4503 sd_card->sd_lock_status |= SD_PWD_EXIST;
4504 }
4505
4506 dev_dbg(rtsx_dev(chip), "sd_lock_state = 0x%x, sd_card->sd_lock_status = 0x%x\n",
4507 sd_lock_state, sd_card->sd_lock_status);
4508 if (sd_lock_state ^ (sd_card->sd_lock_status & SD_LOCKED)) {
4509 sd_card->sd_lock_notify = 1;
4510 if (sd_lock_state &&
4511 (sd_card->sd_lock_status & SD_LOCK_1BIT_MODE)) {
4512 sd_card->sd_lock_status |= (
4513 SD_UNLOCK_POW_ON | SD_SDR_RST);
4514 if (CHK_SD(sd_card)) {
4515 retval = reset_sd(chip);
4516 if (retval != STATUS_SUCCESS) {
4517 sd_card->sd_lock_status &= ~(SD_UNLOCK_POW_ON | SD_SDR_RST);
4518 goto sd_execute_write_cmd_failed;
4519 }
4520 }
4521
4522 sd_card->sd_lock_status &= ~(SD_UNLOCK_POW_ON | SD_SDR_RST);
4523 }
4524 }
4525 }
4526
4527 if (lock_cmd_fail) {
4528 scsi_set_resid(srb, 0);
4529 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
4530 return TRANSPORT_FAILED;
4531 }
4532#endif
4533
4534 scsi_set_resid(srb, 0);
4535 return TRANSPORT_GOOD;
4536
4537sd_execute_write_cmd_failed:
4538 sd_card->pre_cmd_err = 1;
4539 set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
4540 if (write_err)
4541 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
4542
4543 release_sd_card(chip);
4544 do_reset_sd_card(chip);
4545 if (!(chip->card_ready & SD_CARD))
4546 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
4547
4548 return TRANSPORT_FAILED;
4549}
4550
4551int sd_get_cmd_rsp(struct scsi_cmnd *srb, struct rtsx_chip *chip)
4552{
4553 struct sd_info *sd_card = &chip->sd_card;
4554 unsigned int lun = SCSI_LUN(srb);
4555 int count;
4556 u16 data_len;
4557
4558 if (!sd_card->sd_pass_thru_en) {
4559 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4560 return TRANSPORT_FAILED;
4561 }
4562
4563 if (sd_card->pre_cmd_err) {
4564 sd_card->pre_cmd_err = 0;
4565 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
4566 return TRANSPORT_FAILED;
4567 }
4568
4569 data_len = ((u16)srb->cmnd[7] << 8) | srb->cmnd[8];
4570
4571 if (sd_card->last_rsp_type == SD_RSP_TYPE_R0) {
4572 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4573 return TRANSPORT_FAILED;
4574 } else if (sd_card->last_rsp_type == SD_RSP_TYPE_R2) {
4575 count = (data_len < 17) ? data_len : 17;
4576 } else {
4577 count = (data_len < 6) ? data_len : 6;
4578 }
4579 rtsx_stor_set_xfer_buf(sd_card->rsp, count, srb);
4580
4581 dev_dbg(rtsx_dev(chip), "Response length: %d\n", data_len);
4582 dev_dbg(rtsx_dev(chip), "Response: 0x%x 0x%x 0x%x 0x%x\n",
4583 sd_card->rsp[0], sd_card->rsp[1],
4584 sd_card->rsp[2], sd_card->rsp[3]);
4585
4586 scsi_set_resid(srb, 0);
4587 return TRANSPORT_GOOD;
4588}
4589
4590int sd_hw_rst(struct scsi_cmnd *srb, struct rtsx_chip *chip)
4591{
4592 struct sd_info *sd_card = &chip->sd_card;
4593 unsigned int lun = SCSI_LUN(srb);
4594 int retval;
4595
4596 if (!sd_card->sd_pass_thru_en) {
4597 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4598 return TRANSPORT_FAILED;
4599 }
4600
4601 if (sd_card->pre_cmd_err) {
4602 sd_card->pre_cmd_err = 0;
4603 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
4604 return TRANSPORT_FAILED;
4605 }
4606
4607 if ((srb->cmnd[2] != 0x53) || (srb->cmnd[3] != 0x44) ||
4608 (srb->cmnd[4] != 0x20) || (srb->cmnd[5] != 0x43) ||
4609 (srb->cmnd[6] != 0x61) || (srb->cmnd[7] != 0x72) ||
4610 (srb->cmnd[8] != 0x64)) {
4611 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4612 return TRANSPORT_FAILED;
4613 }
4614
4615 switch (srb->cmnd[1] & 0x0F) {
4616 case 0:
4617#ifdef SUPPORT_SD_LOCK
4618 if (srb->cmnd[9] == 0x64)
4619 sd_card->sd_lock_status |= SD_SDR_RST;
4620#endif
4621 retval = reset_sd_card(chip);
4622 if (retval != STATUS_SUCCESS) {
4623#ifdef SUPPORT_SD_LOCK
4624 sd_card->sd_lock_status &= ~SD_SDR_RST;
4625#endif
4626 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
4627 sd_card->pre_cmd_err = 1;
4628 return TRANSPORT_FAILED;
4629 }
4630#ifdef SUPPORT_SD_LOCK
4631 sd_card->sd_lock_status &= ~SD_SDR_RST;
4632#endif
4633 break;
4634
4635 case 1:
4636 retval = reset_sd(chip);
4637 if (retval != STATUS_SUCCESS) {
4638 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
4639 sd_card->pre_cmd_err = 1;
4640 return TRANSPORT_FAILED;
4641 }
4642 break;
4643
4644 default:
4645 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
4646 return TRANSPORT_FAILED;
4647 }
4648
4649 scsi_set_resid(srb, 0);
4650 return TRANSPORT_GOOD;
4651}
4652#endif
4653
4654void sd_cleanup_work(struct rtsx_chip *chip)
4655{
4656 struct sd_info *sd_card = &chip->sd_card;
4657
4658 if (sd_card->seq_mode) {
4659 dev_dbg(rtsx_dev(chip), "SD: stop transmission\n");
4660 sd_stop_seq_mode(chip);
4661 sd_card->cleanup_counter = 0;
4662 }
4663}
4664
4665int sd_power_off_card3v3(struct rtsx_chip *chip)
4666{
4667 int retval;
4668
4669 retval = disable_card_clock(chip, SD_CARD);
4670 if (retval != STATUS_SUCCESS)
4671 return STATUS_FAIL;
4672
4673 retval = rtsx_write_register(chip, CARD_OE, SD_OUTPUT_EN, 0);
4674 if (retval)
4675 return retval;
4676
4677 if (!chip->ft2_fast_mode) {
4678 retval = card_power_off(chip, SD_CARD);
4679 if (retval != STATUS_SUCCESS)
4680 return STATUS_FAIL;
4681
4682 mdelay(50);
4683 }
4684
4685 if (chip->asic_code) {
4686 retval = sd_pull_ctl_disable(chip);
4687 if (retval != STATUS_SUCCESS)
4688 return STATUS_FAIL;
4689 } else {
4690 retval = rtsx_write_register(chip, FPGA_PULL_CTL,
4691 FPGA_SD_PULL_CTL_BIT | 0x20,
4692 FPGA_SD_PULL_CTL_BIT);
4693 if (retval)
4694 return retval;
4695 }
4696
4697 return STATUS_SUCCESS;
4698}
4699
4700int release_sd_card(struct rtsx_chip *chip)
4701{
4702 struct sd_info *sd_card = &chip->sd_card;
4703 int retval;
4704
4705 chip->card_ready &= ~SD_CARD;
4706 chip->card_fail &= ~SD_CARD;
4707 chip->card_wp &= ~SD_CARD;
4708
4709 chip->sd_io = 0;
4710 chip->sd_int = 0;
4711
4712#ifdef SUPPORT_SD_LOCK
4713 sd_card->sd_lock_status = 0;
4714 sd_card->sd_erase_status = 0;
4715#endif
4716
4717 memset(sd_card->raw_csd, 0, 16);
4718 memset(sd_card->raw_scr, 0, 8);
4719
4720 retval = sd_power_off_card3v3(chip);
4721 if (retval != STATUS_SUCCESS)
4722 return STATUS_FAIL;
4723
4724 return STATUS_SUCCESS;
4725}
4726
