273 lines
8.1 KiB
C
273 lines
8.1 KiB
C
/*-----------------------------------------------------------------------*/
|
|
/* Low level disk I/O module skeleton for FatFs (C)ChaN, 2013 */
|
|
/*-----------------------------------------------------------------------*/
|
|
/* If a working storage control module is available, it should be */
|
|
/* attached to the FatFs via a glue function rather than modifying it. */
|
|
/* This is an example of glue functions to attach various exsisting */
|
|
/* storage control module to the FatFs module with a defined API. */
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include "ff.h" /* FatFs lower layer API */
|
|
#include "diskio.h" /* FatFs lower layer API */
|
|
|
|
PARTITION VolToPart[] = {
|
|
{0, 1}, // Logical drive 0 ==> Physical drive 0, 1st partition
|
|
/*
|
|
{0, 2}, // Logical drive 1 ==> Physical drive 0, 2nd partition
|
|
{0, 3}, // Logical drive 2 ==> Physical drive 0, 3rd partition
|
|
{1, 0}, // Logical drive 3 ==> Physical drive 1 (auto detection)
|
|
*/
|
|
};
|
|
|
|
#define PD_FLASH_SECTOR_SIZE (512)
|
|
#define PD_FLASH_PART1_START_SECTOR (0x100)
|
|
#define PD_FLASH_PART1_NUM_SECTORS (128) // 64k
|
|
#define PD_FLASH_MEM_START_ADDR (0x08020000) // 128k above start, first 128k block
|
|
|
|
#define PD_FLASH_RAM_BUF (0x10000000) // CCM data RAM, 64k
|
|
|
|
static void pd_flash_init() {
|
|
printf("IN\n");
|
|
// fill RAM buffer
|
|
uint32_t *src = (uint32_t*)PD_FLASH_MEM_START_ADDR;
|
|
uint32_t *dest = (uint32_t*)PD_FLASH_RAM_BUF;
|
|
for (int i = 0; i < PD_FLASH_PART1_NUM_SECTORS * PD_FLASH_SECTOR_SIZE / 4; i++) {
|
|
*dest++ = *src++;
|
|
}
|
|
}
|
|
|
|
extern void flash_write(uint32_t flash_dest, const uint32_t *src, uint32_t num_word32);
|
|
|
|
static void pd_flash_flush() {
|
|
printf("FL\n");
|
|
// sync the RAM buffer by writing it to the flash page
|
|
flash_write(PD_FLASH_MEM_START_ADDR, (const uint32_t*)PD_FLASH_RAM_BUF, PD_FLASH_PART1_NUM_SECTORS * PD_FLASH_SECTOR_SIZE / 4);
|
|
}
|
|
|
|
static void build_partition(uint8_t *buf, int boot, int type, uint32_t start_sector, uint32_t num_sectors) {
|
|
buf[0] = boot;
|
|
|
|
if (num_sectors == 0) {
|
|
buf[1] = 0;
|
|
buf[2] = 0;
|
|
buf[3] = 0;
|
|
} else {
|
|
buf[1] = 0xff;
|
|
buf[2] = 0xff;
|
|
buf[3] = 0xff;
|
|
}
|
|
|
|
buf[4] = type;
|
|
|
|
if (num_sectors == 0) {
|
|
buf[5] = 0;
|
|
buf[6] = 0;
|
|
buf[7] = 0;
|
|
} else {
|
|
buf[5] = 0xff;
|
|
buf[6] = 0xff;
|
|
buf[7] = 0xff;
|
|
}
|
|
|
|
buf[8] = start_sector;
|
|
buf[9] = start_sector >> 8;
|
|
buf[10] = start_sector >> 16;
|
|
buf[11] = start_sector >> 24;
|
|
|
|
buf[12] = num_sectors;
|
|
buf[13] = num_sectors >> 8;
|
|
buf[14] = num_sectors >> 16;
|
|
buf[15] = num_sectors >> 24;
|
|
}
|
|
|
|
static DRESULT pd_flash_read_sector(uint8_t *dest, uint32_t sector) {
|
|
//printf("RD %u\n", sector);
|
|
if (sector == 0) {
|
|
// fake the MBR so we can decide on our own partition table
|
|
|
|
for (int i = 0; i < 446; i++) {
|
|
dest[i] = 0;
|
|
}
|
|
|
|
build_partition(dest + 446, 0, 0x01 /* FAT12 */, PD_FLASH_PART1_START_SECTOR, PD_FLASH_PART1_NUM_SECTORS);
|
|
build_partition(dest + 462, 0, 0, 0, 0);
|
|
build_partition(dest + 478, 0, 0, 0, 0);
|
|
build_partition(dest + 494, 0, 0, 0, 0);
|
|
|
|
dest[510] = 0x55;
|
|
dest[511] = 0xaa;
|
|
|
|
return RES_OK;
|
|
|
|
} else if (PD_FLASH_PART1_START_SECTOR <= sector && sector < PD_FLASH_PART1_START_SECTOR + PD_FLASH_PART1_NUM_SECTORS) {
|
|
// non-MBR sector(s), just copy straight from flash
|
|
uint8_t *src = (uint8_t*)PD_FLASH_RAM_BUF + (sector - PD_FLASH_PART1_START_SECTOR) * PD_FLASH_SECTOR_SIZE;
|
|
for (int i = PD_FLASH_SECTOR_SIZE; i > 0; i--) {
|
|
*dest++ = *src++;
|
|
}
|
|
return RES_OK;
|
|
|
|
} else {
|
|
// bad sector number
|
|
return RES_ERROR;
|
|
}
|
|
}
|
|
|
|
static DRESULT pd_flash_write_sector(const uint8_t *src, uint32_t sector) {
|
|
printf("WR %u\n", sector);
|
|
if (sector == 0) {
|
|
// can't write MBR, but pretend we did
|
|
|
|
return RES_OK;
|
|
|
|
} else if (PD_FLASH_PART1_START_SECTOR <= sector && sector < PD_FLASH_PART1_START_SECTOR + PD_FLASH_PART1_NUM_SECTORS) {
|
|
// non-MBR sector(s), copy to RAM buffer
|
|
uint8_t *dest = (uint8_t*)PD_FLASH_RAM_BUF + (sector - PD_FLASH_PART1_START_SECTOR) * PD_FLASH_SECTOR_SIZE;
|
|
for (int i = PD_FLASH_SECTOR_SIZE; i > 0; i--) {
|
|
*dest++ = *src++;
|
|
}
|
|
return RES_OK;
|
|
|
|
} else {
|
|
// bad sector number
|
|
return RES_ERROR;
|
|
}
|
|
}
|
|
|
|
/* Definitions of physical drive number for each media */
|
|
#define PD_FLASH (0)
|
|
#define PD_SD (1)
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* Initialize a Drive */
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
DSTATUS disk_initialize (
|
|
BYTE pdrv /* Physical drive nmuber (0..) */
|
|
)
|
|
{
|
|
switch (pdrv) {
|
|
case PD_FLASH :
|
|
pd_flash_init();
|
|
return 0;
|
|
}
|
|
|
|
return STA_NOINIT;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* Get Disk Status */
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
DSTATUS disk_status (
|
|
BYTE pdrv /* Physical drive nmuber (0..) */
|
|
)
|
|
{
|
|
switch (pdrv) {
|
|
case PD_FLASH :
|
|
// flash is ready
|
|
return 0;
|
|
|
|
case PD_SD:
|
|
return STA_NOINIT;
|
|
}
|
|
|
|
return STA_NOINIT;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* Read Sector(s) */
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
DRESULT disk_read (
|
|
BYTE pdrv, /* Physical drive nmuber (0..) */
|
|
BYTE *buff, /* Data buffer to store read data */
|
|
DWORD sector, /* Sector address (LBA) */
|
|
UINT count /* Number of sectors to read (1..128) */
|
|
)
|
|
{
|
|
DRESULT res;
|
|
switch (pdrv) {
|
|
case PD_FLASH:
|
|
for (int i = 0; i < count; i++) {
|
|
if ((res = pd_flash_read_sector(buff + i * PD_FLASH_SECTOR_SIZE, sector + i)) != RES_OK) {
|
|
return res;
|
|
}
|
|
}
|
|
return RES_OK;
|
|
}
|
|
|
|
return RES_PARERR;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* Write Sector(s) */
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
#if _USE_WRITE
|
|
DRESULT disk_write (
|
|
BYTE pdrv, /* Physical drive nmuber (0..) */
|
|
const BYTE *buff, /* Data to be written */
|
|
DWORD sector, /* Sector address (LBA) */
|
|
UINT count /* Number of sectors to write (1..128) */
|
|
)
|
|
{
|
|
DRESULT res;
|
|
switch (pdrv) {
|
|
case PD_FLASH:
|
|
for (int i = 0; i < count; i++) {
|
|
if ((res = pd_flash_write_sector(buff + i * PD_FLASH_SECTOR_SIZE, sector + i)) != RES_OK) {
|
|
return res;
|
|
}
|
|
}
|
|
return RES_OK;
|
|
}
|
|
|
|
return RES_PARERR;
|
|
}
|
|
#endif
|
|
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* Miscellaneous Functions */
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
#if _USE_IOCTL
|
|
DRESULT disk_ioctl (
|
|
BYTE pdrv, /* Physical drive nmuber (0..) */
|
|
BYTE cmd, /* Control code */
|
|
void *buff /* Buffer to send/receive control data */
|
|
)
|
|
{
|
|
switch (pdrv) {
|
|
case PD_FLASH:
|
|
switch (cmd) {
|
|
case CTRL_SYNC:
|
|
pd_flash_flush();
|
|
return RES_OK;
|
|
|
|
case GET_BLOCK_SIZE:
|
|
*((DWORD*)buff) = 1; // block erase size in units of the sector size
|
|
return RES_OK;
|
|
}
|
|
}
|
|
|
|
return RES_PARERR;
|
|
}
|
|
#endif
|
|
|
|
DWORD get_fattime (
|
|
void
|
|
)
|
|
{
|
|
int year = 2013;
|
|
int month = 10;
|
|
int day = 12;
|
|
int hour = 21;
|
|
int minute = 42;
|
|
int second = 13;
|
|
return ((year - 1980) << 25) | ((month) << 21) | ((day) << 16) | ((hour) << 11) | ((minute) << 5) | (second / 2);
|
|
}
|