pure sdk for main

sdk/lib/fs/fatfs/diskio.c

@@ -0,0 +1,105 @@
+/*-----------------------------------------------------------------------*/
+/* Low level disk I/O module skeleton for FatFs     (C)ChaN, 2016        */
+/*-----------------------------------------------------------------------*/
+/* 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 */
+
+
+
+
+/* Definitions of physical drive number for each drive */
+
+#define FATFS_MAX_DRIVE_NUM 4
+static struct fatfs_diskio* phys_drive[FATFS_MAX_DRIVE_NUM];
+static void* phys_device[FATFS_MAX_DRIVE_NUM];
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Get Drive Status                                                      */
+/*-----------------------------------------------------------------------*/
+
+DSTATUS disk_status(BYTE pdrv /* Physical drive nmuber to identify the drive */
+                    )
+{
+  if(pdrv >= FATFS_MAX_DRIVE_NUM || NULL == phys_drive[pdrv] || NULL == phys_drive[pdrv]->status)
+    return STA_NOINIT;
+
+  return (*phys_drive[pdrv]->status)(phys_device[pdrv]);
+}
+
+/*-----------------------------------------------------------------------*/
+/* Inidialize a Drive                                                    */
+/*-----------------------------------------------------------------------*/
+
+DSTATUS disk_initialize(BYTE pdrv /* Physical drive nmuber to identify the drive */
+                        )
+{
+  if(pdrv >= FATFS_MAX_DRIVE_NUM || NULL == phys_drive[pdrv] || NULL == phys_drive[pdrv]->init)
+    return STA_NOINIT;
+
+  return (*phys_drive[pdrv]->init)(phys_device[pdrv]);
+}
+
+/*-----------------------------------------------------------------------*/
+/* Read Sector(s)                                                        */
+/*-----------------------------------------------------------------------*/
+
+DRESULT disk_read(BYTE pdrv,    /* Physical drive nmuber to identify the drive */
+                  BYTE* buff,   /* Data buffer to store read data */
+                  DWORD sector, /* Start sector in LBA */
+                  UINT count    /* Number of sectors to read */
+                  )
+{
+  if(pdrv >= FATFS_MAX_DRIVE_NUM || NULL == phys_drive[pdrv] || NULL == phys_drive[pdrv]->read)
+    return RES_PARERR;
+
+  return (*phys_drive[pdrv]->read)(phys_device[pdrv], buff, sector, count);
+
+}
+
+/*-----------------------------------------------------------------------*/
+/* Write Sector(s)                                                       */
+/*-----------------------------------------------------------------------*/
+
+DRESULT disk_write(BYTE pdrv,        /* Physical drive nmuber to identify the drive */
+                   const BYTE* buff, /* Data to be written */
+                   DWORD sector,     /* Start sector in LBA */
+                   UINT count        /* Number of sectors to write */
+                   )
+{
+  if(pdrv >= FATFS_MAX_DRIVE_NUM || NULL == phys_drive[pdrv] || NULL == phys_drive[pdrv]->write)
+    return RES_PARERR;
+  	
+  return (*phys_drive[pdrv]->write)(phys_device[pdrv], (BYTE*)buff, sector, count);
+}
+
+/*-----------------------------------------------------------------------*/
+/* Miscellaneous Functions                                               */
+/*-----------------------------------------------------------------------*/
+
+DRESULT disk_ioctl(BYTE pdrv, /* Physical drive nmuber (0..) */
+                   BYTE cmd,  /* Control code */
+                   void* buff /* Buffer to send/receive control data */
+                   )
+{
+  if(pdrv >= FATFS_MAX_DRIVE_NUM || NULL == phys_drive[pdrv] || NULL == phys_drive[pdrv]->ioctl)
+    return RES_PARERR;
+
+  return (*phys_drive[pdrv]->ioctl)(phys_device[pdrv], cmd, buff);
+}
+
+void fatfs_register_drive(BYTE pdrv, struct fatfs_diskio* driver, void *device)
+{
+  if(pdrv < FATFS_MAX_DRIVE_NUM) {
+    phys_drive[pdrv]  = driver;
+    phys_device[pdrv] = device;
+  }// else
+    //TEST_INFO_SHOW("Drive Number %d too large", pdrv);
+}

sdk/lib/fs/fatfs/diskio.h

