1 http://cba.si/stuff/fatfs_diskio_sdcard_spi.c
2
3 /*
4 * (c) Domen Puncer, Visionect, d.o.o.
5 * BSD License
6 *
7 * v0.2 add support for SDHC
8 */
9
10 #include <stdio.h>
11 #include "stm32f10x_lib.h"
12
13 /*
14 * Code is split into 3 parts:
15 * - generic SPI code: adapt for your MCU
16 * - sd card code, with crc7 and crc16 calculations
17 * there's lots of it, but it's simple
18 * - fatfs interface. If you use anything else, look here for
19 * interface to SD card code
20 */
21
22 struct hwif
23 {
24 int initialized;
25 int sectors;
26 int erase_sectors;
27 int capabilities;
28 } ;
29
30 typedef struct hwif hwif;
31
32 #define CAP_VER2_00 (1<<0)
33 #define CAP_SDHC (1<<1)
34
35 enum sd_speed
36 {
37 SD_SPEED_INVALID, SD_SPEED_400KHZ, SD_SPEED_25MHZ
38 } ;
39
40 /*** spi functions ***/
41
42 static void spi_set_speed ( enum sd_speed speed );
43
44 /* SD card is connected to SPI1, PA4-7 */
45 #define SPI_SD SPI1
46
47 static void spi_init ( void )
48 {
49 GPIO_InitTypeDef gpio;
50
51 RCC_APB2PeriphClockCmd ( RCC_APB2Periph_GPIOA, ENABLE );
52 RCC_APB2PeriphClockCmd ( RCC_APB2Periph_SPI1, ENABLE );
53
54 gpio.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
55 gpio.GPIO_Speed = GPIO_Speed_50MHz;
56 gpio.GPIO_Mode = GPIO_Mode_AF_PP;
57 GPIO_Init ( GPIOA, & gpio );
58
59 gpio.GPIO_Pin = GPIO_Pin_4;
60 gpio.GPIO_Speed = GPIO_Speed_50MHz;
61 gpio.GPIO_Mode = GPIO_Mode_Out_PP;
62 GPIO_Init ( GPIOA, & gpio );
63
64 spi_set_speed ( SD_SPEED_400KHZ );
65 }
66 #define spi_cs_low() do { GPIOA->BRR = GPIO_Pin_4; } while (0)
67 #define spi_cs_high() do { GPIOA->BSRR = GPIO_Pin_4; } while (0)
68
69 static void spi_set_speed ( enum sd_speed speed )
70 {
71 SPI_InitTypeDef spi;
72 int prescaler = SPI_BaudRatePrescaler_128;
73
74 if ( speed == SD_SPEED_400KHZ )
75 {
76 prescaler = SPI_BaudRatePrescaler_128;
77 }
78 else if ( speed == SD_SPEED_25MHZ )
79 {
80 prescaler = SPI_BaudRatePrescaler_2;
81 }
82 /* ^ with /2 APB1 this will be 15mhz/234k at 60mhz
83 * 18/281 at 72. which is ok, 100<x<400khz, and <25mhz */
84
85 SPI_Cmd ( SPI_SD, DISABLE );
86
87 spi.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
88 spi.SPI_Mode = SPI_Mode_Master;
89 spi.SPI_DataSize = SPI_DataSize_8b;
90 spi.SPI_CPOL = SPI_CPOL_Low;
91 spi.SPI_CPHA = SPI_CPHA_1Edge;
92
93 spi.SPI_NSS = SPI_NSS_Soft;
94 spi.SPI_BaudRatePrescaler = prescaler;
95 spi.SPI_FirstBit = SPI_FirstBit_MSB;
96 spi.SPI_CRCPolynomial = 7;
97 SPI_Init ( SPI_SD, & spi );
98
99 SPI_Cmd ( SPI_SD, ENABLE );
100 }
101
102 static u8 spi_txrx ( u8 data )
103 {
104 /* RXNE always happens after TXE, so if this function is used
105 * we don't need to check for TXE */
106 SPI_SD->DR = data;
107 while ( ( SPI_SD->SR & SPI_I2S_FLAG_RXNE ) == 0 )
108 { ;
109 }
110 return SPI_SD->DR;
111 }
112
113 /* crc helpers */
114 static u8 crc7_one ( u8 t, u8 data )
115 {
116 int i;
117 const u8 g = 0x89;
118
119 t ^= data;
120 for ( i = 0; i < 8; i++ )
121 {
122 if ( t & 0x80 )
123 {
124 t ^= g;
125 }
126 t <<= 1;
127 }
128 return t;
129 }
130
131 u8 crc7 ( const u8 * p, int len )
132 {
133 int j;
134 u8 crc = 0;
135 for ( j = 0; j < len; j++ )
136 {
137 crc = crc7_one ( crc, p[ j ] );
138 }
139
140 return crc >> 1;
141 }
142
143 /* http://www.eagleairaust.com.au/code/crc16.htm */
144 static u16 crc16_ccitt ( u16 crc, u8 ser_data )
145 {
146 crc = ( u8 )( crc >> 8 ) | ( crc << 8 );
147 crc ^= ser_data;
148 crc ^= ( u8 )( crc & 0xff ) >> 4;
149 crc ^= ( crc << 8 ) << 4;
150 crc ^= ( ( crc & 0xff ) << 4 ) << 1;
151
152 return crc;
153 }
154
155 u16 crc16 ( const u8 * p, int len )
156 {
157 int i;
158 u16 crc = 0;
159
160 for ( i = 0; i < len; i++ )
161 {
162 crc = crc16_ccitt ( crc, p[ i ] );
163 }
164
165 return crc;
166 }
167
168 /*** sd functions - on top of spi code ***/
169
170 static void sd_cmd ( u8 cmd, u32 arg )
171 {
172 u8 crc = 0;
173 spi_txrx ( 0x40 | cmd );
174 crc = crc7_one ( crc, 0x40 | cmd );
175 spi_txrx ( arg >> 24 );
176 crc = crc7_one ( crc, arg >> 24 );
177 spi_txrx ( arg >> 16 );
178 crc = crc7_one ( crc, arg >> 16 );
179 spi_txrx ( arg >> 8 );
180 crc = crc7_one ( crc, arg >> 8 );
181 spi_txrx ( arg );
182 crc = crc7_one ( crc, arg );
183 // spi_txrx(0x95); /* crc7, for cmd0 */
184 spi_txrx ( crc | 0x1 ); /* crc7, for cmd0 */
185 }
186
187 static u8 sd_get_r1 ( )
188 {
189 int tries = 1000;
190 u8 r;
191
192 while ( tries-- )
193 {
194 r = spi_txrx ( 0xff );
195 if ( ( r & 0x80 ) == 0 )
196 {
197 return r;
198 }
199 }
200 return 0xff;
201 }
202
203 static u16 sd_get_r2 ( )
204 {
205 int tries = 1000;
206 u16 r;
207
208 while ( tries-- )
209 {
210 r = spi_txrx ( 0xff );
211 if ( ( r & 0x80 ) == 0 )
212 {
213 break;
214 }
215 }
216 if ( tries < 0 )
217 {
218 return 0xff;
219 }
220 r = r << 8 | spi_txrx ( 0xff );
221
222 return r;
223 }
224
225 /*
226 * r1, then 32-bit reply... same format as r3
227 */
228 static u8 sd_get_r7 ( u32 * r7 )
229 {
230 u32 r;
231 r = sd_get_r1 ( );
232 if ( r != 0x01 )
233 {
234 return r;
235 }
236
237 r = spi_txrx ( 0xff ) << 24;
238 r |= spi_txrx ( 0xff ) << 16;
239 r |= spi_txrx ( 0xff ) << 8;
240 r |= spi_txrx ( 0xff );
241
242 *r7 = r;
243 return 0x01;
244 }
245 #define sd_get_r3 sd_get_r7
246
247 static const char * r1_strings[ 7 ] =
248 {
249 "in idle",
250 "erase reset",
251 "illegal command",
252 "communication crc error",
253 "erase sequence error",
254 "address error",
255 "parameter error"
256 } ;
257
258 static void print_r1 ( u8 r )
259 {
260 int i;
261 printf ( "R1: %02x\n", r );
262 for ( i = 0; i < 7; i++ )
263 {
264 if ( r & ( 1 << i ) )
265 {
266 printf ( " %s\n", r1_strings[ i ] );
267 }
268 }
269 }
270
271 static const char * r2_strings[ 15 ] =
272 {
273 "card is locked",
274 "wp erase skip | lock/unlock cmd failed",
275 "error",
276 "CC error",
277 "card ecc failed",
278 "wp violation",
279 "erase param",
280 "out of range | csd overwrite",
281 "in idle state",
282 "erase reset",
283 "illegal command",
284 "com crc error",
285 "erase sequence error",
286 "address error",
287 "parameter error",
288 } ;
289
290 static void print_r2 ( u16 r )
291 {
292 int i;
293 printf ( "R2: %04x\n", r );
294 for ( i = 0; i < 15; i++ )
295 {
296 if ( r & ( 1 << i ) )
297 {
298 printf ( " %s\n", r2_strings[ i ] );
299 }
300 }
301 }
302
303 /* Nec (=Ncr? which is limited to [0,8]) dummy bytes before lowering CS,
304 * as described in sandisk doc, 5.4. */
305 static void sd_nec ( )
306 {
307 int i;
308 for ( i = 0; i < 8; i++ )
309 {
310 spi_txrx ( 0xff );
311 }
312 }
313
314 static int sd_init ( hwif * hw )
315 {
316 int i;
317 int r;
318 u32 r7;
319 u32 r3;
320 int tries;
321
322 hw->capabilities = 0;
323
324 /* start with 100-400 kHz clock */
325 spi_set_speed ( SD_SPEED_400KHZ );
326
327 printf ( "cmd0 - reset.. " );
328 spi_cs_high ( );
329 /* 74+ clocks with CS high */
330 for ( i = 0; i < 10; i++ )
331 {
332 spi_txrx ( 0xff );
333 }
334
335 /* reset */
336 spi_cs_low ( );
337 sd_cmd ( 0, 0 );
338 r = sd_get_r1 ( );
339 sd_nec ( );
340 spi_cs_high ( );
341 if ( r == 0xff )
342 {
343 goto err_spi;
344 }
345 if ( r != 0x01 )
346 {
347 printf ( "fail\n" );
348 print_r1 ( r );
349 goto err;
350 }
351 printf ( "success\n" );
352
353 printf ( "cmd8 - voltage.. " );
354 /* ask about voltage supply */
355 spi_cs_low ( );
356 sd_cmd ( 8, 0x1aa /* VHS = 1 */ );
357 r = sd_get_r7 ( &r7 );
358 sd_nec ( );
359 spi_cs_high ( );
360 hw->capabilities |= CAP_VER2_00;
361 if ( r == 0xff )
362 {
363 goto err_spi;
364 }
365 if ( r == 0x01 )
366 {
367 printf ( "success, SD v2.x\n" );
368 }
369 else if ( r & 0x4 )
370 {
371 hw->capabilities &= ~CAP_VER2_00;
372 printf ( "not implemented, SD v1.x\n" );
373 }
374 else
375 {
376 printf ( "fail\n" );
377 print_r1 ( r );
378 return -2;
379 }
380
381 printf ( "cmd58 - ocr.. " );
382 /* ask about voltage supply */
383 spi_cs_low ( );
384 sd_cmd ( 58, 0 );
385 r = sd_get_r3 ( &r3 );
386 sd_nec ( );
387 spi_cs_high ( );
388 if ( r == 0xff )
389 {
390 goto err_spi;
391 }
392 if ( r != 0x01 && !( r & 0x4 ) )
393 { /* allow it to not be implemented - old cards */
394 printf ( "fail\n" );
395 print_r1 ( r );
396 return -2;
397 }
398 else
399 {
400 int i;
401 for ( i = 4; i <= 23; i++ )
402 {
403 if ( r3 & 1 << i )
404 {
405 break;
406 }
407 }
408 printf ( "Vdd voltage window: %i.%i-", ( 12 + i ) / 10, ( 12 + i ) % 10 );
409 for ( i = 23; i >= 4; i-- )
410 {
411 if ( r3 & 1 << i )
412 {
413 break;
414 }
415 }
416 /* CCS shouldn't be valid here yet */
417 printf ( "%i.%iV, CCS:%li, power up status:%li\n", ( 13 + i ) / 10,
418 ( 13 + i ) % 10, r3 >> 30 & 1, r3 >> 31 );
419 printf ( "success\n" );
420 }
421
422 printf ( "acmd41 - hcs.. " );
423 tries = 1000;
424 u32 hcs = 0;
425 /* say we support SDHC */
426 if ( hw->capabilities & CAP_VER2_00 )
427 {
428 hcs = 1 << 30;
429 }
430
431 /* needs to be polled until in_idle_state becomes 0 */
432 do
433 {
434 /* send we don't support SDHC */
435 spi_cs_low ( );
436 /* next cmd is ACMD */
437 sd_cmd ( 55, 0 );
438 r = sd_get_r1 ( );
439 sd_nec ( );
440 spi_cs_high ( );
441 if ( r == 0xff )
442 {
443 goto err_spi;
444 }
445 /* well... it's probably not idle here, but specs aren't clear */
446 if ( r & 0xfe )
447 {
448 printf ( "fail\n" );
449 print_r1 ( r );
450 goto err;
451 }
452
453 spi_cs_low ( );
454 sd_cmd ( 41, hcs );
455 r = sd_get_r1 ( );
456 sd_nec ( );
457 spi_cs_high ( );
458 if ( r == 0xff )
459 {
460 goto err_spi;
461 }
462 if ( r & 0xfe )
463 {
464 printf ( "fail\n" );
465 print_r1 ( r );
466 goto err;
467 }
468 }
469 while ( r != 0 && tries-- );
470 if ( tries == -1 )
471 {
472 printf ( "timeouted\n" );
473 goto err;
474 }
475 printf ( "success\n" );
476
477 /* Seems after this card is initialized which means bit 0 of R1
478 * will be cleared. Not too sure. */
479
480 if ( hw->capabilities & CAP_VER2_00 )
481 {
482 printf ( "cmd58 - ocr, 2nd time.. " );
483 /* ask about voltage supply */
484 spi_cs_low ( );
485 sd_cmd ( 58, 0 );
486 r = sd_get_r3 ( &r3 );
487 sd_nec ( );
488 spi_cs_high ( );
489 if ( r == 0xff )
490 {
491 goto err_spi;
492 }
493 if ( r & 0xfe )
494 {
495 printf ( "fail\n" );
496 print_r1 ( r );
497 return -2;
498 }
499 else
500 {
501 #if 1
502 int i;
503 for ( i = 4; i <= 23; i++ )
504 {
505 if ( r3 & 1 << i )
506 {
507 break;
508 }
509 }
510 printf ( "Vdd voltage window: %i.%i-", ( 12 + i ) / 10, ( 12 + i ) % 10 );
511 for ( i = 23; i >= 4; i-- )
512 {
513 if ( r3 & 1 << i )
514 {
515 break;
516 }
517 }
518 /* CCS shouldn't be valid here yet */
519 printf ( "%i.%iV, CCS:%li, power up status:%li\n", ( 13 + i ) / 10,
520 ( 13 + i ) % 10, r3 >> 30 & 1, r3 >> 31 );
521 // XXX power up status should be 1 here, since we're finished initializing, but it's not. WHY?
522 // that means CCS is invalid, so we'll set CAP_SDHC later
523 #endif
524 if ( r3 >> 30 & 1 )
525 {
526 hw->capabilities |= CAP_SDHC;
527 }
528
529 printf ( "success\n" );
530 }
531 }
532
533 /* with SDHC block length is fixed to 1024 */
534 if ( ( hw->capabilities & CAP_SDHC ) == 0 )
535 {
536 printf ( "cmd16 - block length.. " );
537 spi_cs_low ( );
538 sd_cmd ( 16, 512 );
539 r = sd_get_r1 ( );
540 sd_nec ( );
541 spi_cs_high ( );
542 if ( r == 0xff )
543 {
544 goto err_spi;
545 }
546 if ( r & 0xfe )
547 {
548 printf ( "fail\n" );
549 print_r1 ( r );
550 goto err;
551 }
552 printf ( "success\n" );
553 }
554
555 printf ( "cmd59 - enable crc.. " );
556 /* crc on */
557 spi_cs_low ( );
558 sd_cmd ( 59, 0 );
559 r = sd_get_r1 ( );
560 sd_nec ( );
561 spi_cs_high ( );
562 if ( r == 0xff )
563 {
564 goto err_spi;
565 }
566 if ( r & 0xfe )
567 {
568 printf ( "fail\n" );
569 print_r1 ( r );
570 goto err;
571 }
572 printf ( "success\n" );
573
574 /* now we can up the clock to <= 25 MHz */
575 spi_set_speed ( SD_SPEED_25MHZ );
576
577 return 0;
578
579 err_spi:
580 printf ( "fail spi\n" );
581 return -1;
582 err:
583 return -2;
584 }
585
586 static int sd_read_status ( hwif * hw )
587 {
588 u16 r2;
589
590 spi_cs_low ( );
591 sd_cmd ( 13, 0 );
592 r2 = sd_get_r2 ( );
593 sd_nec ( );
594 spi_cs_high ( );
595 if ( r2 & 0x8000 )
596 {
597 return -1;
598 }
599 if ( r2 )
600 {
601 print_r2 ( r2 );
602 }
603
604 return 0;
605 }
606
607 /* 0xfe marks data start, then len bytes of data and crc16 */
608 static int sd_get_data ( hwif * hw, u8 * buf, int len )
609 {
610 int tries = 20000;
611 u8 r;
612 u16 _crc16;
613 u16 calc_crc;
614 int i;
615
616 while ( tries-- )
617 {
618 r = spi_txrx ( 0xff );
619 if ( r == 0xfe )
620 {
621 break;
622 }
623 }
624 if ( tries < 0 )
625 {
626 return -1;
627 }
628
629 for ( i = 0; i < len; i++ )
630 {
631 buf[ i ] = spi_txrx ( 0xff );
632 }
633
634 _crc16 = spi_txrx ( 0xff ) << 8;
635 _crc16 |= spi_txrx ( 0xff );
636
637 calc_crc = crc16 ( buf, len );
638 if ( _crc16 != calc_crc )
639 {
640 printf ( "%s, crcs differ: %04x vs. %04x, len:%i\n", __func__, _crc16,
641 calc_crc, len );
642 return -1;
643 }
644
645 return 0;
646 }
647
648 static int sd_put_data ( hwif * hw, const u8 * buf, int len )
649 {
650 u8 r;
651 int tries = 10;
652 u8 b[ 16 ];
653 int bi = 0;
654 u16 crc;
655
656 spi_txrx ( 0xfe ); /* data start */
657
658 while ( len-- )
659 {
660 spi_txrx ( * buf++ );
661 }
662
663 crc = crc16 ( buf, len );
664 /* crc16 */
665 spi_txrx ( crc >> 8 );
666 spi_txrx ( crc );
667
668 /* normally just one dummy read in between... specs don't say how many */
669 while ( tries-- )
670 {
671 b[ bi++ ] = r = spi_txrx ( 0xff );
672 if ( r != 0xff )
673 {
674 break;
675 }
676 }
677 if ( tries < 0 )
678 {
679 return -1;
680 }
681
682 /* poll busy, about 300 reads for 256 MB card */
683 tries = 100000;
684 while ( tries-- )
685 {
686 if ( spi_txrx( 0xff ) == 0xff )
687 {
688 break;
689 }
690 }
691 if ( tries < 0 )
692 {
693 return -2;
694 }
695
696 /* data accepted, WIN */
697 if ( ( r & 0x1f ) == 0x05 )
698 {
699 return 0;
700 }
701
702 return r;
703 }
704
705 static int sd_read_csd ( hwif * hw )
706 {
707 u8 buf[ 16 ];
708 int r;
709 int capacity;
710
711 spi_cs_low ( );
712 sd_cmd ( 9, 0 );
713 r = sd_get_r1 ( );
714 if ( r == 0xff )
715 {
716 spi_cs_high ( );
717 return -1;
718 }
719 if ( r & 0xfe )
720 {
721 spi_cs_high ( );
722 printf ( "%s ", __func__ );
723 print_r1 ( r );
724 return -2;
725 }
726
727 r = sd_get_data ( hw, buf, 16 );
728 sd_nec ( );
729 spi_cs_high ( );
730 if ( r == -1 )
731 {
732 printf ( "failed to get csd\n" );
733 return -3;
734 }
735
736 if ( ( buf[ 0 ] >> 6 ) + 1 == 1 )
737 {
738 /* CSD v1 */
739 printf (
740 "CSD: CSD v%i taac:%02x, nsac:%i, tran:%02x, classes:%02x%x, read_bl_len:%i, " "read_bl_part:%i, write_blk_misalign:%i, read_blk_misalign:%i, dsr_imp:%i, "
741 "c_size:%i, vdd_rmin:%i, vdd_rmax:%i, vdd_wmin:%i, vdd_wmax:%i, " "c_size_mult:%i, erase_blk_en:%i, erase_s_size:%i, "
742 "wp_grp_size:%i, wp_grp_enable:%i, r2w_factor:%i, write_bl_len:%i, write_bl_part:%i, " "filef_gpr:%i, copy:%i, perm_wr_prot:%i, tmp_wr_prot:%i, filef:%i\n"
743 , ( buf[ 0 ] >> 6 ) + 1, buf[ 1 ], buf[ 2 ], buf[ 3 ], buf[ 4 ],
744 buf[ 5 ] >> 4, 1 << ( buf[ 5 ] & 0xf ),
745 /* classes, read_bl_len */ buf[ 6 ] >> 7, ( buf[ 6 ] >> 6 ) & 1,
746 ( buf[ 6 ] >> 5 ) & 1, ( buf[ 6 ] >> 4 ) & 1,
747 ( buf[ 6 ] & 0x3 ) << 10 | buf[ 7 ] << 2 | buf[ 8 ] >> 6,
748 /* c_size */ ( buf[ 8 ] & 0x38 ) >> 3, buf[ 8 ] & 0x07, buf[ 9 ] >> 5,
749 ( buf[ 9 ] >> 2 ) & 0x7,
750 1 << ( 2 + ( ( ( buf[ 9 ] & 3 ) << 1 ) | buf[ 10 ] >> 7 ) ),
751 /* c_size_mult */ ( buf[ 10 ] >> 6 ) & 1,
752 ( ( buf[ 10 ] & 0x3f ) << 1 | buf[ 11 ] >> 7 ) + 1,
753 /* erase sector size */ ( buf[ 11 ] & 0x7f ) + 1,
754 /* write protect group size */ buf[ 12 ] >> 7,
755 1 << ( ( buf[ 12 ] >> 2 ) & 7 ),
756 1 << ( ( buf[ 12 ] & 3 ) << 2 | buf[ 13 ] >> 6 ),
757 /* write_bl_len */ ( buf[ 13 ] >> 5 ) & 1, buf[ 14 ] >> 7,
758 ( buf[ 14 ] >> 6 ) & 1, ( buf[ 14 ] >> 5 ) & 1, ( buf[ 14 ] >> 4 ) & 1,
759 ( buf[ 14 ] >> 2 ) & 3 /* file format */ );
760
761 capacity = ( ( ( buf[ 6 ] & 0x3 ) << 10 | buf[ 7 ] << 2 | buf[ 8 ] >> 6 ) +
762 1 ) << ( 2 + ( ( ( buf[ 9 ] & 3 ) << 1 ) | buf[ 10 ] >> 7 ) ) <<
763 ( ( buf[ 5 ] & 0xf ) - 9 );
764 /* ^ = (c_size+1) * 2**(c_size_mult+2) * 2**(read_bl_len-9) */
765
766 }
767 else
768 {
769 /* CSD v2 */
770 /* this means the card is HC */
771 hw->capabilities |= CAP_SDHC;
772
773 printf (
774 "CSD: CSD v%i taac:%02x, nsac:%i, tran:%02x, classes:%02x%x, read_bl_len:%i, " "read_bl_part:%i, write_blk_misalign:%i, read_blk_misalign:%i, dsr_imp:%i, "
775 "c_size:%i, erase_blk_en:%i, erase_s_size:%i, " "wp_grp_size:%i, wp_grp_enable:%i, r2w_factor:%i, write_bl_len:%i, write_bl_part:%i, "
776 "filef_gpr:%i, copy:%i, perm_wr_prot:%i, tmp_wr_prot:%i, filef:%i\n",
777 ( buf[ 0 ] >> 6 ) + 1, buf[ 1 ], buf[ 2 ], buf[ 3 ], buf[ 4 ],
778 buf[ 5 ] >> 4, 1 << ( buf[ 5 ] & 0xf ),
779 /* classes, read_bl_len */ buf[ 6 ] >> 7, ( buf[ 6 ] >> 6 ) & 1,
780 ( buf[ 6 ] >> 5 ) & 1, ( buf[ 6 ] >> 4 ) & 1,
781 buf[ 7 ] << 16 | buf[ 8 ] << 8 | buf[ 9 ],
782 /* c_size */ ( buf[ 10 ] >> 6 ) & 1,
783 ( ( buf[ 10 ] & 0x3f ) << 1 | buf[ 11 ] >> 7 ) + 1,
784 /* erase sector size */ ( buf[ 11 ] & 0x7f ) + 1,
785 /* write protect group size */ buf[ 12 ] >> 7,
786 1 << ( ( buf[ 12 ] >> 2 ) & 7 ),
787 1 << ( ( buf[ 12 ] & 3 ) << 2 | buf[ 13 ] >> 6 ),
788 /* write_bl_len */ ( buf[ 13 ] >> 5 ) & 1, buf[ 14 ] >> 7,
789 ( buf[ 14 ] >> 6 ) & 1, ( buf[ 14 ] >> 5 ) & 1, ( buf[ 14 ] >> 4 ) & 1,
790 ( buf[ 14 ] >> 2 ) & 3 /* file format */ );
791
792 capacity = buf[ 7 ] << 16 | buf[ 8 ] << 8 | buf[ 9 ]; /* in 512 kB */
793 capacity *= 1024; /* in 512 B sectors */
794
795 }
796
797 printf ( "capacity = %i kB\n", capacity / 2 );
798 hw->sectors = capacity;
799
800 /* if erase_blk_en = 0, then only this many sectors can be erased at once
801 * this is NOT yet tested */
802 hw->erase_sectors = 1;
803 if ( ( ( buf[ 10 ] >> 6 ) & 1 ) == 0 )
804 {
805 hw->erase_sectors = ( ( buf[ 10 ] & 0x3f ) << 1 | buf[ 11 ] >> 7 ) + 1;
806 }
807
808 return 0;
809 }
810
811 static int sd_read_cid ( hwif * hw )
812 {
813 u8 buf[ 16 ];
814 int r;
815
816 spi_cs_low ( );
817 sd_cmd ( 10, 0 );
818 r = sd_get_r1 ( );
819 if ( r == 0xff )
820 {
821 spi_cs_high ( );
822 return -1;
823 }
824 if ( r & 0xfe )
825 {
826 spi_cs_high ( );
827 printf ( "%s ", __func__ );
828 print_r1 ( r );
829 return -2;
830 }
831
832 r = sd_get_data ( hw, buf, 16 );
833 sd_nec ( );
834 spi_cs_high ( );
835 if ( r == -1 )
836 {
837 printf ( "failed to get cid\n" );
838 return -3;
839 }
840
841 printf (
842 "CID: mid:%x, oid:%c%c, pnm:%c%c%c%c%c, prv:%i.%i, psn:%02x%02x%02x%02x, mdt:%i/%i\n",
843 buf[ 0 ], buf[ 1 ], buf[ 2 ], /* mid, oid */ buf[ 3 ], buf[ 4 ], buf[ 5 ],
844 buf[ 6 ], buf[ 7 ], /* pnm */ buf[ 8 ] >> 4, buf[ 8 ] & 0xf,
845 /* prv */ buf[ 9 ], buf[ 10 ], buf[ 11 ], buf[ 12 ],
846 /* psn */ 2000 + ( buf[ 13 ] << 4 | buf[ 14 ] >> 4 ),
847 1 + ( buf[ 14 ] & 0xf ) );
848
849 return 0;
850 }
851
852 static int sd_readsector ( hwif * hw, u32 address, u8 * buf )
853 {
854 int r;
855
856 spi_cs_low ( );
857 if ( hw->capabilities & CAP_SDHC )
858 {
859 sd_cmd ( 17, address );
860 } /* read single block */
861 else
862 {
863 sd_cmd ( 17, address * 512 );
864 } /* read single block */
865
866 r = sd_get_r1 ( );
867 if ( r == 0xff )
868 {
869 spi_cs_high ( );
870 r = -1;
871 goto fail;
872 }
873 if ( r & 0xfe )
874 {
875 spi_cs_high ( );
876 printf ( "%s\n", __func__ );
877 print_r1 ( r );
878 r = -2;
879 goto fail;
880 }
881
882 r = sd_get_data ( hw, buf, 512 );
883 sd_nec ( );
884 spi_cs_high ( );
885 if ( r == -1 )
886 {
887 r = -3;
888 goto fail;
889 }
890
891 return 0;
892 fail:
893 printf ( "failed to read sector %li, err:%i\n", address, r );
894 return r;
895 }
896
897 static int sd_writesector ( hwif * hw, u32 address, const u8 * buf )
898 {
899 int r;
900
901 spi_cs_low ( );
902 if ( hw->capabilities & CAP_SDHC )
903 {
904 sd_cmd ( 24, address );
905 } /* write block */
906 else
907 {
908 sd_cmd ( 24, address * 512 );
909 } /* write block */
910
911 r = sd_get_r1 ( );
912 if ( r == 0xff )
913 {
914 spi_cs_high ( );
915 r = -1;
916 goto fail;
917 }
918 if ( r & 0xfe )
919 {
920 spi_cs_high ( );
921 printf ( "%s\n", __func__ );
922 print_r1 ( r );
923 r = -2;
924 goto fail;
925 }
926
927 spi_txrx ( 0xff ); /* Nwr (>= 1) high bytes */
928 r = sd_put_data ( hw, buf, 512 );
929 sd_nec ( );
930 spi_cs_high ( );
931 if ( r != 0 )
932 {
933 printf ( "sd_put_data returned: %i\n", r );
934 r = -3;
935 goto fail;
936 }
937
938 /* efsl code is weird shit, 0 is error in there?
939 * not that it's properly handled or anything,
940 * and the return type is char, fucking efsl */
941 return 0;
942 fail:
943 printf ( "failed to write sector %li, err:%i\n", address, r );
944 return r;
945 }
946
947 /*** public API - on top of sd/spi code ***/
948
949 int hwif_init ( hwif * hw )
950 {
951 int tries = 10;
952
953 if ( hw->initialized )
954 {
955 return 0;
956 }
957
958 spi_init ( );
959
960 while ( tries-- )
961 {
962 if ( sd_init( hw ) == 0 )
963 {
964 break;
965 }
966 }
967 if ( tries == -1 )
968 {
969 return -1;
970 }
971
972 /* read status register */
973 sd_read_status ( hw );
974
975 sd_read_cid ( hw );
976 if ( sd_read_csd( hw ) != 0 )
977 {
978 return -1;
979 }
980
981 hw->initialized = 1;
982 return 0;
983 }
984
985 int sd_read ( hwif * hw, u32 address, u8 * buf )
986 {
987 int r;
988 int tries = 10;
989
990 r = sd_readsector ( hw, address, buf );
991
992 while ( r < 0 && tries-- )
993 {
994 if ( sd_init( hw ) != 0 )
995 {
996 continue;
997 }
998
999 /* read status register */
1000 sd_read_status ( hw );
1001
1002 r = sd_readsector ( hw, address, buf );
1003 }
1004 if ( tries == -1 )
1005 {
1006 printf ( "%s: couldn't read sector %li\n", __func__, address );
1007 }
1008
1009 return r;
1010 }
1011
1012 int sd_write ( hwif * hw, u32 address, const u8 * buf )
1013 {
1014 int r;
1015 int tries = 10;
1016
1017 r = sd_writesector ( hw, address, buf );
1018
1019 while ( r < 0 && tries-- )
1020 {
1021 if ( sd_init( hw ) != 0 )
1022 {
1023 continue;
1024 }
1025
1026 /* read status register */
1027 sd_read_status ( hw );
1028
1029 r = sd_writesector ( hw, address, buf );
1030 }
1031 if ( tries == -1 )
1032 {
1033 printf ( "%s: couldn't write sector %li\n", __func__, address );
1034 }
1035
1036 return r;
1037 }
1038
1039 /*** fatfs code that uses the public API ***/
1040
1041 #include "diskio.h"
1042
1043 hwif hw;
1044
1045 DSTATUS disk_initialize ( BYTE drv )
1046 {
1047 if ( hwif_init( &hw ) == 0 )
1048 {
1049 return 0;
1050 }
1051
1052 return STA_NOINIT;
1053 }
1054
1055 DSTATUS disk_status ( BYTE drv )
1056 {
1057 if ( hw.initialized )
1058 {
1059 return 0;
1060 }
1061
1062 return STA_NOINIT;
1063 }
1064
1065 DRESULT disk_read ( BYTE drv, BYTE * buff, DWORD sector, BYTE count )
1066 {
1067 int i;
1068
1069 for ( i = 0; i < count; i++ )
1070 {
1071 if ( sd_read( &hw, sector + i, buff + 512 * i ) != 0 )
1072 {
1073 return RES_ERROR;
1074 }
1075 }
1076
1077 return RES_OK;
1078 }
1079
1080 #if _READONLY == 0
1081
1082 DRESULT disk_write ( BYTE drv, const BYTE * buff, DWORD sector, BYTE count )
1083 {
1084 int i;
1085
1086 for ( i = 0; i < count; i++ )
1087 {
1088 if ( sd_write( &hw, sector + i, buff + 512 * i ) != 0 )
1089 {
1090 return RES_ERROR;
1091 }
1092 }
1093
1094 return RES_OK;
1095 }
1096 #endif /* _READONLY */
1097
1098 DRESULT disk_ioctl ( BYTE drv, BYTE ctrl, void * buff )
1099 {
1100 switch ( ctrl )
1101 {
1102 case CTRL_SYNC:
1103 return RES_OK;
1104 case GET_SECTOR_SIZE:
1105 *( WORD * )buff = 512;
1106 return RES_OK;
1107 case GET_SECTOR_COUNT:
1108 *( DWORD* )buff = hw.sectors;
1109 return RES_OK;
1110 case GET_BLOCK_SIZE:
1111 *( DWORD* )buff = hw.erase_sectors;
1112 return RES_OK;
1113 }
1114 return RES_PARERR;
1115 }
1116
1117 /*
1118 * FAT filestamp format:
1119 * [31:25] - year - 1980
1120 * [24:21] - month 1..12
1121 * [20:16] - day 1..31
1122 * [15:11] - hour 0..23
1123 * [10:5] - minute 0..59
1124 * [4:0] - second/2 0..29
1125 * so... midnight 2009 is 0x3a000000
1126 */
1127 DWORD get_fattime ( )
1128 {
1129 int time = RTC_GetCounter ( );
1130 int y, m, d;
1131 epoch_days_to_date ( time / DAY_SECONDS, & y, & m, & d );
1132 time %= DAY_SECONDS;
1133 return ( y - 1980 ) << 25 | m << 21 | d << 16 | ( time / 3600 ) << 11 |
1134 ( time / 60 % 60 ) << 5 | ( time / 2 % 30 );
1135 }
