From 7f552300815ccadd45ebb3e7f0ae72a3b2e0c4e5 Mon Sep 17 00:00:00 2001 From: Leo C Date: Sat, 22 Nov 2014 13:07:04 +0100 Subject: [PATCH] Integrate fatfs. Add some sd card test commands. --- avr/cmd_sd.c | 289 ++++++++++++++ avr/command_tbl.c | 18 +- avr/main.c | 11 +- avr/mmc.c | 637 +++++++++++++++++++++++++++++++ avr/timer.c | 4 +- fatfs/src/diskio.h | 80 ---- fatfs/src/ffconf.h | 13 +- include/avr/ffconf.h | 25 ++ include/diskio.h | 86 +++++ include/ff.h | 2 + {fatfs/src => include}/integer.h | 23 +- include/spi.h | 54 +++ 12 files changed, 1125 insertions(+), 117 deletions(-) create mode 100644 avr/cmd_sd.c create mode 100644 avr/mmc.c delete mode 100644 fatfs/src/diskio.h create mode 100644 include/avr/ffconf.h create mode 100644 include/diskio.h create mode 100644 include/ff.h rename {fatfs/src => include}/integer.h (51%) create mode 100644 include/spi.h diff --git a/avr/cmd_sd.c b/avr/cmd_sd.c new file mode 100644 index 0000000..55acf2f --- /dev/null +++ b/avr/cmd_sd.c @@ -0,0 +1,289 @@ +#include "common.h" +#include + +#include "diskio.h" +#include "ff.h" +#include "command.h" +#include "print-utils.h" + + +static const FLASH char * const FLASH rc_names[] = { + FSTR("OK"), + FSTR("DISK_ERR"), + FSTR("INT_ERR"), + FSTR("NOT_READY"), + FSTR("NO_FILE"), + FSTR("NO_PATH"), + FSTR("INVALID_NAME"), + FSTR("DENIED"), + FSTR("EXIST"), + FSTR("INVALID_OBJECT"), + FSTR("WRITE_PROTECTED"), + FSTR("INVALID_DRIVE"), + FSTR("NOT_ENABLED"), + FSTR("NO_FILE_SYSTEM"), + FSTR("MKFS_ABORTED"), + FSTR("TIMEOUT"), + FSTR("LOCKED"), + FSTR("NOT_ENOUGH_CORE"), + FSTR("TOO_MANY_OPEN_FILES") + }; + +static +void put_rc (FRESULT rc) +{ +#if 0 + printf_P(PSTR("rc=%u FR_%S\n"), rc, rc_names[rc]); +#else + printf_P(PSTR("rc=%u FR_"), rc); + my_puts_P(rc_names[rc]); + printf_P(PSTR("\n")); + +#endif + +} + +#define BUFF_SIZE 1024 +BYTE Buff[BUFF_SIZE]; /* Working buffer */ + +static DWORD last_sect; + + +/* + * dd [] - Dump sector + * + */ +command_ret_t do_dd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + FRESULT res; + BYTE dev; + unsigned long sec; + + (void) cmdtp; (void) flag; + + if (argc < 2) + return CMD_RET_USAGE; + + dev = (BYTE) strtoul(argv[1], 0, 10); + + if (argc > 2) + sec = strtoul(argv[2], 0, 10); + else + sec = last_sect; + + res = disk_read(dev, Buff, sec, 1); + + if (res) { + printf_P(PSTR("rc=%.2x\n"), res); + return CMD_RET_FAILURE; + } + + last_sect = sec + 1; + printf_P(PSTR("Sector:%lu\n"), sec); + dump_ram((uint32_t) (size_t) Buff, 0, 0x200, NULL); + + return CMD_RET_SUCCESS; +} + +/* + * di - Initialize disk + * + */ +command_ret_t do_di(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + FRESULT res; + BYTE dev; + + (void) cmdtp; (void) flag; + + if (argc < 2) + return CMD_RET_USAGE; + + dev = (BYTE) strtoul(argv[1], 0, 10); + res = disk_status(dev); + printf_P(PSTR("disk_status=%.2x\n"), res); + + if ((res & STA_NODISK) == 0) { + res = disk_initialize(dev); + } + printf_P(PSTR("rc=%.2x\n"), res); + if (res) { + return CMD_RET_FAILURE; + } + + return CMD_RET_SUCCESS; +} + +/* + * ds - Show disk status + * + */ +command_ret_t do_ds(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + BYTE dev; + + union { + unsigned long lval; + unsigned char cval; + } dat; + + (void) cmdtp; (void) flag; + + if (argc < 2) + return CMD_RET_USAGE; + + dev = (BYTE) strtoul(argv[1], 0, 10); + + + if (disk_ioctl(dev, GET_SECTOR_COUNT, &dat.lval) == RES_OK) + printf_P(PSTR("Drive size: %lu sectors\n"), dat.lval); + + if (disk_ioctl(dev, GET_BLOCK_SIZE, &dat.lval) == RES_OK) + printf_P(PSTR("Erase block: %lu sectors\n"), dat.lval); + + if (disk_ioctl(dev, MMC_GET_TYPE, &dat.cval) == RES_OK) + printf_P(PSTR("Card type: %u\n"), dat.cval); + + if (disk_ioctl(dev, MMC_GET_CSD, Buff) == RES_OK) + dump_ram((uint32_t) (size_t) Buff, 0, 16, "CSD:"); + + if (disk_ioctl(dev, MMC_GET_CID, Buff) == RES_OK) + dump_ram((uint32_t) (size_t) Buff, 0, 16, "CID:"); + + if (disk_ioctl(dev, MMC_GET_OCR, Buff) == RES_OK) + dump_ram((uint32_t) (size_t) Buff, 0, 4, "OCR:"); + + if (disk_ioctl(dev, MMC_GET_SDSTAT, Buff) == RES_OK) + dump_ram((uint32_t) (size_t) Buff, 0, 64, "SD Status:"); + + if (disk_ioctl(dev, ATA_GET_MODEL, Buff) == RES_OK) { + Buff[40] = '\0'; + printf_P(PSTR("Model: %s\n"), Buff); + } + if (disk_ioctl(dev, ATA_GET_SN, Buff) == RES_OK) { + Buff[20] = '\0'; printf_P(PSTR("S/N: %s\n"), Buff); + } + + return CMD_RET_SUCCESS; +} + + + +/* + * Disk ioctl + * dcs - CTRL_SYNC + * + */ +command_ret_t do_dcs(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + BYTE dev; + + (void) cmdtp; (void) flag; + + if (argc < 2) + return CMD_RET_USAGE; + + dev = (BYTE) strtoul(argv[1], 0, 10); + printf_P(PSTR("rc=%.2x\n"), disk_ioctl(dev, CTRL_SYNC, 0)); + + return CMD_RET_SUCCESS; +} + + + +command_ret_t do_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + (void) cmdtp; (void) flag; + (void) argc; (void) argv; + + printf_P(_USE_LFN ? PSTR("LFN Enabled") : PSTR("LFN Disabled")); + printf_P(PSTR(", Code page: %u\n"), _CODE_PAGE); + + for (FRESULT i=0; i<19; i++) + put_rc(i); + + + return CMD_RET_SUCCESS; +} + +extern command_ret_t do_echo(cmd_tbl_t *, int, int, char * const []); + + +static +command_ret_t do_help(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]); + +cmd_tbl_t cmd_sd_sub[] = { +CMD_TBL_ITEM( + dd, CONFIG_SYS_MAXARGS, 1, do_dd, + "Dump sector", + "" +), +CMD_TBL_ITEM( + di, 2, 1, do_di, + "Initialize disk", + "" +), +CMD_TBL_ITEM( + ds, 2, 1, do_ds, + "Disk status", + "" +), +CMD_TBL_ITEM( + dcs, 2, 1, do_dcs, + "Device control: SYNC", + "" +), +CMD_TBL_ITEM( + echo, CONFIG_SYS_MAXARGS, 1, do_echo, + "sane as echo (simple test)", "" +), +CMD_TBL_ITEM( + test, CONFIG_SYS_MAXARGS, 1, do_test, + "print some compiled in parameters", "" +), +CMD_TBL_ITEM( + help, CONFIG_SYS_MAXARGS, 1, do_help, + "print sub command description/usage", + "\n" + " - print brief description of all sub commands\n" + "sd help command ...\n" + " - print detailed usage of sub cmd 'command'" +), + +/* This does not use the CMD_TBL_ITEM macro as ? can't be used in symbol names */ + {FSTR("?"), CONFIG_SYS_MAXARGS, 1, do_help, + FSTR("alias for 'help'"), +#ifdef CONFIG_SYS_LONGHELP + FSTR(""), +#endif /* CONFIG_SYS_LONGHELP */ +#ifdef CONFIG_AUTO_COMPLETE + 0, +#endif +}, +}; + +static +command_ret_t do_help(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + return _do_help(cmd_sd_sub, ARRAY_SIZE(cmd_sd_sub), cmdtp, flag, argc, argv); +} + + +command_ret_t do_sd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + cmd_tbl_t *cp; + + if (argc < 2) + return CMD_RET_USAGE; + + /* drop initial "sd" arg */ + argc--; + argv++; + + cp = find_cmd_tbl(argv[0], cmd_sd_sub, ARRAY_SIZE(cmd_sd_sub)); + + if (cp) + return cp->cmd(cmdtp, flag, argc, argv); + + return CMD_RET_USAGE; +} diff --git a/avr/command_tbl.c b/avr/command_tbl.c index 97110fd..6b53fad 100644 --- a/avr/command_tbl.c +++ b/avr/command_tbl.c @@ -231,6 +231,13 @@ CMD_TBL_ITEM( ), #endif /* CONFIG_MX_CYCLIC */ +CMD_TBL_ITEM( + sd, CONFIG_SYS_MAXARGS, 1, do_sd, + "SD/MMC card handling commands", + " args ...\n" + "sd help\n" + " - print help on subcommands" +), CMD_TBL_ITEM( help, CONFIG_SYS_MAXARGS, 1, do_help, @@ -241,17 +248,6 @@ CMD_TBL_ITEM( " - print detailed usage of 'command'" ), -/* TODO: make macro CMD_TBL_ITEM work with this */ - {FSTR("sd"), CONFIG_SYS_MAXARGS, 1, do_sd, - FSTR("SD/MMC card handling commands"), -#ifdef CONFIG_SYS_LONGHELP - sd_help_text, -#endif /* CONFIG_SYS_LONGHELP */ -#ifdef CONFIG_AUTO_COMPLETE - 0, -#endif -}, - /* This does not use the CMD_TBL_ITEM macro as ? can't be used in symbol names */ {FSTR("?"), CONFIG_SYS_MAXARGS, 1, do_help, FSTR("alias for 'help'"), diff --git a/avr/main.c b/avr/main.c index 2f9a62f..af082a3 100644 --- a/avr/main.c +++ b/avr/main.c @@ -18,6 +18,7 @@ #include "cli.h" #include "env.h" #include "z180-serv.h" +#include "spi.h" static uint8_t mcusr; @@ -108,8 +109,15 @@ void setup_avr(void) TCCR3B = (0b01< +#include +#include "timer.h" +#include "spi.h" +#include "diskio.h" +#include "debug.h" +#include "print-utils.h" + + +/* Definitions for MMC/SDC command */ +#define CMD0 (0) /* GO_IDLE_STATE */ +#define CMD1 (1) /* SEND_OP_COND (MMC) */ +#define ACMD41 (0x80+41) /* SEND_OP_COND (SDC) */ +#define CMD8 (8) /* SEND_IF_COND */ +#define CMD9 (9) /* SEND_CSD */ +#define CMD10 (10) /* SEND_CID */ +#define CMD12 (12) /* STOP_TRANSMISSION */ +#define ACMD13 (0x80+13) /* SD_STATUS (SDC) */ +#define CMD16 (16) /* SET_BLOCKLEN */ +#define CMD17 (17) /* READ_SINGLE_BLOCK */ +#define CMD18 (18) /* READ_MULTIPLE_BLOCK */ +#define CMD23 (23) /* SET_BLOCK_COUNT (MMC) */ +#define ACMD23 (0x80+23) /* SET_WR_BLK_ERASE_COUNT (SDC) */ +#define CMD24 (24) /* WRITE_BLOCK */ +#define CMD25 (25) /* WRITE_MULTIPLE_BLOCK */ +#define CMD55 (55) /* APP_CMD */ +#define CMD58 (58) /* READ_OCR */ + + +/* SD card socket connections */ +#if 0 +//#define MMC_PORT PORTG /* Socket contact port */ +//#define MMC_INPORT PING +//#define SD_WP_PIN 5 /* Write protect switch */ +#endif + +/* SD card SPI access */ +#define SD_CD_PORT PORTG +#define SD_CD_DDR DDRG +#define SD_CD_INPORT PING +#define SD_CD_PIN 3 /* Card detect switch */ + +#define SD_WP_PORT PORTG +#define SD_WP_DDR DDRG +#define SD_WP_INPORT PING +//#define SD_WP_PIN 5 /* Write protect switch */ + +#define SD_CS_PORT PORTG +#define SD_CS_DDR DDRG +#define SD_CS_PIN 4 /* Chip select pin */ + + +/* Port Controls (Platform dependent) */ + +#ifdef SD_CD_PIN +static inline +bool sd_cd(void) +{ + return (SD_CD_INPORT & _BV(SD_CD_PIN)) == 0; +} +#endif + +#ifdef SD_WP_PIN +static inline +bool sd_wp(void) +{ + return (SD_WP_INPORT & _BV(SD_WP_PIN)) == 0; +} +#endif + +#define CS_LOW() SD_CS_PORT &= ~(1< is the command sequense of CMD55-CMD */ + cmd &= 0x7F; + res = send_cmd(CMD55, 0); + if (res > 1) + return res; + } + + /* Select the card and wait for ready except to stop multiple block read */ + if (cmd != CMD12) { + deselect(); + if (!select()) + return 0xFF; + } + + /* Send command packet */ + spi_xmit(0x40 | cmd); /* Start + Command index */ + argtmp.as32 = arg; + spi_xmit(argtmp.as8[3]); /* Argument[31..24] */ + spi_xmit(argtmp.as8[2]); /* Argument[23..16] */ + spi_xmit(argtmp.as8[1]); /* Argument[15..8] */ + spi_xmit(argtmp.as8[0]); /* Argument[7..0] */ + + n = 0x01; /* Dummy CRC + Stop */ + if (cmd == CMD0) + n = 0x95; /* Valid CRC for CMD0(0) */ + if (cmd == CMD8) + n = 0x87; /* Valid CRC for CMD8(0x1AA) */ + spi_xmit(n); + + /* Receive command response */ + if (cmd == CMD12) + spi_rcvr(); /* Skip a stuff byte when stop reading */ + n = 10; /* Wait for a valid response in timeout of 10 attempts */ + do + res = spi_rcvr(); + while ((res & 0x80) && --n); + + return res; /* Return with the response value */ +} + +/*-------------------------------------------------------------------------- + + Public Functions + + ---------------------------------------------------------------------------*/ + +/*-----------------------------------------------------------------------*/ +/* Initialize Disk Drive */ +/*-----------------------------------------------------------------------*/ + +#define MMC_INIT_TO 1000 /* 1s */ + +DSTATUS disk_initialize ( + BYTE drv /* Physical drive nmuber (0) */ +) +{ + BYTE n, cmd, ty, ocr[4]; + + if (drv) + return STA_NOINIT; /* Supports only single drive */ + if (disk_stat & STA_NODISK) + return disk_stat; /* No card in the socket */ + + power_on(); /* Force socket power on */ + FCLK_SLOW(); + for (n = 10; n; n--) + spi_rcvr(); /* 80 dummy clocks */ + + ty = 0; + if (send_cmd(CMD0, 0) == 1) { /* Enter Idle state */ + /* Init timeout timer */ + uint32_t timer = get_timer(0); + + if (send_cmd(CMD8, 0x1AA) == 1) { /* SDv2? */ + for (n = 0; n < 4; n++) ocr[n] = spi_rcvr(); /* Get trailing return value of R7 resp */ + if (ocr[2] == 0x01 && ocr[3] == 0xAA) { /* The card can work at vdd range of 2.7-3.6V */ + while (get_timer(timer) < MMC_INIT_TO && send_cmd(ACMD41, 1UL << 30)); /* Wait for leaving idle state (ACMD41 with HCS bit) */ + if (get_timer(timer) < MMC_INIT_TO && send_cmd(CMD58, 0) == 0) { /* Check CCS bit in the OCR */ + for (n = 0; n < 4; n++) ocr[n] = spi_rcvr(); + 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 */ + while (get_timer(timer) < MMC_INIT_TO && send_cmd(cmd, 0)); + + /* Set R/W block length to 512 */ + if (!(get_timer(timer) < MMC_INIT_TO) || send_cmd(CMD16, 512) != 0) + ty = 0; + } + } + CardType = ty; + deselect(); + + if (ty) { /* Initialization succeded */ + disk_stat &= ~STA_NOINIT; /* Clear STA_NOINIT */ + FCLK_FAST(); + } else { /* Initialization failed */ + power_off(); + } + + return disk_stat; +} + +/*-----------------------------------------------------------------------*/ +/* Get Disk Status */ +/*-----------------------------------------------------------------------*/ + +DSTATUS disk_status ( + BYTE drv /* Physical drive nmuber (0) */ +) +{ + if (drv) return STA_NOINIT; /* Supports only single drive */ + return disk_stat; +} + +/*-----------------------------------------------------------------------*/ +/* Read Sector(s) */ +/*-----------------------------------------------------------------------*/ + +DRESULT disk_read ( + BYTE drv, /* Physical drive nmuber (0) */ + BYTE *buff, /* Pointer to the data buffer to store read data */ + DWORD sector, /* Start sector number (LBA) */ + UINT count /* Sector count (1..255) */ +) +{ + BYTE cmd; + + if (drv || !count) return RES_PARERR; + if (disk_stat & STA_NOINIT) return RES_NOTRDY; + + if (!(CardType & CT_BLOCK)) sector *= 512; /* Convert to byte address if needed */ + + cmd = count > 1 ? CMD18 : CMD17; /* READ_MULTIPLE_BLOCK : READ_SINGLE_BLOCK */ + if (send_cmd(cmd, sector) == 0) { + do { + if (!rcvr_datablock(buff, 512)) + break; + buff += 512; + } while (--count); + if (cmd == CMD18) + send_cmd(CMD12, 0); /* STOP_TRANSMISSION */ + } + deselect(); + + return count ? RES_ERROR : RES_OK; +} + +/*-----------------------------------------------------------------------*/ +/* Write Sector(s) */ +/*-----------------------------------------------------------------------*/ + +#if _USE_WRITE +DRESULT disk_write ( + BYTE drv, /* Physical drive nmuber (0) */ + const BYTE *buff, /* Pointer to the data to be written */ + DWORD sector, /* Start sector number (LBA) */ + UINT count /* Sector count (1..255) */ +) +{ + if (drv || !count) return RES_PARERR; + if (disk_stat & STA_NOINIT) return RES_NOTRDY; + if (disk_stat & STA_PROTECT) return RES_WRPRT; + + if (!(CardType & CT_BLOCK)) sector *= 512; /* Convert to byte address if needed */ + + if (count == 1) { /* Single block write */ + if ((send_cmd(CMD24, sector) == 0) /* WRITE_BLOCK */ + && xmit_datablock(buff, 0xFE)) + count = 0; + } + else { /* Multiple block write */ + if (CardType & CT_SDC) send_cmd(ACMD23, count); + if (send_cmd(CMD25, sector) == 0) { /* WRITE_MULTIPLE_BLOCK */ + do { + if (!xmit_datablock(buff, 0xFC)) break; + buff += 512; + }while (--count); + if (!xmit_datablock(0, 0xFD)) /* STOP_TRAN token */ + count = 1; + } + } + deselect(); + + return count ? RES_ERROR : RES_OK; +} +#endif /* _USE_WRITE */ + +/*-----------------------------------------------------------------------*/ +/* Miscellaneous Functions */ +/*-----------------------------------------------------------------------*/ + +#if _USE_IOCTL +DRESULT disk_ioctl ( + BYTE drv, /* Physical drive nmuber (0) */ + BYTE cmd, /* Control code */ + void *buff /* Buffer to send/receive control data */ +) +{ + DRESULT res; + BYTE n, csd[16], *ptr = buff; + DWORD csize; + + if (drv) + return RES_PARERR; + + res = RES_ERROR; + + if (disk_stat & STA_NOINIT) return RES_NOTRDY; + + switch (cmd) { + case CTRL_SYNC : /* Make sure that no pending write process. Do not remove this or written sector might not left updated. */ + if (select()) + res = RES_OK; + break; + + case GET_SECTOR_COUNT: /* Get number of sectors on the disk (DWORD) */ + if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) { + if ((csd[0] >> 6) == 1) { /* SDC ver 2.00 */ + csize = csd[9] + ((WORD)csd[8] << 8) + ((DWORD)(csd[7] & 63) << 16) + 1; + *(DWORD*)buff = csize << 10; + } else { /* SDC ver 1.XX or MMC*/ + n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2; + csize = (csd[8] >> 6) + ((WORD)csd[7] << 2) + ((WORD)(csd[6] & 3) << 10) + 1; + *(DWORD*)buff = csize << (n - 9); + } + res = RES_OK; + } + break; + + case GET_BLOCK_SIZE: /* Get erase block size in unit of sector (DWORD) */ + if (CardType & CT_SD2) { /* SDv2? */ + if (send_cmd(ACMD13, 0) == 0) { /* Read SD status */ + spi_rcvr(); + if (rcvr_datablock(csd, 16)) { /* Read partial block */ + for (n = 64 - 16; n; n--) + spi_rcvr(); /* Purge trailing data */ + *(DWORD*) buff = 16UL << (csd[10] >> 4); + res = RES_OK; + } + } + } else { /* SDv1 or MMCv3 */ + if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) { /* Read CSD */ + if (CardType & CT_SD1) { /* SDv1 */ + *(DWORD*)buff = (((csd[10] & 63) << 1) + ((WORD)(csd[11] & 128) >> 7) + 1) << ((csd[13] >> 6) - 1); + } else { /* MMCv3 */ + *(DWORD*)buff = ((WORD)((csd[10] & 124) >> 2) + 1) * (((csd[11] & 3) << 3) + ((csd[11] & 224) >> 5) + 1); + } + res = RES_OK; + } + } + break; + + /* Following commands are never used by FatFs module */ + + case MMC_GET_TYPE: /* Get card type flags (1 byte) */ + *ptr = CardType; + res = RES_OK; + break; + + case MMC_GET_CSD: /* Receive CSD as a data block (16 bytes) */ + if (send_cmd(CMD9, 0) == 0 /* READ_CSD */ + && rcvr_datablock(ptr, 16)) + res = RES_OK; + break; + + case MMC_GET_CID: /* Receive CID as a data block (16 bytes) */ + if (send_cmd(CMD10, 0) == 0 /* READ_CID */ + && rcvr_datablock(ptr, 16)) + res = RES_OK; + break; + + case MMC_GET_OCR: /* Receive OCR as an R3 resp (4 bytes) */ + if (send_cmd(CMD58, 0) == 0) { /* READ_OCR */ + for (n = 4; n; n--) + *ptr++ = spi_rcvr(); + res = RES_OK; + } + break; + + case MMC_GET_SDSTAT: /* Receive SD status as a data block (64 bytes) */ + if (send_cmd(ACMD13, 0) == 0) { /* SD_STATUS */ + spi_rcvr(); + if (rcvr_datablock(ptr, 64)) + res = RES_OK; + } + break; + + case CTRL_POWER_OFF : /* Power off */ + power_off(); + disk_stat |= STA_NOINIT; + res = RES_OK; + break; + + default: + res = RES_PARERR; + } + + deselect(); + + return res; +} +#endif /* _USE_IOCTL */ + +/*-----------------------------------------------------------------------*/ +/* Device Timer Interrupt Procedure (Platform dependent) */ +/*-----------------------------------------------------------------------*/ +/* This function must be called in period of 10ms */ + +void disk_timerproc (void) +{ + BYTE s; + + s = disk_stat; + +#ifdef SD_WP_PIN + if (sd_wp()) /* Write protected */ + s |= STA_PROTECT; + else /* Write enabled */ + s &= ~STA_PROTECT; +#endif + +#ifdef SD_CD_PIN + if (sd_cd()) /* Card inserted */ + s &= ~STA_NODISK; + else /* Socket empty */ + s |= (STA_NODISK | STA_NOINIT); +#endif + + disk_stat = s; /* Update MMC status */ +} diff --git a/avr/timer.c b/avr/timer.c index 67b4a49..6fb19a8 100644 --- a/avr/timer.c +++ b/avr/timer.c @@ -25,6 +25,7 @@ ISR(TIMER3_COMPA_vect) static int_fast8_t tick_10ms; int_fast8_t i; + extern void disk_timerproc(void); timestamp++; @@ -34,7 +35,7 @@ ISR(TIMER3_COMPA_vect) Stat |= S_10MS_TO; /* Drive timer procedure of low level disk I/O module */ - //disk_timerproc(); + disk_timerproc(); } tick_10ms = i; @@ -83,4 +84,3 @@ uint32_t get_timer(uint32_t base) } return ret - base; } - diff --git a/fatfs/src/diskio.h b/fatfs/src/diskio.h deleted file mode 100644 index 9650f68..0000000 --- a/fatfs/src/diskio.h +++ /dev/null @@ -1,80 +0,0 @@ -/*-----------------------------------------------------------------------/ -/ Low level disk interface modlue include file (C)ChaN, 2014 / -/-----------------------------------------------------------------------*/ - -#ifndef _DISKIO_DEFINED -#define _DISKIO_DEFINED - -#ifdef __cplusplus -extern "C" { -#endif - -#define _USE_WRITE 1 /* 1: Enable disk_write function */ -#define _USE_IOCTL 1 /* 1: Enable disk_ioctl fucntion */ - -#include "integer.h" - - -/* Status of Disk Functions */ -typedef BYTE DSTATUS; - -/* Results of Disk Functions */ -typedef enum { - RES_OK = 0, /* 0: Successful */ - RES_ERROR, /* 1: R/W Error */ - RES_WRPRT, /* 2: Write Protected */ - RES_NOTRDY, /* 3: Not Ready */ - RES_PARERR /* 4: Invalid Parameter */ -} DRESULT; - - -/*---------------------------------------*/ -/* Prototypes for disk control functions */ - - -DSTATUS disk_initialize (BYTE pdrv); -DSTATUS disk_status (BYTE pdrv); -DRESULT disk_read (BYTE pdrv, BYTE* buff, DWORD sector, UINT count); -DRESULT disk_write (BYTE pdrv, const BYTE* buff, DWORD sector, UINT count); -DRESULT disk_ioctl (BYTE pdrv, BYTE cmd, void* buff); - - -/* Disk Status Bits (DSTATUS) */ - -#define STA_NOINIT 0x01 /* Drive not initialized */ -#define STA_NODISK 0x02 /* No medium in the drive */ -#define STA_PROTECT 0x04 /* Write protected */ - - -/* Command code for disk_ioctrl fucntion */ - -/* Generic command (Used by FatFs) */ -#define CTRL_SYNC 0 /* Complete pending write process (needed at _FS_READONLY == 0) */ -#define GET_SECTOR_COUNT 1 /* Get media size (needed at _USE_MKFS == 1) */ -#define GET_SECTOR_SIZE 2 /* Get sector size (needed at _MAX_SS != _MIN_SS) */ -#define GET_BLOCK_SIZE 3 /* Get erase block size (needed at _USE_MKFS == 1) */ -#define CTRL_TRIM 4 /* Inform device that the data on the block of sectors is no longer used (needed at _USE_TRIM == 1) */ - -/* Generic command (Not used by FatFs) */ -#define CTRL_POWER 5 /* Get/Set power status */ -#define CTRL_LOCK 6 /* Lock/Unlock media removal */ -#define CTRL_EJECT 7 /* Eject media */ -#define CTRL_FORMAT 8 /* Create physical format on the media */ - -/* MMC/SDC specific ioctl command */ -#define MMC_GET_TYPE 10 /* Get card type */ -#define MMC_GET_CSD 11 /* Get CSD */ -#define MMC_GET_CID 12 /* Get CID */ -#define MMC_GET_OCR 13 /* Get OCR */ -#define MMC_GET_SDSTAT 14 /* Get SD status */ - -/* ATA/CF specific ioctl command */ -#define ATA_GET_REV 20 /* Get F/W revision */ -#define ATA_GET_MODEL 21 /* Get model name */ -#define ATA_GET_SN 22 /* Get serial number */ - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/fatfs/src/ffconf.h b/fatfs/src/ffconf.h index 0442945..adc4b87 100644 --- a/fatfs/src/ffconf.h +++ b/fatfs/src/ffconf.h @@ -51,7 +51,7 @@ /* This option switches fast seek feature. (0:Disable or 1:Enable) */ -#define _USE_LABEL 0 +#define _USE_LABEL 1 /* This option switches volume label functions, f_getlabel() and f_setlabel(). / (0:Disable or 1:Enable) */ @@ -65,7 +65,7 @@ / Locale and Namespace Configurations /---------------------------------------------------------------------------*/ -#define _CODE_PAGE 932 +#define _CODE_PAGE 858 /* This option specifies the OEM code page to be used on the target system. / Incorrect setting of the code page can cause a file open failure. / @@ -97,8 +97,8 @@ / 1 - ASCII (No extended character. Valid for only non-LFN configuration.) */ -#define _USE_LFN 0 -#define _MAX_LFN 255 +#define _USE_LFN 1 +#define _MAX_LFN 128 /* The _USE_LFN option switches the LFN feature. / / 0: Disable LFN feature. _MAX_LFN has no effect. @@ -131,7 +131,7 @@ / When _LFN_UNICODE is 0, this option has no effect. */ -#define _FS_RPATH 0 +#define _FS_RPATH 2 /* This option configures relative path feature. / / 0: Disable relative path feature and remove related functions. @@ -209,7 +209,7 @@ / defined by _NORTC_MON, _NORTC_MDAY and _NORTC_YEAR. / When timestamp feature is enabled (_FS_NORTC == 0), get_fattime() function need / to be added to the project to read current time form RTC. _NORTC_MON, -/ _NORTC_MDAY and _NORTC_YEAR have no effect. +/ _NORTC_MDAY and _NORTC_YEAR have no effect. / These options have no effect at read-only configuration (_FS_READONLY == 1). */ @@ -267,4 +267,3 @@ / PIC24 0 H8S 0 MSP430 0 / PIC32 0 H8/300H 0 8051 0/1 */ - diff --git a/include/avr/ffconf.h b/include/avr/ffconf.h new file mode 100644 index 0000000..88c53d1 --- /dev/null +++ b/include/avr/ffconf.h @@ -0,0 +1,25 @@ + +#undef _WORD_ACCESS + +#define _WORD_ACCESS 0 /* 0 or 1 */ +/* The _WORD_ACCESS option is an only platform dependent option. It defines +/ which access method is used to the word data on the FAT volume. +/ +/ 0: Byte-by-byte access. Always compatible with all platforms. +/ 1: Word access. Do not choose this unless under both the following conditions. +/ +/ * Address misaligned memory access is always allowed to ALL instructions. +/ * Byte order on the memory is little-endian. +/ +/ If it is the case, _WORD_ACCESS can also be set to 1 to reduce code size. +/ Following table shows allowable settings of some processor types. +/ +/ ARM7TDMI 0 ColdFire 0 V850E 0 +/ Cortex-M3 0 Z80 0/1 V850ES 0/1 +/ Cortex-M0 0 x86 0/1 TLCS-870 0/1 +/ AVR 0/1 RX600(LE) 0/1 TLCS-900 0/1 +/ AVR32 0 RL78 0 R32C 0 +/ PIC18 0/1 SH-2 0 M16C 0/1 +/ PIC24 0 H8S 0 MSP430 0 +/ PIC32 0 H8/300H 0 8051 0/1 +*/ diff --git a/include/diskio.h b/include/diskio.h new file mode 100644 index 0000000..f5ba3e0 --- /dev/null +++ b/include/diskio.h @@ -0,0 +1,86 @@ +/*----------------------------------------------------------------------- +/ Low level disk interface modlue include file R0.07 (C)ChaN, 2009 +/-----------------------------------------------------------------------*/ + +#ifndef _DISKIO_H +#define _DISKIO_H + +#define _USE_WRITE 1 /* 1: Enable disk_write function */ +#define _USE_IOCTL 1 /* 1: Enable disk_ioctl fucntion */ + +#include "integer.h" + + +/* Status of Disk Functions */ +typedef BYTE DSTATUS; + +/* Results of Disk Functions */ +typedef enum { + RES_OK = 0, /* 0: Successful */ + RES_ERROR, /* 1: R/W Error */ + RES_WRPRT, /* 2: Write Protected */ + RES_NOTRDY, /* 3: Not Ready */ + RES_PARERR /* 4: Invalid Parameter */ +} DRESULT; + + +/*---------------------------------------*/ +/* Prototypes for disk control functions */ + +DSTATUS disk_initialize (BYTE drv); +DSTATUS disk_status (BYTE drv); +DRESULT disk_read (BYTE drv, BYTE* buff, DWORD sector, UINT count); +#if _USE_WRITE +DRESULT disk_write (BYTE drv, const BYTE* buff, DWORD sector, UINT count); +#endif +#if _USE_IOCTL +DRESULT disk_ioctl (BYTE drv, BYTE cmd, void* buff); +#endif +void disk_timerproc (void); + + + +/* Disk Status Bits (DSTATUS) */ + +#define STA_NOINIT 0x01 /* Drive not initialized */ +#define STA_NODISK 0x02 /* No medium in the drive */ +#define STA_PROTECT 0x04 /* Write protected */ + + +/* Command code for disk_ioctrl() */ + +/* Generic command (Used by FatFs) */ +#define CTRL_SYNC 0 /* Complete pending write process (needed at _FS_READONLY == 0) */ +#define GET_SECTOR_COUNT 1 /* Get media size (needed at _USE_MKFS == 1) */ +#define GET_SECTOR_SIZE 2 /* Get sector size (needed at _MAX_SS != _MIN_SS) */ +#define GET_BLOCK_SIZE 3 /* Get erase block size (needed at _USE_MKFS == 1) */ +#define CTRL_TRIM 4 /* Inform device that the data on the block of sectors is no longer used (needed at _USE_TRIM == 1) */ + +/* Generic command (Not used by FatFs) */ +#define CTRL_FORMAT 5 /* Create physical format on the media */ +#define CTRL_POWER_IDLE 6 /* Put the device idle state */ +#define CTRL_POWER_OFF 7 /* Put the device off state */ +#define CTRL_LOCK 8 /* Lock media removal */ +#define CTRL_UNLOCK 9 /* Unlock media removal */ +#define CTRL_EJECT 10 /* Eject media */ + +/* MMC/SDC specific command (Not used by FatFs) */ +#define MMC_GET_TYPE 50 /* Get card type */ +#define MMC_GET_CSD 51 /* Get CSD */ +#define MMC_GET_CID 52 /* Get CID */ +#define MMC_GET_OCR 53 /* Get OCR */ +#define MMC_GET_SDSTAT 54 /* Get SD status */ + +/* ATA/CF specific command (Not used by FatFs) */ +#define ATA_GET_REV 60 /* Get F/W revision */ +#define ATA_GET_MODEL 61 /* Get model name */ +#define ATA_GET_SN 62 /* Get serial number */ + +/* MMC card type flags (MMC_GET_TYPE) */ +#define CT_MMC 0x01 /* MMC ver 3 */ +#define CT_SD1 0x02 /* SD ver 1 */ +#define CT_SD2 0x04 /* SD ver 2 */ +#define CT_SDC (CT_SD1|CT_SD2) /* SD */ +#define CT_BLOCK 0x08 /* Block addressing */ + +#endif /* _DISKIO_H */ diff --git a/include/ff.h b/include/ff.h new file mode 100644 index 0000000..c19b7b5 --- /dev/null +++ b/include/ff.h @@ -0,0 +1,2 @@ +#include "../fatfs/src/ff.h" +#include "avr/ffconf.h" diff --git a/fatfs/src/integer.h b/include/integer.h similarity index 51% rename from fatfs/src/integer.h rename to include/integer.h index 074a46b..a263f7c 100644 --- a/fatfs/src/integer.h +++ b/include/integer.h @@ -5,29 +5,22 @@ #ifndef _FF_INTEGER #define _FF_INTEGER -#ifdef _WIN32 /* FatFs development platform */ - -#include -#include - -#else /* Embedded platform */ +#include /* This type MUST be 8 bit */ -typedef unsigned char BYTE; +typedef uint8_t BYTE; /* These types MUST be 16 bit */ -typedef short SHORT; -typedef unsigned short WORD; -typedef unsigned short WCHAR; +typedef int16_t SHORT; +typedef uint16_t WORD; +typedef uint16_t WCHAR; /* These types MUST be 16 bit or 32 bit */ -typedef int INT; +typedef int INT; typedef unsigned int UINT; /* These types MUST be 32 bit */ -typedef long LONG; -typedef unsigned long DWORD; - -#endif +typedef int32_t LONG; +typedef uint32_t DWORD; #endif diff --git a/include/spi.h b/include/spi.h new file mode 100644 index 0000000..04ea726 --- /dev/null +++ b/include/spi.h @@ -0,0 +1,54 @@ +/* + * spi.h + * + * Created on: 17.04.2009 + * Author: leo + */ + +#ifndef SPI_H_ +#define SPI_H_ + +#define SPI_PORT PORTB /* SPI Connection port */ +#define SPI_DDR DDRB /* SPI Direction port */ +#define SPI_SS 0 +#define SPI_SCK 1 +#define SPI_MOSI 2 +#define SPI_MISO 3 + + +/* SPI macros */ + +#define SPI_SET_SPEED_F_2 do {SPCR = (1<