330 lines
9.5 KiB
C
330 lines
9.5 KiB
C
/*-----------------------------------------------------------------------*/
|
|
/* Low level disk I/O module skeleton for Petit FatFs (C)ChaN, 2014 */
|
|
/* */
|
|
/* ... completed by ... */
|
|
/* */
|
|
/* PFF - Low level disk control module for AVR (C)ChaN, 2014 */
|
|
/* File avr_mmcp.c, part of avr/ in pffsample, a package with sample */
|
|
/* implementations on http://elm-chan.org/fsw/ff/00index_p.html */
|
|
/*-----------------------------------------------------------------------*/
|
|
/* Changes for Teacup see pff.c. */
|
|
|
|
#include "pff_diskio.h"
|
|
|
|
#ifdef SD
|
|
|
|
#include <stdlib.h>
|
|
#include "spi.h"
|
|
#include "delay.h"
|
|
|
|
/* Definitions for MMC/SDC command. */
|
|
#define CMD0 (0x40 + 0) /* GO_IDLE_STATE */
|
|
#define CMD1 (0x40 + 1) /* SEND_OP_COND (MMC) */
|
|
#define ACMD41 (0xC0 + 41) /* SEND_OP_COND (SDC) */
|
|
#define CMD8 (0x40 + 8) /* SEND_IF_COND */
|
|
#define CMD16 (0x40 + 16) /* SET_BLOCKLEN */
|
|
#define CMD17 (0x40 + 17) /* READ_SINGLE_BLOCK */
|
|
#define CMD24 (0x40 + 24) /* WRITE_BLOCK */
|
|
#define CMD55 (0x40 + 55) /* APP_CMD */
|
|
#define CMD58 (0x40 + 58) /* READ_OCR */
|
|
|
|
/* Card type flags (card_type). */
|
|
#define CT_MMC 0x01 /* MMC ver 3 */
|
|
#define CT_SD1 0x02 /* SD ver 1 */
|
|
#define CT_SD2 0x04 /* SD ver 2 */
|
|
#define CT_BLOCK 0x08 /* Block addressing */
|
|
|
|
|
|
static BYTE card_type; /* Card type flags. */
|
|
|
|
|
|
/** Send a command packet to MMC/SD card.
|
|
|
|
\param cmd Command.
|
|
\param arg Argument (32 bit).
|
|
|
|
\return response byte (bit 7 == 1: send failed).
|
|
*/
|
|
static BYTE send_cmd(BYTE cmd, DWORD arg) {
|
|
BYTE n, res;
|
|
|
|
if (cmd & 0x80) { /* ACMD<n> is the command sequence of CMD55-CMD<n>. */
|
|
cmd &= 0x7F;
|
|
res = send_cmd(CMD55, 0);
|
|
if (res > 1)
|
|
return res;
|
|
}
|
|
|
|
/* Select the card */
|
|
spi_deselect_sd();
|
|
spi_rw(0xFF);
|
|
spi_select_sd();
|
|
spi_rw(0xFF);
|
|
|
|
/* Send command packet */
|
|
spi_rw(cmd); /* Start + Command index */
|
|
spi_rw((BYTE)(arg >> 24)); /* Argument[31..24] */
|
|
spi_rw((BYTE)(arg >> 16)); /* Argument[23..16] */
|
|
spi_rw((BYTE)(arg >> 8)); /* Argument[15..8] */
|
|
spi_rw((BYTE)arg); /* Argument[7..0] */
|
|
n = 0x01; /* Dummy CRC + Stop */
|
|
if (cmd == CMD0) n = 0x95; /* Valid CRC for CMD0(0) + Stop */
|
|
if (cmd == CMD8) n = 0x87; /* Valid CRC for CMD8(0x1AA) Stop */
|
|
spi_rw(n);
|
|
|
|
/* Receive command response */
|
|
n = 10; /* Wait for a response, try 10 times. */
|
|
do {
|
|
res = spi_rw(0xFF);
|
|
n--;
|
|
} while ((res & 0x80) && n);
|
|
|
|
return res;
|
|
}
|
|
|
|
/** Initialize disk drive.
|
|
|
|
\return 0 on success, else STA_NOINIT.
|
|
|
|
Initialize disk drive and also find out which kind of card we're talking to.
|
|
|
|
Description about what's going on here see
|
|
http://elm-chan.org/docs/mmc/mmc_e.html, center section.
|
|
*/
|
|
DSTATUS disk_initialize(void) {
|
|
BYTE n, cmd, ty, ocr[4];
|
|
UINT timeout;
|
|
|
|
spi_deselect_sd();
|
|
spi_speed_100_400();
|
|
for (n = 10; n; n--) /* 80 dummy clocks with CS = high. */
|
|
spi_rw(0xFF);
|
|
|
|
/* Find card type: MMCv3, SDv1 or SDv2. */
|
|
ty = 0;
|
|
if (send_cmd(CMD0, 0) == 1) { /* Software reset, enter idle state. */
|
|
if (send_cmd(CMD8, 0x1AA) == 1) { /* SDv2? (rejected on others) */
|
|
for (n = 0; n < 4; n++) /* Get trailing return value of R7. */
|
|
ocr[n] = spi_rw(0xFF);
|
|
|
|
if (ocr[2] == 0x01 && ocr[3] == 0xAA) {
|
|
/* The card can work at Vdd range of 2.7 - 3.6V. */
|
|
|
|
/* Wait for leaving idle state (ACMD41 with HCS bit). */
|
|
for (timeout = 10000; timeout && send_cmd(ACMD41, 1UL << 30); timeout--)
|
|
delay_us(100);
|
|
|
|
/* Find out whether it's a block device (CCS bit in OCR). */
|
|
if (timeout && send_cmd(CMD58, 0) == 0) {
|
|
for (n = 0; n < 4; n++)
|
|
ocr[n] = spi_rw(0xFF);
|
|
ty = (ocr[0] & 0x40) ? CT_SD2 | CT_BLOCK : CT_SD2; /* SDv2 */
|
|
}
|
|
}
|
|
}
|
|
else { /* SDv1 or MMCv3 */
|
|
if (send_cmd(ACMD41, 0) <= 1) {
|
|
ty = CT_SD1; cmd = ACMD41; /* SDv1 */
|
|
}
|
|
else {
|
|
ty = CT_MMC; cmd = CMD1; /* MMCv3 */
|
|
}
|
|
|
|
/* Wait for leaving idle state. */
|
|
for (timeout = 10000; timeout && send_cmd(cmd, 0); timeout--)
|
|
delay_us(100);
|
|
|
|
/* Set R/W block length to 512. */
|
|
if ( ! timeout || send_cmd(CMD16, 512) != 0)
|
|
ty = 0;
|
|
}
|
|
}
|
|
|
|
card_type = ty;
|
|
spi_deselect_sd();
|
|
spi_rw(0xFF);
|
|
|
|
return ty ? 0 : STA_NOINIT;
|
|
}
|
|
|
|
/** Read partial sector.
|
|
|
|
\param buffer Received data should go in here.
|
|
\param sector Sector number (LBA).
|
|
\param offset Offset into the sector.
|
|
\param count Byte count (bit 15: destination).
|
|
|
|
\return RES_OK on success, else RES_ERROR.
|
|
|
|
This is the main reading function. Forming this into directory listings,
|
|
file reads and such stuff is done by Petit FatFs it's self.
|
|
|
|
Description about what's going on here see
|
|
http://elm-chan.org/docs/mmc/mmc_e.html, bottom section.
|
|
*/
|
|
#if _USE_READ
|
|
DRESULT disk_readp(BYTE* buffer, DWORD sector, UINT offset, UINT count) {
|
|
DRESULT result;
|
|
BYTE token = 0xFF;
|
|
uint16_t timeout;
|
|
UINT trailing = 514 - offset - count; /* 514 = block size + 2 bytes CRC */
|
|
|
|
/* Convert to byte address on non-block cards. */
|
|
if ( ! (card_type & CT_BLOCK))
|
|
sector *= 512;
|
|
|
|
/* Read one sector, copy only as many bytes as required. */
|
|
result = RES_ERROR;
|
|
spi_speed_max();
|
|
if (send_cmd(CMD17, sector) == 0) { /* Read single block. */
|
|
/* Wait for data packet. */
|
|
for (timeout = 40000; timeout && (token == 0xFF); timeout--)
|
|
token = spi_rw(0xFF);
|
|
|
|
if (token == 0xFE) { /* Valid data arrived. */
|
|
/* Skip leading bytes. */
|
|
while (offset--)
|
|
spi_rw(0xFF);
|
|
|
|
/* Receive the requested part of the sector. */
|
|
do {
|
|
/**
|
|
Note that this isn't optimised for performance. The increment and
|
|
the dereferencing could be done while waiting for the SPIF bit
|
|
to become set in spi_rw(). See http://www.matuschek.net/atmega-spi/.
|
|
*/
|
|
*buffer++ = spi_rw(0xFF);
|
|
} while (--count);
|
|
|
|
/* Skip trailing bytes and CRC. */
|
|
while (trailing--)
|
|
spi_rw(0xFF);
|
|
|
|
result = RES_OK;
|
|
}
|
|
}
|
|
|
|
spi_deselect_sd(); /* Every send_cmd() selects. */
|
|
spi_rw(0xFF);
|
|
|
|
return result;
|
|
}
|
|
|
|
/** Read and parse a line.
|
|
|
|
\param sector Sector number (LBA).
|
|
\param offset Offset into the sector.
|
|
\param count Number of bytes read.
|
|
\param parser Pointer to the parser function, which should return 1 on EOL,
|
|
else zero.
|
|
|
|
\return RES_OK on success, else RES_ERROR.
|
|
|
|
This starts reading a sector at offset and sends each character to the
|
|
parser. The parser reports back whether an end of line (EOL) was reached,
|
|
which ends this function. If end of the sector is reached without finding
|
|
an EOL, this function should be called again with the next sector of the
|
|
file.
|
|
|
|
Reading lines of code this way should be more efficient than reading all the
|
|
bytes into a small, not line-aligned buffer, just to read this buffer(s)
|
|
right again byte by byte for parsing. It makes buffering entirely obsolete.
|
|
*/
|
|
DRESULT disk_parsep(DWORD sector, UINT offset, UINT* count,
|
|
uint8_t (*parser)(uint8_t)) {
|
|
DRESULT result;
|
|
BYTE token = 0xFF;
|
|
uint16_t timeout;
|
|
UINT trailing = 514 - offset, read = 0; /* 514 = block size + 2 bytes CRC */
|
|
|
|
/* Convert to byte address on non-block cards. */
|
|
if ( ! (card_type & CT_BLOCK))
|
|
sector *= 512;
|
|
|
|
/* Read one sector, copy only as many bytes as required. */
|
|
result = RES_ERROR;
|
|
spi_speed_max();
|
|
if (send_cmd(CMD17, sector) == 0) { /* Read single block. */
|
|
/* Wait for data packet. */
|
|
for (timeout = 40000; timeout && (token == 0xFF); timeout--)
|
|
token = spi_rw(0xFF);
|
|
|
|
if (token == 0xFE) { /* Valid data arrived. */
|
|
/* Skip leading bytes. */
|
|
while (offset--)
|
|
spi_rw(0xFF);
|
|
|
|
/* Receive and parse the sector up to EOL or end of the sector. */
|
|
do {
|
|
/**
|
|
Note that this isn't optimised for performance. See
|
|
http://www.matuschek.net/atmega-spi/.
|
|
*/
|
|
result = parser(spi_rw(0xFF));
|
|
read++;
|
|
trailing--;
|
|
} while (trailing > 2 && ! result);
|
|
|
|
*count = read;
|
|
|
|
/* Skip trailing bytes and CRC. */
|
|
while (trailing--)
|
|
spi_rw(0xFF);
|
|
|
|
if (result)
|
|
result = RES_EOL_FOUND;
|
|
else
|
|
result = RES_OK;
|
|
}
|
|
}
|
|
|
|
spi_deselect_sd(); /* Every send_cmd() selects. */
|
|
spi_rw(0xFF);
|
|
|
|
return result;
|
|
}
|
|
#endif /* _USE_READ */
|
|
|
|
/** Write partial pector.
|
|
|
|
\param buff Pointer to the data to be written.
|
|
NULL: Initiate/Finalize write operation.
|
|
\param sc Sector number (LBA) or number of bytes to send.
|
|
|
|
\return RES_OK on success, else RES_ERROR.
|
|
|
|
This is the main writing function. Forming this into file writes and such
|
|
stuff is done by Petit FatFs it's self.
|
|
|
|
Description about what's going on here see
|
|
http://elm-chan.org/docs/mmc/mmc_e.html, bottom section.
|
|
*/
|
|
#if _USE_WRITE
|
|
DRESULT disk_writep(const BYTE* buff, DWORD sc) {
|
|
#error disk_writep() not yet implemented
|
|
DRESULT res;
|
|
|
|
if ( ! buff) {
|
|
if (sc) {
|
|
|
|
// Initiate write process
|
|
|
|
}
|
|
else {
|
|
|
|
// Finalize write process
|
|
|
|
}
|
|
}
|
|
else {
|
|
|
|
// Send data to the disk
|
|
|
|
}
|
|
|
|
return res;
|
|
}
|
|
#endif /* _USE_WRITE */
|
|
|
|
#endif /* SD */
|