@@ -0,0 +1,98 @@
+/*-----------------------------------------------------------------------/
+/  Low level disk interface modlue include file   (C)ChaN, 2014          /
+/-----------------------------------------------------------------------*/
+
+#ifndef _DISKIO_DEFINED
+#define _DISKIO_DEFINED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "integer.h"
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
+
+#define DEV_RAM 0 /* Example: Map Ramdisk to physical drive 0 */
+#define DEV_FLASH 1 /* Example: Map MMC/SD card to physical drive 1 */
+#define DEV_USB 2 /* Example: Map USB MSD to physical drive 2 */
+
+
+/* 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 */
+#define ISDIO_READ 55     /* Read data form SD iSDIO register */
+#define ISDIO_WRITE 56    /* Write data to SD iSDIO register */
+#define ISDIO_MRITE 57    /* Masked write data to SD iSDIO register */
+
+/* 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 */
+
+typedef DSTATUS (*fatfs_disk_status)(void*);
+typedef DSTATUS (*fatfs_disk_initialize)(void*);
+typedef DRESULT (*fatfs_disk_read)(void*, BYTE*, DWORD, UINT);
+typedef DRESULT (*fatfs_disk_write)(void*,BYTE*, DWORD, UINT);
+typedef DRESULT (*fatfs_disk_ioctl)(void*, BYTE, void*);
+struct fatfs_diskio {
+  fatfs_disk_status status;
+  fatfs_disk_initialize init;
+  fatfs_disk_read read;
+  fatfs_disk_write write;
+  fatfs_disk_ioctl ioctl;
+};
+void fatfs_register_drive(BYTE, struct fatfs_diskio*, void*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

sdk/lib/fs/fatfs/fatfs_test.c

@@ -0,0 +1,180 @@
+#include "sys_config.h"
+
+#include "integer.h"
+#include "diskio.h"
+#include "ff.h"
+#include <stdio.h>
+#include "osal/sleep.h"
+#include "typesdef.h"
+#include "osal/task.h"
+#include "osal/semaphore.h"
+#include "osal/mutex.h"
+#include "list.h"
+#include "dev.h"
+#include "sdhost.h"
+#include "devid.h"
+#include "osal/string.h"
+//#include "test.h"
+
+//#include "osal.h"
+#define TEST_INFO_SHOW(...) 
+#if FS_EN
+
+
+static DSTATUS fatfs_status(void *status);
+static DSTATUS fatfs_init(void *init_dev);
+static DRESULT fatfs_read(void *dev, BYTE* buf, DWORD sector, UINT count);
+static DRESULT fatfs_write(void *dev, BYTE* buf, DWORD sector, UINT count);
+static DRESULT fatfs_ioctl(void *init_dev, BYTE cmd, void* buf);
+uint32 get_sdhost_status(struct sdh_device *host);
+uint32 sd_tran_stop(struct sdh_device * host);
+static struct fatfs_diskio sdcdisk_driver = {
+  .status = fatfs_status,
+  .init = fatfs_init,
+  .read = fatfs_read,
+  .write = fatfs_write,
+  .ioctl = fatfs_ioctl
+}; 
+
+static FATFS fatfs[1];
+
+DWORD get_fatbase(int num)
+{
+	return fatfs[num].fatbase;
+}
+
+
+DWORD get_fatfree(int num)
+{
+	DWORD fre_clust,fre_sect, tot_sect;
+	FATFS *fs = &fatfs[num];
+	fre_clust = fs->free_clst;
+	tot_sect = (fs->n_fatent - 2) * fs->csize;
+	fre_sect = fre_clust * fs->csize;
+	printf("%s %ldKB\n",__FUNCTION__,fre_sect>>1);
+	return fre_sect>>1;
+}
+
+
+
+static DSTATUS fatfs_status(void *status){
+	//TEST_INFO_SHOW ("fatfs_status_test\r\n");
+	uint32 err = get_sdhost_status(status);
+	return err;
+}
+
+static DSTATUS fatfs_init(void *init_dev){
+	//TEST_INFO_SHOW ("fatfs_init_test\r\n");
+	uint32 err;
+	err = sdhost_init(48*1000*1000);
+	return err;
+}
+
+static DRESULT fatfs_read(void *dev, BYTE* buf, DWORD sector, UINT count){
+	int err;
+	TEST_INFO_SHOW ("fatfs_read_test:%d %x %d\r\n",sector,buf,count);
+	err = sd_multiple_read((struct sdh_device*)dev,sector,count*512,buf);
+	
+	return err;
+}
+
+static DRESULT fatfs_write(void *dev, BYTE* buf, DWORD sector, UINT count){
+	int err;
+	TEST_INFO_SHOW ("fatfs_write_test:%d %x %d\r\n",sector,buf,count);
+	err = sd_multiple_write((struct sdh_device*)dev,sector,count*512,buf);
+	return err;	
+}  
+
+extern unsigned int sd_dwCap;
+extern uint32 fatfs_sd_tran_stop(struct sdh_device * host);
+static DRESULT fatfs_ioctl(void *init_dev, BYTE cmd, void* buf){
+	uint8 ret	= RES_OK;
+	switch(cmd)
+    {
+		case CTRL_SYNC:
+			fatfs_sd_tran_stop(init_dev);
+			break;
+		case GET_SECTOR_COUNT:
+			*(DWORD *)buf = sd_dwCap*2;	
+			ret = RES_OK;
+			break;
+
+		case GET_SECTOR_SIZE:
+			*(WORD *)buf = 512;
+			ret = RES_OK;
+			
+			break;
+		case GET_BLOCK_SIZE:
+			*(DWORD *)buf = 4;
+			// printf("*0B:%d\n",*B);
+			ret = RES_OK;
+			break;
+
+				
+		default:
+			ret = RES_ERROR;            //not finish
+			printf("rtos_sd_ioctl err\n");
+			break;
+    }
+	return ret;
+
+}
+
+
+bool fatfs_register(){
+
+	int ret = 1;
+	struct sdh_device *fatfs_sdh;
+	TEST_INFO_SHOW("enter %s test\r\n",__func__);
+	fatfs_sdh = (struct sdh_device *)dev_get(HG_SDIOHOST_DEVID);
+	if(fatfs_sdh)
+	{
+		fatfs_register_drive(0,&sdcdisk_driver,fatfs_sdh);
+		ret = f_mount (&fatfs[0],_SYSDSK_, 1);
+		if (ret) {
+			printf("%s ret:%d\n",__FUNCTION__,ret);
+			f_mount (NULL,_SYSDSK_, 0);
+			return ret;
+		}	
+	}
+	
+	return ret;
+
+}
+
+void fatfs_unregister_loop()
+{
+	int ret = 1;
+	struct sdh_device *fatfs_sdh;
+	fatfs_sdh = (struct sdh_device *)dev_get(HG_SDIOHOST_DEVID);
+	if(fatfs_sdh)
+	{
+		ret = f_mount (NULL,_SYSDSK_, 0);
+		if (ret) {
+			printf("%s ret:%d\n",__FUNCTION__,ret);
+			return ;
+		}	
+	}
+}
+
+void fatfs_unregister()
+{
+	int ret = 1;
+	struct sdh_device *fatfs_sdh;
+	fatfs_sdh = (struct sdh_device *)dev_get(HG_SDIOHOST_DEVID);
+	if(fatfs_sdh)
+	{
+		//sd卡的锁移除
+		sdhost_deinit_for_sleep();
+		ret = f_mount (NULL,_SYSDSK_, 0);
+		if (ret) {
+			printf("%s ret:%d\n",__FUNCTION__,ret);
+			return ;
+		}	
+
+
+	}
+}
+
+#endif
+

sdk/lib/fs/fatfs/ff.h

@@ -0,0 +1,375 @@
+/*----------------------------------------------------------------------------/
+/  FatFs - Generic FAT Filesystem module  R0.13                               /
+/-----------------------------------------------------------------------------/
+/
+/ Copyright (C) 2017, ChaN, all right reserved.
+/
+/ FatFs module is an open source software. Redistribution and use of FatFs in
+/ source and binary forms, with or without modification, are permitted provided
+/ that the following condition is met:
+
+/ 1. Redistributions of source code must retain the above copyright notice,
+/    this condition and the following disclaimer.
+/
+/ This software is provided by the copyright holder and contributors "AS IS"
+/ and any warranties related to this software are DISCLAIMED.
+/ The copyright owner or contributors be NOT LIABLE for any damages caused
+/ by use of this software.
+/
+/----------------------------------------------------------------------------*/
+
+
+#ifndef FF_DEFINED
+#define FF_DEFINED	87030	/* Revision ID */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "integer.h"	/* Basic integer types */
+#include "ffconf.h"		/* FatFs configuration options */
+
+#if FF_DEFINED != FFCONF_DEF
+#error Wrong configuration file (ffconf.h).
+#endif
+
+
+
+/* Definitions of volume management */
+
+#if FF_MULTI_PARTITION		/* Multiple partition configuration */
+typedef struct {
+	BYTE pd;	/* Physical drive number */
+	BYTE pt;	/* Partition: 0:Auto detect, 1-4:Forced partition) */
+} PARTITION;
+extern PARTITION VolToPart[];	/* Volume - Partition resolution table */
+#endif
+
+
+
+/* Type of path name strings on FatFs API */
+
+#if FF_LFN_UNICODE && FF_USE_LFN	/* Unicode (UTF-16) string */
+#ifndef _INC_TCHAR
+typedef WCHAR TCHAR;
+#define _T(x) L ## x
+#define _TEXT(x) L ## x
+#define _INC_TCHAR
+#endif
+#else						/* ANSI/OEM string */
+#ifndef _INC_TCHAR
+typedef char TCHAR;
+#define _T(x) x
+#define _TEXT(x) x
+#define _INC_TCHAR
+#endif
+#endif
+
+
+
+/* Type of file size variables */
+
+#if FF_FS_EXFAT
+#if !FF_USE_LFN
+#error LFN must be enabled when enable exFAT
+#endif
+typedef QWORD FSIZE_t;
+#else
+typedef DWORD FSIZE_t;
+#endif
+
+
+
+/* Filesystem object structure (FATFS) */
+
+typedef struct {
+	BYTE	fs_type;		/* Filesystem type (0:N/A) */
+	BYTE	pdrv;			/* Physical drive number */
+	BYTE	n_fats;			/* Number of FATs (1 or 2) */
+	BYTE	wflag;			/* win[] flag (b0:dirty) */
+	BYTE	fsi_flag;		/* FSINFO flags (b7:disabled, b0:dirty) */
+	WORD	id;				/* Volume mount ID */
+	WORD	n_rootdir;		/* Number of root directory entries (FAT12/16) */
+	WORD	csize;			/* Cluster size [sectors] */
+#if FF_MAX_SS != FF_MIN_SS
+	WORD	ssize;			/* Sector size (512, 1024, 2048 or 4096) */
+#endif
+#if FF_USE_LFN
+	WCHAR*	lfnbuf;			/* LFN working buffer */
+#endif
+#if FF_FS_EXFAT
+	BYTE*	dirbuf;			/* Directory entry block scratchpad buffer for exFAT */
+#endif
+#if FF_FS_REENTRANT
+	FF_SYNC_t	sobj;		/* Identifier of sync object */
+#endif
+#if !FF_FS_READONLY
+	DWORD	last_clst;		/* Last allocated cluster */
+	DWORD	free_clst;		/* Number of free clusters */
+#endif
+#if FF_FS_RPATH
+	DWORD	cdir;			/* Current directory start cluster (0:root) */
+#if FF_FS_EXFAT
+	DWORD	cdc_scl;		/* Containing directory start cluster (invalid when cdir is 0) */
+	DWORD	cdc_size;		/* b31-b8:Size of containing directory, b7-b0: Chain status */
+	DWORD	cdc_ofs;		/* Offset in the containing directory (invalid when cdir is 0) */
+#endif
+#endif
+	DWORD	n_fatent;		/* Number of FAT entries (number of clusters + 2) */
+	DWORD	fsize;			/* Size of an FAT [sectors] */
+	DWORD	volbase;		/* Volume base sector */
+	DWORD	fatbase;		/* FAT base sector */
+	DWORD	dirbase;		/* Root directory base sector/cluster */
+	DWORD	database;		/* Data base sector */
+	DWORD	winsect;		/* Current sector appearing in the win[] */
+	__attribute__ ((aligned(16))) BYTE	win[FF_MAX_SS];	/* Disk access window for Directory, FAT (and file data at tiny cfg) */
+} FATFS;
+
+
+
+/* Object ID and allocation information (FFOBJID) */
+
+typedef struct {
+	FATFS*	fs;				/* Pointer to the hosting volume of this object */
+	WORD	id;				/* Hosting volume mount ID */
+	BYTE	attr;			/* Object attribute */
+	BYTE	stat;			/* Object chain status (b1-0: =0:not contiguous, =2:contiguous, =3:flagmented in this session, b2:sub-directory stretched) */
+	DWORD	sclust;			/* Object data start cluster (0:no cluster or root directory) */
+	FSIZE_t	objsize;		/* Object size (valid when sclust != 0) */
+#if FF_FS_EXFAT
+	DWORD	n_cont;			/* Size of first fragment - 1 (valid when stat == 3) */
+	DWORD	n_frag;			/* Size of last fragment needs to be written to FAT (valid when not zero) */
+	DWORD	c_scl;			/* Containing directory start cluster (valid when sclust != 0) */
+	DWORD	c_size;			/* b31-b8:Size of containing directory, b7-b0: Chain status (valid when c_scl != 0) */
+	DWORD	c_ofs;			/* Offset in the containing directory (valid when file object and sclust != 0) */
+#endif
+#if FF_FS_LOCK
+	UINT	lockid;			/* File lock ID origin from 1 (index of file semaphore table Files[]) */
+#endif
+} FFOBJID;
+
+
+
+/* File object structure (FIL) */
+
+typedef struct {
+	FFOBJID	obj;			/* Object identifier (must be the 1st member to detect invalid object pointer) */
+	BYTE	flag;			/* File status flags */
+	BYTE	err;			/* Abort flag (error code) */
+	FSIZE_t	fptr;			/* File read/write pointer (Zeroed on file open) */
+	DWORD	clust;			/* Current cluster of fpter (invalid when fptr is 0) */
+	DWORD	sect;			/* Sector number appearing in buf[] (0:invalid) */
+#if !FF_FS_READONLY
+	DWORD	dir_sect;		/* Sector number containing the directory entry (not used at exFAT) */
+	BYTE*	dir_ptr;		/* Pointer to the directory entry in the win[] (not used at exFAT) */
+#endif
+#if FF_USE_FASTSEEK
+	DWORD*	cltbl;			/* Pointer to the cluster link map table (nulled on open, set by application) */
+#endif
+#if !FF_FS_TINY
+	BYTE	buf[FF_MAX_SS];	/* File private data read/write window */
+#endif
+} FIL;
+
+
+
+/* Directory object structure (DIR) */
+
+typedef struct {
+	FFOBJID	obj;			/* Object identifier */
+	DWORD	dptr;			/* Current read/write offset */
+	DWORD	clust;			/* Current cluster */
+	DWORD	sect;			/* Current sector (0:Read operation has terminated) */
+	BYTE*	dir;			/* Pointer to the directory item in the win[] */
+	BYTE	fn[12];			/* SFN (in/out) {body[8],ext[3],status[1]} */
+#if FF_USE_LFN
+	DWORD	blk_ofs;		/* Offset of current entry block being processed (0xFFFFFFFF:Invalid) */
+#endif
+#if FF_USE_FIND
+	const TCHAR* pat;		/* Pointer to the name matching pattern */
+#endif
+} DIR;
+
+
+
+/* File information structure (FILINFO) */
+
+typedef struct {
+	FSIZE_t	fsize;			/* File size */
+	WORD	fdate;			/* Modified date */
+	WORD	ftime;			/* Modified time */
+	BYTE	fattrib;		/* File attribute */
+#if FF_USE_LFN
+	TCHAR	altname[13];			/* Altenative file name */
+	TCHAR	fname[FF_MAX_LFN + 1];	/* Primary file name */
+#else
+	TCHAR	fname[13];		/* File name */
+#endif
+} FILINFO;
+
+
+
+/* File function return code (FRESULT) */
+
+typedef enum {
+	FR_OK = 0,				/* (0) Succeeded */
+	FR_DISK_ERR,			/* (1) A hard error occurred in the low level disk I/O layer */
+	FR_INT_ERR,				/* (2) Assertion failed */
+	FR_NOT_READY,			/* (3) The physical drive cannot work */
+	FR_NO_FILE,				/* (4) Could not find the file */
+	FR_NO_PATH,				/* (5) Could not find the path */
+	FR_INVALID_NAME,		/* (6) The path name format is invalid */
+	FR_DENIED,				/* (7) Access denied due to prohibited access or directory full */
+	FR_EXIST,				/* (8) Access denied due to prohibited access */
+	FR_INVALID_OBJECT,		/* (9) The file/directory object is invalid */
+	FR_WRITE_PROTECTED,		/* (10) The physical drive is write protected */
+	FR_INVALID_DRIVE,		/* (11) The logical drive number is invalid */
+	FR_NOT_ENABLED,			/* (12) The volume has no work area */
+	FR_NO_FILESYSTEM,		/* (13) There is no valid FAT volume */
+	FR_MKFS_ABORTED,		/* (14) The f_mkfs() aborted due to any problem */
+	FR_TIMEOUT,				/* (15) Could not get a grant to access the volume within defined period */
+	FR_LOCKED,				/* (16) The operation is rejected according to the file sharing policy */
+	FR_NOT_ENOUGH_CORE,		/* (17) LFN working buffer could not be allocated */
+	FR_TOO_MANY_OPEN_FILES,	/* (18) Number of open files > FF_FS_LOCK */
+	FR_INVALID_PARAMETER	/* (19) Given parameter is invalid */
+} FRESULT;
+
+
+
+/*--------------------------------------------------------------*/
+/* FatFs module application interface                           */
+
+FRESULT f_open (FIL* fp, const TCHAR* path, BYTE mode);				/* Open or create a file */
+FRESULT f_close (FIL* fp);											/* Close an open file object */
+FRESULT f_read (FIL* fp, void* buff, UINT btr, UINT* br);			/* Read data from the file */
+FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw);	/* Write data to the file */
+FRESULT f_lseek (FIL* fp, FSIZE_t ofs);								/* Move file pointer of the file object */
+FRESULT f_truncate (FIL* fp);										/* Truncate the file */
+FRESULT f_sync (FIL* fp);											/* Flush cached data of the writing file */
+FRESULT f_opendir (DIR* dp, const TCHAR* path);						/* Open a directory */
+FRESULT f_closedir (DIR* dp);										/* Close an open directory */
+FRESULT f_readdir (DIR* dp, FILINFO* fno);							/* Read a directory item */
+FRESULT f_findfirst (DIR* dp, FILINFO* fno, const TCHAR* path, const TCHAR* pattern);	/* Find first file */
+FRESULT f_findnext (DIR* dp, FILINFO* fno);							/* Find next file */
+FRESULT f_mkdir (const TCHAR* path);								/* Create a sub directory */
+FRESULT f_unlink (const TCHAR* path);								/* Delete an existing file or directory */
+FRESULT f_rename (const TCHAR* path_old, const TCHAR* path_new);	/* Rename/Move a file or directory */
+FRESULT f_stat (const TCHAR* path, FILINFO* fno);					/* Get file status */
+FRESULT f_chmod (const TCHAR* path, BYTE attr, BYTE mask);			/* Change attribute of a file/dir */
+FRESULT f_utime (const TCHAR* path, const FILINFO* fno);			/* Change timestamp of a file/dir */
+FRESULT f_chdir (const TCHAR* path);								/* Change current directory */
+FRESULT f_chdrive (const TCHAR* path);								/* Change current drive */
+FRESULT f_getcwd (TCHAR* buff, UINT len);							/* Get current directory */
+FRESULT f_getfree (const TCHAR* path, DWORD* nclst, FATFS** fatfs);	/* Get number of free clusters on the drive */
+FRESULT f_getlabel (const TCHAR* path, TCHAR* label, DWORD* vsn);	/* Get volume label */
+FRESULT f_setlabel (const TCHAR* label);							/* Set volume label */
+FRESULT f_forward (FIL* fp, UINT(*func)(const BYTE*,UINT), UINT btf, UINT* bf);	/* Forward data to the stream */
+FRESULT f_expand (FIL* fp, FSIZE_t szf, BYTE opt);					/* Allocate a contiguous block to the file */
+FRESULT f_mount (FATFS* fs, const TCHAR* path, BYTE opt);			/* Mount/Unmount a logical drive */
+FRESULT f_mkfs (const TCHAR* path, BYTE opt, DWORD au, void* work, UINT len);	/* Create a FAT volume */
+FRESULT f_fdisk (BYTE pdrv, const DWORD* szt, void* work);			/* Divide a physical drive into some partitions */
+FRESULT f_setcp (WORD cp);											/* Set current code page */
+int f_putc (TCHAR c, FIL* fp);										/* Put a character to the file */
+int f_puts (const TCHAR* str, FIL* cp);								/* Put a string to the file */
+int f_printf (FIL* fp, const TCHAR* str, ...);						/* Put a formatted string to the file */
+TCHAR* f_gets (TCHAR* buff, int len, FIL* fp);						/* Get a string from the file */
+DWORD clust2sect (FATFS* fs,DWORD clst);
+
+int f_eof(FIL* fp);
+int f_error(FIL* fp);
+unsigned int f_size(FIL *fp);
+void f_rewind(FIL *fp);
+void f_rewinddir(DIR *dp);
+int f_rmdir( const char *dirname);
+int f_umount(const char *target);
+long int f_tell(FIL *fp);
+
+#ifndef EOF
+#define EOF (-1)
+#endif
+
+
+
+
+/*--------------------------------------------------------------*/
+/* Additional user defined functions                            */
+
+/* RTC function */
+#if !FF_FS_READONLY && !FF_FS_NORTC
+DWORD get_fattime (void);
+#endif
+
+/* LFN support functions */
+#if FF_USE_LFN						/* Code conversion (defined in unicode.c) */
+WCHAR ff_oem2uni (WCHAR oem, WORD cp);	/* OEM code to Unicode conversion */
+WCHAR ff_uni2oem (WCHAR uni, WORD cp);	/* Unicode to OEM code conversion */
+WCHAR ff_wtoupper (WCHAR uni);			/* Unicode upper-case conversion */
+#endif
+#if FF_USE_LFN == 3						/* Dynamic memory allocation */
+void* ff_memalloc (UINT msize);			/* Allocate memory block */
+void ff_memfree (void* mblock);			/* Free memory block */
+#endif
+
+/* Sync functions */
+#if FF_FS_REENTRANT
+int ff_cre_syncobj (BYTE vol, FF_SYNC_t* sobj);	/* Create a sync object */
+int ff_req_grant (FF_SYNC_t sobj);		/* Lock sync object */
+void ff_rel_grant (FF_SYNC_t sobj);		/* Unlock sync object */
+int ff_del_syncobj (FF_SYNC_t sobj);	/* Delete a sync object */
+#endif
+
+FRESULT f_system_status(FATFS* fs,const TCHAR* path);
+int f_ioctl(FIL *fp, long cmd, void *argp);
+int f_cntl(FIL *fp, int cmd, long arg);;
+
+
+
+#define _SYSDSK_ "0:"
+#define _DATDSK_ "1:"
+
+
+
+
+
+/*--------------------------------------------------------------*/
+/* Flags and offset address                                     */
+
+
+/* File access mode and open method flags (3rd argument of f_open) */
+#define	FA_READ				0x01
+#define	FA_WRITE			0x02
+#define	FA_OPEN_EXISTING	0x00
+#define	FA_CREATE_NEW		0x04
+#define	FA_CREATE_ALWAYS	0x08
+#define	FA_OPEN_ALWAYS		0x10
+#define	FA_OPEN_APPEND		0x30
+
+/* Fast seek controls (2nd argument of f_lseek) */
+#define CREATE_LINKMAP	((FSIZE_t)0 - 1)
+
+/* Format options (2nd argument of f_mkfs) */
+#define FM_FAT		0x01
+#define FM_FAT32	0x02
+#define FM_EXFAT	0x04
+#define FM_ANY		0x07
+#define FM_SFD		0x08
+
+/* Filesystem type (FATFS.fs_type) */
+#define FS_FAT12	1
+#define FS_FAT16	2
+#define FS_FAT32	3
+#define FS_EXFAT	4
+
+/* File attribute bits for directory entry (FILINFO.fattrib) */
+#define	AM_RDO	0x01	/* Read only */
+#define	AM_HID	0x02	/* Hidden */
+#define	AM_SYS	0x04	/* System */
+#define AM_DIR	0x10	/* Directory */
+#define AM_ARC	0x20	/* Archive */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FF_DEFINED */

