1 /*
2 // Copyright (C) 2022 Beken Corporation
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <common/bk_include.h>
17 #include "sys_rtos.h"
18 #include <common/bk_kernel_err.h>
19
20 #if CONFIG_SDCARD_HOST
21 #include "sdio_driver.h"
22 #include <os/os.h>
23 #include "sys_rtos.h"
24 #include "sdcard.h"
25 #include "sdcard_pub.h"
26 #include "bk_drv_model.h"
27 #include "bk_sys_ctrl.h"
28 #include <os/mem.h>
29 #include "bk_arm_arch.h"
30 #include "bk_gpio.h"
31 #include "bk_misc.h"
32 #include <driver/gpio.h>
33
34 #if CONFIG_SOC_BK7256XX
35 #include "gpio_driver.h"
36 #endif
37
38 /* Standard sd commands ( ) type argument response */
39 #define GO_IDLE_STATE 0 /* bc */
40 #define ALL_SEND_CID 2
41 #define SEND_RELATIVE_ADDR 3 /* ac [31:16] RCA R6 */
42 #define IO_SEND_OP_COND 5 /* ac R4 */
43 #define SWITCH_FUNC 6
44 #define SELECT_CARD 7 /* ac [31:16] RCA R7 */
45 #define SEND_IF_COND 8 /* adtc R1 */
46 #define SEND_CSD 9
47 #define SEND_STATUS 13
48 #define READ_SINGLE_BLOCK 17
49 #define WRITE_BLOCK 24
50 #define WRITE_MULTI_BLOCK 25
51 #define SD_APP_OP_COND 41
52 #define IO_RW_DIRECT 52 /* ac [31:0] See below R5 */
53 #define IO_RW_EXTENDED 53 /* adtc [31:0] See below R5 */
54 #define APP_CMD 55
55
56 #define R5_COM_CRC_ERROR (1 << 15) /* er, b */
57 #define R5_ILLEGAL_COMMAND (1 << 14) /* er, b */
58 #define R5_ERROR (1 << 11) /* erx, c */
59 #define R5_FUNCTION_NUMBER (1 << 9) /* er, c */
60 #define R5_OUT_OF_RANGE (1 << 8) /* er, c */
61 #define R5_STATUS(x) (x & 0xCB00)
62 #define R5_IO_CURRENT_STATE(x) ((x & 0x3000) >> 12) /* s, b */
63
64 /*STM32 register bit define*/
65 #define SDIO_ICR_MASK 0x5FF
66 #define SDIO_STATIC_FLAGS ((UINT32)0x000005FF)
67 #define SDIO_FIFO_ADDRESS ((UINT32)0x40018080)
68
69 #define OCR_MSK_BUSY 0x80000000 // Busy flag
70 #define OCR_MSK_HC 0x40000000 // High Capacity flag
71 #define OCR_MSK_VOLTAGE_ALL 0x00FF8000 // All Voltage flag
72
73 #define SD_DEFAULT_OCR (OCR_MSK_VOLTAGE_ALL|OCR_MSK_HC)
74
75 //#define SD_CLK_PIN 34
76 #define REG_A2_CONFIG ((0x0802800) + 50*4)
77
78 typedef enum {
79 SD_CARD_IDLE = ((UINT32)0),
80 SD_CARD_READY = ((UINT32)1),
81 SD_CARD_IDENTIFICATION = ((UINT32)2),
82 SD_CARD_STANDBY = ((UINT32)3),
83 SD_CARD_TRANSFER = ((UINT32)4),
84 SD_CARD_SENDING = ((UINT32)5),
85 SD_CARD_RECEIVING = ((UINT32)6),
86 SD_CARD_PROGRAMMING = ((UINT32)7),
87 SD_CARD_DISCONNECTED = ((UINT32)8),
88 SD_CARD_ERROR = ((UINT32)0xff)
89 } SDCardState;
90
91 typedef struct sdio_command {
92 UINT32 index;
93 UINT32 arg;
94 UINT32 flags; /* expected response type */
95 UINT32 timeout;
96 bool crc_check;
97 UINT32 resp[4];
98 void *data; /* data segment associated with cmd */
99 SDIO_Error err; /* command error */
100 } SDIO_CMD_S, *SDIO_CMD_PTR;
101
102 static SDCARD_S sdcard;
103 static const DD_OPERATIONS sdcard_op = {
104 sdcard_open,
105 sdcard_close,
106 sdcard_read,
107 sdcard_write,
108 sdcard_ctrl
109 };
110
111
112 //#define SD_DEBOUNCE_COUNT 10
113
114 //static uint8 sd_online = SD_CARD_OFFLINE;
115 //static uint32 sd_clk_pin = SD_CLK_PIN;
116 //static uint32 sd_cd_pin = SD_DETECT_DEFAULT_GPIO;
117
118 static uint16 NoneedInitflag = 0;
119 //uint8 SD_det_gpio_flag = 1;
120 //static uint16 Sd_MMC_flag = 0;
121 //static uint16 cnt_online = 0;
122 //static beken_timer_t sd_cd_timer = {0};
123
124
125
126 static UINT8 no_need_send_cmd12_flag = 1;
127 static UINT8 SDIO_WR_flag = SDIO_RD_DATA;
128 static UINT32 last_WR_addr = 0;
129 static sdcard_ps_callback_t s_sdcard_ps_suspend_cb = NULL;
130 static sdcard_ps_callback_t s_sdcard_ps_resume_cb = NULL;
131
132 #define SDIO_RD_DATA 0
133 #define SDIO_WR_DATA 1
134
135 /*
136 * Func: check and wait the SD-CARD inserted
137 *
138 */
sdcard_check_inserted(void)139 static bool sdcard_check_inserted(void)
140 {
141 UINT32 sd_data0;
142 gpio_config_t gpio_config = {0};
143 volatile uint32_t i = 0;
144 bool is_inserted = true;
145 #if CONFIG_SOC_BK7256XX //Temp code.
146 sd_data0 = 6; //GPIO_6;
147 #else
148 #if (CONFIG_SD1_HOST_INTF)
149 sd_data0 = 36;
150 #else
151 sd_data0 = 17;
152 #endif
153 #endif
154
155 #if CONFIG_SOC_BK7256XX //Temp code.
156 gpio_dev_unmap(sd_data0);
157 #endif
158 gpio_config.io_mode = GPIO_INPUT_ENABLE;
159 gpio_config.pull_mode = GPIO_PULL_UP_EN;
160 gpio_config.func_mode = GPIO_SECOND_FUNC_DISABLE;
161 bk_gpio_set_config(sd_data0, &gpio_config);
162 delay_us(125); //confirm the gpio switch to input mode finish.
163 while (!bk_gpio_get_input(sd_data0))
164 {
165 i++;
166 if(i > 80000) //240M CPU clock, 60M * 4wire flash:i++ is 125ns,total is about ~~10ms
167 {
168 os_printf("sdcard isn't insert\r\n");
169 os_printf("WARNIG:HW will change detect pin, do not forget to modify code\r\n");
170 is_inserted = false;
171 break;
172 }
173 }
174
175 #if CONFIG_SOC_BK7256XX //Temp code.
176 gpio_dev_map(sd_data0, GPIO_DEV_SDIO_HOST_DATA0);
177 bk_gpio_pull_up(sd_data0);
178 bk_gpio_set_capacity(sd_data0, 3);
179 #else
180 gpio_config.io_mode = GPIO_IO_DISABLE;
181 gpio_config.pull_mode = GPIO_PULL_UP_EN;
182 gpio_config.func_mode = GPIO_SECOND_FUNC_ENABLE;
183 bk_gpio_set_config(sd_data0, &gpio_config);
184 #endif
185
186 //WARNING:temp workaround for HW card insert detect PIN is error.
187 //HW PIN6 can't detect voltage switch if card plug-in/out.
188 #if CONFIG_SOC_BK7256XX
189 is_inserted = true;
190 #endif
191
192 return is_inserted;
193 }
194
195 /******************************************************************************/
196 /***************************** public function ********************************/
197 /******************************************************************************/
198 #if (CONFIG_SOC_BK7256XX) //temp code, will be switch to sdcard_driver.c
sdcard_clock_set(uint8 clk_index)199 static void sdcard_clock_set(uint8 clk_index)
200 {
201 sdio_set_clock(clk_index);
202 sdcard.clk_cfg = clk_index;
203 }
204 #else
sdcard_clock_set(uint8 clk_index)205 static void sdcard_clock_set(uint8 clk_index)
206 {
207 if (clk_index <= CLK_LOWEST)
208 {
209 sdio_set_clock(clk_index);
210 sdcard.clk_cfg = clk_index;
211 }
212 }
213 #endif
214
sdio_hw_init(void)215 static void sdio_hw_init(void)
216 {
217 #if (CONFIG_SOC_BK7271)
218 UINT32 param;
219
220 param = BLK_BIT_MIC_QSPI_RAM_OR_FLASH;
221 sddev_control(DD_DEV_TYPE_SCTRL, CMD_SCTRL_BLK_ENABLE, ¶m);
222
223 param = PSRAM_VDD_3_3V;
224 //sddev_control(DD_DEV_TYPE_SCTRL, CMD_QSPI_VDDRAM_VOLTAGE, ¶m);
225 sys_drv_set_qspi_vddram_voltage(param);
226 #endif
227
228 #if CONFIG_SDCARD_HOST
229 if(sdcard_check_inserted() == false)
230 return;
231 #endif
232
233 /* config sdcard gpio */
234 sdio_gpio_config();
235
236 /* reset sdcard moudle register */
237 sdio_register_reset();
238
239 /* set sdcard low clk */
240 sdcard_clock_set(CLK_LOWEST);
241
242 /* set sdcard clk enable*/
243 sdio_clk_config(1);
244
245 os_printf("%s exit\r\n", __func__);
246 }
247
sdio_send_cmd(SDIO_CMD_PTR sdio_cmd_ptr)248 static void sdio_send_cmd(SDIO_CMD_PTR sdio_cmd_ptr)
249 {
250 sdio_sendcmd_function(sdio_cmd_ptr->index,
251 sdio_cmd_ptr->flags,
252 sdio_cmd_ptr->timeout,
253 (void *)sdio_cmd_ptr->arg);
254 }
255
sdio_hw_uninit(void)256 static void sdio_hw_uninit(void)
257 {
258 sdio_clk_config(0);
259 }
260
sdio_sw_init(void)261 static void sdio_sw_init(void)
262 {
263 os_memset((void *)&sdcard, 0, sizeof(SDCARD_S));
264 sdcard.clk_cfg = CLK_LOWEST;
265 }
266
get_timeout_param(uint8 cmd_or_data)267 uint32 get_timeout_param(uint8 cmd_or_data)
268 {
269 uint32 timeout_param;
270 switch (sdcard.clk_cfg) {
271 #if CONFIG_SOC_BK7256XX //Temp code, clock module should re-arch.
272 case CLK_100K:
273 if (cmd_or_data)
274 timeout_param = CMD_TIMEOUT_100K; //CMD_TIMEOUT_200K; //really is 100K
275 else
276 timeout_param = DATA_TIMEOUT_100K;
277 break;
278 #else
279 case CLK_200K:
280 if (cmd_or_data)
281 timeout_param = CMD_TIMEOUT_200K;
282 else
283 timeout_param = DATA_TIMEOUT_200K;
284 break;
285 #endif
286
287 case CLK_6_5M:
288 if (cmd_or_data)
289 timeout_param = CMD_TIMEOUT_6_5_M;
290 else
291 timeout_param = DATA_TIMEOUT_6_5_M;
292 break;
293
294 case CLK_13M:
295 if (cmd_or_data)
296 timeout_param = CMD_TIMEOUT_13M;
297 else
298 timeout_param = DATA_TIMEOUT_13M;
299 break;
300
301 #if CONFIG_SOC_BK7256XX
302 case CLK_20M:
303 if (cmd_or_data)
304 timeout_param = CMD_TIMEOUT_20M;
305 else
306 timeout_param = DATA_TIMEOUT_20M;
307 break;
308
309 //hasn't 26M
310 case CLK_40M:
311 if (cmd_or_data)
312 timeout_param = CMD_TIMEOUT_40M;
313 else
314 timeout_param = DATA_TIMEOUT_40M;
315 break;
316
317 case CLK_80M:
318 default:
319 if (cmd_or_data)
320 timeout_param = CMD_TIMEOUT_80M;
321 else
322 timeout_param = DATA_TIMEOUT_80M;
323 break;
324 #else
325 case CLK_26M:
326 default:
327 if (cmd_or_data)
328 timeout_param = CMD_TIMEOUT_26M;
329 else
330 timeout_param = DATA_TIMEOUT_26M;
331 break;
332 #endif
333
334 }
335 return timeout_param;
336 }
337
338 /******************************************************************************/
339 /***************************** sdcard function ********************************/
340 /******************************************************************************/
341 /* GO_IDLE_STATE */
sdcard_cmd0_process(void)342 static SDIO_Error sdcard_cmd0_process(void)
343 {
344 SDIO_CMD_S cmd;
345
346 cmd.index = GO_IDLE_STATE;
347 cmd.arg = 0;
348 cmd.flags = SD_CMD_NORESP;
349 cmd.timeout = get_timeout_param(1);
350 cmd.crc_check = false; //no response, so no need to check slave response's crc
351 sdio_send_cmd(&cmd);
352 cmd.err = sdio_wait_cmd_response(cmd.index);
353 return cmd.err;
354 }
355
sdcard_cmd1_process(void)356 static SDIO_Error sdcard_cmd1_process(void)
357 {
358 SDIO_CMD_S cmd;
359 uint32 response, reg;
360
361 cmd.index = 1;
362 cmd.arg = 0x40ff8000;
363 cmd.flags = SD_CMD_SHORT;
364 cmd.timeout = get_timeout_param(1);
365 cmd.crc_check = true; //multi-media card will response, sdcard no response
366 cmd1_loop:
367 sdio_send_cmd(&cmd);
368 cmd.err = sdio_wait_cmd_response(cmd.index);
369 if (cmd.err == SD_OK) {
370 sdio_get_cmdresponse_argument(0, &response);
371 if (!(response & OCR_MSK_VOLTAGE_ALL))
372 cmd.err = SD_ERR_CMD41_CNT;
373 if (!(response & OCR_MSK_BUSY))
374 goto cmd1_loop;
375 if (response & OCR_MSK_HC)
376 sdcard.Addr_shift_bit = 0;
377 else
378 sdcard.Addr_shift_bit = 9;
379 }
380 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
381 #if CONFIG_SOC_BK7256XX
382 reg |= SDCARD_FIFO_SD_STA_RST;
383 #else
384 reg |= 20;
385 #endif
386 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
387
388 return cmd.err;
389 }
390
sdcard_mmc_cmd8_process(void)391 static SDIO_Error sdcard_mmc_cmd8_process(void)
392 {
393 int i;
394 SDIO_CMD_S cmd;
395 uint32 tmp;
396 uint8 *tmpptr = (uint8 *)os_malloc(512);
397 if (tmpptr == NULL)
398 return 1;
399 os_memset(tmpptr, 0, 512);
400
401 cmd.index = SEND_IF_COND;
402 cmd.arg = 0;
403 cmd.flags = SD_CMD_SHORT;
404 cmd.timeout = get_timeout_param(1);
405 cmd.crc_check = true;
406 sdio_send_cmd(&cmd);
407
408 if (cmd.err != SD_OK)
409 goto freebuf;
410 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, (1 << 20));// reset first
411 #if CONFIG_SOC_BK7256XX
412 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, SDIO_REG0XD_CLK_REC_SEL | SDIO_REG0XD_SD_RD_WAIT_SEL | 0x3ffff);// set fifo later
413 #else
414 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, 0x3ffff);// set fifo later
415 #endif
416 driver_sdcard_recv_data_start(get_timeout_param(0));
417
418 tmp = 0;
419 cmd.err = wait_Receive_Data();
420 if (cmd.err == SD_OK) {
421 for (i = 0; i < 128; i++) {
422 while (!(REG_READ(REG_SDCARD_FIFO_THRESHOLD) & (0x1 << 18))) {
423 tmp++;
424 if (tmp > 0x20)
425 break;
426 }
427
428 *((uint32 *)tmpptr + i) = REG_READ(REG_SDCARD_RD_DATA_ADDR);
429 }
430 sdcard.total_block = tmpptr[212] | (tmpptr[213] << 8) | (tmpptr[214] << 16) | (tmpptr[215] << 24);
431 }
432
433 freebuf:
434 os_free(tmpptr);
435 return cmd.err;
436 }
437
438
sdcard_cmd8_process(void)439 static SDIO_Error sdcard_cmd8_process(void)
440 {
441 SDIO_CMD_S cmd;
442 UINT8 voltage_accpet, check_pattern;
443
444 cmd.index = SEND_IF_COND;
445 cmd.arg = 0x1AA;
446 cmd.flags = SD_CMD_SHORT;
447 cmd.timeout = get_timeout_param(1);
448 cmd.crc_check = true;
449
450 sdio_send_cmd(&cmd);
451 cmd.err = sdio_wait_cmd_response(cmd.index);
452
453 if (cmd.err == SD_CMD_RSP_TIMEOUT) {
454 SDCARD_WARN("cmd8 noresp, voltage mismatch or Ver1.X SD or not SD\r\n");
455 return SD_CMD_RSP_TIMEOUT;
456 } else if (cmd.err == SD_CMD_CRC_FAIL) {
457 SDCARD_WARN("cmd8 cmdcrc err\r\n");
458 return SD_CMD_CRC_FAIL;
459 }
460
461 SDCARD_PRT("found a Ver2.00 or later SDCard\r\n");
462
463 // check Valid Response,
464 // R7-[11:8]:voltage accepted, [7:0] echo-back of check pattern
465 sdio_get_cmdresponse_argument(0, &cmd.resp[0]);
466
467 check_pattern = cmd.resp[0] & 0xff;
468 voltage_accpet = cmd.resp[0] >> 8 & 0xf;
469
470 if (voltage_accpet == 0x1 && check_pattern == 0xaa) {
471 SDCARD_PRT("support 2.7~3.6V\r\n");
472 return SD_OK;
473 } else {
474 SDCARD_WARN("unsupport voltage\r\n");
475 return SD_INVALID_VOLTRANGE;
476 }
477 return SD_OK;
478 }
479
480 /*Send host capacity support information(HCS) and asks
481 the card to send its OCR in the response on CMD line*/
sdcard_acmd41_process(UINT32 ocr)482 static SDIO_Error sdcard_acmd41_process(UINT32 ocr)
483 {
484 SDIO_CMD_S cmd;
485
486
487 cmd.index = APP_CMD;
488 cmd.arg = 0;
489 cmd.flags = SD_CMD_SHORT;
490 cmd.timeout = get_timeout_param(1);
491 cmd.crc_check = true;
492
493 sdio_send_cmd(&cmd);
494 cmd.err = sdio_wait_cmd_response(cmd.index);
495 if (cmd.err != SD_OK) {
496 SDCARD_WARN("send cmd55 err:%d\r\n", cmd.err);
497 return cmd.err;
498 }
499
500
501 cmd.index = SD_APP_OP_COND;
502 cmd.arg = ocr;
503 cmd.flags = SD_CMD_SHORT;
504 cmd.timeout = get_timeout_param(1);
505 cmd.crc_check = false; //response cmd-index is 63,not 41, and the crc is err value if checked.
506 sdio_send_cmd(&cmd);
507 cmd.err = sdio_wait_cmd_response(cmd.index);
508 // why cmd41 always return crc fail?
509 if (cmd.err != SD_OK && cmd.err != SD_CMD_CRC_FAIL) {
510 SDCARD_WARN("send cmd41 err:%d\r\n", cmd.err);
511 return cmd.err;
512 }
513
514 return SD_OK;
515 }
516
517 /*ask the CID number on the CMD line*/
518 // Manufacturer ID MID 8 [127:120]
519 // OEM/Application ID OID 16 [119:104]
520 // Product name PNM 40 [103:64]
521 // Product revision PRV 8 [63:56]
522 // Product serial number PSN 32 [55:24]
523 // reserved -- 4 [23:20]
524 // Manufacturing date MDT 12 [19:8]
sdcard_cmd2_process(void)525 static SDIO_Error sdcard_cmd2_process(void)
526 {
527 SDIO_CMD_S cmd;
528
529 cmd.index = ALL_SEND_CID;
530 cmd.arg = 0;
531 cmd.flags = SD_CMD_LONG;
532 cmd.timeout = get_timeout_param(1);
533 cmd.crc_check = false; //response cmd-index is 63,not 2,and the crc is err value if checked.
534 sdio_send_cmd(&cmd);
535 cmd.err = sdio_wait_cmd_response(cmd.index);
536
537 // dismiss the CID info
538
539 return cmd.err;
540 }
541
sdcard_mmc_cmd3_process(void)542 static SDIO_Error sdcard_mmc_cmd3_process(void)
543 {
544 SDIO_CMD_S cmd;
545
546 cmd.index = SEND_RELATIVE_ADDR;
547 sdcard.card_rca = 1;
548 cmd.arg = (sdcard.card_rca << 16);
549 cmd.flags = SD_CMD_SHORT;
550 cmd.timeout = get_timeout_param(1);
551 cmd.crc_check = true;
552
553 sdio_send_cmd(&cmd);
554 cmd.err = sdio_wait_cmd_response(cmd.index);
555
556 if (cmd.err == SD_CMD_RSP_TIMEOUT) {
557 SDCARD_WARN("mmc cmd3 noresp \r\n");
558 return SD_CMD_RSP_TIMEOUT;
559 } else if (cmd.err == SD_CMD_CRC_FAIL) {
560 SDCARD_WARN("mmc cmd3 cmdcrc err\r\n");
561 return SD_CMD_CRC_FAIL;
562 }
563
564 SDCARD_PRT("mmc cmd3 is ok, card rca:0x%x\r\n", sdcard.card_rca);
565 return SD_OK;
566 }
567
568 /*ask the card to publish a new RCA*/
sdcard_cmd3_process(void)569 static SDIO_Error sdcard_cmd3_process(void)
570 {
571 SDIO_CMD_S cmd;
572
573 cmd.index = SEND_RELATIVE_ADDR;
574 cmd.arg = 0;
575 cmd.flags = SD_CMD_SHORT;
576 cmd.timeout = get_timeout_param(1);
577 cmd.crc_check = true;
578
579 sdio_send_cmd(&cmd);
580 cmd.err = sdio_wait_cmd_response(cmd.index);
581
582 if (cmd.err == SD_CMD_RSP_TIMEOUT) {
583 SDCARD_WARN("cmd3 noresp \r\n");
584 return SD_CMD_RSP_TIMEOUT;
585 } else if (cmd.err == SD_CMD_CRC_FAIL) {
586 SDCARD_WARN("cmd3 cmdcrc err\r\n");
587 return SD_CMD_CRC_FAIL;
588 }
589
590 sdio_get_cmdresponse_argument(0, &cmd.resp[0]);
591 sdcard.card_rca = (UINT16)(cmd.resp[0] >> 16);
592 SDCARD_PRT("cmd3 is ok, card rca:0x%x\r\n", sdcard.card_rca);
593 return SD_OK;
594 }
595
596 #define SD_CARD 0
597 #define MMC_CARD 1
598 /*get CSD Register content*/
sdcard_cmd9_process(uint8 card_type)599 static SDIO_Error sdcard_cmd9_process(uint8 card_type)
600 {
601 SDIO_CMD_S cmd;
602 int mult, csize;
603
604 cmd.index = SEND_CSD;
605 cmd.arg = (UINT32)(sdcard.card_rca << 16);
606 cmd.flags = SD_CMD_LONG;
607 cmd.timeout = get_timeout_param(1);
608 cmd.crc_check = false; //response cmd-index is 63,not 9,and the crc is err value if checked.
609
610 sdio_send_cmd(&cmd);
611 cmd.err = sdio_wait_cmd_response(cmd.index);
612 if (cmd.err != SD_OK)
613 return cmd.err;
614
615 sdio_get_cmdresponse_argument(0, &cmd.resp[0]);
616 sdio_get_cmdresponse_argument(1, &cmd.resp[1]);
617 sdio_get_cmdresponse_argument(2, &cmd.resp[2]);
618
619 sdcard.block_size = 1 << ((cmd.resp[1] >> 16) & 0xf);
620 //os_printf("arg:%x %x %x %x size:%x\r\n", cmd.resp[0],
621 // cmd.resp[1], cmd.resp[2], cmd.resp[3], sdcard.block_size);
622
623 if (card_type == SD_CARD) {
624
625 if (((cmd.resp[0] >> 30) & 0x3) == 0) {
626 csize = (((cmd.resp[1] & 0x3FF) << 2) | ((cmd.resp[2] >> 30) & 0x3));
627 mult = (cmd.resp[2] >> 15) & 0x7;
628
629 sdcard.total_block = (csize + 1) * (1 << (mult + 2));
630 sdcard.total_block *= (sdcard.block_size >> 9);
631 } else {
632 csize = (((cmd.resp[1] & 0x3F) << 16) | ((cmd.resp[2] >> 16) & 0xFFFF));
633 sdcard.total_block = (csize + 1) * 1024;
634 }
635
636 os_printf("size:%x total_block:%x\r\n", sdcard.block_size, sdcard.total_block);
637 } else {
638 if (sdcard.Addr_shift_bit != 0) {
639 csize = (((cmd.resp[1] & 0x3FF) << 2)
640 | ((cmd.resp[2] >> 30) & 0x3));
641 mult = (cmd.resp[2] >> 15) & 0x7;
642
643 sdcard.total_block = (csize + 1) * (1 << (mult + 2));
644 sdcard.total_block *= (sdcard.block_size >> 9);
645 } else
646 sdcard.total_block = 0;
647 }
648
649 sdcard.block_size = SD_DEFAULT_BLOCK_SIZE;
650 SDCARD_PRT("Bsize:%x;Total_block:%x\r\n", sdcard.block_size, sdcard.total_block);
651 BK_ASSERT(sdcard.block_size == SD_DEFAULT_BLOCK_SIZE);
652
653 return SD_OK;
654 }
655
656
657 /*select/deselect card*/
sdcard_cmd7_process(void)658 static SDIO_Error sdcard_cmd7_process(void)
659 {
660 SDIO_CMD_S cmd;
661
662 cmd.index = SELECT_CARD;
663 cmd.arg = (UINT32)(sdcard.card_rca << 16);
664 cmd.flags = SD_CMD_SHORT;
665 cmd.timeout = get_timeout_param(1);
666 cmd.crc_check = true;
667
668 sdio_send_cmd(&cmd);
669 cmd.err = sdio_wait_cmd_response(cmd.index);
670 return cmd.err;
671 }
672
673 /*set bus width*/
sdcard_acmd6_process(void)674 static SDIO_Error sdcard_acmd6_process(void)
675 {
676 SDIO_CMD_S cmd;
677 cmd.index = APP_CMD;
678 cmd.arg = (UINT32)(sdcard.card_rca << 16);
679 cmd.flags = SD_CMD_SHORT;
680 cmd.timeout = get_timeout_param(1);
681 cmd.crc_check = true;
682 sdio_send_cmd(&cmd);
683 cmd.err = sdio_wait_cmd_response(cmd.index);
684 if (cmd.err != SD_OK)
685 return cmd.err;
686
687 cmd.index = SWITCH_FUNC;
688 #ifdef CONFIG_SDCARD_BUSWIDTH_4LINE
689 cmd.arg = 2;
690 #else
691 cmd.arg = 0;
692 #endif
693 cmd.flags = SD_CMD_SHORT;
694 cmd.timeout = get_timeout_param(1);
695 cmd.crc_check = true;
696
697 sdio_send_cmd(&cmd);
698 cmd.err = sdio_wait_cmd_response(cmd.index);
699
700 return cmd.err;
701 }
702
sdcard_cmd18_process(uint32 addr)703 static SDIO_Error sdcard_cmd18_process(uint32 addr)
704 {
705 SDIO_CMD_S cmd;
706
707 cmd.index = 18;
708 cmd.arg = (UINT32)(addr << sdcard.Addr_shift_bit);
709 cmd.flags = SD_CMD_SHORT;
710 cmd.timeout = get_timeout_param(1);
711 cmd.crc_check = true;
712 sdio_send_cmd(&cmd);
713 cmd.err = sdio_wait_cmd_response(cmd.index);
714 return cmd.err;
715 }
sdcard_cmd12_process(uint32 addr)716 static SDIO_Error sdcard_cmd12_process(uint32 addr)
717 {
718 SDIO_CMD_S cmd;
719
720 #if CONFIG_SOC_BK7256XX
721 //1:clock always on, 0:auto gate
722 //after one block transfer finish, the clock is auto gate, and next cmd can't send out
723 {
724 sdio_clk_gate_config(1);
725 }
726 #endif
727
728 cmd.index = 12;
729 cmd.arg = addr;
730 cmd.flags = SD_CMD_SHORT;
731 cmd.timeout = get_timeout_param(1);
732 cmd.crc_check = true;
733 sdio_send_cmd(&cmd);
734 cmd.err = sdio_wait_cmd_response(cmd.index);
735
736 #if CONFIG_SOC_BK7256XX
737 {
738 uint32_t reg = REG_READ(REG_SDCARD_CMD_RSP_INT_MASK);
739 reg &= ~(0x1 << SDIO_REG0XA_TX_FIFO_NEED_WRITE_MASK_CG_POS);
740 REG_WRITE(REG_SDCARD_CMD_RSP_INT_MASK, reg);
741 }
742
743 //1:clock always on, 0:auto gate
744 //after cmd12 send out,restore the clock to auto gate status
745 {
746 sdio_clk_gate_config(0);
747 }
748 #endif
749
750 return cmd.err;
751 }
752
sdcard_send_read_stop(void)753 static SDIO_Error sdcard_send_read_stop(void)
754 {
755 //send stop command
756 UINT32 reg;
757 int Ret = 0;
758
759 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
760 reg &= ~(0xFFFF | (1 << 16) | (1 << 20));
761 reg |= (0x0101 | ((1 << 16) | (1 << 20)));
762 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
763 Ret = sdcard_cmd12_process(0);
764
765 //close clock
766 sdio_clk_config(0);
767 return Ret;
768 }
769
770 __maybe_unused static SDIO_Error sdcard_cmd17_process(uint32 addr);
sdcard_cmd17_process(uint32 addr)771 static SDIO_Error sdcard_cmd17_process(uint32 addr)
772 {
773 SDIO_CMD_S cmd;
774
775 cmd.index = 17;
776 cmd.arg = addr;
777 cmd.flags = SD_CMD_SHORT;
778 cmd.timeout = get_timeout_param(1);
779 cmd.crc_check = true;
780 sdio_send_cmd(&cmd);
781 cmd.err = sdio_wait_cmd_response(cmd.index);
782 return cmd.err;
783 }
784
sdcard_initialize(void)785 SDIO_Error sdcard_initialize(void)
786 {
787 SDIO_Error err = SD_OK;
788 sdio_sw_init();
789 rtos_delay_milliseconds(20);
790 sdio_hw_init();
791 rtos_delay_milliseconds(30);
792 SDIO_WR_flag = SDIO_RD_DATA;
793 no_need_send_cmd12_flag = 1;
794 last_WR_addr = 0;
795 // rest card
796 err = sdcard_cmd0_process();
797 if (err != SD_OK) {
798 SDCARD_FATAL("send cmd0 err\r\n");
799 goto err_return;
800 }
801 rtos_delay_milliseconds(5);
802
803 rtos_delay_milliseconds(50);
804 err = sdcard_cmd1_process();
805 os_printf("cmd 1:%x \r\n", err);
806 if (err == SD_OK)
807 goto MMC_init;
808
809 rtos_delay_milliseconds(5);
810
811
812 // check support voltage
813 err = sdcard_cmd8_process();
814 if (err != SD_OK && err != SD_CMD_RSP_TIMEOUT) {
815 SDCARD_FATAL("send cmd8 err\r\n");
816 goto err_return;
817 }
818
819 if (err == SD_OK) {
820 int retry_time = SD_MAX_VOLT_TRIAL;
821 UINT32 resp0;
822 while (retry_time) {
823 err = sdcard_acmd41_process(SD_DEFAULT_OCR);
824 if (err != SD_OK) {
825 SDCARD_FATAL("send cmd55&cmd41 err:%d, quite loop\r\n", err);
826 goto err_return;
827 }
828 sdio_get_cmdresponse_argument(0, &resp0);
829 if (resp0 & OCR_MSK_BUSY) {
830 if (resp0 & OCR_MSK_HC)
831 sdcard.Addr_shift_bit = 0;
832 else
833 sdcard.Addr_shift_bit = 9;
834 break;
835 }
836
837 rtos_delay_milliseconds(2);
838 retry_time--;
839 }
840 if (!retry_time) {
841 SDCARD_FATAL("send cmd55&cmd41 retry time out\r\n");
842 return SD_INVALID_VOLTRANGE;
843 }
844
845 SDCARD_PRT("send cmd55&cmd41 complete, card is ready, retry_time=%d\r\n", (SD_MAX_VOLT_TRIAL-retry_time));
846
847 if (resp0 & OCR_MSK_HC)
848 SDCARD_PRT("High Capacity SD Memory Card\r\n");
849 else
850 SDCARD_PRT("Standard Capacity SD Memory Card\r\n");
851 } else if (err == SD_CMD_RSP_TIMEOUT) {
852 int retry_time = SD_MAX_VOLT_TRIAL;
853 UINT32 resp0;
854 while (retry_time) {
855 err = sdcard_acmd41_process(OCR_MSK_VOLTAGE_ALL);
856 if (err != SD_OK) {
857 SDCARD_FATAL("send cmd55&cmd41 err, quite loop\r\n");
858 goto err_return;
859 }
860 sdio_get_cmdresponse_argument(0, &resp0);
861 if (resp0 & OCR_MSK_BUSY) {
862 if (resp0 & OCR_MSK_HC)
863 sdcard.Addr_shift_bit = 0;
864 else
865 sdcard.Addr_shift_bit = 9;
866 break;
867 }
868 rtos_delay_milliseconds(2);
869 retry_time--;
870 }
871 if (!retry_time) {
872 SDCARD_FATAL("send cmd55&cmd41 retry time out, maybe a MMC card\r\n");
873 err = SD_ERROR;
874 goto err_return;
875 }
876 SDCARD_PRT("send cmd55&cmd41 complete, SD V1.X card is ready\r\n");
877 }
878 rtos_delay_milliseconds(2);
879 // get CID, return R2
880 err = sdcard_cmd2_process();
881 if (err != SD_OK) {
882 SDCARD_FATAL("send cmd2 err:%d\r\n", err);
883 goto err_return;
884 }
885 rtos_delay_milliseconds(2);
886 // get RCA,
887 err = sdcard_cmd3_process();
888 if (err != SD_OK) {
889 SDCARD_FATAL("send cmd3 err:%d\r\n", err);
890 goto err_return;
891 }
892
893 #if (CONFIG_SOC_BK7256XX) //temp code, will be switch to sdcard_driver.c
894 sdcard_clock_set(CLK_80M);
895 #else
896 // change to default speed clk
897 sdcard_clock_set(CLK_13M);
898 #endif
899
900 rtos_delay_milliseconds(2);
901 // get CSD
902 err = sdcard_cmd9_process(SD_CARD);
903 if (err != SD_OK) {
904 SDCARD_FATAL("send cmd9 err:%d\r\n", err);
905 goto err_return;
906 }
907 rtos_delay_milliseconds(2);
908 // select card
909 err = sdcard_cmd7_process();
910 if (err != SD_OK) {
911 SDCARD_FATAL("send cmd7 err:%d\r\n", err);
912 goto err_return;
913 }
914 rtos_delay_milliseconds(2);
915 // change bus width, for high speed
916 err = sdcard_acmd6_process();
917 if (err != SD_OK) {
918 SDCARD_FATAL("send acmd6 err:%d\r\n", err);
919 goto err_return;
920 }
921
922 // Sd_MMC_flag = SD_CARD;
923 err = SD_OK;
924 SDCARD_PRT("sdcard initialize is done\r\n");
925 goto right_return;
926
927 MMC_init:
928 err = sdcard_cmd2_process();
929 os_printf("cmd 2 :%x\r\n", err);
930 if (err != SD_OK)
931 goto err_return;
932 err = sdcard_mmc_cmd3_process();
933 os_printf("cmd 3 :%x\r\n", err);
934
935 #if (CONFIG_SOC_BK7256XX) //temp code, will be switch to sdcard_driver.c
936 sdcard_clock_set(CLK_80M);
937 #else
938 sdcard_clock_set(CLK_13M);
939 #endif
940
941 err = sdcard_cmd9_process(MMC_CARD);
942 os_printf("cmd 9 :%x\r\n", err);
943 if (sdcard.Addr_shift_bit == 0) {
944 err = sdcard_mmc_cmd8_process();
945 os_printf("cmd 8 :%x\r\n", err);
946 }
947 if (err != SD_OK)
948 goto err_return;
949 err = sdcard_cmd7_process();
950 if (err != SD_OK)
951 goto err_return;
952 // Sd_MMC_flag = MMC_CARD;
953 goto right_return;
954
955 right_return:
956 NoneedInitflag = 1;
957 err_return:
958 sdio_clk_config(0);
959 return err;
960 }
961
sdcard_uninitialize(void)962 void sdcard_uninitialize(void)
963 {
964 sdio_hw_uninit();
965 sdio_sw_init();
966 NoneedInitflag = 0;
967 }
968
sdcard_get_card_info(SDCARD_S * card_info)969 void sdcard_get_card_info(SDCARD_S *card_info)
970 {
971 card_info->total_block = sdcard.total_block;
972 card_info->block_size = sdcard.block_size;
973 card_info->card_rca = sdcard.card_rca;
974 card_info->init_flag = sdcard.init_flag;
975 card_info->clk_cfg = sdcard.clk_cfg;
976 card_info->Addr_shift_bit = sdcard.Addr_shift_bit;
977 }
978
979 #if CONFIG_SOC_BK7256XX
sdcard_dump_transfer_data(UINT8 * write_buff,uint32_t first_block,uint32_t cnt)980 static void sdcard_dump_transfer_data(UINT8 *write_buff, uint32_t first_block, uint32_t cnt)
981 {
982 uint32_t i = 0;
983
984 SDCARD_DBG("[+]sdcard_dump_transfer_data:addr=0x%x,cnt=%d\r\n", write_buff, cnt);
985
986 for(i = 0; i < cnt; i+=16)
987 {
988 SDCARD_DBG("0x%08x, 0x%08x, 0x%08x, 0x%08x\r\n",
989 (uint32_t)(*(uint32_t *)&write_buff[i]),
990 (uint32_t)(*(uint32_t *)&write_buff[i+4]),
991 (uint32_t)(*(uint32_t *)&write_buff[i+8]),
992 (uint32_t)(*(uint32_t *)&write_buff[i+12]));
993 }
994
995 SDCARD_DBG("[-]sdcard_dump_transfer_data:addr=0x%x,cnt=%d\r\n", first_block, cnt);
996 }
997 #endif
998
999 SDIO_Error
sdcard_read_single_block(UINT8 * readbuff,UINT32 readaddr,UINT32 blocksize)1000 sdcard_read_single_block(UINT8 *readbuff, UINT32 readaddr, UINT32 blocksize)
1001 {
1002 SDIO_CMD_S cmd;
1003 SDIO_Error ret;
1004
1005 #if CONFIG_SOC_BK7256
1006
1007 #else
1008 #if CONFIG_SDCARD_HOST
1009 if(sdcard_check_inserted() == false)
1010 return SD_ERROR;
1011 #endif
1012 #endif
1013
1014 sdio_clk_config(1);
1015
1016 REG_WRITE(REG_SDCARD_CMD_RSP_INT_SEL, 0xffffffff);
1017 // setup data reg first
1018 sdio_set_data_timeout(get_timeout_param(0)); //DEF_DATA_TIME_OUT);
1019 sdio_setup_data(SDIO_RD_DATA, blocksize);
1020
1021 cmd.index = READ_SINGLE_BLOCK;
1022 cmd.arg = (UINT32)(readaddr << sdcard.Addr_shift_bit);
1023 cmd.flags = SD_CMD_SHORT;
1024 cmd.timeout = get_timeout_param(1);
1025 cmd.crc_check = true;
1026 sdio_send_cmd(&cmd);
1027 cmd.err = sdio_wait_cmd_response(cmd.index);
1028
1029 ret = cmd.err;
1030
1031 if (ret == SD_CMD_RSP_TIMEOUT) {
1032 SDCARD_FATAL("cmd17 noresp, readsingle block err\r\n");
1033 goto read_return;
1034 } else if (ret == SD_CMD_CRC_FAIL) {
1035 SDCARD_FATAL("cmd17 cmdcrc err, readsingle block err\r\n");
1036 goto read_return;
1037 }
1038
1039 cmd.err = sdcard_wait_receive_data(readbuff);
1040 ret = cmd.err;
1041
1042 if (ret != SD_OK) {
1043 SDCARD_FATAL("read single block wait data receive err:%d\r\n", cmd.err);
1044 goto read_return;
1045 }
1046 read_return:
1047 sdio_clk_config(0);
1048 return ret;
1049 }
1050
1051 static SDIO_Error sdcard_send_write_stop(int err);
1052 /////////read:first phase////////////
sd_read_data_init(void)1053 static void sd_read_data_init(void)
1054 {
1055 UINT32 reg;
1056
1057 #if CONFIG_SOC_BK7256XX
1058
1059 #else
1060 #if CONFIG_SDCARD_HOST
1061 if(sdcard_check_inserted() == false)
1062 return;
1063 #endif
1064 #endif
1065
1066 sdio_clk_config(1);
1067 reg = get_timeout_param(0);
1068 REG_WRITE(REG_SDCARD_DATA_REC_TIMER, reg);
1069 REG_WRITE(REG_SDCARD_CMD_RSP_INT_SEL, 0xFFFFFFFF);
1070
1071 #if CONFIG_SOC_BK7256XX
1072 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
1073
1074 //reset to 0
1075 reg &= ~(SDCARD_FIFO_SD_STA_RST | SDCARD_FIFO_TX_FIFO_RST | SDCARD_FIFO_RX_FIFO_RST);
1076 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
1077
1078 //reset to 1
1079 reg |= (SDCARD_FIFO_SD_STA_RST | SDCARD_FIFO_TX_FIFO_RST | SDCARD_FIFO_RX_FIFO_RST);
1080 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
1081
1082 reg &= (0xffff | (SDCARD_FIFO_SD_RATE_SELECT_MASK << SDCARD_FIFO_SD_RATE_SELECT_POSI) | SDIO_REG0XD_CLK_REC_SEL | SDIO_REG0XD_SD_RD_WAIT_SEL);
1083 reg |= (0x0101 | SDCARD_FIFO_RX_FIFO_RST);
1084 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
1085 #else
1086 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
1087 reg &= ~(0xFFFF | (1 << 16) | (1 << 20));
1088 reg |= (0x0101 | ((1 << 16) | (1 << 20)));
1089 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
1090 #endif
1091
1092 #ifdef CONFIG_SDCARD_BUSWIDTH_4LINE
1093 reg = 0x1 | (1 << 2) | (1 << 3) | (512 << 4) | (1 << 17);
1094 REG_WRITE(REG_SDCARD_DATA_REC_CTRL, reg);
1095 #else
1096 reg = 0x1 | (0 << 2) | (1 << 3) | (512 << 4) | (1 << 17);
1097 REG_WRITE(REG_SDCARD_DATA_REC_CTRL, reg);
1098 #endif
1099 }
1100
1101 /////////read:second phase////////////
sdcard_rcv_data(UINT8 * read_buff,int block_num)1102 static SDIO_Error sdcard_rcv_data(UINT8 *read_buff, int block_num)
1103 {
1104 int i, Ret, reg;
1105 UINT32 size;
1106 Ret = SD_OK;
1107 i = 0;
1108
1109 size = block_num << 9;/* *512*/;
1110
1111 while (1) {
1112 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_SEL);
1113 if (reg & SDCARD_CMDRSP_DATA_REC_END_INT) {
1114 REG_WRITE(REG_SDCARD_CMD_RSP_INT_SEL, SDCARD_CMDRSP_DATA_REC_END_INT);
1115 if (reg & SDCARD_CMDRSP_DATA_CRC_FAIL)
1116 Ret = SD_DATA_CRC_FAIL;
1117
1118 while (1) {
1119 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
1120 if (reg & SDCARD_FIFO_RXFIFO_RD_READY) {
1121 reg = REG_READ(REG_SDCARD_RD_DATA_ADDR);
1122 *(read_buff + i++) = reg & 0xff;
1123 *(read_buff + i++) = (reg >> 8) & 0xff;
1124 *(read_buff + i++) = (reg >> 16) & 0xff;
1125 *(read_buff + i++) = (reg >> 24) & 0xff;
1126 if ((i % 512) == 0)
1127 break;
1128 }
1129 }
1130
1131 if (i >= size)
1132 break;
1133 } else {
1134 if (reg & SDCARD_CMDRSP_DATA_TIME_OUT_INT) {
1135 Ret = SD_DATA_TIMEOUT;
1136 break;
1137 }
1138 }
1139 }
1140 return Ret;
1141 }
1142
1143 #if 1
sdcard_read_multi_block(UINT8 * read_buffer,int first_block,int block_num)1144 SDIO_Error sdcard_read_multi_block(UINT8 *read_buffer, int first_block, int block_num)
1145 {
1146 int ret = SD_OK;
1147 UINT8 op_flag = 0;
1148
1149 if (SDIO_WR_flag == SDIO_WR_DATA) {
1150 op_flag = 1; //write stop
1151 } else {
1152 if (last_WR_addr == first_block) {
1153 op_flag = 0;//continue read
1154 } else {
1155 op_flag = 2;//read stop
1156 }
1157 }
1158
1159 if (1 == no_need_send_cmd12_flag)
1160 op_flag = 3;//stop has send
1161
1162 no_need_send_cmd12_flag = 0;
1163 if (0 == op_flag)
1164 ret = sdcard_rcv_data(read_buffer, block_num);
1165 else {
1166 #if CONFIG_SOC_BK7256XX
1167 uint32_t ret2 = 0;
1168 uint32_t retry_cnt = 0;
1169 #endif
1170
1171 if (1 == op_flag)
1172 ret = sdcard_send_write_stop(0);
1173 else if (2 == op_flag)
1174 ret = sdcard_send_read_stop();
1175
1176 /*
1177 * WORKAROUND:
1178 * Some special sdcard maybe at busy status after CMD12,
1179 * so it can't response the next cmd,F.E:CMD18 which reads multi-block data.
1180 * BK7256XX_MP chip can't retry with CMD18, if it sends CMD18,BK7256 sdio
1181 * will start to read data from data-lines to the sdio FIFO but the data is 0.
1182 */
1183 #if CONFIG_SOC_BK7256XX
1184 /*
1185 * after stop cmd, should do check busy;
1186 * 1.read to switch start address
1187 * 2.write to read
1188 * 3.write and has sent stop(file system use sdcard_ctrl), and then start read
1189 */
1190 if((1 == op_flag) || (2 == op_flag) || ((3 == op_flag) && SDIO_WR_flag == SDIO_WR_DATA))
1191 {
1192 sdio_clk_config(1);
1193 while(retry_cnt < 256)
1194 {
1195 retry_cnt++;
1196
1197 ret2 = sdcard_acmd6_process();
1198 if (SD_OK == ret2)
1199 {
1200 SDCARD_DBG("check sdcard ready:acmd6 pass,retry_cnt=%d\r\n", retry_cnt);
1201 break;
1202 }
1203 }
1204 }
1205 #endif
1206 sd_read_data_init();
1207 #if CONFIG_SOC_BK7256XX
1208 if(ret2 == SD_OK) //ACMD6 pass means sdcard is not busy.
1209 {
1210 //CMD18:notify sdcard,will read multi-block data
1211 ret2 = sdcard_cmd18_process(first_block);
1212 if (SD_OK == ret2)
1213 {
1214 ret2 += sdcard_rcv_data(read_buffer, block_num);
1215 }
1216 else
1217 SDCARD_FATAL("--cmd18 send error:ret=%d\r\n", ret2);
1218 }
1219
1220 ret += ret2;
1221 #else
1222 ret += sdcard_cmd18_process(first_block);
1223 if (SD_OK == ret)
1224 {
1225 ret = sdcard_rcv_data(read_buffer, block_num);
1226 }
1227 #endif
1228
1229 }
1230
1231 if (SD_OK != ret) {
1232 no_need_send_cmd12_flag = 1;
1233 ret += sdcard_send_read_stop();
1234 }
1235
1236 #if CONFIG_SOC_BK7256XX
1237 {
1238 SDCARD_DBG("[-]%s:first_block=%d,block_num=%d\r\n", __func__, first_block, block_num);
1239 sdcard_dump_transfer_data(read_buffer, first_block, block_num*512);
1240 }
1241 #endif
1242
1243 SDIO_WR_flag = SDIO_RD_DATA;
1244 last_WR_addr = first_block + block_num;
1245 return ret;
1246 }
1247 #else
1248 /********* actual function: single read*********/
sdcard_read_multi_block(UINT8 * read_buff,int first_block,int block_num)1249 SDIO_Error sdcard_read_multi_block(UINT8 *read_buff, int first_block, int block_num)
1250 {
1251 int Ret = SD_OK;
1252 unsigned int i;
1253 SDIO_CMD_S cmd;
1254 UINT32 reg;
1255
1256 //rt_kprintf("----single read: %d\r\n",SDIO_WR_flag);
1257
1258 if (SDIO_WR_flag == SDIO_WR_DATA) { // if last state is multi write ,send stop cmd
1259 SDIO_WR_flag = SDIO_RD_DATA;
1260 Ret = sdcard_send_write_stop(0); //write stop
1261 }
1262
1263 #if CONFIG_SOC_BK7256
1264
1265 #else
1266 #if CONFIG_SDCARD_HOST
1267 if(sdcard_check_inserted() == false)
1268 return SD_ERROR;
1269 #endif
1270 #endif
1271
1272 sdio_clk_config(1);
1273 reg = get_timeout_param(0);
1274 REG_WRITE(REG_SDCARD_DATA_REC_TIMER, reg);
1275 REG_WRITE(REG_SDCARD_CMD_RSP_INT_SEL, 0xFFFFFFFF);
1276 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
1277 reg &= ~(0xFFFF | (1 << 16) | (1 << 20));
1278 reg |= (0x0101 | ((1 << 16) | (1 << 20)));
1279 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
1280
1281 #ifdef CONFIG_SDCARD_BUSWIDTH_4LINE
1282 reg = 0x1 | (1 << 2) | (1 << 3) | (512 << 4) | (1 << 17);
1283 REG_WRITE(REG_SDCARD_DATA_REC_CTRL, reg);
1284 #else
1285 reg = 0x1 | (0 << 2) | (1 << 3) | (512 << 4) | (1 << 17);
1286 REG_WRITE(REG_SDCARD_DATA_REC_CTRL, reg);
1287 #endif
1288
1289 // if((SD_CARD == Sd_MMC_flag)&&(driver_sdcard.total_block > 0x100000))
1290 {
1291 cmd.index = 18;
1292 cmd.arg = (UINT32)(first_block << sdcard.Addr_shift_bit);
1293 cmd.flags = SD_CMD_SHORT;
1294 cmd.timeout = get_timeout_param(1);
1295 cmd.crc_check = true;
1296 sdio_send_cmd(&cmd);
1297 cmd.err = sdio_wait_cmd_response(cmd.index);
1298
1299 Ret = cmd.err;
1300 }
1301 if (Ret == SD_OK) {
1302 unsigned int size = SD_DEFAULT_BLOCK_SIZE * block_num;
1303 //reveive data
1304 i = 0;
1305 while (1) {
1306 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_SEL);
1307 if (reg & SDCARD_CMDRSP_DATA_REC_END_INT) {
1308 REG_WRITE(REG_SDCARD_CMD_RSP_INT_SEL, SDCARD_CMDRSP_DATA_REC_END_INT);
1309 if (reg & SDCARD_CMDRSP_DATA_CRC_FAIL)
1310 Ret = SD_DATA_CRC_FAIL;
1311
1312 while (1) {
1313 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
1314 if (reg & SDCARD_FIFO_RXFIFO_RD_READY) {
1315 reg = REG_READ(REG_SDCARD_RD_DATA_ADDR);
1316 *(read_buff + i++) = reg & 0xff;
1317 *(read_buff + i++) = (reg >> 8) & 0xff;
1318 *(read_buff + i++) = (reg >> 16) & 0xff;
1319 *(read_buff + i++) = (reg >> 24) & 0xff;
1320 if ((i % 512) == 0)
1321 break;
1322 }
1323 }
1324 if (i >= size)
1325 break;
1326 } else {
1327 if (reg & SDCARD_CMDRSP_DATA_TIME_OUT_INT) {
1328 Ret = SD_DATA_TIMEOUT;
1329 break;
1330 }
1331 }
1332 }
1333 }
1334 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
1335 reg &= ~(0xFFFF | (1 << 16) | (1 << 20));
1336 reg |= (0x0101 | ((1 << 16) | (1 << 20)));
1337 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
1338 Ret += sdcard_cmd12_process(get_timeout_param(1));
1339
1340 sdio_clk_config(0);
1341
1342 if (Ret != SD_OK)
1343 os_printf("SD Ret:%d\r\n", Ret);
1344 return Ret;
1345 }
1346 #endif
sdcard_write_single_block(UINT8 * writebuff,UINT32 writeaddr)1347 SDIO_Error sdcard_write_single_block(UINT8 *writebuff, UINT32 writeaddr)
1348 {
1349 int i, ret;
1350 SDIO_CMD_S cmd;
1351 UINT32 tmpval, reg;
1352
1353 #if CONFIG_SOC_BK7256XX
1354
1355 #else
1356 #if CONFIG_SDCARD_HOST
1357 if(sdcard_check_inserted() == false)
1358 return SD_ERROR;
1359 #endif
1360 #endif
1361
1362 sdio_clk_config(1);
1363
1364 reg = REG_READ(REG_SDCARD_DATA_REC_CTRL);
1365 reg &= (~((1 << 16) | (1 << 0) | (1 << 1) | (1 << 3)));
1366 REG_WRITE(REG_SDCARD_DATA_REC_CTRL, reg);
1367
1368 REG_WRITE(REG_SDCARD_CMD_RSP_INT_SEL, 0xffffffff);
1369
1370 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
1371 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg | SDCARD_FIFO_SD_STA_RST);
1372
1373 #if CONFIG_SOC_BK7256XX
1374 reg &= (0xffff | (SDCARD_FIFO_SD_RATE_SELECT_MASK << SDCARD_FIFO_SD_RATE_SELECT_POSI) | SDIO_REG0XD_CLK_REC_SEL | SDIO_REG0XD_SD_RD_WAIT_SEL);
1375 #else
1376 reg &= (0xffff | (SDCARD_FIFO_SD_RATE_SELECT_MASK << SDCARD_FIFO_SD_RATE_SELECT_POSI));
1377 #endif
1378 reg |= (0x0101 /*| SDCARD_FIFO_TX_FIFO_RST*/);
1379 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
1380
1381 i = 0;
1382 while (REG_READ(REG_SDCARD_FIFO_THRESHOLD) & SDCARD_FIFO_TXFIFO_WR_READY) {
1383 tmpval = (writebuff[i] << 24) | (writebuff[i + 1] << 16) | (writebuff[i + 2] << 8) | writebuff[i + 3];
1384 REG_WRITE(REG_SDCARD_WR_DATA_ADDR, tmpval);
1385 i += 4;
1386 if (SD_DEFAULT_BLOCK_SIZE <= i)
1387 break;
1388 }
1389
1390 cmd.index = 24;//WRITE_MULTIPLE_BLOCK;
1391 cmd.arg = (UINT32)(writeaddr << sdcard.Addr_shift_bit);
1392 cmd.flags = SD_CMD_SHORT;
1393 cmd.timeout = get_timeout_param(1);
1394 cmd.crc_check = true;
1395 sdio_send_cmd(&cmd);
1396
1397 cmd.err = sdio_wait_cmd_response(cmd.index);
1398 ret = cmd.err;
1399
1400 if (SD_OK == ret) {
1401 REG_WRITE(REG_SDCARD_DATA_REC_TIMER, get_timeout_param(1));
1402 reg = (1 << 16) | (0 << 3) | (512 << 4) | (1 << 17)
1403 #ifdef CONFIG_SDCARD_BUSWIDTH_4LINE
1404 | SDCARD_DATA_REC_CTRL_DATA_BUS
1405 #endif
1406 ;
1407 REG_WRITE(REG_SDCARD_DATA_REC_CTRL, reg);
1408
1409 #if CONFIG_SOC_BK7256XX
1410 //no need to check tx fifo need write
1411 #else
1412 do {
1413 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_SEL);
1414 } while (!(reg & SDCARD_CMDRSP_TX_FIFO_NEED_WRITE));
1415 #endif
1416
1417 while (1) {
1418 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_SEL);
1419
1420 if (reg & (SDCARD_CMDRSP_DATA_TIME_OUT_INT)) {
1421 ret = SD_ERROR;
1422 break;
1423 }
1424
1425 if (reg & SDCARD_CMDRSP_DATA_WR_END_INT) {
1426 if (2 != ((reg & SDCARD_CMDRSP_WR_STATU) >> 20))
1427 ret = SD_ERROR;
1428 else
1429 ret = SD_OK;
1430 break;
1431 }
1432 }
1433 reg = REG_READ(REG_SDCARD_DATA_REC_CTRL);
1434 reg &= (~((1 << 16) | (1 << 0) | (1 << 1) | (1 << 3))
1435 #ifdef CONFIG_SDCARD_BUSWIDTH_4LINE
1436 | SDCARD_DATA_REC_CTRL_DATA_BUS
1437 #endif
1438 );
1439 REG_WRITE(REG_SDCARD_DATA_REC_CTRL, reg);
1440 }
1441
1442 if (ret != SD_OK)
1443 os_printf("--single blk write err:%d---\r\n", ret);
1444 sdio_clk_config(0);
1445
1446 return ret;
1447 }
1448
1449 ////////////////write:first phase///////////
sdcard_cmd25_process(UINT32 block_addr)1450 static SDIO_Error sdcard_cmd25_process(UINT32 block_addr)
1451 {
1452 SDIO_CMD_S cmd;
1453 UINT32 reg;
1454
1455 #if CONFIG_SOC_BK7256XX
1456
1457 #else
1458 #if CONFIG_SDCARD_HOST
1459 if(sdcard_check_inserted() == false)
1460 return SD_ERROR;
1461 #endif
1462 #endif
1463
1464 sdio_clk_config(1);
1465 REG_WRITE(REG_SDCARD_CMD_RSP_INT_SEL, 0xffffffff);
1466
1467 #if CONFIG_SOC_BK7256XX
1468 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
1469
1470 //reset to 0: 0 active
1471 reg &= ~(SDCARD_FIFO_SD_STA_RST | SDCARD_FIFO_TX_FIFO_RST | SDCARD_FIFO_RX_FIFO_RST);
1472 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
1473
1474 //reset to 1
1475 reg |= (SDCARD_FIFO_SD_STA_RST | SDCARD_FIFO_TX_FIFO_RST | SDCARD_FIFO_RX_FIFO_RST);
1476 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
1477
1478 reg &= (0xffff | (SDCARD_FIFO_SD_RATE_SELECT_MASK << SDCARD_FIFO_SD_RATE_SELECT_POSI) | SDIO_REG0XD_CLK_REC_SEL | SDIO_REG0XD_SD_RD_WAIT_SEL);
1479 reg |= (0x0101 | SDCARD_FIFO_TX_FIFO_RST);
1480 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
1481 #else
1482 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
1483 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg | SDCARD_FIFO_SD_STA_RST);
1484
1485 reg &= (0xffff | (SDCARD_FIFO_SD_RATE_SELECT_MASK << SDCARD_FIFO_SD_RATE_SELECT_POSI));
1486 reg |= (0x0101 | SDCARD_FIFO_TX_FIFO_RST);
1487 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
1488 #endif
1489
1490 cmd.index = 25;//WRITE_MULTIPLE_BLOCK;
1491 cmd.arg = (UINT32)(block_addr << sdcard.Addr_shift_bit);
1492 cmd.flags = SD_CMD_SHORT;
1493 cmd.timeout = get_timeout_param(1);
1494 cmd.crc_check = true;
1495 sdio_send_cmd(&cmd);
1496
1497 cmd.err = sdio_wait_cmd_response(cmd.index);
1498 return cmd.err;
1499 }
1500
1501 ////////////////write:second phase///////////
sdcard_write_data(UINT8 * write_buff,UINT32 block_num,UINT8 first_data_after_cmd)1502 static SDIO_Error sdcard_write_data(UINT8 *write_buff, UINT32 block_num, UINT8 first_data_after_cmd)
1503 {
1504 int i, j, tmpval, reg, ret;
1505 i = 0;
1506 ret = SD_OK;
1507
1508 if (1 == first_data_after_cmd) {
1509 // 1. fill the first block to fifo and start write data enable
1510 while (REG_READ(REG_SDCARD_FIFO_THRESHOLD) & SDCARD_FIFO_TXFIFO_WR_READY) {
1511 tmpval = (write_buff[i] << 24) | (write_buff[i + 1] << 16) | (write_buff[i + 2] << 8) | write_buff[i + 3];
1512 REG_WRITE(REG_SDCARD_WR_DATA_ADDR, tmpval);
1513 i += 4;
1514 if (SD_DEFAULT_BLOCK_SIZE <= i)
1515 break;
1516 }
1517
1518 #if CONFIG_SOC_BK7256XX
1519 //soc modification:enable clock gate function.
1520 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_MASK);
1521 reg |= (0x1 << SDIO_REG0XA_TX_FIFO_NEED_WRITE_MASK_CG_POS);
1522 REG_WRITE(REG_SDCARD_CMD_RSP_INT_MASK, reg);
1523 #endif
1524
1525 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_MASK);
1526 reg |= SDCARD_CMDRSP_TX_FIFO_EMPTY_MASK;
1527 REG_WRITE(REG_SDCARD_CMD_RSP_INT_MASK, reg);
1528
1529 REG_WRITE(REG_SDCARD_DATA_REC_TIMER, get_timeout_param(0));
1530 reg = (SD_DEFAULT_BLOCK_SIZE << SDCARD_DATA_REC_CTRL_BLK_SIZE_POSI) |
1531 SDCARD_DATA_REC_CTRL_DATA_MUL_BLK | SDCARD_DATA_REC_CTRL_DATA_BYTE_SEL |
1532 SDCARD_DATA_REC_CTRL_DATA_WR_DATA_EN
1533 #ifdef CONFIG_SDCARD_BUSWIDTH_4LINE
1534 | SDCARD_DATA_REC_CTRL_DATA_BUS
1535 #endif
1536 ;
1537 REG_WRITE(REG_SDCARD_DATA_REC_CTRL, reg);
1538
1539 #if CONFIG_SOC_BK7256XX
1540 {
1541 uint32_t k = 0;
1542 do {
1543 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_SEL);
1544
1545 k++;
1546 if(k > 0x10000000)
1547 {
1548 SDCARD_FATAL("write data too much time\r\n");
1549 break;
1550 }
1551 } while (!(reg & SDCARD_CMDRSP_DATA_WR_END_INT));
1552 SDCARD_DBG("SD Info:write blk data end, k=%d\r\n", k);
1553 REG_WRITE(REG_SDCARD_CMD_RSP_INT_SEL, SDCARD_CMDRSP_DATA_WR_END_INT);
1554 }
1555 #endif
1556
1557 do {
1558 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_SEL);
1559 } while (!(reg & SDCARD_CMDRSP_TX_FIFO_NEED_WRITE));
1560
1561 block_num -= 1;
1562 }
1563
1564 // 2. write other blocks
1565 while (block_num) {
1566 block_num--;
1567 j = 0;
1568 while (j < SD_DEFAULT_BLOCK_SIZE) {
1569 if (REG_READ(REG_SDCARD_FIFO_THRESHOLD) & SDCARD_FIFO_TXFIFO_WR_READY) {
1570 tmpval = (write_buff[i] << 24) | (write_buff[i + 1] << 16) | (write_buff[i + 2] << 8) | write_buff[i + 3];
1571 REG_WRITE(REG_SDCARD_WR_DATA_ADDR, tmpval);
1572 i += 4;
1573 j += 4;
1574 }
1575 }
1576
1577 do {
1578 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_SEL);
1579 } while (!(reg & SDCARD_CMDRSP_DATA_WR_END_INT));
1580
1581 REG_WRITE(REG_SDCARD_CMD_RSP_INT_SEL, SDCARD_CMDRSP_DATA_WR_END_INT);
1582
1583 #if CONFIG_SOC_BK7256XX
1584
1585 #else
1586 do {
1587 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_SEL);
1588 } while (!(reg & SDCARD_CMDRSP_TX_FIFO_NEED_WRITE));
1589 #endif
1590 if (2 != ((reg & SDCARD_CMDRSP_WR_STATU) >> 20)) {
1591 ret = SD_ERROR;
1592 os_printf("write data error !!!\r\n");
1593 break;
1594 }
1595 }
1596 return ret;
1597 }
1598 ////////////////write:last phase///////////
sdcard_send_write_stop(int err)1599 static SDIO_Error sdcard_send_write_stop(int err)
1600 {
1601 int reg, ret;
1602 GLOBAL_INT_DECLARATION();
1603 ret = SD_OK;
1604 // if(err != ret)
1605 {
1606 // 3. after the last block,write zero
1607 GLOBAL_INT_DISABLE();
1608 #if CONFIG_SOC_BK7256XX
1609 //soc modification:uses recovery function to instead fill-0.
1610 #else
1611 while (1) {
1612 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
1613 if (reg & SDCARD_FIFO_TXFIFO_WR_READY) {
1614 REG_WRITE(REG_SDCARD_WR_DATA_ADDR, 0);
1615 break;
1616 }
1617 }
1618 // 4.wait and clear flag
1619 do {
1620 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_SEL);
1621 if (reg & (SDCARD_CMDRSP_DATA_BUSY | SDCARD_CMDRSP_DATA_WR_END_INT))
1622 break;
1623 } while (1); //BUSY
1624 if ((reg & SDCARD_CMDRSP_DATA_BUSY)) {
1625 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_MASK);
1626 reg &= ~SDCARD_CMDRSP_TX_FIFO_EMPTY_MASK;
1627 REG_WRITE(REG_SDCARD_CMD_RSP_INT_MASK, reg);
1628 }
1629 if ((reg & SDCARD_CMDRSP_DATA_WR_END_INT))
1630 REG_WRITE(REG_SDCARD_CMD_RSP_INT_SEL, SDCARD_CMDRSP_DATA_WR_END_INT);
1631
1632 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_SEL);
1633 if (2 != ((reg & SDCARD_CMDRSP_WR_STATU) >> 20))
1634 ret = SD_ERROR;
1635 else
1636 ret = SD_OK;
1637 #endif
1638 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
1639 reg |= SDCARD_FIFO_TX_FIFO_RST;
1640 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
1641
1642 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_MASK);
1643 reg &= ~SDCARD_CMDRSP_TX_FIFO_EMPTY_MASK;
1644 REG_WRITE(REG_SDCARD_CMD_RSP_INT_MASK, reg);
1645 GLOBAL_INT_RESTORE();
1646
1647 #if CONFIG_SOC_BK7256XX
1648
1649 #else
1650 #if CONFIG_SDCARD_HOST
1651 if(sdcard_check_inserted() == false)
1652 return SD_ERROR;
1653 #endif
1654 #endif
1655 }
1656 ret += sdcard_cmd12_process(0);
1657 if (ret != SD_OK)
1658 SDCARD_FATAL("===write err:%x====\r\n", ret);
1659 ret += err;
1660 return ret;
1661 }
1662
1663 #if 1
sdcard_write_multi_block(UINT8 * write_buff,UINT32 first_block,UINT32 block_num)1664 SDIO_Error sdcard_write_multi_block(UINT8 *write_buff, UINT32 first_block, UINT32 block_num)
1665 {
1666 int ret = SD_OK;
1667 UINT8 op_flag = 0;
1668 if (SDIO_WR_flag == SDIO_RD_DATA) {
1669 op_flag = 1; //read stop
1670 } else {
1671 if (last_WR_addr == first_block) {
1672 op_flag = 0;//continue write
1673 } else {
1674 op_flag = 2;//write stop
1675 }
1676 }
1677
1678 #if CONFIG_SOC_BK7256XX
1679 {
1680 SDCARD_DBG("%s:start dump first_block=%d, block_num = %d\r\n", __func__, first_block, block_num);
1681 sdcard_dump_transfer_data(write_buff, first_block, block_num*512);
1682 }
1683 #endif
1684
1685 if (1 == no_need_send_cmd12_flag)
1686 op_flag = 3;//stop has send
1687
1688 //os_printf("===sd write: start = %d,block_num = %d,op_flag = %d=====\r\n", first_block, block_num, op_flag);
1689
1690 no_need_send_cmd12_flag = 0;
1691 if (0 == op_flag)//continue write
1692 ret = sdcard_write_data(write_buff, block_num, 0);
1693 else {
1694 #if CONFIG_SOC_BK7256XX
1695 uint32_t retry_cnt = 0;
1696 uint32_t ret2 = 0;
1697 #endif
1698 if (1 == op_flag) {
1699 /************if last state is single read:not send stop;***************/
1700 ret = sdcard_send_read_stop();
1701 } else if (op_flag == 2) {
1702 ret = sdcard_send_write_stop(0);
1703 }
1704
1705 #if CONFIG_SOC_BK7256XX
1706 if(ret == SD_OK)
1707 {
1708 //CMD25:notify sdcard,will write multi-block data
1709 while(retry_cnt < 16) //add retry count,maybe the card is busy after CMD12.
1710 {
1711 retry_cnt++;
1712
1713 ret2 = sdcard_cmd25_process(first_block);
1714 if (SD_OK == ret2)
1715 {
1716 ret2 += sdcard_write_data(write_buff, block_num, 1);
1717 if(SD_OK == ret2)
1718 {
1719 SDCARD_DBG("write data try_cnt=%d pass\r\n", retry_cnt);
1720 break;
1721 }
1722 else
1723 SDCARD_FATAL("sdcard write data fail \r\n");
1724 }
1725 }
1726 if(retry_cnt >= 16)
1727 SDCARD_FATAL("cmd25 retry_cnt=%d fail:ret=%d\r\n", retry_cnt);
1728
1729 ret += ret2;
1730 }
1731 #else
1732 //CMD25:notify sdcard,will write multi-block data
1733 ret += sdcard_cmd25_process(first_block);
1734 if (SD_OK == ret)
1735 ret += sdcard_write_data(write_buff, block_num, 1);
1736 else
1737 SDCARD_FATAL("--cmd25 send error:ret=%d\r\n", ret);
1738 #endif
1739 }
1740 if (ret != SD_OK) {
1741 ret += sdcard_send_write_stop(ret);
1742 no_need_send_cmd12_flag = 1;
1743 }
1744 last_WR_addr = first_block + block_num;
1745 SDIO_WR_flag = SDIO_WR_DATA;
1746 return ret;
1747 }
1748 #else
sdcard_write_multi_block(UINT8 * write_buff,UINT32 first_block,UINT32 block_num)1749 SDIO_Error sdcard_write_multi_block(UINT8 *write_buff, UINT32 first_block, UINT32 block_num)
1750 {
1751 SDIO_CMD_S cmd;
1752 int ret;
1753 UINT32 i, j, reg, tmpval;
1754 GLOBAL_INT_DECLARATION();
1755
1756 #if CONFIG_SOC_BK7256
1757
1758 #else
1759 #if CONFIG_SDCARD_HOST
1760 if(sdcard_check_inserted() == false)
1761 return SD_ERROR;
1762 #endif
1763 #endif
1764
1765 sdio_clk_config(1);
1766 REG_WRITE(REG_SDCARD_CMD_RSP_INT_SEL, 0xffffffff);
1767 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
1768
1769 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg | SDCARD_FIFO_SD_STA_RST);
1770
1771 #if CONFIG_SOC_BK7256XX
1772 reg &= (0xffff | (SDCARD_FIFO_SD_RATE_SELECT_MASK << SDCARD_FIFO_SD_RATE_SELECT_POSI) | SDIO_REG0XD_SD_RD_WAIT_SEL | SDIO_REG0XD_CLK_REC_SEL);
1773 reg |= (0x0101 | SDCARD_FIFO_TX_FIFO_RST);
1774 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
1775 #else
1776 reg &= (0xffff | (SDCARD_FIFO_SD_RATE_SELECT_MASK << SDCARD_FIFO_SD_RATE_SELECT_POSI));
1777 reg |= (0x0101 | SDCARD_FIFO_TX_FIFO_RST);
1778 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
1779 #endif
1780
1781 cmd.index = 25;//WRITE_MULTIPLE_BLOCK;
1782 cmd.arg = (UINT32)(first_block << sdcard.Addr_shift_bit);
1783 cmd.flags = SD_CMD_SHORT;
1784 cmd.timeout = get_timeout_param(1);
1785 cmd.crc_check = true;
1786 sdio_send_cmd(&cmd);
1787
1788 cmd.err = sdio_wait_cmd_response(cmd.index);
1789 ret = cmd.err;
1790
1791 if (SD_OK == ret) {
1792 i = 0;
1793 // 1. fill the first block to fifo and start write data enable
1794 while (REG_READ(REG_SDCARD_FIFO_THRESHOLD) & SDCARD_FIFO_TXFIFO_WR_READY) {
1795 tmpval = (write_buff[i] << 24) | (write_buff[i + 1] << 16) | (write_buff[i + 2] << 8) | write_buff[i + 3];
1796 REG_WRITE(REG_SDCARD_WR_DATA_ADDR, tmpval);
1797 i += 4;
1798 if (SD_DEFAULT_BLOCK_SIZE <= i)
1799 break;
1800 }
1801 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_MASK);
1802 reg |= SDCARD_CMDRSP_TX_FIFO_EMPTY_MASK;
1803 REG_WRITE(REG_SDCARD_CMD_RSP_INT_MASK, reg);
1804
1805 REG_WRITE(REG_SDCARD_DATA_REC_TIMER, get_timeout_param(0));
1806 reg = (SD_DEFAULT_BLOCK_SIZE << SDCARD_DATA_REC_CTRL_BLK_SIZE_POSI) |
1807 SDCARD_DATA_REC_CTRL_DATA_MUL_BLK | SDCARD_DATA_REC_CTRL_DATA_BYTE_SEL |
1808 SDCARD_DATA_REC_CTRL_DATA_WR_DATA_EN
1809 #ifdef CONFIG_SDCARD_BUSWIDTH_4LINE
1810 | SDCARD_DATA_REC_CTRL_DATA_BUS
1811 #endif
1812 ;
1813 REG_WRITE(REG_SDCARD_DATA_REC_CTRL, reg);
1814
1815 #if CONFIG_SOC_BK7256XX
1816
1817 #else
1818 do {
1819 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_SEL);
1820 } while (!(reg & SDCARD_CMDRSP_TX_FIFO_NEED_WRITE));
1821 #endif
1822
1823 // 2. write other blocks
1824 while (--block_num) {
1825 j = 0;
1826 while (j < SD_DEFAULT_BLOCK_SIZE) {
1827 if (REG_READ(REG_SDCARD_FIFO_THRESHOLD) & SDCARD_FIFO_TXFIFO_WR_READY) {
1828 tmpval = (write_buff[i] << 24) | (write_buff[i + 1] << 16) | (write_buff[i + 2] << 8) | write_buff[i + 3];
1829 REG_WRITE(REG_SDCARD_WR_DATA_ADDR, tmpval);
1830 i += 4;
1831 j += 4;
1832 }
1833 }
1834
1835 do {
1836 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_SEL);
1837 } while (!(reg & SDCARD_CMDRSP_DATA_WR_END_INT));
1838 REG_WRITE(REG_SDCARD_CMD_RSP_INT_SEL, SDCARD_CMDRSP_DATA_WR_END_INT);
1839
1840 #if CONFIG_SOC_BK7256XX
1841
1842 #else
1843 do {
1844 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_SEL);
1845 } while (!(reg & SDCARD_CMDRSP_TX_FIFO_NEED_WRITE));
1846 #endif
1847
1848 if (2 != ((reg & SDCARD_CMDRSP_WR_STATU) >> 20)) {
1849 ret = SD_ERROR;
1850 goto sndcmd12;
1851 }
1852 }
1853
1854 // 3. after the last block,write zero
1855 GLOBAL_INT_DISABLE();
1856 while (1) {
1857 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
1858 if (reg & SDCARD_FIFO_TXFIFO_WR_READY) {
1859 REG_WRITE(REG_SDCARD_WR_DATA_ADDR, 0);
1860 break;
1861 }
1862 }
1863 // 4.wait and clear flag
1864 do {
1865 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_SEL);
1866 if (reg & (SDCARD_CMDRSP_DATA_BUSY | SDCARD_CMDRSP_DATA_WR_END_INT))
1867 break;
1868 } while (1); //BUSY
1869
1870 if ((reg & SDCARD_CMDRSP_DATA_BUSY)) {
1871 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_MASK);
1872 reg &= ~SDCARD_CMDRSP_TX_FIFO_EMPTY_MASK;
1873 REG_WRITE(REG_SDCARD_CMD_RSP_INT_MASK, reg);
1874 }
1875 if ((reg & SDCARD_CMDRSP_DATA_WR_END_INT))
1876 REG_WRITE(REG_SDCARD_CMD_RSP_INT_SEL, SDCARD_CMDRSP_DATA_WR_END_INT);
1877
1878 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_SEL);
1879 if (2 != ((reg & SDCARD_CMDRSP_WR_STATU) >> 20))
1880 ret = SD_ERROR;
1881 else
1882 ret = SD_OK;
1883 }
1884 reg = REG_READ(REG_SDCARD_FIFO_THRESHOLD);
1885 reg |= SDCARD_FIFO_TX_FIFO_RST;
1886 REG_WRITE(REG_SDCARD_FIFO_THRESHOLD, reg);
1887 reg = REG_READ(REG_SDCARD_CMD_RSP_INT_MASK);
1888 reg &= ~SDCARD_CMDRSP_TX_FIFO_EMPTY_MASK;
1889 REG_WRITE(REG_SDCARD_CMD_RSP_INT_MASK, reg);
1890
1891 GLOBAL_INT_RESTORE();
1892
1893 #if CONFIG_SOC_BK7256XX
1894
1895 #else
1896 #if CONFIG_SDCARD_HOST
1897 if(sdcard_check_inserted() == false)
1898 return SD_ERROR;
1899 #endif
1900 #endif
1901
1902 sndcmd12:
1903 ret += sdcard_cmd12_process(0);
1904 if (ret != SD_OK)
1905 SDCARD_FATAL("===write err:%x,%x,%x====\r\n", first_block, ret, cmd.err);
1906 #if 0
1907 #if CONFIG_SDCARD_HOST
1908 if(sdcard_check_inserted() == false)
1909 return SD_ERROR;
1910 #endif
1911 sdio_clk_config(0);
1912 #endif
1913 return ret;
1914 }
1915 #endif
sdcard_init(void)1916 void sdcard_init(void)
1917 {
1918 ddev_register_dev(DD_DEV_TYPE_SDCARD, (DD_OPERATIONS *)&sdcard_op);
1919 //sdcard_cd_timer_init();
1920 }
1921
sdcard_exit(void)1922 void sdcard_exit(void)
1923 {
1924 ddev_unregister_dev(DD_DEV_TYPE_SDCARD);
1925 }
1926
1927
1928 /******************************************************************************/
1929 /***************************** sdcard API function ****************************/
1930 /******************************************************************************/
1931
sdcard_open(UINT32 op_flag)1932 UINT32 sdcard_open(UINT32 op_flag)
1933 {
1934 UINT8 cnt;
1935
1936 os_printf("===sd card open:%d===\r\n", NoneedInitflag);
1937 cnt = 3;
1938 while (1) {
1939 if (sdcard_initialize() == SD_OK)
1940 break;
1941 if (--cnt == 0) {
1942 SDCARD_FATAL("sdcard_open err\r\n");
1943 return SDCARD_FAILURE;
1944 }
1945 }
1946
1947 return SDCARD_SUCCESS;
1948 }
1949
sdcard_close(void)1950 UINT32 sdcard_close(void)
1951 {
1952 sdcard_uninitialize();
1953 return SDCARD_SUCCESS;
1954 }
1955
sdcard_read(char * user_buf,UINT32 count,UINT32 op_flag)1956 UINT32 sdcard_read(char *user_buf, UINT32 count, UINT32 op_flag)
1957 {
1958 UINT32 result = SD_OK;
1959 #if 1
1960 //os_printf("sd_read:buf = %x, count=%d,sector num=%d\r\n", user_buf, count, op_flag);
1961 result = sdcard_read_multi_block((uint8 *)user_buf, op_flag, count);
1962 if(result)
1963 os_printf("read err:%d\r\n", result);
1964 return result;
1965 #else
1966
1967 UINT32 start_blk_addr;
1968 UINT8 read_blk_numb, numb;
1969 UINT8 *read_data_buf;
1970 peri_busy_count_add();
1971 // check operate parameter
1972 start_blk_addr = op_flag;
1973 read_blk_numb = count;
1974 read_data_buf = (UINT8 *)user_buf;
1975
1976 os_printf("sd_read:buf = %x, count=%d,op_flag=%d\r\n", user_buf, count, op_flag);
1977
1978
1979
1980 {
1981 for (numb = 0; numb < read_blk_numb; numb++) {
1982 result = sdcard_read_single_block(read_data_buf, start_blk_addr,
1983 SD_DEFAULT_BLOCK_SIZE);
1984 if (result != SD_OK) {
1985 os_printf("sdcard_read err:%d, curblk:0x%x\r\n", result, start_blk_addr);
1986 count = 0;
1987 goto exit;
1988 }
1989
1990 start_blk_addr++;
1991 read_data_buf += SD_DEFAULT_BLOCK_SIZE;
1992 }
1993 }
1994 exit:
1995 peri_busy_count_dec();
1996 return result;
1997 #endif
1998 }
1999
sdcard_write_new(int first_block,int block_num,uint8_t * data)2000 UINT32 sdcard_write_new(int first_block, int block_num, uint8_t *data)
2001 {
2002 return sdcard_write_multi_block(data, first_block, block_num);
2003 }
2004
sdcard_read_new(int first_block,int block_num,uint8 * dest)2005 UINT32 sdcard_read_new(int first_block, int block_num, uint8 *dest)
2006 {
2007 return sdcard_read_multi_block(dest, first_block, block_num);
2008 }
2009
2010 //op_flag:first start block ID.
sdcard_write(char * user_buf,UINT32 count,UINT32 op_flag)2011 UINT32 sdcard_write(char *user_buf, UINT32 count, UINT32 op_flag)
2012 {
2013 SDIO_Error err = SD_OK;
2014 UINT32 start_blk_addr;
2015
2016 if (s_sdcard_ps_suspend_cb) {
2017 s_sdcard_ps_suspend_cb();
2018 }
2019 // check operate parameter
2020 start_blk_addr = op_flag;
2021 err = sdcard_write_multi_block((UINT8 *)user_buf, start_blk_addr, count);
2022 if (s_sdcard_ps_resume_cb) {
2023 s_sdcard_ps_resume_cb();
2024 }
2025 return err;
2026 }
2027
sdcard_ctrl(UINT32 cmd,void * parm)2028 UINT32 sdcard_ctrl(UINT32 cmd, void *parm)
2029 {
2030 if (s_sdcard_ps_suspend_cb) {
2031 s_sdcard_ps_suspend_cb();
2032 }
2033 switch (cmd) {
2034 case 0: //it's called in fatfs:disk_io.c
2035 #if CONFIG_SOC_BK7256XX //JIRA BK7256-1674
2036 if(no_need_send_cmd12_flag == 0)
2037 {
2038 sdcard_send_write_stop(0);
2039 no_need_send_cmd12_flag = 1;
2040 }
2041 #else //reserve previous codes.
2042 sdcard_cmd12_process(0);
2043 #endif
2044 break;
2045 default:
2046 break;
2047 }
2048 if (s_sdcard_ps_resume_cb) {
2049 s_sdcard_ps_resume_cb();
2050 }
2051
2052 return 0;
2053 }
2054
2055
sdcard_get_size(void)2056 int sdcard_get_size(void)
2057 {
2058 return sdcard.total_block;
2059 }
sdcard_get_block_size(void)2060 int sdcard_get_block_size(void)
2061 {
2062 return sdcard.block_size;
2063 }
clr_sd_noinitial_flag(void)2064 void clr_sd_noinitial_flag(void)
2065 {
2066 NoneedInitflag = 0;
2067 }
2068
sdcard_register_ps_suspend_callback(sdcard_ps_callback_t ps_suspend_cb)2069 void sdcard_register_ps_suspend_callback(sdcard_ps_callback_t ps_suspend_cb)
2070 {
2071 s_sdcard_ps_suspend_cb = ps_suspend_cb;
2072 }
2073
sdcard_register_ps_resume_callback(sdcard_ps_callback_t ps_resume_cb)2074 void sdcard_register_ps_resume_callback(sdcard_ps_callback_t ps_resume_cb)
2075 {
2076 s_sdcard_ps_resume_cb = ps_resume_cb;
2077 }
2078
2079 #endif // CONFIG_SDCARD_HOST
2080 // EOF
2081