mirror of
https://github.com/oopuuu/zTC1.git
synced 2025-12-17 07:28:14 +08:00
260 lines
8.8 KiB
C
260 lines
8.8 KiB
C
/**
|
|
******************************************************************************
|
|
* @file fatfs_to_block_device_driver.c
|
|
* @author You xx
|
|
* @version V1.0.0
|
|
* @date 20-Dec-2016
|
|
* @brief This file provide User API driver for FatFs
|
|
******************************************************************************
|
|
*
|
|
* UNPUBLISHED PROPRIETARY SOURCE CODE
|
|
* Copyright (c) 2016 MXCHIP Inc.
|
|
*
|
|
* The contents of this file may not be disclosed to third parties, copied or
|
|
* duplicated in any form, in whole or in part, without the prior written
|
|
* permission of MXCHIP Corporation.
|
|
******************************************************************************
|
|
*/
|
|
/** @file
|
|
* Block device driver for FatFs
|
|
* Provides the functions which are called by the bottom
|
|
* of FatFS
|
|
*/
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* Low level disk I/O module skeleton for FatFs (C)ChaN, 2014 */
|
|
/*-----------------------------------------------------------------------*/
|
|
/* 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 modules to the FatFs module with a defined API. */
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
#include "diskio.h" /* FatFs lower layer API */
|
|
#include "platform_block_device.h"
|
|
#include "mico_filesystem_internal.h"
|
|
#include "mico.h"
|
|
|
|
/******************************************************
|
|
* Macros
|
|
******************************************************/
|
|
|
|
/******************************************************
|
|
* Constants
|
|
******************************************************/
|
|
|
|
#define FATFS_WRITE_STRATEGY BLOCK_DEVICE_WRITE_IMMEDIATELY
|
|
|
|
/******************************************************
|
|
* Enumerations
|
|
******************************************************/
|
|
|
|
/******************************************************
|
|
* Type Definitions
|
|
******************************************************/
|
|
|
|
/******************************************************
|
|
* Structures
|
|
******************************************************/
|
|
|
|
/******************************************************
|
|
* Static Function Declarations
|
|
******************************************************/
|
|
|
|
/******************************************************
|
|
* Variable Definitions
|
|
******************************************************/
|
|
|
|
/******************************************************
|
|
* Function Definitions
|
|
******************************************************/
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* Get Drive Status */
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
DSTATUS disk_status(
|
|
void* user_data /* Physical drive nmuber to identify the drive */
|
|
)
|
|
{
|
|
OSStatus result;
|
|
mico_block_device_status_t status;
|
|
mico_block_device_t* device = (mico_block_device_t*) user_data;
|
|
|
|
/* Get the block device status */
|
|
result = device->driver->status( device, &status );
|
|
if ( result != kNoErr )
|
|
{
|
|
return STA_NOINIT;
|
|
}
|
|
|
|
/* Translate the status into a FatFS status */
|
|
if ( status == BLOCK_DEVICE_UNINITIALIZED )
|
|
{
|
|
return STA_NOINIT;
|
|
}
|
|
|
|
if ( status == BLOCK_DEVICE_DOWN )
|
|
{
|
|
return STA_NODISK;
|
|
}
|
|
|
|
if ( status == BLOCK_DEVICE_UP_READ_ONLY )
|
|
{
|
|
return STA_PROTECT;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* Inidialize a Drive */
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
DSTATUS disk_initialize(
|
|
void* user_data /* Physical drive nmuber to identify the drive */
|
|
)
|
|
{
|
|
mico_block_device_t* device = (mico_block_device_t*) user_data;
|
|
mico_result_t result;
|
|
|
|
/* Init the block device */
|
|
result = device->driver->init( device, FATFS_WRITE_STRATEGY );
|
|
if ( result != kNoErr )
|
|
{
|
|
return STA_NOINIT;
|
|
}
|
|
|
|
return disk_status( user_data );
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* Read Sector(s) */
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
DRESULT disk_read(
|
|
void* user_data, /* Physical drive nmuber to identify the drive */
|
|
FATFS_BYTE *buff, /* Data buffer to store read data */
|
|
FATFS_DWORD sector, /* Sector address in LBA */
|
|
FATFS_UINT count /* Number of sectors to read */
|
|
)
|
|
{
|
|
/* Read from the block device */
|
|
mico_result_t result;
|
|
mico_block_device_t* device = (mico_block_device_t*) user_data;
|
|
|
|
result = device->driver->read( device, sector * DEFAULT_SECTOR_SIZE, buff, count );
|
|
|
|
if ( result != kNoErr )
|
|
{
|
|
return RES_ERROR;
|
|
}
|
|
|
|
return RES_OK;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* Write Sector(s) */
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
#if _FS_READONLY == 0
|
|
DRESULT disk_write(
|
|
void* user_data, /* Physical drive nmuber to identify the drive */
|
|
const FATFS_BYTE *buff, /* Data to be written */
|
|
FATFS_DWORD sector, /* Sector address in LBA */
|
|
FATFS_UINT count /* Number of sectors to write */
|
|
)
|
|
{
|
|
/* Write to the block device */
|
|
mico_result_t result;
|
|
mico_block_device_t* device = (mico_block_device_t*) user_data;
|
|
|
|
result = device->driver->write( device, sector * DEFAULT_SECTOR_SIZE, buff, count );
|
|
|
|
if ( result != kNoErr )
|
|
{
|
|
return RES_ERROR;
|
|
}
|
|
|
|
return RES_OK;
|
|
}
|
|
#endif
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* Miscellaneous Functions */
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
#if !_FS_READONLY
|
|
DRESULT disk_ioctl(
|
|
void* user_data,
|
|
FATFS_BYTE cmd, /* Control code */
|
|
void *buff /* Buffer to send/receive control data */
|
|
)
|
|
{
|
|
/* Handle the various IOCTL's */
|
|
mico_block_device_t* device = (mico_block_device_t*) user_data;
|
|
mico_logic_partition_t *fatfs_partition;
|
|
fatfs_partition = MicoFlashGetInfo( MICO_PARTITION_FILESYS );
|
|
|
|
switch ( cmd )
|
|
{
|
|
case CTRL_SYNC: /* Complete pending write process (needed at _FS_READONLY == 0) */
|
|
{
|
|
if ( device->driver->flush( device ) != kNoErr )
|
|
{
|
|
return RES_ERROR;
|
|
}
|
|
}
|
|
break;
|
|
case GET_SECTOR_COUNT: /* Get media size (needed at _USE_MKFS == 1) */
|
|
{
|
|
FATFS_DWORD* number_of_sectors = (FATFS_DWORD*) buff;
|
|
|
|
if((device->device_size)>(fatfs_partition->partition_length))
|
|
{
|
|
*number_of_sectors = fatfs_partition->partition_length / DEFAULT_SECTOR_SIZE;
|
|
}
|
|
else
|
|
{
|
|
*number_of_sectors = device->device_size / DEFAULT_SECTOR_SIZE;
|
|
}
|
|
}
|
|
break;
|
|
case GET_SECTOR_SIZE: /* Get sector size (needed at _MAX_SS != _MIN_SS) */
|
|
// return RES_ERROR; /* TODO: Not implemented yet */
|
|
*(FATFS_DWORD*)buff = DEFAULT_SECTOR_SIZE;
|
|
break;
|
|
case GET_BLOCK_SIZE: /* Get erase block size (needed at _USE_MKFS == 1) */
|
|
{
|
|
FATFS_DWORD* block_size = (FATFS_DWORD*) buff;
|
|
*block_size = (device->erase_block_size == BLOCK_DEVICE_ERASE_NOT_REQUIRED) ? 1 : device->erase_block_size;
|
|
}
|
|
break;
|
|
case CTRL_TRIM: /* Inform device that the data on the block of sectors is no longer used (needed at _USE_TRIM == 1) */
|
|
{
|
|
FATFS_DWORD* start_end_sector = (FATFS_DWORD*) buff;
|
|
uint64_t start = start_end_sector[0] * start_end_sector[2];
|
|
uint64_t size = (start_end_sector[1] - start_end_sector[0]) * start_end_sector[2];
|
|
if ( (device->driver->erase != NULL) &&
|
|
(device->driver->erase( device, start, size ) != kNoErr) )
|
|
{
|
|
return RES_ERROR;
|
|
}
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
return RES_OK;
|
|
}
|
|
#endif
|
|
|
|
#if !_FS_READONLY && !_FS_NORTC
|
|
FATFS_DWORD get_fattime( void )
|
|
{
|
|
mico_time_t time = 0;
|
|
mico_time_get_time( &time );
|
|
return time;
|
|
}
|
|
#endif /* if !_FS_READONLY && !_FS_NORTC */
|