uint16_t sd_raw_read_start(uint32_t offset, uint8_t* buffer, uint16_t length) { uint32_t block_address; if (currentblockoffset != 0xFFFF) { putstring("YEEEK"); while (1); } if (length > 512) length = 512; /* determine byte count to read at once */ block_address = offset & 0xfffffe00; // putstring("\n\raddr "); uart_putdw_hex(block_address); /* address card */ select_card(); /* send single block request */ if(sd_raw_send_command_r1(CMD_READ_SINGLE_BLOCK, block_address)) { unselect_card(); return 0; } /* wait for data block (start byte 0xfe) */ while(sd_raw_rec_byte() != 0xfe); /* read byte block */ for(currentblockoffset = 0; currentblockoffset < length; ++currentblockoffset) { *buffer++ = sd_raw_rec_byte(); //uart_putc(b); } return length; }
/** * \ingroup sd_raw * Reads informational data from the card. * * This function reads and returns the card's registers * containing manufacturing and status information. * * \note: The information retrieved by this function is * not required in any way to operate on the card, * but it might be nice to display some of the data * to the user. * * \param[in] info A pointer to the structure into which to save the information. * \returns 0 on failure, 1 on success. */ uint8_t sd_raw_get_info(struct sd_raw_info* info) { uint8_t i; if(!info || !sd_raw_available()) return 0; memset(info, 0, sizeof(*info)); select_card(); /* read cid register */ if(sd_raw_send_command_r1(CMD_SEND_CID, 0)) { unselect_card(); return 0; } while(sd_raw_rec_byte() != 0xfe); for(i = 0; i < 18; ++i) { uint8_t b = sd_raw_rec_byte(); switch(i) { case 0: info->manufacturer = b; break; case 1: case 2: info->oem[i - 1] = b; break; case 3: case 4: case 5: case 6: case 7: info->product[i - 3] = b; break; case 8: info->revision = b; break; case 9: case 10: case 11: case 12: info->serial |= (uint32_t) b << ((12 - i) * 8); break; case 13: info->manufacturing_year = b << 4; break; case 14: info->manufacturing_year |= b >> 4; info->manufacturing_month = b & 0x0f; break; } } /* read csd register */ uint8_t csd_read_bl_len = 0; uint8_t csd_c_size_mult = 0; uint16_t csd_c_size = 0; if(sd_raw_send_command_r1(CMD_SEND_CSD, 0)) { unselect_card(); return 0; } while(sd_raw_rec_byte() != 0xfe); for(i = 0; i < 18; ++i) { uint8_t b = sd_raw_rec_byte(); switch(i) { case 5: csd_read_bl_len = b & 0x0f; break; case 6: csd_c_size = (uint16_t) (b & 0x03) << 8; break; case 7: csd_c_size |= b; csd_c_size <<= 2; break; case 8: csd_c_size |= b >> 6; ++csd_c_size; break; case 9: csd_c_size_mult = (b & 0x03) << 1; break; case 10: csd_c_size_mult |= b >> 7; info->capacity = (uint32_t) csd_c_size << (csd_c_size_mult + csd_read_bl_len + 2); break; case 14: if(b & 0x40) info->flag_copy = 1; if(b & 0x20) info->flag_write_protect = 1; if(b & 0x10) info->flag_write_protect_temp = 1; info->format = (b & 0x0c) >> 2; break; } } unselect_card(); return 1; }
/** * \ingroup sd_raw * Writes raw data to the card. * * \note If write buffering is enabled, you might have to * call sd_raw_sync() before disconnecting the card * to ensure all remaining data has been written. * * \param[in] offset The offset where to start writing. * \param[in] buffer The buffer containing the data to be written. * \param[in] length The number of bytes to write. * \returns 0 on failure, 1 on success. * \see sd_raw_write_interval, sd_raw_read, sd_raw_read_interval */ uint8_t sd_raw_write(uint32_t offset, const uint8_t* buffer, uint16_t length) { #if SD_RAW_WRITE_SUPPORT if(get_pin_locked()) return 0; uint32_t block_address; uint16_t block_offset; uint16_t write_length; uint16_t i; while(length > 0) { /* determine byte count to write at once */ block_address = offset & 0xfffffe00; block_offset = offset & 0x01ff; write_length = 512 - block_offset; /* write up to block border */ if(write_length > length) write_length = length; /* Merge the data to write with the content of the block. * Use the cached block if available. */ if(block_address != raw_block_address) { #if SD_RAW_WRITE_BUFFERING if(!raw_block_written) { if(!sd_raw_write(raw_block_address, raw_block, sizeof(raw_block))) return 0; } #endif if(block_offset || write_length < 512) { if(!sd_raw_read(block_address, raw_block, sizeof(raw_block))) return 0; } raw_block_address = block_address; } if(buffer != raw_block) { memcpy(raw_block + block_offset, buffer, write_length); #if SD_RAW_WRITE_BUFFERING raw_block_written = 0; if(length == write_length) return 1; #endif } buffer += write_length; /* address card */ select_card(); /* send single block request */ if(sd_raw_send_command_r1(CMD_WRITE_SINGLE_BLOCK, block_address)) { unselect_card(); return 0; } /* send start byte */ sd_raw_send_byte(0xfe); /* write byte block */ uint8_t* cache = raw_block; for(i = 0; i < 512; ++i) sd_raw_send_byte(*cache++); /* write dummy crc16 */ sd_raw_send_byte(0xff); sd_raw_send_byte(0xff); /* wait while card is busy */ while(sd_raw_rec_byte() != 0xff); sd_raw_rec_byte(); /* deaddress card */ unselect_card(); length -= write_length; offset += write_length; #if SD_RAW_WRITE_BUFFERING raw_block_written = 1; #endif } return 1; #else return 0; #endif }
/** * \ingroup sd_raw * Continuously reads units of \c interval bytes and calls a callback function. * * This function starts reading at the specified offset. Every \c interval bytes, * it calls the callback function with the associated data buffer. * * By returning zero, the callback may stop reading. * * \note Within the callback function, you can not start another read or * write operation. * \note This function only works if the following conditions are met: * - (offset - (offset % 512)) % interval == 0 * - length % interval == 0 * * \param[in] offset Offset from which to start reading. * \param[in] buffer Pointer to a buffer which is at least interval bytes in size. * \param[in] interval Number of bytes to read before calling the callback function. * \param[in] length Number of bytes to read altogether. * \param[in] callback The function to call every interval bytes. * \param[in] p An opaque pointer directly passed to the callback function. * \returns 0 on failure, 1 on success * \see sd_raw_write_interval, sd_raw_read, sd_raw_write */ uint8_t sd_raw_read_interval(uint32_t offset, uint8_t* buffer, uint16_t interval, uint16_t length, sd_raw_read_interval_handler_t callback, void* p) { if(!buffer || interval == 0 || length < interval || !callback) return 0; #if !SD_RAW_SAVE_RAM while(length >= interval) { /* as reading is now buffered, we directly * hand over the request to sd_raw_read() */ if(!sd_raw_read(offset, buffer, interval)) return 0; if(!callback(buffer, offset, p)) break; offset += interval; length -= interval; } return 1; #else /* address card */ select_card(); uint16_t block_offset; uint16_t read_length; uint8_t* buffer_cur; uint8_t finished = 0; do { /* determine byte count to read at once */ block_offset = offset & 0x01ff; read_length = 512 - block_offset; /* send single block request */ if(sd_raw_send_command_r1(CMD_READ_SINGLE_BLOCK, offset & 0xfffffe00)) { unselect_card(); return 0; } /* wait for data block (start byte 0xfe) */ while(sd_raw_rec_byte() != 0xfe); /* read up to the data of interest */ for(i = 0; i < block_offset; ++i) sd_raw_rec_byte(); /* read interval bytes of data and execute the callback */ do { if(read_length < interval || length < interval) break; buffer_cur = buffer; for(i = 0; i < interval; ++i) *buffer_cur++ = sd_raw_rec_byte(); if(!callback(buffer, offset + (512 - read_length), p)) { finished = 1; break; } read_length -= interval; length -= interval; } while(read_length > 0 && length > 0); /* read rest of data block */ while(read_length-- > 0) sd_raw_rec_byte(); /* read crc16 */ sd_raw_rec_byte(); sd_raw_rec_byte(); if(length < interval) break; offset = (offset & 0xfffffe00) + 512; } while(!finished); /* deaddress card */ unselect_card(); /* let card some time to finish */ sd_raw_rec_byte(); return 1; #endif }
/** * \ingroup sd_raw * Reads raw data from the card. * * \param[in] offset The offset from which to read. * \param[out] buffer The buffer into which to write the data. * \param[in] length The number of bytes to read. * \returns 0 on failure, 1 on success. * \see sd_raw_read_interval, sd_raw_write, sd_raw_write_interval */ uint8_t sd_raw_read(uint32_t offset, uint8_t* buffer, uint16_t length) { uint32_t block_address; uint16_t block_offset; uint16_t read_length; uint16_t i; while(length > 0) { /* determine byte count to read at once */ block_address = offset & 0xfffffe00; block_offset = offset & 0x01ff; read_length = 512 - block_offset; /* read up to block border */ if(read_length > length) read_length = length; #if !SD_RAW_SAVE_RAM /* check if the requested data is cached */ if(block_address != raw_block_address) #endif { #if SD_RAW_WRITE_BUFFERING if(!raw_block_written) { if(!sd_raw_write(raw_block_address, raw_block, sizeof(raw_block))) return 0; } #endif /* address card */ select_card(); /* send single block request */ if(sd_raw_send_command_r1(CMD_READ_SINGLE_BLOCK, block_address)) { unselect_card(); return 0; } /* wait for data block (start byte 0xfe) */ i = 0; while(sd_raw_rec_byte() != 0xfe) { i++; if (i == 0) { unselect_card(); return 0; } } #if SD_RAW_SAVE_RAM /* read byte block */ uint16_t read_to = block_offset + read_length; for(i = 0; i < 512; ++i) { uint8_t b = sd_raw_rec_byte(); if(i >= block_offset && i < read_to) *buffer++ = b; } #else /* read byte block */ uint8_t* cache = raw_block; for(i = 0; i < 512; ++i) *cache++ = sd_raw_rec_byte(); raw_block_address = block_address; memcpy(buffer, raw_block + block_offset, read_length); buffer += read_length; #endif /* read crc16 */ sd_raw_rec_byte(); sd_raw_rec_byte(); /* deaddress card */ unselect_card(); /* let card some time to finish */ sd_raw_rec_byte(); } #if !SD_RAW_SAVE_RAM else { /* use cached data */ memcpy(buffer, raw_block + block_offset, read_length); buffer += read_length; } #endif length -= read_length; offset += read_length; } return 1; }
/** * \ingroup sd_raw * Initializes memory card communication. * * \returns 0 on failure, 1 on success. */ uint8_t sd_raw_init() { uint16_t i; uint8_t response; /* enable inputs for reading card status */ configure_pin_available(); configure_pin_locked(); /* enable outputs for MOSI, SCK, SS, input for MISO */ configure_pin_mosi(); configure_pin_sck(); configure_pin_ss(); configure_pin_miso(); unselect_card(); /* initialize SPI with lowest frequency; max. 400kHz during identification mode of card */ SPCR = (0 << SPIE) | /* SPI Interrupt Enable */ (1 << SPE) | /* SPI Enable */ (0 << DORD) | /* Data Order: MSB first */ (1 << MSTR) | /* Master mode */ (0 << CPOL) | /* Clock Polarity: SCK low when idle */ (0 << CPHA) | /* Clock Phase: sample on rising SCK edge */ (1 << SPR1) | /* Clock Frequency: f_OSC / 128 */ (1 << SPR0); SPSR &= ~(1 << SPI2X); /* No doubled clock frequency */ /* initialization procedure */ if(!sd_raw_available()) return 0; /* card needs 74 cycles minimum to start up */ for(i = 0; i < 10; ++i) { /* wait 8 clock cycles */ sd_raw_rec_byte(); } /* address card */ select_card(); /* reset card */ for(i = 0; ; ++i) { response = sd_raw_send_command_r1(CMD_GO_IDLE_STATE, 0); if(response == (1 << R1_IDLE_STATE)) break; if(i == 0x1ff) { unselect_card(); return 0; } } /* wait for card to get ready */ for(i = 0; ; ++i) { response = sd_raw_send_command_r1(CMD_SEND_OP_COND, 0); if(!(response & (1 << R1_IDLE_STATE))) break; if(i == 0x7fff) { unselect_card(); return 0; } } /* set block size to 512 bytes */ if(sd_raw_send_command_r1(CMD_SET_BLOCKLEN, 512)) { unselect_card(); return 0; } /* deaddress card */ unselect_card(); /* switch to highest SPI frequency possible */ SPCR &= ~((1 << SPR1) | (1 << SPR0)); /* Clock Frequency: f_OSC / 4 */ SPSR |= (1 << SPI2X); /* Doubled Clock Frequency: f_OSC / 2 */ #if !SD_RAW_SAVE_RAM /* the first block is likely to be accessed first, so precache it here */ raw_block_address = 0xffffffff; #if SD_RAW_WRITE_BUFFERING raw_block_written = 1; #endif if(!sd_raw_read(0, raw_block, sizeof(raw_block))) return 0; #endif return 1; }
/** * \ingroup sd_raw * Writes raw data to the card. * * \note If write buffering is enabled, you might have to * call sd_raw_sync() before disconnecting the card * to ensure all remaining data has been written. * * \param[in] offset The offset where to start writing. * \param[in] buffer The buffer containing the data to be written. * \param[in] length The number of bytes to write. * \returns 0 on failure, 1 on success. * \see sd_raw_write_interval, sd_raw_read, sd_raw_read_interval */ uint8_t sd_raw_write(uint32_t offset, const uint8_t* buffer, uint16_t length) { #if SD_RAW_WRITE_SUPPORT if(get_pin_locked()) return 0; uint32_t block_address; uint16_t block_offset; uint16_t write_length; while(length > 0) { /* determine byte count to write at once */ block_address = offset & 0xfffffe00; block_offset = offset & 0x01ff; write_length = 512 - block_offset; /* write up to block border */ if(write_length > length) write_length = length; /* Merge the data to write with the content of the block. * Use the cached block if available. */ if(block_address != raw_block_address) { #if SD_RAW_WRITE_BUFFERING if(!sd_raw_sync()) return 0; #endif if(block_offset || write_length < 512) { if(!sd_raw_read(block_address, raw_block, sizeof(raw_block))) return 0; } raw_block_address = block_address; } if(buffer != raw_block) { memcpy(raw_block + block_offset, buffer, write_length); #if SD_RAW_WRITE_BUFFERING raw_block_written = 0; if(length == write_length) return 1; #endif } /* address card */ select_card(); /* send single block request */ if(sd_raw_send_command_r1(CMD_WRITE_SINGLE_BLOCK, block_address)) { unselect_card(); spi_rec_byte(); return 0; } /* send start byte */ spi_send_byte(0xfe); /* write byte block */ spi_send_data(raw_block, 512); /* write dummy crc16 */ spi_send_byte(0xff); spi_send_byte(0xff); /* wait while card is busy */ /* uint16_t i; for(i = 0; i < 0x7fff; ++i) { if(spi_rec_byte() == 0xff) break; } if(i >= 0x7fff) { unselect_card(); spi_rec_byte(); return 0; } */ // obiger code reicht bei langsamen Karten nicht aus! // daher nachfolgende alte Version mit endlos Warteschleife // Wil. while(spi_rec_byte() != 0xff); spi_rec_byte(); /* deaddress card */ unselect_card(); buffer += write_length; offset += write_length; length -= write_length; #if SD_RAW_WRITE_BUFFERING raw_block_written = 1; #endif } return 1; #else return 0; #endif }
/** * \ingroup sd_raw * Initializes memory card communication. * * \returns 0 on failure, 1 on success. */ uint8_t sd_raw_init() { /* enable inputs for reading card status */ configure_pin_available(); configure_pin_locked(); /* enable output CS */ configure_pin_cs(); unselect_card(); /* initialization procedure */ if(!sd_raw_available()) return 0; /* wait for the card being powered up */ _delay_ms(10); /* initialize SPI with lowest frequency; max. 400kHz during identification mode of card */ spi_low_frequency(); /* card needs 74 cycles minimum to start up */ for(uint8_t i = 0; i < 32; ++i) { /* wait 8 clock cycles */ spi_rec_byte(); } /* address card */ select_card(); printf_P(PSTR("Card reset\n\r")); /* reset card */ uint8_t response; for(uint16_t i = 0; ; ++i) { response = sd_raw_send_command_r1(CMD_GO_IDLE_STATE, 0); if(response == (1 << R1_IDLE_STATE)) break; if(i == 0x1ff) { unselect_card(); spi_rec_byte(); spi_high_frequency(); return 0; } } printf_P(PSTR("Card: wait\n\r")); /* wait for card to get ready */ for(uint16_t i = 0; ; ++i) { // ACMD41 für "dünne" und "normale" SD-Karten (wil) // response = sd_raw_send_command_r1(55, 0); // APP_CMD // response = sd_raw_send_command_r1(41, 0); // SD_SEND_OP_COND (keine 'high capacity') response = sd_raw_send_command_r1(1, 0); // CMD1 (for MMC) if(!(response & (1 << R1_IDLE_STATE))) break; if(i == 0x7fff) { unselect_card(); spi_rec_byte(); spi_high_frequency(); return 0; } } printf_P(PSTR("Card ready\n\r")); /* set block size to 512 bytes */ if(sd_raw_send_command_r1(CMD_SET_BLOCKLEN, 512)) { unselect_card(); spi_rec_byte(); spi_high_frequency(); return 0; } /* deaddress card */ unselect_card(); spi_rec_byte(); /* switch to highest SPI frequency possible */ spi_high_frequency(); #if !SD_RAW_SAVE_RAM /* the first block is likely to be accessed first, so precache it here */ raw_block_address = 0xffffffff; #if SD_RAW_WRITE_BUFFERING raw_block_written = 1; #endif if(!sd_raw_read(0, raw_block, sizeof(raw_block))) return 0; #endif return 1; }