sdk/lib/fs/fatfs/ffconf.h

@@ -0,0 +1,276 @@
+/*---------------------------------------------------------------------------/
+/  FatFs - Configuration file
+/---------------------------------------------------------------------------*/
+//#include "osal/osal_sema.h"
+//#include "board_config.h"
+
+
+#define FFCONF_DEF 87030	/* Revision ID */
+
+/*---------------------------------------------------------------------------/
+/ Function Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_FS_READONLY	0
+/* This option switches read-only configuration. (0:Read/Write or 1:Read-only)
+/  Read-only configuration removes writing API functions, f_write(), f_sync(),
+/  f_unlink(), f_mkdir(), f_chmod(), f_rename(), f_truncate(), f_getfree()
+/  and optional writing functions as well. */
+
+
+#define FF_FS_MINIMIZE	0
+/* This option defines minimization level to remove some basic API functions.
+/
+/   0: All basic functions are enabled.
+/   1: f_stat(), f_getfree(), f_unlink(), f_mkdir(), f_truncate() and f_rename()
+/      are removed.
+/   2: f_opendir(), f_readdir() and f_closedir() are removed in addition to 1.
+/   3: f_lseek() function is removed in addition to 2. */
+
+
+#define FF_USE_STRFUNC	1
+/* This option switches string functions, f_gets(), f_putc(), f_puts() and f_printf().
+/
+/  0: Disable string functions.
+/  1: Enable without LF-CRLF conversion.
+/  2: Enable with LF-CRLF conversion. */
+
+
+#define FF_USE_FIND		1
+/* This option switches filtered directory read functions, f_findfirst() and
+/  f_findnext(). (0:Disable, 1:Enable 2:Enable with matching altname[] too) */
+
+
+#define FF_USE_MKFS		1
+/* This option switches f_mkfs() function. (0:Disable or 1:Enable) */
+
+
+#define FF_USE_FASTSEEK	0
+/* This option switches fast seek function. (0:Disable or 1:Enable) */
+
+
+#define FF_USE_EXPAND	0
+/* This option switches f_expand function. (0:Disable or 1:Enable) */
+
+
+#define FF_USE_CHMOD	1
+/* This option switches attribute manipulation functions, f_chmod() and f_utime().
+/  (0:Disable or 1:Enable) Also FF_FS_READONLY needs to be 0 to enable this option. */
+
+
+#define FF_USE_LABEL	0
+/* This option switches volume label functions, f_getlabel() and f_setlabel().
+/  (0:Disable or 1:Enable) */
+
+
+#define FF_USE_FORWARD	0
+/* This option switches f_forward() function. (0:Disable or 1:Enable) */
+
+
+/*---------------------------------------------------------------------------/
+/ Locale and Namespace Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_CODE_PAGE	936
+/* This option specifies the OEM code page to be used on the target system.
+/  Incorrect code page setting can cause a file open failure.
+/
+/   437 - U.S.
+/   720 - Arabic
+/   737 - Greek
+/   771 - KBL
+/   775 - Baltic
+/   850 - Latin 1
+/   852 - Latin 2
+/   855 - Cyrillic
+/   857 - Turkish
+/   860 - Portuguese
+/   861 - Icelandic
+/   862 - Hebrew
+/   863 - Canadian French
+/   864 - Arabic
+/   865 - Nordic
+/   866 - Russian
+/   869 - Greek 2
+/   932 - Japanese (DBCS)
+/   936 - Simplified Chinese (DBCS)
+/   949 - Korean (DBCS)
+/   950 - Traditional Chinese (DBCS)
+/     0 - Include all code pages above and configured by f_setcp()
+*/
+
+
+#define FF_USE_LFN		0//2
+#define FF_MAX_LFN		255
+/* The FF_USE_LFN switches the support for LFN (long file name).
+/
+/   0: Disable LFN. FF_MAX_LFN has no effect.
+/   1: Enable LFN with static working buffer on the BSS. Always NOT thread-safe.
+/   2: Enable LFN with dynamic working buffer on the STACK.
+/   3: Enable LFN with dynamic working buffer on the HEAP.
+/
+/  To enable the LFN, Unicode handling functions (option/unicode.c) must be added
+/  to the project. The working buffer occupies (FF_MAX_LFN + 1) * 2 bytes and
+/  additional 608 bytes at exFAT enabled. FF_MAX_LFN can be in range from 12 to 255.
+/  It should be set 255 to support full featured LFN operations.
+/  When use stack for the working buffer, take care on stack overflow. When use heap
+/  memory for the working buffer, memory management functions, ff_memalloc() and
+/  ff_memfree(), must be added to the project. */
+
+
+#define FF_LFN_UNICODE	0
+/* This option switches character encoding on the API, 0:ANSI/OEM or 1:UTF-16,
+/  when LFN is enabled. Also behavior of string I/O functions will be affected by
+/  this option. When LFN is not enabled, this option has no effect.
+*/
+
+
+#define FF_STRF_ENCODE	3
+/* When FF_LFN_UNICODE = 1 with LFN enabled, string I/O functions, f_gets(),
+/  f_putc(), f_puts and f_printf() convert the character encoding in it.
+/  This option selects assumption of character encoding ON THE FILE to be
+/  read/written via those functions.
+/
+/   0: ANSI/OEM
+/   1: UTF-16LE
+/   2: UTF-16BE
+/   3: UTF-8
+*/
+
+
+#define FF_FS_RPATH		2
+/* This option configures support for relative path.
+/
+/   0: Disable relative path and remove related functions.
+/   1: Enable relative path. f_chdir() and f_chdrive() are available.
+/   2: f_getcwd() function is available in addition to 1.
+*/
+
+
+/*---------------------------------------------------------------------------/
+/ Drive/Volume Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_VOLUMES		3
+/* Number of volumes (logical drives) to be used. (1-10) */
+
+
+#define FF_STR_VOLUME_ID	1
+#define FF_VOLUME_STRS		"SD","FLASH","USB","USB2","USB3","CF","SD","SD2"
+/* FF_STR_VOLUME_ID switches string support for volume ID.
+/  When FF_STR_VOLUME_ID is set to 1, also pre-defined strings can be used as drive
+/  number in the path name. FF_VOLUME_STRS defines the drive ID strings for each
+/  logical drives. Number of items must be equal to FF_VOLUMES. Valid characters for
+/  the drive ID strings are: A-Z and 0-9. */
+
+
+#define FF_MULTI_PARTITION	0
+/* This option switches support for multiple volumes on the physical drive.
+/  By default (0), each logical drive number is bound to the same physical drive
+/  number and only an FAT volume found on the physical drive will be mounted.
+/  When this function is enabled (1), each logical drive number can be bound to
+/  arbitrary physical drive and partition listed in the VolToPart[]. Also f_fdisk()
+/  funciton will be available. */
+
+
+#define FF_MIN_SS		512
+#define FF_MAX_SS		4096
+/* This set of options configures the range of sector size to be supported. (512,
+/  1024, 2048 or 4096) Always set both 512 for most systems, generic memory card and
+/  harddisk. But a larger value may be required for on-board flash memory and some
+/  type of optical media. When FF_MAX_SS is larger than FF_MIN_SS, FatFs is configured
+/  for variable sector size mode and disk_ioctl() function needs to implement
+/  GET_SECTOR_SIZE command. */
+
+
+#define FF_USE_TRIM		0
+/* This option switches support for ATA-TRIM. (0:Disable or 1:Enable)
+/  To enable Trim function, also CTRL_TRIM command should be implemented to the
+/  disk_ioctl() function. */
+
+
+#define FF_FS_NOFSINFO	0
+/* If you need to know correct free space on the FAT32 volume, set bit 0 of this
+/  option, and f_getfree() function at first time after volume mount will force
+/  a full FAT scan. Bit 1 controls the use of last allocated cluster number.
+/
+/  bit0=0: Use free cluster count in the FSINFO if available.
+/  bit0=1: Do not trust free cluster count in the FSINFO.
+/  bit1=0: Use last allocated cluster number in the FSINFO if available.
+/  bit1=1: Do not trust last allocated cluster number in the FSINFO.
+*/
+
+
+
+/*---------------------------------------------------------------------------/
+/ System Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_FS_TINY		0
+/* This option switches tiny buffer configuration. (0:Normal or 1:Tiny)
+/  At the tiny configuration, size of file object (FIL) is shrinked FF_MAX_SS bytes.
+/  Instead of private sector buffer eliminated from the file object, common sector
+/  buffer in the filesystem object (FATFS) is used for the file data transfer. */
+
+
+#define FF_FS_EXFAT		0
+/* This option switches support for exFAT filesystem. (0:Disable or 1:Enable)
+/  When enable exFAT, also LFN needs to be enabled.
+/  Note that enabling exFAT discards ANSI C (C89) compatibility. */
+
+
+#define FF_FS_NORTC		1
+#define FF_NORTC_MON	5
+#define FF_NORTC_MDAY	1
+#define FF_NORTC_YEAR	2017
+/* The option FF_FS_NORTC switches timestamp functiton. If the system does not have
+/  any RTC function or valid timestamp is not needed, set FF_FS_NORTC = 1 to disable
+/  the timestamp function. All objects modified by FatFs will have a fixed timestamp
+/  defined by FF_NORTC_MON, FF_NORTC_MDAY and FF_NORTC_YEAR in local time.
+/  To enable timestamp function (FF_FS_NORTC = 0), get_fattime() function need to be
+/  added to the project to read current time form real-time clock. FF_NORTC_MON,
+/  FF_NORTC_MDAY and FF_NORTC_YEAR have no effect.
+/  These options have no effect at read-only configuration (FF_FS_READONLY = 1). */
+
+
+#define FF_FS_LOCK		0
+/* The option FF_FS_LOCK switches file lock function to control duplicated file open
+/  and illegal operation to open objects. This option must be 0 when FF_FS_READONLY
+/  is 1.
+/
+/  0:  Disable file lock function. To avoid volume corruption, application program
+/      should avoid illegal open, remove and rename to the open objects.
+/  >0: Enable file lock function. The value defines how many files/sub-directories
+/      can be opened simultaneously under file lock control. Note that the file
+/      lock control is independent of re-entrancy. */
+
+
+#define FF_FS_REENTRANT	1						//重入保护
+#define FF_FS_TIMEOUT	1000
+
+
+#define FF_SYNC_t		void *
+
+
+/* The option FF_FS_REENTRANT switches the re-entrancy (thread safe) of the FatFs
+/  module itself. Note that regardless of this option, file access to different
+/  volume is always re-entrant and volume control functions, f_mount(), f_mkfs()
+/  and f_fdisk() function, are always not re-entrant. Only file/directory access
+/  to the same volume is under control of this function.
+/
+/   0: Disable re-entrancy. FF_FS_TIMEOUT and FF_SYNC_t have no effect.
+/   1: Enable re-entrancy. Also user provided synchronization handlers,
+/      ff_req_grant(), ff_rel_grant(), ff_del_syncobj() and ff_cre_syncobj()
+/      function, must be added to the project. Samples are available in
+/      option/syscall.c.
+/
+/  The FF_FS_TIMEOUT defines timeout period in unit of time tick.
+/  The FF_SYNC_t defines O/S dependent sync object type. e.g. HANDLE, ID, OS_EVENT*,
+/  SemaphoreHandle_t and etc. A header file for O/S definitions needs to be
+/  included somewhere in the scope of ff.h. */
+
+/* #include <windows.h>	// O/S definitions  */
+
+
+
+/*--- End of configuration options ---*/

