1 // This file is Copyright (c) 2017-2020 Florent Kermarrec <florent@enjoy-digital.fr>
2 // This file is Copyright (c) 2019 Kees Jongenburger <kees.jongenburger@gmail.com>
3 // This file is Copyright (c) 2018 bunnie <bunnie@kosagi.com>
4 // This file is Copyright (c) 2020 Antmicro <www.antmicro.com>
11 #include <generated/csr.h>
12 #include <generated/mem.h>
16 #include "fat/diskio.h"
19 #ifdef CSR_SDCORE_BASE
21 //#define SDCARD_DEBUG
22 //#define SDCARD_CMD23_SUPPORT
24 #ifndef SDCARD_CLK_FREQ_INIT
25 #define SDCARD_CLK_FREQ_INIT 400000
28 #ifndef SDCARD_CLK_FREQ
29 #define SDCARD_CLK_FREQ 25000000
32 unsigned int sdcard_response
[SD_CMD_RESPONSE_SIZE
/4];
34 /*-----------------------------------------------------------------------*/
36 /*-----------------------------------------------------------------------*/
38 #define max(x, y) (((x) > (y)) ? (x) : (y))
39 #define min(x, y) (((x) < (y)) ? (x) : (y))
41 /*-----------------------------------------------------------------------*/
42 /* SDCard command helpers */
43 /*-----------------------------------------------------------------------*/
45 static void busy_wait_us(unsigned int us
)
48 timer0_reload_write(0);
49 timer0_load_write(CONFIG_CLOCK_FREQUENCY
/1000000*us
);
51 timer0_update_value_write(1);
52 while(timer0_value_read()) timer0_update_value_write(1);
55 int sdcard_wait_cmd_done(void) {
58 cmdevt
= sdcore_cmd_event_read();
61 printf("cmdevt: %08x\n", cmdevt
);
66 printf("cmdevt: SD_TIMEOUT\n");
70 else if (cmdevt
& 0x8) {
72 printf("cmdevt: SD_CRCERROR\n");
81 int sdcard_wait_data_done(void) {
84 dataevt
= sdcore_data_event_read();
87 printf("dataevt: %08x\n", dataevt
);
92 else if (dataevt
& 0x8)
99 int sdcard_wait_response(void) {
105 status
= sdcard_wait_cmd_done();
107 csr_rd_buf_uint32(CSR_SDCORE_CMD_RESPONSE_ADDR
, sdcard_response
, SD_CMD_RESPONSE_SIZE
/4);
110 for(i
= 0; i
< SD_CMD_RESPONSE_SIZE
/4; i
++) {
111 printf("%08x ", sdcard_response
[i
]);
119 /*-----------------------------------------------------------------------*/
120 /* SDCard clocker functions */
121 /*-----------------------------------------------------------------------*/
123 static uint32_t log2(uint32_t x
)
130 static void sdcard_set_clk_freq(uint32_t clk_freq
) {
132 divider
= CONFIG_CLOCK_FREQUENCY
/clk_freq
+ 1;
133 divider
= (1 << log2(divider
));
134 divider
= max(divider
, 2);
135 divider
= min(divider
, 128);
137 printf("Setting SDCard clk freq to ");
138 if (clk_freq
> 1000000)
139 printf("%d MHz\n", (CONFIG_CLOCK_FREQUENCY
/divider
)/1000000);
141 printf("%d KHz\n", (CONFIG_CLOCK_FREQUENCY
/divider
)/1000);
143 sdphy_clocker_divider_write(divider
);
146 /*-----------------------------------------------------------------------*/
147 /* SDCard commands functions */
148 /*-----------------------------------------------------------------------*/
150 int sdcard_go_idle(void) {
152 printf("CMD0: GO_IDLE\n");
154 sdcore_cmd_argument_write(0x00000000);
155 sdcore_cmd_command_write((0 << 8) | SDCARD_CTRL_RESPONSE_NONE
);
156 sdcore_cmd_send_write(1);
157 return sdcard_wait_response();
160 int sdcard_send_ext_csd(void) {
164 printf("CMD8: SEND_EXT_CSD, arg: 0x%08x\n", arg
);
166 sdcore_cmd_argument_write(arg
);
167 sdcore_cmd_command_write((8 << 8) | SDCARD_CTRL_RESPONSE_SHORT
);
168 sdcore_cmd_send_write(1);
169 return sdcard_wait_response();
172 int sdcard_app_cmd(int rca
) {
174 printf("CMD55: APP_CMD\n");
176 sdcore_cmd_argument_write(rca
<< 16);
177 sdcore_cmd_command_write((55 << 8) | SDCARD_CTRL_RESPONSE_SHORT
);
178 sdcore_cmd_send_write(1);
179 return sdcard_wait_response();
182 int sdcard_app_send_op_cond(int hcs
) {
188 printf("ACMD41: APP_SEND_OP_COND, arg: %08x\n", arg
);
190 sdcore_cmd_argument_write(arg
);
191 sdcore_cmd_command_write((41 << 8) | SDCARD_CTRL_RESPONSE_SHORT
);
192 sdcore_cmd_send_write(1);
193 return sdcard_wait_response();
196 int sdcard_all_send_cid(void) {
198 printf("CMD2: ALL_SEND_CID\n");
200 sdcore_cmd_argument_write(0x00000000);
201 sdcore_cmd_command_write((2 << 8) | SDCARD_CTRL_RESPONSE_LONG
);
202 sdcore_cmd_send_write(1);
203 return sdcard_wait_response();
206 int sdcard_set_relative_address(void) {
208 printf("CMD3: SET_RELATIVE_ADDRESS\n");
210 sdcore_cmd_argument_write(0x00000000);
211 sdcore_cmd_command_write((3 << 8) | SDCARD_CTRL_RESPONSE_SHORT
);
212 sdcore_cmd_send_write(1);
213 return sdcard_wait_response();
216 int sdcard_send_cid(unsigned int rca
) {
218 printf("CMD10: SEND_CID\n");
220 sdcore_cmd_argument_write(rca
<< 16);
221 sdcore_cmd_command_write((10 << 8) | SDCARD_CTRL_RESPONSE_LONG
);
222 sdcore_cmd_send_write(1);
223 return sdcard_wait_response();
226 int sdcard_send_csd(unsigned int rca
) {
228 printf("CMD9: SEND_CSD\n");
230 sdcore_cmd_argument_write(rca
<< 16);
231 sdcore_cmd_command_write((9 << 8) | SDCARD_CTRL_RESPONSE_LONG
);
232 sdcore_cmd_send_write(1);
233 return sdcard_wait_response();
236 int sdcard_select_card(unsigned int rca
) {
238 printf("CMD7: SELECT_CARD\n");
240 sdcore_cmd_argument_write(rca
<< 16);
241 sdcore_cmd_command_write((7 << 8) | SDCARD_CTRL_RESPONSE_SHORT
);
242 sdcore_cmd_send_write(1);
243 return sdcard_wait_response();
246 int sdcard_app_set_bus_width(void) {
248 printf("ACMD6: SET_BUS_WIDTH\n");
250 sdcore_cmd_argument_write(0x00000002);
251 sdcore_cmd_command_write((6 << 8) | SDCARD_CTRL_RESPONSE_SHORT
);
252 sdcore_cmd_send_write(1);
253 return sdcard_wait_response();
256 int sdcard_switch(unsigned int mode
, unsigned int group
, unsigned int value
) {
260 printf("CMD6: SWITCH_FUNC\n");
262 arg
= (mode
<< 31) | 0xffffff;
263 arg
&= ~(0xf << (group
* 4));
264 arg
|= value
<< (group
* 4);
266 sdcore_cmd_argument_write(arg
);
267 sdcore_block_length_write(64);
268 sdcore_block_count_write(1);
269 sdcore_cmd_command_write((6 << 8) |
270 SDCARD_CTRL_RESPONSE_SHORT
|
271 (SDCARD_CTRL_DATA_TRANSFER_READ
<< 5));
272 sdcore_cmd_send_write(1);
273 sdcard_wait_response();
274 return sdcard_wait_data_done();
277 int sdcard_app_send_scr(void) {
279 printf("CMD51: APP_SEND_SCR\n");
281 sdcore_cmd_argument_write(0x00000000);
282 sdcore_block_length_write(8);
283 sdcore_block_count_write(1);
284 sdcore_cmd_command_write((51 << 8) |
285 SDCARD_CTRL_RESPONSE_SHORT
|
286 (SDCARD_CTRL_DATA_TRANSFER_READ
<< 5));
287 sdcore_cmd_send_write(1);
288 sdcard_wait_response();
289 return sdcard_wait_data_done();
293 int sdcard_app_set_blocklen(unsigned int blocklen
) {
295 printf("CMD16: SET_BLOCKLEN\n");
297 sdcore_cmd_argument_write(blocklen
);
298 sdcore_cmd_command_write((16 << 8) | SDCARD_CTRL_RESPONSE_SHORT
);
299 sdcore_cmd_send_write(1);
300 return sdcard_wait_response();
303 int sdcard_write_single_block(unsigned int blockaddr
) {
305 printf("CMD24: WRITE_SINGLE_BLOCK\n");
307 int cmd_response
= -1;
308 while (cmd_response
!= SD_OK
) {
309 sdcore_cmd_argument_write(blockaddr
);
310 sdcore_block_length_write(512);
311 sdcore_block_count_write(1);
312 sdcore_cmd_command_write((24 << 8) |
313 SDCARD_CTRL_RESPONSE_SHORT
|
314 (SDCARD_CTRL_DATA_TRANSFER_WRITE
<< 5));
315 sdcore_cmd_send_write(1);
316 cmd_response
= sdcard_wait_response();
321 int sdcard_write_multiple_block(unsigned int blockaddr
, unsigned int blockcnt
) {
323 printf("CMD25: WRITE_MULTIPLE_BLOCK\n");
325 int cmd_response
= -1;
326 while (cmd_response
!= SD_OK
) {
327 sdcore_cmd_argument_write(blockaddr
);
328 sdcore_block_length_write(512);
329 sdcore_block_count_write(blockcnt
);
330 sdcore_cmd_command_write((25 << 8) |
331 SDCARD_CTRL_RESPONSE_SHORT
|
332 (SDCARD_CTRL_DATA_TRANSFER_WRITE
<< 5));
333 sdcore_cmd_send_write(1);
334 cmd_response
= sdcard_wait_response();
339 int sdcard_read_single_block(unsigned int blockaddr
) {
341 printf("CMD17: READ_SINGLE_BLOCK\n");
343 int cmd_response
= -1;
344 while (cmd_response
!= SD_OK
) {
345 sdcore_cmd_argument_write(blockaddr
);
346 sdcore_block_length_write(512);
347 sdcore_block_count_write(1);
348 sdcore_cmd_command_write((17 << 8) |
349 SDCARD_CTRL_RESPONSE_SHORT
|
350 (SDCARD_CTRL_DATA_TRANSFER_READ
<< 5));
351 sdcore_cmd_send_write(1);
352 cmd_response
= sdcard_wait_response();
354 return sdcard_wait_data_done();
357 int sdcard_read_multiple_block(unsigned int blockaddr
, unsigned int blockcnt
) {
359 printf("CMD18: READ_MULTIPLE_BLOCK\n");
361 int cmd_response
= -1;
362 while (cmd_response
!= SD_OK
) {
363 sdcore_cmd_argument_write(blockaddr
);
364 sdcore_block_length_write(512);
365 sdcore_block_count_write(blockcnt
);
366 sdcore_cmd_command_write((18 << 8) |
367 SDCARD_CTRL_RESPONSE_SHORT
|
368 (SDCARD_CTRL_DATA_TRANSFER_READ
<< 5));
369 sdcore_cmd_send_write(1);
370 cmd_response
= sdcard_wait_response();
375 int sdcard_stop_transmission(void) {
377 printf("CMD12: STOP_TRANSMISSION\n");
379 sdcore_cmd_argument_write(0x0000000);
380 sdcore_cmd_command_write((12 << 8) | SDCARD_CTRL_RESPONSE_SHORT
);
381 sdcore_cmd_send_write(1);
382 return sdcard_wait_response();
385 int sdcard_send_status(unsigned int rca
) {
387 printf("CMD13: SEND_STATUS\n");
389 sdcore_cmd_argument_write(rca
<< 16);
390 sdcore_cmd_command_write((13 << 8) | SDCARD_CTRL_RESPONSE_SHORT
);
391 sdcore_cmd_send_write(1);
392 return sdcard_wait_response();
395 int sdcard_set_block_count(unsigned int blockcnt
) {
397 printf("CMD23: SET_BLOCK_COUNT\n");
399 sdcore_cmd_argument_write(blockcnt
);
400 sdcore_cmd_command_write((23 << 8) | SDCARD_CTRL_RESPONSE_SHORT
);
401 sdcore_cmd_send_write(1);
402 return sdcard_wait_response();
405 void sdcard_decode_cid(void) {
407 "CID Register: 0x%08x%08x%08x%08x\n"
408 "Manufacturer ID: 0x%x\n"
409 "Application ID 0x%x\n"
410 "Product name: %c%c%c%c%c\n",
416 (sdcard_response
[0] >> 16) & 0xffff,
418 sdcard_response
[0] & 0xffff,
420 (sdcard_response
[1] >> 24) & 0xff,
421 (sdcard_response
[1] >> 16) & 0xff,
422 (sdcard_response
[1] >> 8) & 0xff,
423 (sdcard_response
[1] >> 0) & 0xff,
424 (sdcard_response
[2] >> 24) & 0xff
426 int crc
= sdcard_response
[3] & 0x000000FF;
427 int month
= (sdcard_response
[3] & 0x00000F00) >> 8;
428 int year
= (sdcard_response
[3] & 0x000FF000) >> 12;
429 int psn
= ((sdcard_response
[3] & 0xFF000000) >> 24) | ((sdcard_response
[2] & 0x00FFFFFF) << 8);
430 printf( "CRC: %02x\n", crc
);
431 printf( "Production date(m/yy): %d/%d\n", month
, year
);
432 printf( "PSN: %08x\n", psn
);
433 printf( "OID: %c%c\n", (sdcard_response
[0] & 0x00FF0000) >> 16, (sdcard_response
[0] & 0x0000FF00) >> 8);
436 void sdcard_decode_csd(void) {
437 /* FIXME: only support CSR structure version 2.0 */
439 int size
= ((sdcard_response
[2] & 0xFFFF0000) >> 16) + ((sdcard_response
[1] & 0x000000FF) << 16) + 1;
441 "CSD Register: 0x%x%08x%08x%08x\n"
442 "Max data transfer rate: %d MB/s\n"
443 "Max read block length: %d bytes\n"
444 "Device size: %d GB\n",
450 (sdcard_response
[0] >> 24) & 0xff,
452 (1 << ((sdcard_response
[1] >> 16) & 0xf)),
454 size
* 512 / (1024 * 1024)
458 /*-----------------------------------------------------------------------*/
459 /* SDCard user functions */
460 /*-----------------------------------------------------------------------*/
462 int sdcard_init(void) {
466 /* Set SD clk freq to Initialization frequency */
467 sdcard_set_clk_freq(SDCARD_CLK_FREQ_INIT
);
470 for (timeout
=1000; timeout
>0; timeout
--) {
471 /* Set SDCard in SPI Mode (generate 80 dummy clocks) */
472 sdphy_init_initialize_write(1);
475 /* Set SDCard in Idle state */
476 if (sdcard_go_idle() == SD_OK
)
483 /* Set SDCard voltages, only supported by ver2.00+ SDCards */
484 if (sdcard_send_ext_csd() != SD_OK
)
487 /* Set SD clk freq to Operational frequency */
488 sdcard_set_clk_freq(SDCARD_CLK_FREQ
);
491 /* Set SDCard in Operational state */
492 for (timeout
=1000; timeout
>0; timeout
--) {
494 if (sdcard_app_send_op_cond(1) != SD_OK
)
501 /* Send identification */
502 if (sdcard_all_send_cid() != SD_OK
)
507 /* Set Relative Card Address (RCA) */
508 if (sdcard_set_relative_address() != SD_OK
)
510 rca
= (sdcard_response
[3] >> 16) & 0xffff;
513 if (sdcard_send_cid(rca
) != SD_OK
)
516 /* FIXME: add cid decoding (optional) */
520 if (sdcard_send_csd(rca
) != SD_OK
)
527 if (sdcard_select_card(rca
) != SD_OK
)
531 if (sdcard_app_cmd(rca
) != SD_OK
)
533 if(sdcard_app_set_bus_width() != SD_OK
)
537 if (sdcard_switch(SD_SWITCH_SWITCH
, SD_GROUP_ACCESSMODE
, SD_SPEED_SDR50
) != SD_OK
)
540 /* Switch driver strength */
541 if (sdcard_switch(SD_SWITCH_SWITCH
, SD_GROUP_DRIVERSTRENGTH
, SD_DRIVER_STRENGTH_D
) != SD_OK
)
545 /* FIXME: add scr decoding (optional) */
546 if (sdcard_app_cmd(rca
) != SD_OK
)
548 if (sdcard_app_send_scr() != SD_OK
)
551 /* Set block length */
552 if (sdcard_app_set_blocklen(512) != SD_OK
)
558 #ifdef CSR_SDBLOCK2MEM_BASE
560 void sdcard_read(uint32_t sector
, uint32_t count
, uint8_t* buf
)
562 /* Initialize DMA Writer */
563 sdblock2mem_dma_enable_write(0);
564 sdblock2mem_dma_base_write((uint32_t) buf
);
565 sdblock2mem_dma_length_write(512*count
);
566 sdblock2mem_dma_enable_write(1);
568 /* Read Block(s) from SDCard */
569 #ifdef SDCARD_CMD23_SUPPORT
570 sdcard_set_block_count(count
);
572 sdcard_read_multiple_block(sector
, count
);
574 /* Wait for DMA Writer to complete */
575 while ((sdblock2mem_dma_done_read() & 0x1) == 0);
577 sdcard_stop_transmission();
579 #ifndef CONFIG_CPU_HAS_DMA_BUS
580 /* Flush CPU caches */
582 #ifdef CONFIG_L2_SIZE
590 #ifdef CSR_SDMEM2BLOCK_BASE
592 void sdcard_write(uint32_t sector
, uint32_t count
, uint8_t* buf
)
595 /* Initialize DMA Reader */
596 sdmem2block_dma_enable_write(0);
597 sdmem2block_dma_base_write((uint32_t) buf
);
598 sdmem2block_dma_length_write(512);
599 sdmem2block_dma_enable_write(1);
601 /* Wait for DMA Reader to complete */
602 while ((sdmem2block_dma_done_read() & 0x1) == 0);
604 /* Write Single Block to SDCard */
605 #ifndef SDCARD_CMD23_SUPPORT
606 sdcard_set_block_count(1);
608 sdcard_write_single_block(sector
);
610 sdcard_stop_transmission();
612 /* Update buf/sector */
619 /*-----------------------------------------------------------------------*/
620 /* SDCard FatFs disk functions */
621 /*-----------------------------------------------------------------------*/
623 static DSTATUS sdcardstatus
= STA_NOINIT
;
625 DSTATUS
disk_status(uint8_t drv
) {
626 if (drv
) return STA_NOINIT
;
630 DSTATUS
disk_initialize(uint8_t drv
) {
631 if (drv
) return STA_NOINIT
;
633 sdcardstatus
= sdcard_init() ? 0 : STA_NOINIT
;
637 DRESULT
disk_read(uint8_t drv
, uint8_t *buf
, uint32_t sector
, uint32_t count
) {
638 sdcard_read(sector
, count
, buf
);
642 #endif /* CSR_SDCORE_BASE */