Mercurial > pihelp

comparison sd_raw.c @ 19:5f9a40d6991b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import SD handling from http://www.roland-riegel.de/sd-reader/index.html Use smaller build options
author Matt Johnston <matt@ucc.asn.au>
date Tue, 25 Jun 2013 13:55:11 +0800
parents
children 9e888708f33d
comparison
equal deleted inserted replaced
18:021e6e0006f4 19:5f9a40d6991b
1
2 /*
3 * Copyright (c) 2006-2012 by Roland Riegel <[email protected]>
4 *
5 * This file is free software; you can redistribute it and/or modify
6 * it under the terms of either the GNU General Public License version 2
7 * or the GNU Lesser General Public License version 2.1, both as
8 * published by the Free Software Foundation.
9 */
10
11 #include <string.h>
12 #include <avr/io.h>
13 #include "sd_raw.h"
14
15 /**
16 * \addtogroup sd_raw MMC/SD/SDHC card raw access
17 *
18 * This module implements read and write access to MMC, SD
19 * and SDHC cards. It serves as a low-level driver for the
20 * higher level modules such as partition and file system
21 * access.
22 *
23 * @{
24 */
25 /**
26 * \file
27 * MMC/SD/SDHC raw access implementation (license: GPLv2 or LGPLv2.1)
28 *
29 * \author Roland Riegel
30 */
31
32 /**
33 * \addtogroup sd_raw_config MMC/SD configuration
34 * Preprocessor defines to configure the MMC/SD support.
35 */
36
37 /**
38 * @}
39 */
40
41 /* commands available in SPI mode */
42
43 /* CMD0: response R1 */
44 #define CMD_GO_IDLE_STATE 0x00
45 /* CMD1: response R1 */
46 #define CMD_SEND_OP_COND 0x01
47 /* CMD8: response R7 */
48 #define CMD_SEND_IF_COND 0x08
49 /* CMD9: response R1 */
50 #define CMD_SEND_CSD 0x09
51 /* CMD10: response R1 */
52 #define CMD_SEND_CID 0x0a
53 /* CMD12: response R1 */
54 #define CMD_STOP_TRANSMISSION 0x0c
55 /* CMD13: response R2 */
56 #define CMD_SEND_STATUS 0x0d
57 /* CMD16: arg0[31:0]: block length, response R1 */
58 #define CMD_SET_BLOCKLEN 0x10
59 /* CMD17: arg0[31:0]: data address, response R1 */
60 #define CMD_READ_SINGLE_BLOCK 0x11
61 /* CMD18: arg0[31:0]: data address, response R1 */
62 #define CMD_READ_MULTIPLE_BLOCK 0x12
63 /* CMD24: arg0[31:0]: data address, response R1 */
64 #define CMD_WRITE_SINGLE_BLOCK 0x18
65 /* CMD25: arg0[31:0]: data address, response R1 */
66 #define CMD_WRITE_MULTIPLE_BLOCK 0x19
67 /* CMD27: response R1 */
68 #define CMD_PROGRAM_CSD 0x1b
69 /* CMD28: arg0[31:0]: data address, response R1b */
70 #define CMD_SET_WRITE_PROT 0x1c
71 /* CMD29: arg0[31:0]: data address, response R1b */
72 #define CMD_CLR_WRITE_PROT 0x1d
73 /* CMD30: arg0[31:0]: write protect data address, response R1 */
74 #define CMD_SEND_WRITE_PROT 0x1e
75 /* CMD32: arg0[31:0]: data address, response R1 */
76 #define CMD_TAG_SECTOR_START 0x20
77 /* CMD33: arg0[31:0]: data address, response R1 */
78 #define CMD_TAG_SECTOR_END 0x21
79 /* CMD34: arg0[31:0]: data address, response R1 */
80 #define CMD_UNTAG_SECTOR 0x22
81 /* CMD35: arg0[31:0]: data address, response R1 */
82 #define CMD_TAG_ERASE_GROUP_START 0x23
83 /* CMD36: arg0[31:0]: data address, response R1 */
84 #define CMD_TAG_ERASE_GROUP_END 0x24
85 /* CMD37: arg0[31:0]: data address, response R1 */
86 #define CMD_UNTAG_ERASE_GROUP 0x25
87 /* CMD38: arg0[31:0]: stuff bits, response R1b */
88 #define CMD_ERASE 0x26
89 /* ACMD41: arg0[31:0]: OCR contents, response R1 */
90 #define CMD_SD_SEND_OP_COND 0x29
91 /* CMD42: arg0[31:0]: stuff bits, response R1b */
92 #define CMD_LOCK_UNLOCK 0x2a
93 /* CMD55: arg0[31:0]: stuff bits, response R1 */
94 #define CMD_APP 0x37
95 /* CMD58: arg0[31:0]: stuff bits, response R3 */
96 #define CMD_READ_OCR 0x3a
97 /* CMD59: arg0[31:1]: stuff bits, arg0[0:0]: crc option, response R1 */
98 #define CMD_CRC_ON_OFF 0x3b
99
100 /* command responses */
101 /* R1: size 1 byte */
102 #define R1_IDLE_STATE 0
103 #define R1_ERASE_RESET 1
104 #define R1_ILL_COMMAND 2
105 #define R1_COM_CRC_ERR 3
106 #define R1_ERASE_SEQ_ERR 4
107 #define R1_ADDR_ERR 5
108 #define R1_PARAM_ERR 6
109 /* R1b: equals R1, additional busy bytes */
110 /* R2: size 2 bytes */
111 #define R2_CARD_LOCKED 0
112 #define R2_WP_ERASE_SKIP 1
113 #define R2_ERR 2
114 #define R2_CARD_ERR 3
115 #define R2_CARD_ECC_FAIL 4
116 #define R2_WP_VIOLATION 5
117 #define R2_INVAL_ERASE 6
118 #define R2_OUT_OF_RANGE 7
119 #define R2_CSD_OVERWRITE 7
120 #define R2_IDLE_STATE (R1_IDLE_STATE + 8)
121 #define R2_ERASE_RESET (R1_ERASE_RESET + 8)
122 #define R2_ILL_COMMAND (R1_ILL_COMMAND + 8)
123 #define R2_COM_CRC_ERR (R1_COM_CRC_ERR + 8)
124 #define R2_ERASE_SEQ_ERR (R1_ERASE_SEQ_ERR + 8)
125 #define R2_ADDR_ERR (R1_ADDR_ERR + 8)
126 #define R2_PARAM_ERR (R1_PARAM_ERR + 8)
127 /* R3: size 5 bytes */
128 #define R3_OCR_MASK (0xffffffffUL)
129 #define R3_IDLE_STATE (R1_IDLE_STATE + 32)
130 #define R3_ERASE_RESET (R1_ERASE_RESET + 32)
131 #define R3_ILL_COMMAND (R1_ILL_COMMAND + 32)
132 #define R3_COM_CRC_ERR (R1_COM_CRC_ERR + 32)
133 #define R3_ERASE_SEQ_ERR (R1_ERASE_SEQ_ERR + 32)
134 #define R3_ADDR_ERR (R1_ADDR_ERR + 32)
135 #define R3_PARAM_ERR (R1_PARAM_ERR + 32)
136 /* Data Response: size 1 byte */
137 #define DR_STATUS_MASK 0x0e
138 #define DR_STATUS_ACCEPTED 0x05
139 #define DR_STATUS_CRC_ERR 0x0a
140 #define DR_STATUS_WRITE_ERR 0x0c
141
142 /* status bits for card types */
143 #define SD_RAW_SPEC_1 0
144 #define SD_RAW_SPEC_2 1
145 #define SD_RAW_SPEC_SDHC 2
146
147 #if !SD_RAW_SAVE_RAM
148 /* static data buffer for acceleration */
149 static uint8_t raw_block[512];
150 /* offset where the data within raw_block lies on the card */
151 static offset_t raw_block_address;
152 #if SD_RAW_WRITE_BUFFERING
153 /* flag to remember if raw_block was written to the card */
154 static uint8_t raw_block_written;
155 #endif
156 #endif
157
158 /* card type state */
159 static uint8_t sd_raw_card_type;
160
161 /* private helper functions */
162 static void sd_raw_send_byte(uint8_t b);
163 static uint8_t sd_raw_rec_byte();
164 static uint8_t sd_raw_send_command(uint8_t command, uint32_t arg);
165
166 /**
167 * \ingroup sd_raw
168 * Initializes memory card communication.
169 *
170 * \returns 0 on failure, 1 on success.
171 */
172 uint8_t sd_raw_init()
173 {
174 /* enable inputs for reading card status */
175 configure_pin_available();
176 configure_pin_locked();
177
178 /* enable outputs for MOSI, SCK, SS, input for MISO */
179 configure_pin_mosi();
180 configure_pin_sck();
181 configure_pin_ss();
182 configure_pin_miso();
183
184 unselect_card();
185
186 /* initialize SPI with lowest frequency; max. 400kHz during identification mode of card */
187 SPCR = (0 << SPIE) | /* SPI Interrupt Enable */
188 (1 << SPE) | /* SPI Enable */
189 (0 << DORD) | /* Data Order: MSB first */
190 (1 << MSTR) | /* Master mode */
191 (0 << CPOL) | /* Clock Polarity: SCK low when idle */
192 (0 << CPHA) | /* Clock Phase: sample on rising SCK edge */
193 (1 << SPR1) | /* Clock Frequency: f_OSC / 128 */
194 (1 << SPR0);
195 SPSR &= ~(1 << SPI2X); /* No doubled clock frequency */
196
197 /* initialization procedure */
198 sd_raw_card_type = 0;
199
200 if(!sd_raw_available())
201 return 0;
202
203 /* card needs 74 cycles minimum to start up */
204 for(uint8_t i = 0; i < 10; ++i)
205 {
206 /* wait 8 clock cycles */
207 sd_raw_rec_byte();
208 }
209
210 /* address card */
211 select_card();
212
213 /* reset card */
214 uint8_t response;
215 for(uint16_t i = 0; ; ++i)
216 {
217 response = sd_raw_send_command(CMD_GO_IDLE_STATE, 0);
218 if(response == (1 << R1_IDLE_STATE))
219 break;
220
221 if(i == 0x1ff)
222 {
223 unselect_card();
224 return 0;
225 }
226 }
227
228 #if SD_RAW_SDHC
229 /* check for version of SD card specification */
230 response = sd_raw_send_command(CMD_SEND_IF_COND, 0x100 /* 2.7V - 3.6V */ | 0xaa /* test pattern */);
231 if((response & (1 << R1_ILL_COMMAND)) == 0)
232 {
233 sd_raw_rec_byte();
234 sd_raw_rec_byte();
235 if((sd_raw_rec_byte() & 0x01) == 0)
236 return 0; /* card operation voltage range doesn't match */
237 if(sd_raw_rec_byte() != 0xaa)
238 return 0; /* wrong test pattern */
239
240 /* card conforms to SD 2 card specification */
241 sd_raw_card_type |= (1 << SD_RAW_SPEC_2);
242 }
243 else
244 #endif
245 {
246 /* determine SD/MMC card type */
247 sd_raw_send_command(CMD_APP, 0);
248 response = sd_raw_send_command(CMD_SD_SEND_OP_COND, 0);
249 if((response & (1 << R1_ILL_COMMAND)) == 0)
250 {
251 /* card conforms to SD 1 card specification */
252 sd_raw_card_type |= (1 << SD_RAW_SPEC_1);
253 }
254 else
255 {
256 /* MMC card */
257 }
258 }
259
260 /* wait for card to get ready */
261 for(uint16_t i = 0; ; ++i)
262 {
263 if(sd_raw_card_type & ((1 << SD_RAW_SPEC_1) | (1 << SD_RAW_SPEC_2)))
264 {
265 uint32_t arg = 0;
266 #if SD_RAW_SDHC
267 if(sd_raw_card_type & (1 << SD_RAW_SPEC_2))
268 arg = 0x40000000;
269 #endif
270 sd_raw_send_command(CMD_APP, 0);
271 response = sd_raw_send_command(CMD_SD_SEND_OP_COND, arg);
272 }
273 else
274 {
275 response = sd_raw_send_command(CMD_SEND_OP_COND, 0);
276 }
277
278 if((response & (1 << R1_IDLE_STATE)) == 0)
279 break;
280
281 if(i == 0x7fff)
282 {
283 unselect_card();
284 return 0;
285 }
286 }
287
288 #if SD_RAW_SDHC
289 if(sd_raw_card_type & (1 << SD_RAW_SPEC_2))
290 {
291 if(sd_raw_send_command(CMD_READ_OCR, 0))
292 {
293 unselect_card();
294 return 0;
295 }
296
297 if(sd_raw_rec_byte() & 0x40)
298 sd_raw_card_type |= (1 << SD_RAW_SPEC_SDHC);
299
300 sd_raw_rec_byte();
301 sd_raw_rec_byte();
302 sd_raw_rec_byte();
303 }
304 #endif
305
306 /* set block size to 512 bytes */
307 if(sd_raw_send_command(CMD_SET_BLOCKLEN, 512))
308 {
309 unselect_card();
310 return 0;
311 }
312
313 /* deaddress card */
314 unselect_card();
315
316 /* switch to highest SPI frequency possible */
317 SPCR &= ~((1 << SPR1) | (1 << SPR0)); /* Clock Frequency: f_OSC / 4 */
318 SPSR |= (1 << SPI2X); /* Doubled Clock Frequency: f_OSC / 2 */
319
320 #if !SD_RAW_SAVE_RAM
321 /* the first block is likely to be accessed first, so precache it here */
322 raw_block_address = (offset_t) -1;
323 #if SD_RAW_WRITE_BUFFERING
324 raw_block_written = 1;
325 #endif
326 if(!sd_raw_read(0, raw_block, sizeof(raw_block)))
327 return 0;
328 #endif
329
330 return 1;
331 }
332
333 /**
334 * \ingroup sd_raw
335 * Checks wether a memory card is located in the slot.
336 *
337 * \returns 1 if the card is available, 0 if it is not.
338 */
339 uint8_t sd_raw_available()
340 {
341 return get_pin_available() == 0x00;
342 }
343
344 /**
345 * \ingroup sd_raw
346 * Checks wether the memory card is locked for write access.
347 *
348 * \returns 1 if the card is locked, 0 if it is not.
349 */
350 uint8_t sd_raw_locked()
351 {
352 return get_pin_locked() == 0x00;
353 }
354
355 /**
356 * \ingroup sd_raw
357 * Sends a raw byte to the memory card.
358 *
359 * \param[in] b The byte to sent.
360 * \see sd_raw_rec_byte
361 */
362 void sd_raw_send_byte(uint8_t b)
363 {
364 SPDR = b;
365 /* wait for byte to be shifted out */
366 while(!(SPSR & (1 << SPIF)));
367 SPSR &= ~(1 << SPIF);
368 }
369
370 /**
371 * \ingroup sd_raw
372 * Receives a raw byte from the memory card.
373 *
374 * \returns The byte which should be read.
375 * \see sd_raw_send_byte
376 */
377 uint8_t sd_raw_rec_byte()
378 {
379 /* send dummy data for receiving some */
380 SPDR = 0xff;
381 while(!(SPSR & (1 << SPIF)));
382 SPSR &= ~(1 << SPIF);
383
384 return SPDR;
385 }
386
387 /**
388 * \ingroup sd_raw
389 * Send a command to the memory card which responses with a R1 response (and possibly others).
390 *
391 * \param[in] command The command to send.
392 * \param[in] arg The argument for command.
393 * \returns The command answer.
394 */
395 uint8_t sd_raw_send_command(uint8_t command, uint32_t arg)
396 {
397 uint8_t response;
398
399 /* wait some clock cycles */
400 sd_raw_rec_byte();
401
402 /* send command via SPI */
403 sd_raw_send_byte(0x40 | command);
404 sd_raw_send_byte((arg >> 24) & 0xff);
405 sd_raw_send_byte((arg >> 16) & 0xff);
406 sd_raw_send_byte((arg >> 8) & 0xff);
407 sd_raw_send_byte((arg >> 0) & 0xff);
408 switch(command)
409 {
410 case CMD_GO_IDLE_STATE:
411 sd_raw_send_byte(0x95);
412 break;
413 case CMD_SEND_IF_COND:
414 sd_raw_send_byte(0x87);
415 break;
416 default:
417 sd_raw_send_byte(0xff);
418 break;
419 }
420
421 /* receive response */
422 for(uint8_t i = 0; i < 10; ++i)
423 {
424 response = sd_raw_rec_byte();
425 if(response != 0xff)
426 break;
427 }
428
429 return response;
430 }
431
432 /**
433 * \ingroup sd_raw
434 * Reads raw data from the card.
435 *
436 * \param[in] offset The offset from which to read.
437 * \param[out] buffer The buffer into which to write the data.
438 * \param[in] length The number of bytes to read.
439 * \returns 0 on failure, 1 on success.
440 * \see sd_raw_read_interval, sd_raw_write, sd_raw_write_interval
441 */
442 uint8_t sd_raw_read(offset_t offset, uint8_t* buffer, uintptr_t length)
443 {
444 offset_t block_address;
445 uint16_t block_offset;
446 uint16_t read_length;
447 while(length > 0)
448 {
449 /* determine byte count to read at once */
450 block_offset = offset & 0x01ff;
451 block_address = offset - block_offset;
452 read_length = 512 - block_offset; /* read up to block border */
453 if(read_length > length)
454 read_length = length;
455
456 #if !SD_RAW_SAVE_RAM
457 /* check if the requested data is cached */
458 if(block_address != raw_block_address)
459 #endif
460 {
461 #if SD_RAW_WRITE_BUFFERING
462 if(!sd_raw_sync())
463 return 0;
464 #endif
465
466 /* address card */
467 select_card();
468
469 /* send single block request */
470 #if SD_RAW_SDHC
471 if(sd_raw_send_command(CMD_READ_SINGLE_BLOCK, (sd_raw_card_type & (1 << SD_RAW_SPEC_SDHC) ? block_address / 512 : block_address)))
472 #else
473 if(sd_raw_send_command(CMD_READ_SINGLE_BLOCK, block_address))
474 #endif
475 {
476 unselect_card();
477 return 0;
478 }
479
480 /* wait for data block (start byte 0xfe) */
481 while(sd_raw_rec_byte() != 0xfe);
482
483 #if SD_RAW_SAVE_RAM
484 /* read byte block */
485 uint16_t read_to = block_offset + read_length;
486 for(uint16_t i = 0; i < 512; ++i)
487 {
488 uint8_t b = sd_raw_rec_byte();
489 if(i >= block_offset && i < read_to)
490 *buffer++ = b;
491 }
492 #else
493 /* read byte block */
494 uint8_t* cache = raw_block;
495 for(uint16_t i = 0; i < 512; ++i)
496 *cache++ = sd_raw_rec_byte();
497 raw_block_address = block_address;
498
499 memcpy(buffer, raw_block + block_offset, read_length);
500 buffer += read_length;
501 #endif
502
503 /* read crc16 */
504 sd_raw_rec_byte();
505 sd_raw_rec_byte();
506
507 /* deaddress card */
508 unselect_card();
509
510 /* let card some time to finish */
511 sd_raw_rec_byte();
512 }
513 #if !SD_RAW_SAVE_RAM
514 else
515 {
516 /* use cached data */
517 memcpy(buffer, raw_block + block_offset, read_length);
518 buffer += read_length;
519 }
520 #endif
521
522 length -= read_length;
523 offset += read_length;
524 }
525
526 return 1;
527 }
528
529 /**
530 * \ingroup sd_raw
531 * Continuously reads units of \c interval bytes and calls a callback function.
532 *
533 * This function starts reading at the specified offset. Every \c interval bytes,
534 * it calls the callback function with the associated data buffer.
535 *
536 * By returning zero, the callback may stop reading.
537 *
538 * \note Within the callback function, you can not start another read or
539 * write operation.
540 * \note This function only works if the following conditions are met:
541 * - (offset - (offset % 512)) % interval == 0
542 * - length % interval == 0
543 *
544 * \param[in] offset Offset from which to start reading.
545 * \param[in] buffer Pointer to a buffer which is at least interval bytes in size.
546 * \param[in] interval Number of bytes to read before calling the callback function.
547 * \param[in] length Number of bytes to read altogether.
548 * \param[in] callback The function to call every interval bytes.
549 * \param[in] p An opaque pointer directly passed to the callback function.
550 * \returns 0 on failure, 1 on success
551 * \see sd_raw_write_interval, sd_raw_read, sd_raw_write
552 */
553 uint8_t sd_raw_read_interval(offset_t offset, uint8_t* buffer, uintptr_t interval, uintptr_t length, sd_raw_read_interval_handler_t callback, void* p)
554 {
555 if(!buffer || interval == 0 || length < interval || !callback)
556 return 0;
557
558 #if !SD_RAW_SAVE_RAM
559 while(length >= interval)
560 {
561 /* as reading is now buffered, we directly
562 * hand over the request to sd_raw_read()
563 */
564 if(!sd_raw_read(offset, buffer, interval))
565 return 0;
566 if(!callback(buffer, offset, p))
567 break;
568 offset += interval;
569 length -= interval;
570 }
571
572 return 1;
573 #else
574 /* address card */
575 select_card();
576
577 uint16_t block_offset;
578 uint16_t read_length;
579 uint8_t* buffer_cur;
580 uint8_t finished = 0;
581 do
582 {
583 /* determine byte count to read at once */
584 block_offset = offset & 0x01ff;
585 read_length = 512 - block_offset;
586
587 /* send single block request */
588 #if SD_RAW_SDHC
589 if(sd_raw_send_command(CMD_READ_SINGLE_BLOCK, (sd_raw_card_type & (1 << SD_RAW_SPEC_SDHC) ? offset / 512 : offset - block_offset)))
590 #else
591 if(sd_raw_send_command(CMD_READ_SINGLE_BLOCK, offset - block_offset))
592 #endif
593 {
594 unselect_card();
595 return 0;
596 }
597
598 /* wait for data block (start byte 0xfe) */
599 while(sd_raw_rec_byte() != 0xfe);
600
601 /* read up to the data of interest */
602 for(uint16_t i = 0; i < block_offset; ++i)
603 sd_raw_rec_byte();
604
605 /* read interval bytes of data and execute the callback */
606 do
607 {
608 if(read_length < interval || length < interval)
609 break;
610
611 buffer_cur = buffer;
612 for(uint16_t i = 0; i < interval; ++i)
613 *buffer_cur++ = sd_raw_rec_byte();
614
615 if(!callback(buffer, offset + (512 - read_length), p))
616 {
617 finished = 1;
618 break;
619 }
620
621 read_length -= interval;
622 length -= interval;
623
624 } while(read_length > 0 && length > 0);
625
626 /* read rest of data block */
627 while(read_length-- > 0)
628 sd_raw_rec_byte();
629
630 /* read crc16 */
631 sd_raw_rec_byte();
632 sd_raw_rec_byte();
633
634 if(length < interval)
635 break;
636
637 offset = offset - block_offset + 512;
638
639 } while(!finished);
640
641 /* deaddress card */
642 unselect_card();
643
644 /* let card some time to finish */
645 sd_raw_rec_byte();
646
647 return 1;
648 #endif
649 }
650
651 #if DOXYGEN || SD_RAW_WRITE_SUPPORT
652 /**
653 * \ingroup sd_raw
654 * Writes raw data to the card.
655 *
656 * \note If write buffering is enabled, you might have to
657 * call sd_raw_sync() before disconnecting the card
658 * to ensure all remaining data has been written.
659 *
660 * \param[in] offset The offset where to start writing.
661 * \param[in] buffer The buffer containing the data to be written.
662 * \param[in] length The number of bytes to write.
663 * \returns 0 on failure, 1 on success.
664 * \see sd_raw_write_interval, sd_raw_read, sd_raw_read_interval
665 */
666 uint8_t sd_raw_write(offset_t offset, const uint8_t* buffer, uintptr_t length)
667 {
668 if(sd_raw_locked())
669 return 0;
670
671 offset_t block_address;
672 uint16_t block_offset;
673 uint16_t write_length;
674 while(length > 0)
675 {
676 /* determine byte count to write at once */
677 block_offset = offset & 0x01ff;
678 block_address = offset - block_offset;
679 write_length = 512 - block_offset; /* write up to block border */
680 if(write_length > length)
681 write_length = length;
682
683 /* Merge the data to write with the content of the block.
684 * Use the cached block if available.
685 */
686 if(block_address != raw_block_address)
687 {
688 #if SD_RAW_WRITE_BUFFERING
689 if(!sd_raw_sync())
690 return 0;
691 #endif
692
693 if(block_offset || write_length < 512)
694 {
695 if(!sd_raw_read(block_address, raw_block, sizeof(raw_block)))
696 return 0;
697 }
698 raw_block_address = block_address;
699 }
700
701 if(buffer != raw_block)
702 {
703 memcpy(raw_block + block_offset, buffer, write_length);
704
705 #if SD_RAW_WRITE_BUFFERING
706 raw_block_written = 0;
707
708 if(length == write_length)
709 return 1;
710 #endif
711 }
712
713 /* address card */
714 select_card();
715
716 /* send single block request */
717 #if SD_RAW_SDHC
718 if(sd_raw_send_command(CMD_WRITE_SINGLE_BLOCK, (sd_raw_card_type & (1 << SD_RAW_SPEC_SDHC) ? block_address / 512 : block_address)))
719 #else
720 if(sd_raw_send_command(CMD_WRITE_SINGLE_BLOCK, block_address))
721 #endif
722 {
723 unselect_card();
724 return 0;
725 }
726
727 /* send start byte */
728 sd_raw_send_byte(0xfe);
729
730 /* write byte block */
731 uint8_t* cache = raw_block;
732 for(uint16_t i = 0; i < 512; ++i)
733 sd_raw_send_byte(*cache++);
734
735 /* write dummy crc16 */
736 sd_raw_send_byte(0xff);
737 sd_raw_send_byte(0xff);
738
739 /* wait while card is busy */
740 while(sd_raw_rec_byte() != 0xff);
741 sd_raw_rec_byte();
742
743 /* deaddress card */
744 unselect_card();
745
746 buffer += write_length;
747 offset += write_length;
748 length -= write_length;
749
750 #if SD_RAW_WRITE_BUFFERING
751 raw_block_written = 1;
752 #endif
753 }
754
755 return 1;
756 }
757 #endif
758
759 #if DOXYGEN || SD_RAW_WRITE_SUPPORT
760 /**
761 * \ingroup sd_raw
762 * Writes a continuous data stream obtained from a callback function.
763 *
764 * This function starts writing at the specified offset. To obtain the
765 * next bytes to write, it calls the callback function. The callback fills the
766 * provided data buffer and returns the number of bytes it has put into the buffer.
767 *
768 * By returning zero, the callback may stop writing.
769 *
770 * \param[in] offset Offset where to start writing.
771 * \param[in] buffer Pointer to a buffer which is used for the callback function.
772 * \param[in] length Number of bytes to write in total. May be zero for endless writes.
773 * \param[in] callback The function used to obtain the bytes to write.
774 * \param[in] p An opaque pointer directly passed to the callback function.
775 * \returns 0 on failure, 1 on success
776 * \see sd_raw_read_interval, sd_raw_write, sd_raw_read
777 */
778 uint8_t sd_raw_write_interval(offset_t offset, uint8_t* buffer, uintptr_t length, sd_raw_write_interval_handler_t callback, void* p)
779 {
780 #if SD_RAW_SAVE_RAM
781 #error "SD_RAW_WRITE_SUPPORT is not supported together with SD_RAW_SAVE_RAM"
782 #endif
783
784 if(!buffer || !callback)
785 return 0;
786
787 uint8_t endless = (length == 0);
788 while(endless || length > 0)
789 {
790 uint16_t bytes_to_write = callback(buffer, offset, p);
791 if(!bytes_to_write)
792 break;
793 if(!endless && bytes_to_write > length)
794 return 0;
795
796 /* as writing is always buffered, we directly
797 * hand over the request to sd_raw_write()
798 */
799 if(!sd_raw_write(offset, buffer, bytes_to_write))
800 return 0;
801
802 offset += bytes_to_write;
803 length -= bytes_to_write;
804 }
805
806 return 1;
807 }
808 #endif
809
810 #if DOXYGEN || SD_RAW_WRITE_SUPPORT
811 /**
812 * \ingroup sd_raw
813 * Writes the write buffer's content to the card.
814 *
815 * \note When write buffering is enabled, you should
816 * call this function before disconnecting the
817 * card to ensure all remaining data has been
818 * written.
819 *
820 * \returns 0 on failure, 1 on success.
821 * \see sd_raw_write
822 */
823 uint8_t sd_raw_sync()
824 {
825 #if SD_RAW_WRITE_BUFFERING
826 if(raw_block_written)
827 return 1;
828 if(!sd_raw_write(raw_block_address, raw_block, sizeof(raw_block)))
829 return 0;
830 raw_block_written = 1;
831 #endif
832 return 1;
833 }
834 #endif
835
836 /**
837 * \ingroup sd_raw
838 * Reads informational data from the card.
839 *
840 * This function reads and returns the card's registers
841 * containing manufacturing and status information.
842 *
843 * \note: The information retrieved by this function is
844 * not required in any way to operate on the card,
845 * but it might be nice to display some of the data
846 * to the user.
847 *
848 * \param[in] info A pointer to the structure into which to save the information.
849 * \returns 0 on failure, 1 on success.
850 */
851 uint8_t sd_raw_get_info(struct sd_raw_info* info)
852 {
853 if(!info || !sd_raw_available())
854 return 0;
855
856 memset(info, 0, sizeof(*info));
857
858 select_card();
859
860 /* read cid register */
861 if(sd_raw_send_command(CMD_SEND_CID, 0))
862 {
863 unselect_card();
864 return 0;
865 }
866 while(sd_raw_rec_byte() != 0xfe);
867 for(uint8_t i = 0; i < 18; ++i)
868 {
869 uint8_t b = sd_raw_rec_byte();
870
871 switch(i)
872 {
873 case 0:
874 info->manufacturer = b;
875 break;
876 case 1:
877 case 2:
878 info->oem[i - 1] = b;
879 break;
880 case 3:
881 case 4:
882 case 5:
883 case 6:
884 case 7:
885 info->product[i - 3] = b;
886 break;
887 case 8:
888 info->revision = b;
889 break;
890 case 9:
891 case 10:
892 case 11:
893 case 12:
894 info->serial |= (uint32_t) b << ((12 - i) * 8);
895 break;
896 case 13:
897 info->manufacturing_year = b << 4;
898 break;
899 case 14:
900 info->manufacturing_year |= b >> 4;
901 info->manufacturing_month = b & 0x0f;
902 break;
903 }
904 }
905
906 /* read csd register */
907 uint8_t csd_read_bl_len = 0;
908 uint8_t csd_c_size_mult = 0;
909 #if SD_RAW_SDHC
910 uint16_t csd_c_size = 0;
911 #else
912 uint32_t csd_c_size = 0;
913 #endif
914 uint8_t csd_structure = 0;
915 if(sd_raw_send_command(CMD_SEND_CSD, 0))
916 {
917 unselect_card();
918 return 0;
919 }
920 while(sd_raw_rec_byte() != 0xfe);
921 for(uint8_t i = 0; i < 18; ++i)
922 {
923 uint8_t b = sd_raw_rec_byte();
924
925 if(i == 0)
926 {
927 csd_structure = b >> 6;
928 }
929 else if(i == 14)
930 {
931 if(b & 0x40)
932 info->flag_copy = 1;
933 if(b & 0x20)
934 info->flag_write_protect = 1;
935 if(b & 0x10)
936 info->flag_write_protect_temp = 1;
937 info->format = (b & 0x0c) >> 2;
938 }
939 else
940 {
941 #if SD_RAW_SDHC
942 if(csd_structure == 0x01)
943 {
944 switch(i)
945 {
946 case 7:
947 b &= 0x3f;
948 case 8:
949 case 9:
950 csd_c_size <<= 8;
951 csd_c_size |= b;
952 break;
953 }
954 if(i == 9)
955 {
956 ++csd_c_size;
957 info->capacity = (offset_t) csd_c_size * 512 * 1024;
958 }
959 }
960 else if(csd_structure == 0x00)
961 #endif
962 {
963 switch(i)
964 {
965 case 5:
966 csd_read_bl_len = b & 0x0f;
967 break;
968 case 6:
969 csd_c_size = b & 0x03;
970 csd_c_size <<= 8;
971 break;
972 case 7:
973 csd_c_size |= b;
974 csd_c_size <<= 2;
975 break;
976 case 8:
977 csd_c_size |= b >> 6;
978 ++csd_c_size;
979 break;
980 case 9:
981 csd_c_size_mult = b & 0x03;
982 csd_c_size_mult <<= 1;
983 break;
984 case 10:
985 csd_c_size_mult |= b >> 7;
986
987 info->capacity = (uint32_t) csd_c_size << (csd_c_size_mult + csd_read_bl_len + 2);
988 break;
989 }
990 }
991 }
992 }
993
994 unselect_card();
995
996 return 1;
997 }
998