sdk/lib/fs/fatfs/integer.h

@@ -0,0 +1,38 @@
+/*-------------------------------------------*/
+/* Integer type definitions for FatFs module */
+/*-------------------------------------------*/
+
+#ifndef FF_INTEGER
+#define FF_INTEGER
+
+#ifdef _WIN32	/* FatFs development platform */
+
+#include <windows.h>
+#include <tchar.h>
+typedef unsigned __int64 QWORD;
+
+
+#else			/* Embedded platform */
+
+/* These types MUST be 16-bit or 32-bit */
+typedef int				INT;
+typedef unsigned int	UINT;
+
+/* This type MUST be 8-bit */
+typedef unsigned char	BYTE;
+
+/* These types MUST be 16-bit */
+typedef short			SHORT;
+typedef unsigned short	WORD;
+typedef unsigned short	WCHAR;
+
+/* These types MUST be 32-bit */
+typedef long			LONG;
+typedef unsigned long	DWORD;
+
+/* This type MUST be 64-bit (Remove this for ANSI C (C89) compatibility) */
+typedef unsigned long long QWORD;
+
+#endif
+
+#endif

sdk/lib/fs/fatfs/osal_file.c

@@ -0,0 +1,410 @@
+#include "typesdef.h"
+#include "fatfs/ff.h"
+//#include "osal.h"
+#include <string.h>
+#include "osal_file.h"
+#include "osal/string.h"
+
+
+uint32_t file_mode (const char *mode)
+{
+
+  if (!mode) return 0;
+
+  if (mode[0] == 'r') return FA_READ | FA_OPEN_EXISTING;
+  if (mode[0] == 'w') return FA_READ | FA_WRITE | FA_CREATE_ALWAYS;
+  if (mode[0] == 'a') return FA_READ | FA_WRITE | FA_CREATE_ALWAYS ;
+
+  return 0;
+}
+
+F_FILE *osal_open(const char *filename, int oflags, int mode)
+{
+    uint32_t res;
+	FIL* fp = os_malloc(sizeof(FIL));
+	if(!fp){
+		return 0;
+	}    
+	res = f_open (fp, filename, mode);
+	if(res == FR_OK){
+		return fp;
+	}else{
+		os_printf("%s res:%d\n",__FUNCTION__,res);
+		os_free(fp);
+		return 0;//return NULL;
+	}
+}
+
+F_FILE *osal_fopen(const char *filename,const char *mode)
+{
+	return osal_open(filename, 0, file_mode(mode));
+}
+
+//返回值是读取到的字节数,与标准c返回值有一点点区别
+uint32_t osal_fread(void *ptr,uint32_t size,uint32_t nmemb,F_FILE *fp)
+{
+	
+#if WIN32 == 1
+	return fread(ptr,size,nmemb,fp);
+#else
+	uint32_t readLen;
+	uint32_t res = f_read(fp,ptr,size*nmemb,&readLen);
+	if(res == FR_OK)
+	{
+		return readLen;
+	}
+	else
+	{
+		os_printf("%s res:%d\n",__FUNCTION__,res);
+		return 0;
+	}
+#endif
+} 
+
+
+uint32_t osal_fwrite(void *ptr,uint32_t size,uint32_t nmemb,F_FILE *fp)
+{
+	
+#if WIN32 == 1
+	return fwrite(ptr,size,nmemb,fp);
+#else
+	uint32_t writeLen;
+	uint32_t res =  f_write(fp,ptr,size*nmemb,&writeLen);
+	if(res == FR_OK)
+	{
+		return writeLen;
+	}
+	else
+	{
+		return 0;
+	}
+#endif
+	//return size*nmemb;
+}
+
+int osal_fclose(F_FILE *fp)
+{
+#if WIN32 == 1
+	return fclose(fp);
+#else
+	int res =  f_close(fp);
+	os_free(fp);
+	return res;
+#endif
+}
+
+uint32_t osal_ftell(F_FILE *fp)
+{
+#if WIN32 == 1
+	return ftell(fp);
+#else
+	return f_tell(fp);
+#endif
+}
+
+uint32_t osal_fseek(F_FILE *fp,uint32_t offset)
+{
+#if WIN32 == 1
+	return fseek(fp,offset,SEEK_SET);
+#else
+	return f_lseek(fp,offset);
+#endif
+}
+
+uint32_t osal_fsize(F_FILE *fp)
+{
+#if WIN32 == 1
+		uint32_t tmp;
+		uint32_t size;
+		tmp = osal_ftell(fp);
+		fseek(fp,0,SEEK_END);
+		size = osal_ftell(fp);
+		fseek(fp,tmp,SEEK_SET);
+		return size;
+#else
+	return f_size(fp);
+#endif
+}
+
+
+
+
+uint32_t osal_fread2 (char *buf, uint32_t is, uint32_t s, void *fp)
+{
+  uint32_t bw;
+  FRESULT res;
+	char *temp_buf = NULL;
+	char *read_buf_locate = NULL;
+	uint32_t buf_addr = (uint32_t)buf;
+
+	uint32_t fp_tell = f_tell((FIL*)fp);
+	uint8_t remain =0;
+	
+	//计算输入buf与未读扇区是否对齐
+	if((buf_addr-fp_tell)%4)
+	{
+		remain = fp_tell%4;
+	}
+	
+	//os_printf("fp_tell:%X\t%d\t%d\taddr:%X\terr:%d\r\n",fp_tell,remain,f_tell((FIL*)fp),buf_addr,(buf_addr-fp_tell)%4);
+	if(remain || (buf_addr-fp_tell)%4)
+	{
+		temp_buf = os_malloc(is*s+4);	//申请一个缓冲buf,需要足够大小
+		if(!temp_buf)
+		{
+			os_printf("osal_fread2 os_malloc err!\r\n");
+			return 0;
+		}
+		read_buf_locate = temp_buf+remain;//remain是否4byte对齐,不对齐,代表需要填充4-remain才能4byte对齐,所以write_buf_locate长度应该为is*s+4-remain
+																			//对应位置则为temp_buf+remain
+	}
+	else//不需要缓冲buf
+	{
+		read_buf_locate = buf;
+	}
+  res= f_read (fp, read_buf_locate, is*s, &bw);
+  if (FR_OK != res) {
+    // todo: errno
+    //读取不成功也需要将缓冲buf释放
+	if(read_buf_locate!=buf)
+	{
+		os_free(temp_buf);
+	}
+
+    os_printf("osal_fread err:%d\r\n!!!\r\n",res);
+    return 0;
+  }
+	else//读取成功的话,判断是否为同一个buf,相同,代表没有申请新的缓冲buf
+	{
+		if(read_buf_locate!=buf)
+		{
+			memcpy(buf,read_buf_locate,bw);
+			os_free(temp_buf);
+		}
+
+	}
+
+  return bw;
+}
+
+
+uint32_t osal_fwrite2 (const char *buf, uint32_t is, uint32_t s, void *fp)
+{
+	uint32_t bw;
+	FRESULT res;
+
+	char *temp_buf = NULL;
+	char *write_buf_locate = NULL;
+	uint8_t shift = 0;	//提前写入字节数
+	uint8_t remain =0;
+	uint32_t buf_addr = (uint32_t)buf;
+
+	uint32_t fp_tell = f_tell((FIL*)fp);
+
+	//计算输入buf与未读扇区是否对齐
+	if((buf_addr-fp_tell)%4)
+	{
+		remain = fp_tell%4;//需要填充多少byte
+	}				
+	
+	if(remain || (buf_addr-fp_tell)%4)	//如果需要填充
+	{
+		if(remain)
+		{
+			shift = 4-remain;
+		}
+		//将多余的byte先写入
+		res = f_write (fp, buf, shift, &bw);
+		if (FR_OK != res) {
+			// todo: errno
+			//os_printf("1osal_fwrite2 result %d\r\n",res);
+//			os_printf("1fp addr =  %d\r\n",fp);
+			return 0;
+		}
+
+		temp_buf = os_malloc(is*s);//写入不超过is*s
+		//空间不足
+		if(!temp_buf)
+		{
+			os_printf("osal_fwrite2 os_malloc err!\r\n");
+			return remain;//已经写入的remain字节
+		}
+		write_buf_locate = temp_buf;
+		memcpy(write_buf_locate,buf+shift,is*s-shift);
+	}
+	else
+	{
+		write_buf_locate = (char*)buf;
+	}
+
+	res = f_write (fp, write_buf_locate, is*s-shift, &bw);
+	bw += shift;//写入的总字节数
+
+
+//无论写不写入,如果申请量的buf,都要释放
+	if(temp_buf)
+	{
+		os_free(temp_buf);
+	}
+
+	
+	if (FR_OK != res) {
+	  // todo: errno
+	 // os_printf("osal_fwrite2 result %d\r\n",res);
+	 // os_printf("fp addr =  %d\r\n",fp);
+	  return 0;
+	}
+
+  if(bw == 0)
+  {
+  		os_printf("bw = %d\rwantsize = %d\r\n",bw,is*s);
+  }
+
+  return bw;
+}
+
+
+char *osal_getcwd (char *buf, uint32_t len)
+{
+  if (FR_OK != f_getcwd (buf, len)) return NULL;
+  return buf;
+}
+
+int osal_chdir (char *buf)
+{
+	int res;
+  if (buf[1] == ':') {
+    f_chdrive(buf);
+    if (FR_OK != f_chdir(buf+2)) return -1;
+  } else
+  	{
+  	 res = f_chdir(buf);
+    if (FR_OK != res) 
+		{
+			os_printf("buf:%s\tres:%d\r\n",buf,res);
+			return -1;
+    	}
+  	}
+  return 0;
+}
+
+
+struct diriter {
+  DIR     dir;
+  FILINFO fil;
+};
+
+void *osal_opendir (char *path)
+{
+  struct diriter *dir;
+  dir = os_malloc( sizeof(struct diriter) );
+  if (!dir) return NULL;
+
+  if( f_opendir( &dir->dir, path ) == FR_OK)
+    return dir;
+
+  os_free( dir );
+  return NULL;
+}
+
+void osal_closedir (void *HDIR)
+{
+  struct diriter *dir = (struct diriter *)HDIR;
+  if( !dir ) return;
+
+  os_free( dir );
+}
+
+void *osal_readdir( void *HDIR )
+{
+  struct diriter *dir = (struct diriter *)HDIR;
+  if( !dir ) return NULL;
+
+  if( f_readdir( &dir->dir, &dir->fil ) != FR_OK )
+    return NULL;
+
+  if( dir->dir.sect == 0 )
+    return NULL;
+  return &dir->fil;
+}
+
+char *osal_dirent_name ( void *HFIL)
+{
+  FILINFO *fil = (FILINFO *)HFIL;
+  if( !fil ) return NULL;
+  return fil->fname;
+}
+
+int osal_dirent_isdir ( void *HFIL )
+{
+  FILINFO *fil = (FILINFO *)HFIL;
+  if( !fil ) return 0;
+  return fil->fattrib & AM_DIR;
+}
+
+uint32_t osal_dirent_date ( void *HFIL )
+{
+  FILINFO *fil = (FILINFO *)HFIL;
+  return fil->fdate;
+}
+
+uint32_t osal_dirent_size ( void *HFIL )
+{
+  FILINFO *fil = (FILINFO *)HFIL;
+  return fil->fsize;
+}
+
+uint32_t osal_fmkdir(const char *dir)
+{
+   return f_mkdir(dir); 
+}
+
+
+FRESULT osal_stat(const TCHAR* path,FILINFO* fno)
+{
+    return f_stat(path,fno);
+}
+
+FRESULT osal_unlink(const TCHAR* path)
+{
+    return f_unlink (path);
+}
+
+FRESULT osal_rename(const TCHAR* oldpath,const TCHAR* newpath)
+{
+    return f_rename (oldpath,newpath); 
+}
+
+
+FRESULT osal_fchmod(const TCHAR* path,uint8 attr,uint8 mask)
+{
+	return f_chmod(path,attr,mask);
+}
+
+FRESULT osal_fstat(const TCHAR* path,FILINFO* fno)
+{
+    return f_stat(path,fno);
+}
+
+
+//判断是否存在某个文件
+FRESULT osal_fexist (const char *name)
+{
+  FIL *fp;
+	fp = osal_fopen(name,"rb");
+	if(fp)
+	{
+		osal_fclose(fp);
+		return 0;
+	}
+
+  return 1;
+}
+
+
+
+
+
+
+
+

sdk/lib/fs/fatfs/osal_file.h

@@ -0,0 +1,49 @@
+#ifndef __OSAL_FILE_H
+#define __OSAL_FILE_H
+#include "typesdef.h"
+
+#ifdef WIN32
+	#include <stdio.h>
+	#include <stdlib.h>
+	typedef FILE	F_FILE;
+	
+//不是win32,是mcu平台则要声明文件类型,以及一些宏实现
+#else
+	#include "fatfs/ff.h"
+	typedef FIL	F_FILE;
+#endif
+
+int osal_fopen_no_malloc(F_FILE *fp,const char *filename,const char *mode);
+F_FILE *osal_fopen(const char *filename,const char *mode);
+uint32_t osal_fread(void *ptr,uint32_t size,uint32_t nmemb,F_FILE *fp);
+uint32_t osal_fwrite(void *ptr,uint32_t size,uint32_t nmemb,F_FILE *fp);
+int osal_fclose(F_FILE *fp);
+uint32_t osal_ftell(F_FILE *fp);
+uint32_t osal_fseek(F_FILE *fp,uint32_t offset);
+uint32_t osal_fsize(F_FILE *fp);
+
+
+FRESULT osal_fexist (const char *name);
+FRESULT osal_fstat(const TCHAR* path,FILINFO* fno);
+FRESULT osal_fchmod(const TCHAR* path,uint8 attr,uint8 mask);
+FRESULT osal_rename(const TCHAR* oldpath,const TCHAR* newpath);
+FRESULT osal_unlink(const TCHAR* path);
+FRESULT osal_stat(const TCHAR* path,FILINFO* fno);
+uint32_t osal_fmkdir(const char *dir);
+uint32_t osal_dirent_size ( void *HFIL );
+uint32_t osal_dirent_date ( void *HFIL );
+int osal_dirent_isdir ( void *HFIL );
+char *osal_dirent_name ( void *HFIL);
+void *osal_readdir( void *HDIR );
+void osal_closedir (void *HDIR);
+void *osal_opendir (char *path);
+int osal_chdir (char *buf);
+char *osal_getcwd (char *buf, uint32_t len);
+
+uint32_t osal_fwrite2 (const char *buf, uint32_t is, uint32_t s, void *fp);
+uint32_t osal_fread2 (char *buf, uint32_t is, uint32_t s, void *fp);
+FRESULT osal_unlink(const TCHAR* path);
+uint32_t file_mode (const char *mode);
+
+
+#endif

sdk/lib/fs/fatfs/syscall.c

@@ -0,0 +1,185 @@
+/*------------------------------------------------------------------------*/
+/* Sample code of OS dependent controls for FatFs                         */
+/* (C)ChaN, 2012                                                          */
+/*------------------------------------------------------------------------*/
+
+#include <stdlib.h>		/* ANSI process controls */
+#include <stdio.h>
+
+#include "ff.h"
+#include "csi_kernel.h"
+#include "osal/string.h"
+//#include "osal/osal_sema.h"
+//#include "osal/osal_alloc.h"
+
+
+
+#if FF_FS_REENTRANT
+/*------------------------------------------------------------------------*/
+/* Create a Synchronization Object                                        */
+/*------------------------------------------------------------------------*/
+/* This function is called in f_mount() function to create a new
+   synchronization object, such as semaphore and mutex. When a 0 is returned,
+   the f_mount() function fails with FR_INT_ERR.
+*/
+
+int ff_cre_syncobj (	/* 1:Function succeeded, 0:Could not create due to any error */
+	BYTE vol,			/* Corresponding logical drive being processed */
+	FF_SYNC_t *sobj		/* Pointer to return the created sync object */
+)
+{
+	
+	int ret;
+	static FF_SYNC_t sem[FF_VOLUMES];	/* FreeRTOS */
+	//_os_printf("%s vol:%d\t%X\n",__FUNCTION__,vol,sem[vol]);
+
+	//*sobj = CreateMutex(NULL, FALSE, NULL);		/* Win32 */
+	//ret = (*sobj != INVALID_HANDLE_VALUE);
+
+//	*sobj = SyncObjects[vol];		/* uITRON (give a static created sync object) */
+    //	ret = 1;						/* The initial value of the semaphore must be 1. */
+    
+    //	*sobj = OSMutexCreate(0, &err);	/* uC/OS-II */
+    //	ret = (err == OS_NO_ERR);
+    
+      if (!sem[vol])					/* FreeRTOS */
+	  	{
+			sem[vol] = csi_kernel_mutex_new();
+			
+	  	}
+    	*sobj = sem[vol];
+    
+    	//_os_printf("cre:%X\n",sem[vol]);
+    	ret = (*sobj != NULL);
+
+	return ret;
+}
+
+
+
+/*------------------------------------------------------------------------*/
+/* Delete a Synchronization Object                                        */
+/*------------------------------------------------------------------------*/
+/* This function is called in f_mount() function to delete a synchronization
+/  object that created with ff_cre_syncobj function. When a 0 is returned,
+/  the f_mount() function fails with FR_INT_ERR.
+*/
+
+int ff_del_syncobj (	/* 1:Function succeeded, 0:Could not delete due to any error */
+	FF_SYNC_t sobj		/* Sync object tied to the logical drive to be deleted */
+)
+{
+	int ret;
+
+
+	//ret = CloseHandle(sobj);	/* Win32 */
+
+//	ret = 1;					/* uITRON (nothing to do) */
+
+//	OSMutexDel(sobj, OS_DEL_ALWAYS, &err);	/* uC/OS-II */
+//	ret = (err == OS_NO_ERR);
+
+	//ret = 1;					/* FreeRTOS (nothing to do) */
+	//_os_printf("del:%X\t%X\n",sobj,&sobj);
+	ret = 1;					/* FreeRTOS (nothing to do) */
+
+	return ret;
+
+}
+
+
+
+/*------------------------------------------------------------------------*/
+/* Request Grant to Access the Volume                                     */
+/*------------------------------------------------------------------------*/
+/* This function is called on entering file functions to lock the volume.
+/  When a 0 is returned, the file function fails with FR_TIMEOUT.
+*/
+
+int ff_req_grant (	/* 1:Got a grant to access the volume, 0:Could not get a grant */
+	FF_SYNC_t sobj	/* Sync object to wait */
+)
+{
+	int ret;
+
+	//ret = (WaitForSingleObject(sobj, _FS_TIMEOUT) == WAIT_OBJECT_0);	/* Win32 */
+
+//	ret = (wai_sem(sobj) == E_OK);				/* uITRON */
+
+//	OSMutexPend(sobj, _FS_TIMEOUT, &err));		/* uC/OS-II */
+//	ret = (err == OS_NO_ERR);
+
+	//ret = (xSemaphoreTake(sobj, FF_FS_TIMEOUT) == pdTRUE);	/* FreeRTOS */
+	//_os_printf("A:%X\t%X\n",sobj,&sobj);
+	ret = csi_kernel_mutex_lock(sobj,FF_FS_TIMEOUT, 0);
+	//_os_printf("B\n");
+	if(!ret)
+	{
+		ret = 1;
+	}
+	else
+	{
+		ret = 0;
+	}
+
+	return ret;
+}
+
+
+
+/*------------------------------------------------------------------------*/
+/* Release Grant to Access the Volume                                     */
+/*------------------------------------------------------------------------*/
+/* This function is called on leaving file functions to unlock the volume.
+*/
+
+void ff_rel_grant (
+	FF_SYNC_t sobj	/* Sync object to be signaled */
+)
+{
+	//ReleaseMutex(sobj);		/* Win32 */
+
+//	sig_sem(sobj);			/* uITRON */
+
+//	OSMutexPost(sobj);		/* uC/OS-II */
+
+	//xSemaphoreGive(sobj);	/* FreeRTOS */
+	//_os_printf("C\n");
+	csi_kernel_mutex_unlock(sobj);
+	//_os_printf("D\n");
+}
+
+#endif
+
+
+
+
+#if FF_USE_LFN == 3	/* LFN with a working buffer on the heap */
+/*------------------------------------------------------------------------*/
+/* Allocate a memory block                                                */
+/*------------------------------------------------------------------------*/
+/* If a NULL is returned, the file function fails with FR_NOT_ENOUGH_CORE.
+*/
+
+void* ff_memalloc (	/* Returns pointer to the allocated memory block */
+	UINT msize		/* Number of bytes to allocate */
+)
+{
+	//_os_printf("msize:%d\r\n",msize);
+	return os_malloc(msize);	/* Allocate a memory block with POSIX API */
+}
+
+
+/*------------------------------------------------------------------------*/
+/* Free a memory block                                                    */
+/*------------------------------------------------------------------------*/
+
+
+void ff_memfree (
+	void* mblock	/* Pointer to the memory block to free */
+)
+{
+	os_free(mblock);
+}
+
+#endif