Klagarge/MSE-SoftwEng
1
0
Fork 0
Code Issues Pull Requests Releases Activity

feat: added PicoW_Sensor code template

Browse Source 
Credits to @ext-erich.styger that provided the template
This commit is contained in:
SylvanArnold
2025-04-22 11:30:45 +02:00
committed by Sylvan Arnold
parent b2e9eab44e
commit 6cd510e749
985 changed files with 606823 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

303
TSM_PicoW_Sensor/McuLib/FatFS/source/diskio.c Normal file
View File

@@ -0,0 +1,303 @@
/*
* Copyright (c) 2015, Freescale Semiconductor, Inc.
* Copyright 2016-2019 NXP
* All rights reserved.
*
*
* SPDX-License-Identifier: BSD-3-Clause
*/
/*-----------------------------------------------------------------------*/
/* 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 "McuLib.h"
#if McuLib_CONFIG_USE_FAT_FS
#include "ffconf.h" /* FatFs configuration options */
#include "ff.h" /* Obtains integer types */
#include "diskio.h" /* Declarations of disk functions */
#ifdef RAM_DISK_ENABLE
#include "FatFS/source/fsl_ram_disk/fsl_ram_disk.h"
#endif
#ifdef USB_DISK_ENABLE
#include "FatFS/source/fsl_usb_disk/fsl_usb_disk.h"
#endif
#ifdef SD_DISK_ENABLE
#include "fsl_sd_disk.h"
#endif
#ifdef MMC_DISK_ENABLE
#include "fsl_mmc_disk.h"
#endif
#ifdef SDSPI_DISK_ENABLE
#include "FatFS/source/fsl_sdspi_disk/fsl_sdspi_disk.h"
#endif
#ifdef NAND_DISK_ENABLE
#include "fsl_nand_disk.h"
#endif
/*-----------------------------------------------------------------------*/
/* Get Drive Status */
/*-----------------------------------------------------------------------*/
DSTATUS disk_status (
BYTE pdrv /* Physical drive nmuber to identify the drive */
)
{
DSTATUS stat;
switch (pdrv)
{
#ifdef RAM_DISK_ENABLE
case RAMDISK:
stat = ram_disk_status(pdrv);
return stat;
#endif
#ifdef USB_DISK_ENABLE
case USBDISK:
stat = USB_HostMsdGetDiskStatus(pdrv);
return stat;
#endif
#ifdef SD_DISK_ENABLE
case SDDISK:
stat = sd_disk_status(pdrv);
return stat;
#endif
#ifdef MMC_DISK_ENABLE
case MMCDISK:
stat = mmc_disk_status(pdrv);
return stat;
#endif
#ifdef SDSPI_DISK_ENABLE
case SDSPIDISK:
stat = sdspi_disk_status(pdrv);
return stat;
#endif
#ifdef NAND_DISK_ENABLE
case NANDDISK:
stat = nand_disk_status(pdrv);
return stat;
#endif
default:
break;
}
return STA_NOINIT;
}
/*-----------------------------------------------------------------------*/
/* Inidialize a Drive */
/*-----------------------------------------------------------------------*/
DSTATUS disk_initialize (
BYTE pdrv /* Physical drive nmuber to identify the drive */
)
{
DSTATUS stat;
switch (pdrv)
{
#ifdef RAM_DISK_ENABLE
case RAMDISK:
stat = ram_disk_initialize(pdrv);
return stat;
#endif
#ifdef USB_DISK_ENABLE
case USBDISK:
stat = USB_HostMsdInitializeDisk(pdrv);
return stat;
#endif
#ifdef SD_DISK_ENABLE
case SDDISK:
stat = sd_disk_initialize(pdrv);
return stat;
#endif
#ifdef MMC_DISK_ENABLE
case MMCDISK:
stat = mmc_disk_initialize(pdrv);
return stat;
#endif
#ifdef SDSPI_DISK_ENABLE
case SDSPIDISK:
stat = sdspi_disk_initialize(pdrv);
return stat;
#endif
#ifdef NAND_DISK_ENABLE
case NANDDISK:
stat = nand_disk_initialize(pdrv);
return stat;
#endif
default:
break;
}
return STA_NOINIT;
}
/*-----------------------------------------------------------------------*/
/* 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 */
)
{
DRESULT res;
switch (pdrv)
{
#ifdef RAM_DISK_ENABLE
case RAMDISK:
res = ram_disk_read(pdrv, buff, sector, count);
return res;
#endif
#ifdef USB_DISK_ENABLE
case USBDISK:
res = USB_HostMsdReadDisk(pdrv, buff, sector, count);
return res;
#endif
#ifdef SD_DISK_ENABLE
case SDDISK:
res = sd_disk_read(pdrv, buff, sector, count);
return res;
#endif
#ifdef MMC_DISK_ENABLE
case MMCDISK:
res = mmc_disk_read(pdrv, buff, sector, count);
return res;
#endif
#ifdef SDSPI_DISK_ENABLE
case SDSPIDISK:
res = sdspi_disk_read(pdrv, buff, sector, count);
return res;
#endif
#ifdef NAND_DISK_ENABLE
case NANDDISK:
res = nand_disk_read(pdrv, buff, sector, count);
return res;
#endif
default:
break;
}
return RES_PARERR;
}
/*-----------------------------------------------------------------------*/
/* 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 */
)
{
DRESULT res;
switch (pdrv)
{
#ifdef RAM_DISK_ENABLE
case RAMDISK:
res = ram_disk_write(pdrv, buff, sector, count);
return res;
#endif
#ifdef USB_DISK_ENABLE
case USBDISK:
res = USB_HostMsdWriteDisk(pdrv, buff, sector, count);
return res;
#endif
#ifdef SD_DISK_ENABLE
case SDDISK:
res = sd_disk_write(pdrv, buff, sector, count);
return res;
#endif
#ifdef MMC_DISK_ENABLE
case MMCDISK:
res = mmc_disk_write(pdrv, buff, sector, count);
return res;
#endif
#ifdef SDSPI_DISK_ENABLE
case SDSPIDISK:
res = sdspi_disk_write(pdrv, buff, sector, count);
return res;
#endif
#ifdef NAND_DISK_ENABLE
case NANDDISK:
res = nand_disk_write(pdrv, buff, sector, count);
return res;
#endif
default:
break;
}
return RES_PARERR;
}
/*-----------------------------------------------------------------------*/
/* Miscellaneous Functions */
/*-----------------------------------------------------------------------*/
DRESULT disk_ioctl (
BYTE pdrv, /* Physical drive nmuber (0..) */
BYTE cmd, /* Control code */
void *buff /* Buffer to send/receive control data */
)
{
DRESULT res;
switch (pdrv)
{
#ifdef RAM_DISK_ENABLE
case RAMDISK:
res = ram_disk_ioctl(pdrv, cmd, buff);
return res;
#endif
#ifdef USB_DISK_ENABLE
case USBDISK:
res = USB_HostMsdIoctlDisk(pdrv, cmd, buff);
return res;
#endif
#ifdef SD_DISK_ENABLE
case SDDISK:
res = sd_disk_ioctl(pdrv, cmd, buff);
return res;
#endif
#ifdef MMC_DISK_ENABLE
case MMCDISK:
res = mmc_disk_ioctl(pdrv, cmd, buff);
return res;
#endif
#ifdef SDSPI_DISK_ENABLE
case SDSPIDISK:
res = sdspi_disk_ioctl(pdrv, cmd, buff);
return res;
#endif
#ifdef NAND_DISK_ENABLE
case NANDDISK:
res = nand_disk_ioctl(pdrv, cmd, buff);
return res;
#endif
default:
break;
}
return RES_PARERR;
}
#endif /* McuLib_CONFIG_USE_FAT_FS */

118
TSM_PicoW_Sensor/McuLib/FatFS/source/diskio.h Normal file
View File

@@ -0,0 +1,118 @@
/*-----------------------------------------------------------------------/
/ Low level disk interface modlue include file (C)ChaN, 2014 /
/-----------------------------------------------------------------------*/
#ifndef _DISKIO_DEFINED
#define _DISKIO_DEFINED
#ifdef __cplusplus
extern "C" {
#endif
/* Definitions of physical drive number for each drive */
#if 1 /* << EST */
#define SDSPIDISK 0 /* sdspi disk to physical drive 4 */
#define USBDISK 1 /* usb disk to physical drive 1 */
#define RAMDISK 2 /* Example: ram disk to physical drive 0 */
#define SDDISK 3 /* sd disk to physical drive 2 */
#define MMCDISK 4 /* mmc disk to physical drive 3 */
#define NANDDISK 5 /* nand disk to physical drive 5 */
#else
#define RAMDISK 0 /* Example: ram disk to physical drive 0 */
#define USBDISK 1 /* usb disk to physical drive 1 */
#define SDDISK 2 /* sd disk to physical drive 2 */
#define MMCDISK 3 /* mmc disk to physical drive 3 */
#define SDSPIDISK 4 /* sdspi disk to physical drive 4 */
#define NANDDISK 5 /* nand disk to physical drive 5 */
#endif
/* 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 function */
/* Generic command (Used by FatFs) */
#define CTRL_SYNC 0 /* Complete pending write process (needed at FF_FS_READONLY == 0) */
#define GET_SECTOR_COUNT 1 /* Get media size (needed at FF_USE_MKFS == 1) */
#define GET_SECTOR_SIZE 2 /* Get sector size (needed at FF_MAX_SS != FF_MIN_SS) */
#define GET_BLOCK_SIZE 3 /* Get erase block size (needed at FF_USE_MKFS == 1) */
#define CTRL_TRIM 4 /* Inform device that the data on the block of sectors is no longer used (needed at FF_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 */
/* << EST */
#define CT_SD1 (1<<0) /* LDD_SDHC_SD, Secure Digital memory card */
#define CT_SD2 (1<<1) /* LDD_SDHC_SDIO, Secure Digital IO card */
#define CT_BLOCK (1<<2)
#define CT_MMC (1<<3) /* LDD_SDHC_MMC, MultiMediaCard memory card */
#define CT_SDC (1<<4) /* LDD_SDHC_SDCOMBO, Combined Secure Digital memory and IO card */
#define CT_ATA (1<<5) /* LDD_SDHC_CE_ATA, Consumer Electronics ATA card */
/* << EST */
#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 */
/* << EST */
#define MMC_GET_SDC_VERSION 15 /* 1 byte */
#define MMC_GET_READ_BL_LEN 16 /* 2 bytes */
#define MMC_GET_DRIVER_VERSION 17 /* 1 byte: return: 0 SPI driver, 1 LLD SDHC driver */
#define MMC_GET_LLD_INFO 18 /* array: 1 byte subcommand, 1 byte bufSize, bufSize*bytes */
#define MMC_GET_LLD_CMD_HIGH_CAPACITY 0 /* return 1 byte, 0 for no, 1 for yes */
#define MMC_GET_LLD_CMD_HIGH_SPEED 1 /* return 1 byte, 0 for no, 1 for yes */
#define MMC_GET_LLD_CMD_LOW_VOLTAGE 2 /* return 1 byte, 0 for no, 1 for yes */
#define MMC_GET_LLD_CMD_DATA_WIDTHS 3 /* return 1 byte (bitset), 0x1: 1, 0x2: 4, 0x4: 8 */
#define MMC_GET_LLD_CMD_OPERATIONS 4 /* return 1 byte (bitset), 0x1: block read, 0x2: block write, 0x4: block erase, 0x8: write protection, 0x10: I/O */
/*<< EST */
#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 */
#ifdef __cplusplus
}
#endif
#endif

6559
TSM_PicoW_Sensor/McuLib/FatFS/source/ff.c Normal file
View File

File diff suppressed because it is too large Load Diff

410
TSM_PicoW_Sensor/McuLib/FatFS/source/ff.h Normal file
View File

@@ -0,0 +1,410 @@
/*----------------------------------------------------------------------------/
/ FatFs - Generic FAT Filesystem module R0.13c /
/-----------------------------------------------------------------------------/
/
/ Copyright (C) 2018, 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 86604 /* Revision ID */
#ifdef __cplusplus
extern "C" {
#endif
#include "McuLib.h"
#if McuLib_CONFIG_USE_FAT_FS
#include "ffconf.h" /* FatFs configuration options */
#if FF_DEFINED != FFCONF_DEF
#error Wrong configuration file (ffconf.h).
#endif
/* Integer types used for FatFs API */
#if defined(_WIN32) /* Main development platform */
#define FF_INTDEF 2
#include <windows.h>
typedef unsigned __int64 QWORD;
#elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__cplusplus) /* C99 or later */
#define FF_INTDEF 2
#include <stdint.h>
typedef unsigned int UINT; /* int must be 16-bit or 32-bit */
typedef unsigned char BYTE; /* char must be 8-bit */
typedef uint16_t WORD; /* 16-bit unsigned integer */
typedef uint16_t WCHAR; /* 16-bit unsigned integer */
typedef uint32_t DWORD; /* 32-bit unsigned integer */
typedef uint64_t QWORD; /* 64-bit unsigned integer */
#else /* Earlier than C99 */
#define FF_INTDEF 1
typedef unsigned int UINT; /* int must be 16-bit or 32-bit */
typedef unsigned char BYTE; /* char must be 8-bit */
typedef unsigned short WORD; /* 16-bit unsigned integer */
typedef unsigned short WCHAR; /* 16-bit unsigned integer */
typedef unsigned long DWORD; /* 32-bit unsigned integer */
#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
#if FF_STR_VOLUME_ID
#ifndef FF_VOLUME_STRS
extern const char* VolumeStr[FF_VOLUMES]; /* User defied volume ID */
#endif
#endif
/* Type of path name strings on FatFs API */
#ifndef _INC_TCHAR
#define _INC_TCHAR
#if FF_USE_LFN && FF_LFN_UNICODE == 1 /* Unicode in UTF-16 encoding */
typedef WCHAR TCHAR;
#define _T(x) L ## x
#define _TEXT(x) L ## x
#elif FF_USE_LFN && FF_LFN_UNICODE == 2 /* Unicode in UTF-8 encoding */
typedef char TCHAR;
#define _T(x) u8 ## x
#define _TEXT(x) u8 ## x
#elif FF_USE_LFN && FF_LFN_UNICODE == 3 /* Unicode in UTF-32 encoding */
typedef DWORD TCHAR;
#define _T(x) U ## x
#define _TEXT(x) U ## x
#elif FF_USE_LFN && (FF_LFN_UNICODE < 0 || FF_LFN_UNICODE > 3)
#error Wrong FF_LFN_UNICODE setting
#else /* ANSI/OEM code in SBCS/DBCS */
typedef char TCHAR;
#define _T(x) x
#define _TEXT(x) x
#endif
#endif
/* Type of file size variables */
#if FF_FS_EXFAT
#if FF_INTDEF != 2
#error exFAT feature wants C99 or later
#endif
typedef QWORD FSIZE_t;
#else
typedef DWORD FSIZE_t;
#endif
/* Filesystem object structure (FATFS) */
typedef struct {
BYTE fs_type; /* Filesystem type (0:not mounted) */
BYTE pdrv; /* Associated physical drive */
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 */
#if FF_FS_EXFAT
DWORD bitbase; /* Allocation bitmap base sector */
#endif
DWORD winsect; /* Current sector appearing in the win[] */
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:fragmented 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[FF_SFN_BUF + 1];/* Altenative file name */
TCHAR fname[FF_LFN_BUF + 1]; /* Primary file name */
#else
TCHAR fname[12 + 1]; /* 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 fsz, 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 */
#define f_eof(fp) ((int)((fp)->fptr == (fp)->obj.objsize))
#define f_error(fp) ((fp)->err)
#define f_tell(fp) ((fp)->fptr)
#define f_size(fp) ((fp)->obj.objsize)
#define f_rewind(fp) f_lseek((fp), 0)
#define f_rewinddir(dp) f_readdir((dp), 0)
#define f_rmdir(path) f_unlink(path)
#define f_unmount(path) f_mount(0, path, 0)
#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 >= 1 /* Code conversion (defined in unicode.c) */
WCHAR ff_oem2uni (WCHAR oem, WORD cp); /* OEM code to Unicode conversion */
WCHAR ff_uni2oem (DWORD uni, WORD cp); /* Unicode to OEM code conversion */
DWORD ff_wtoupper (DWORD 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
/*--------------------------------------------------------------*/
/* 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 */
#endif /* McuLib_CONFIG_USE_FAT_FS */

170
TSM_PicoW_Sensor/McuLib/FatFS/source/ffsystem.c Normal file
View File

@@ -0,0 +1,170 @@
/*------------------------------------------------------------------------*/
/* Sample Code of OS Dependent Functions for FatFs */
/* (C)ChaN, 2018 */
/*------------------------------------------------------------------------*/
#include "ff.h"
#if FF_USE_LFN == 3 /* Dynamic memory allocation */
/*------------------------------------------------------------------------*/
/* Allocate a memory block */
/*------------------------------------------------------------------------*/
void* ff_memalloc ( /* Returns pointer to the allocated memory block (null if not enough core) */
UINT msize /* Number of bytes to allocate */
)
{
return malloc(msize); /* Allocate a new memory block with POSIX API */
}
/*------------------------------------------------------------------------*/
/* Free a memory block */
/*------------------------------------------------------------------------*/
void ff_memfree (
void* mblock /* Pointer to the memory block to free (nothing to do if null) */
)
{
free(mblock); /* Free the memory block with POSIX API */
}
#endif
#if 0 && FF_FS_REENTRANT /* Mutal exclusion */
/*------------------------------------------------------------------------*/
/* Create a Synchronization Object */
/*------------------------------------------------------------------------*/
/* This function is called in f_mount() function to create a new
/ synchronization object for the volume, such as semaphore and mutex.
/ When a 0 is returned, the f_mount() function fails with FR_INT_ERR.
*/
//const osMutexDef_t Mutex[FF_VOLUMES]; /* Table of CMSIS-RTOS mutex */
int ff_cre_syncobj ( /* 1:Function succeeded, 0:Could not create the sync object */
BYTE vol, /* Corresponding volume (logical drive number) */
FF_SYNC_t* sobj /* Pointer to return the created sync object */
)
{
/* Win32 */
//*sobj = CreateMutex(NULL, FALSE, NULL);
//return (int)(*sobj != INVALID_HANDLE_VALUE);
/* uITRON */
// T_CSEM csem = {TA_TPRI,1,1};
// *sobj = acre_sem(&csem);
// return (int)(*sobj > 0);
/* uC/OS-II */
// OS_ERR err;
// *sobj = OSMutexCreate(0, &err);
// return (int)(err == OS_NO_ERR);
/* FreeRTOS */
*sobj = xSemaphoreCreateMutex();
return (int)(*sobj != NULL);
/* CMSIS-RTOS */
// *sobj = osMutexCreate(&Mutex[vol]);
// return (int)(*sobj != NULL);
}
/*------------------------------------------------------------------------*/
/* 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 an error */
FF_SYNC_t sobj /* Sync object tied to the logical drive to be deleted */
)
{
/* Win32 */
return (int)CloseHandle(sobj);
/* uITRON */
// return (int)(del_sem(sobj) == E_OK);
/* uC/OS-II */
// OS_ERR err;
// OSMutexDel(sobj, OS_DEL_ALWAYS, &err);
// return (int)(err == OS_NO_ERR);
/* FreeRTOS */
vSemaphoreDelete(sobj);
return 1;
/* CMSIS-RTOS */
// return (int)(osMutexDelete(sobj) == osOK);
}
/*------------------------------------------------------------------------*/
/* 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 */
)
{
/* Win32 */
//return (int)(WaitForSingleObject(sobj, FF_FS_TIMEOUT) == WAIT_OBJECT_0);
/* uITRON */
// return (int)(wai_sem(sobj) == E_OK);
/* uC/OS-II */
// OS_ERR err;
// OSMutexPend(sobj, FF_FS_TIMEOUT, &err));
// return (int)(err == OS_NO_ERR);
/* FreeRTOS */
return (int)(xSemaphoreTake(sobj, FF_FS_TIMEOUT) == pdTRUE);
/* CMSIS-RTOS */
// return (int)(osMutexWait(sobj, FF_FS_TIMEOUT) == osOK);
}
/*------------------------------------------------------------------------*/
/* 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 */
)
{
/* Win32 */
//ReleaseMutex(sobj);
/* uITRON */
// sig_sem(sobj);
/* uC/OS-II */
// OSMutexPost(sobj);
/* FreeRTOS */
xSemaphoreGive(sobj);
/* CMSIS-RTOS */
// osMutexRelease(sobj);
}
#endif

15597
TSM_PicoW_Sensor/McuLib/FatFS/source/ffunicode.c Normal file
View File

File diff suppressed because it is too large Load Diff

117
TSM_PicoW_Sensor/McuLib/FatFS/source/fsl_ram_disk/fsl_ram_disk.c Normal file
View File

@@ -0,0 +1,117 @@
/*
* Copyright (c) 2015, Freescale Semiconductor, Inc.
* Copyright 2016 NXP
* All rights reserved.
*
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#include "McuLib.h"
#if McuLib_CONFIG_USE_FAT_FS
#include "ffconf.h"
/* This fatfs subcomponent is disabled by default
* To enable it, define following macro in ffconf.h */
#ifdef RAM_DISK_ENABLE
#include "fsl_common.h"
#include "fsl_ram_disk.h"
/*******************************************************************************
* Definitions
******************************************************************************/
/* clang-format off */
#define SECTOR_SIZE FF_MIN_SS /* usualy 512 B */
#define DISK_SIZE 65536 /* minmal disk size calculated as 128 * FF_MIN_SS (ff.c ln 4112) , 128*512=65536 */
/* clang-format on */
/*******************************************************************************
* Globals
******************************************************************************/
static uint8_t disk_space[DISK_SIZE];
/*******************************************************************************
* Code
******************************************************************************/
/*!
* @brief Get RAM disk status.
*/
DSTATUS ram_disk_status(BYTE pdrv)
{
if (pdrv != RAMDISK)
{
return STA_NOINIT;
}
return 0;
}
/*!
* @brief Inidialize a RAM disk.
*/
DSTATUS ram_disk_initialize(BYTE pdrv)
{
if (pdrv != RAMDISK)
{
return STA_NOINIT;
}
return 0;
}
/*!
* @brief Read Sector(s) from RAM disk.
*/
DRESULT ram_disk_read(BYTE pdrv, BYTE *buff, DWORD sector, UINT count)
{
if (pdrv != RAMDISK)
{
return RES_PARERR;
}
memcpy(buff, disk_space + sector * SECTOR_SIZE, SECTOR_SIZE * count);
return RES_OK;
}
/*!
* @brief Write Sector(s) to RAM disk.
*/
DRESULT ram_disk_write(BYTE pdrv, const BYTE *buff, DWORD sector, UINT count)
{
if (pdrv != RAMDISK)
{
return RES_PARERR;
}
memcpy(disk_space + sector * SECTOR_SIZE, buff, SECTOR_SIZE * count);
return RES_OK;
}
/*!
* @brief Miscellaneous RAM disk Functions.
*/
DRESULT ram_disk_ioctl(BYTE pdrv, BYTE cmd, void *buff)
{
if (pdrv != RAMDISK)
{
return RES_PARERR;
}
switch (cmd)
{
case GET_SECTOR_COUNT:
*(uint32_t *)buff = DISK_SIZE / SECTOR_SIZE;
return RES_OK;
break;
case GET_SECTOR_SIZE:
*(uint32_t *)buff = SECTOR_SIZE;
return RES_OK;
break;
case CTRL_SYNC:
return RES_OK;
break;
default:
break;
}
return RES_PARERR;
}
#endif /* RAM_DISK_ENABLE */
#endif /* McuLib_CONFIG_USE_FAT_FS */

37
TSM_PicoW_Sensor/McuLib/FatFS/source/fsl_ram_disk/fsl_ram_disk.h Normal file
View File

@@ -0,0 +1,37 @@
/*
* Copyright (c) 2015, Freescale Semiconductor, Inc.
* Copyright 2016 NXP
* All rights reserved.
*
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef __FSL_RAMDISK_H__
#define __FSL_RAMDISK_H__
#include "ff.h"
#include "diskio.h"
/*******************************************************************************
* Definitions
******************************************************************************/
#if defined(__cplusplus)
extern "C" {
#endif
/*******************************************************************************
* API
******************************************************************************/
DSTATUS ram_disk_initialize(BYTE pdrv);
DSTATUS ram_disk_status(BYTE pdrv);
DRESULT ram_disk_read(BYTE pdrv, BYTE *buff, DWORD sector, UINT count);
DRESULT ram_disk_write(BYTE pdrv, const BYTE *buff, DWORD sector, UINT count);
DRESULT ram_disk_ioctl(BYTE pdrv, BYTE cmd, void *buff);
#if defined(__cplusplus)
}
#endif
#endif /* __FSL_RAMDISK_H__ */

545
TSM_PicoW_Sensor/McuLib/FatFS/source/fsl_sdspi_disk/fsl_sdspi_disk.c Normal file
View File

@@ -0,0 +1,545 @@
/*
* Copyright (c) 2015, Freescale Semiconductor, Inc.
* Copyright 2016 NXP
* All rights reserved.
*
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#include "McuLib.h"
#if McuLib_CONFIG_USE_FAT_FS
#include "ffconf.h"
/* This fatfs subcomponent is disabled by default
* To enable it, define following macro in ffconf.h */
#ifdef SDSPI_DISK_ENABLE
#include <assert.h>
#include <stdio.h>
#include <string.h>
#if McuLib_CONFIG_CPU_VARIANT==McuLib_CONFIG_CPU_VARIANT_NXP_K22FN
#include "fsl_dspi.h"
#elif McuLib_CONFIG_CPU_VARIANT==McuLib_CONFIG_CPU_VARIANT_NXP_LPC55S16
#include "fsl_spi.h"
#else
#error "target not supported yet"
#endif /* McuLib_CONFIG_CPU_VARIANT */
#include "fsl_sdspi.h"
#include "fsl_gpio.h"
#include "fsl_sdspi_disk.h"
/* << EST */
/******************************* SD Card Standard Commands **********************************/
#define McuSDCard_CMD0 (0x40+0) /* Resets the SD Memory Card */
#define McuSDCard_CMD1 (0x40+1) /* Sends host capacity support information and activates the card's
initialization process. HCS is effective when card receives SEND_IF_COND
command. Reserved bits shall be set to '0'. */
#define McuSDCard_CMD6 (0x40+6) /* Checks switchable function (mode 0) and switches card function (mode 1).*/
#define McuSDCard_CMD8 (0x40+8) /* Sends SD Memory Card interface condition that includes host supply voltage
information and asks the accessed card whether card can operate in supplied
voltage range. Reserved bits shall be set to '0'.*/
#define McuSDCard_CMD9 (0x40+9) /* Asks the selected card to send its cardspecific data (CSD)*/
#define McuSDCard_CMD10 (0x40+10) /* Asks the selected card to send its card identification (CID) */
#define McuSDCard_CMD12 (0x40+12) /* Forces the card to stop transmission in Multiple Block Read Operation */
#define McuSDCard_CMD13 (0x40+13) /* Asks the selected card to send its status register. */
#define McuSDCard_CMD16 (0x40+16) /* Sets a block length (in bytes) for all following block commands (read and
write) of a Standard Capacity Card. Block length of the read and write
commands are fixed to 512 bytes in a High Capacity Card. The length of
LOCK_UNLOCK command is set by this command in both capacity cards.*/
#define McuSDCard_CMD17 (0x40+17) /* Reads a block of the size selected by the SET_BLOCKLEN command.*/
#define McuSDCard_CMD18 (0x40+18) /* Continuously transfers data blocks from card to host until interrupted by a
STOP_TRANSMISSION command.*/
#define McuSDCard_CMD24 (0x40+24) /* Writes a block of the size selected by the SET_BLOCKLEN command. */
#define McuSDCard_CMD25 (0x40+25) /* Continuously writes blocks of data until ’Stop Tran’ token is sent
(instead ’Start Block’).*/
#define McuSDCard_CMD27 (0x40+27) /* Programming of the programmable bits of the CSD. */
#define McuSDCard_CMD28 (0x40+28) /* If the card has write protection features, this command sets the write protection bit
of the addressed group. The properties of write protection are coded in the card
specific data (WP_GRP_SIZE). The High Capacity Card does not support this command.*/
#define McuSDCard_CMD29 (0x40+29) /* If the card has write protection features, this command clears the write protection
bit of the addressed group. The High Capacity Card does not support this command. */
#define McuSDCard_CMD30 (0x40+30) /* If the card has write protection features, this command asks the card to send the
status of the write protection bits.6 The High Capacity Card does not support this command. */
#define McuSDCard_CMD32 (0x40+32) /* Sets the address of the first write block to be erased.*/
#define McuSDCard_CMD33 (0x40+33) /* Sets the address of the last write block of the continuous range to be erased. */
#define McuSDCard_CMD38 (0x40+38) /* Erases all previously selected write blocks */
#define McuSDCard_CMD42 (0x40+42) /* Used to Set/Reset the Password or lock/unlock the card. A transferred data block includes
all the command details - refer to Chapter 4.3.7. The size of the Data Block is defined
with SET_BLOCK_LEN command. Reserved bits in the argument and in Lock Card Data Structure
shall be set to 0. */
#define McuSDCard_CMD55 (0x40+55) /* Defines to the card that the next command is an application specific command
rather than a standard command */
#define McuSDCard_CMD56 (0x40+56) /* Used either to transfer a Data Block to the card or to get a Data Block from the card
for general purpose/application specific commands. In case of Standard Capacity SD
Memory Card, the size of the Data Block shall be defined with SET_BLOCK_LEN command.
Block length of this command is fixed to 512-byte in High Capacity Card. */
#define McuSDCard_CMD58 (0x40+58) /* Reads the OCR register of a card. CCS bit is assigned to OCR[30]. */
#define McuSDCard_CMD59 (0x40+59) /* Turns the CRC option on or off. A ‘1’ in the CRC option bit will turn the option on,
a ‘0’ will turn it off */
#define McuSDCard_ACMD41 (0xC0+41) /* SEND_OP_COND (SDC) */
#define McuSDCard_ACMD13 (0xC0+13) /* SD_STATUS (SDC) */
#define McuSDCard_ACMD23 (0xC0+23) /* SET_WR_BLK_ERASE_COUNT (SDC) */
static uint8_t CardType = CT_SD1; /* Card type flags */
/* << EST */
/*******************************************************************************
* Definitions
******************************************************************************/
/*******************************************************************************
* Prototypes
******************************************************************************/
/*******************************************************************************
* Variables
******************************************************************************/
/* SDSPI driver state. */
sdspi_card_t g_card;
sdspi_host_t g_host;
/*******************************************************************************
* Code - SD disk interface
******************************************************************************/
DRESULT sdspi_disk_write(uint8_t physicalDrive, const uint8_t *buffer, uint32_t sector, uint8_t count)
{
if (physicalDrive != SDSPIDISK)
{
return RES_PARERR;
}
if (kStatus_Success != SDSPI_WriteBlocks(&g_card, (uint8_t *)buffer, sector, count))
{
return RES_ERROR;
}
return RES_OK;
}
DRESULT sdspi_disk_read(uint8_t physicalDrive, uint8_t *buffer, uint32_t sector, uint8_t count)
{
if (physicalDrive != SDSPIDISK)
{
return RES_PARERR;
}
if (kStatus_Success != SDSPI_ReadBlocks(&g_card, buffer, sector, count))
{
return RES_ERROR;
}
return RES_OK;
}
#if 1 /* << EST */
#include "McuTimeout.h"
#define McuSDCard_DUMMY 0xff /* SPI dummy value */
#define McuSDCard_TIMEOUT_CMD_MS 100 /* user configured wait timeout for commands */
static void McuSDCard_SPI_WRITE(uint8_t data) {
g_card.host->exchange(&data, NULL, 1U);
}
static void McuSDCard_SPI_WRITE_READ(uint8_t data, uint8_t *val) {
g_card.host->exchange(&data, val, 1U);
}
bool McuSDCard_ReceiveDataBlock(uint8_t *data, uint16_t nofBytes) {
status_t status;
status = g_card.host->exchange(NULL, data, nofBytes);
return status==kStatus_Success; /* all ok */
}
uint8_t McuSDCard_SendCmd(uint8_t cmd, uint32_t arg)
{
uint8_t n, res;
McuTimeout_CounterHandle timeout;
if (cmd&0x80) { /* ACMD<n> is the command sequence of CMD55-CMD<n> */
cmd &= 0x7F;
res = McuSDCard_SendCmd(McuSDCard_CMD55, 0);
if (res > 1) {
return res;
}
}
/* Select the card and wait for ready */
//if (McuSDCard_WaitReady() != ERR_OK) {
// return 0xFF;
// }
// McuSDCard_Activate();
/* Send command packet */
McuSDCard_SPI_WRITE(cmd); /* Start + Command index */
n = (uint8_t)(arg>>24);
McuSDCard_SPI_WRITE(n); /* Argument[31..24] */
n = (uint8_t)(arg>>16);
McuSDCard_SPI_WRITE(n); /* Argument[23..16] */
n = (uint8_t)(arg>>8);
McuSDCard_SPI_WRITE(n); /* Argument[15..8] */
McuSDCard_SPI_WRITE((uint8_t)arg); /* Argument[7..0] */
if (cmd == McuSDCard_CMD0) {
n = 0x95; /* Valid CRC for CMD0(0) */
} else if (cmd == McuSDCard_CMD8) {
n = 0x87; /* Valid CRC for CMD8(0x1AA) */
} else {
n = 0x01; /* Dummy CRC + Stop */
}
McuSDCard_SPI_WRITE(n);
/* Receive command response */
if (cmd == McuSDCard_CMD12) {
McuSDCard_SPI_WRITE_READ(McuSDCard_DUMMY, &res); /* send dummy value, poll response */
}
timeout = McuTimeout_GetCounter(McuSDCard_TIMEOUT_CMD_MS/McuTimeout_TICK_PERIOD_MS); /* timeout */
for(;;) { /* will timeout */
McuSDCard_SPI_WRITE_READ(McuSDCard_DUMMY, &res); /* send dummy value, poll response */
if (!(res&0x80)) { /* valid response */
break;
}
if (McuTimeout_CounterExpired(timeout)) {
break;
}
}
McuTimeout_LeaveCounter(timeout);
//McuSDCard_Deactivate();
return res; /* Return with the response value */
}
uint8_t McuSDCard_ReceiveByte(void)
{
uint8_t data;
// McuSDCard_Activate();
McuSDCard_SPI_WRITE_READ(McuSDCard_DUMMY, &data); /* send dummy value, poll response */
// McuSDCard_Deactivate();
return data;
}
#endif
DRESULT sdspi_disk_ioctl(uint8_t physicalDrive, uint8_t command, void *buffer)
{
#if 1 /* << EST */
uint8_t n, csd[16], *ptr = (uint8_t*)buffer;
uint16_t csize;
#endif
DRESULT result = RES_OK;
if (physicalDrive != SDSPIDISK)
{
return RES_PARERR;
}
switch (command)
{
#if 0 /* << EST */
case GET_SECTOR_COUNT:
if (buffer)
{
*(uint32_t *)buffer = g_card.blockCount;
}
else
{
result = RES_PARERR;
}
break;
#endif
case GET_SECTOR_SIZE:
if (buffer)
{
*(uint32_t *)buffer = g_card.blockSize;
}
else
{
result = RES_PARERR;
}
break;
#if 0 /* << EST */
case GET_BLOCK_SIZE:
if (buffer)
{
*(uint32_t *)buffer = g_card.csd.eraseSectorSize;
}
else
{
result = RES_PARERR;
}
break;
#endif
case CTRL_SYNC:
result = RES_OK;
break;
/* << EST */
#if 0
case CTRL_SYNC : /* Make sure that no pending write process. Do not remove this or written sector might not left updated. */
if (McuSDCard_WaitReady() != ERR_OK) {
res = RES_ERROR;
}
break;
#endif
case MMC_GET_READ_BL_LEN: /* get Block Length */
// if (SDSPI_SendCommand(g_card.host, (kSDMMC_SendCsd<<8)|kSDSPI_ResponseTypeR1 /*McuSDCard_CMD9*/, 0, csd)!=kStatus_Success) {
// result = RES_PARERR;
// }
if ((McuSDCard_SendCmd(McuSDCard_CMD9, 0) == 0) && McuSDCard_ReceiveDataBlock(csd, 16)) {
switch((csd[5]&15)) { /* READ_BL_LEN is either 9, 10 or 11, end the block size is 2^READ_BL_LEN */
case 9: *(uint16_t*)ptr = 512; break;
case 10: *(uint16_t*)ptr = 1024; break;
case 11: *(uint16_t*)ptr = 2048; break;
default: *(uint16_t*)ptr = 0; break; /* illegal */
}
}
break;
case MMC_GET_SDC_VERSION: /* get CSD Version (1 byte: 1 for 1.xx or MMC, 2 for 2.0 */
if ((McuSDCard_SendCmd(McuSDCard_CMD9, 0) == 0) && McuSDCard_ReceiveDataBlock(csd, 16)) {
if ((csd[0] >> 6) == 1) { /* SDC ver 2.00 */
*ptr = 2;
} else { /* SDC ver 1.XX or MMC*/
*ptr = 1;
}
}
break;
case GET_SECTOR_COUNT : /* Get number of sectors on the disk (uint32_t) */
if ((McuSDCard_SendCmd(McuSDCard_CMD9, 0) == 0) && McuSDCard_ReceiveDataBlock(csd, 16)) {
if ((csd[0] >> 6) == 1) { /* SDC ver 2.00 */
csize = (uint16_t)(csd[9] + ((uint16_t)csd[8] << 8) + 1);
*(uint32_t*)buffer = (uint32_t)csize << 10;
} else { /* SDC ver 1.XX or MMC*/
n = (uint8_t)((csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2);
csize = (uint16_t)((csd[8] >> 6) + ((uint16_t)csd[7] << 2) + ((uint16_t)(csd[6] & 3) << 10) + 1);
*(uint32_t*)buffer = (uint32_t)csize << (uint8_t)(n - 9);
}
}
break;
// case GET_SECTOR_SIZE : /* Get R/W sector size (uint16_t) */
// *(uint16_t*)buff = McuSDCard_BLOCK_SIZE;
// break;
case GET_BLOCK_SIZE : /* Get erase block size in unit of sector (uint32_t) */
if (CardType & CT_SD2) { /* SDC ver 2.00 */
if (McuSDCard_SendCmd(McuSDCard_ACMD13, 0) == 0) { /* Read SD status */
(void)McuSDCard_ReceiveByte();
if (McuSDCard_ReceiveDataBlock(csd, 16)) { /* Read partial block */
for (n = 64 - 16; n; n--) {
(void)McuSDCard_ReceiveByte(); /* Purge trailing data */
}
*(uint32_t*)buffer = 16UL << (csd[10] >> 4);
}
}
} else { /* SDC ver 1.XX or MMC */
if ((McuSDCard_SendCmd(McuSDCard_CMD9, 0) == 0) && McuSDCard_ReceiveDataBlock(csd, 16)) { /* Read CSD */
if (CardType & CT_SD1) { /* SDC ver 1.XX */
*(uint32_t*)buffer = (uint32_t)((((csd[10] & 63) << 1) + ((uint16_t)(csd[11] & 128) >> 7) + 1) << (uint8_t)((csd[13] >> 6) - 1));
} else { /* MMC */
*(uint32_t*)buffer = (uint32_t)(((uint16_t)((csd[10] & 124) >> 2) + 1) * (((csd[11] & 3) << 3) + ((csd[11] & 224) >> 5) + 1));
}
}
}
break;
case MMC_GET_TYPE : /* Get card type flags (1 byte) */
*ptr = CardType;
break;
case MMC_GET_CSD : /* Receive CSD as a data block (16 bytes) */
if (!(McuSDCard_SendCmd(McuSDCard_CMD9, 0) == 0 /* READ_CSD */
&& McuSDCard_ReceiveDataBlock(ptr, 16)))
{
result = RES_PARERR;
}
break;
case MMC_GET_CID : /* Receive CID as a data block (16 bytes) */
if (!(McuSDCard_SendCmd(McuSDCard_CMD10, 0) == 0 /* READ_CID */
&& McuSDCard_ReceiveDataBlock(ptr, 16)))
{
result = RES_PARERR;
}
break;
case MMC_GET_OCR : /* Receive OCR as an R3 resp (4 bytes) */
if (McuSDCard_SendCmd(McuSDCard_CMD58, 0) == 0) { /* READ_OCR */
for (n = 4; n; n--) {
*ptr++ = McuSDCard_ReceiveByte();
}
} else {
result = RES_PARERR;
}
break;
case MMC_GET_SDSTAT : /* Receive SD status as a data block (64 bytes) */
if (McuSDCard_SendCmd(McuSDCard_ACMD13, 0) == 0) { /* SD_STATUS */
(void)McuSDCard_ReceiveByte();
if (!McuSDCard_ReceiveDataBlock(ptr, 64)) {
result = RES_PARERR;
}
} else {
result = RES_PARERR;
}
break;
case MMC_GET_DRIVER_VERSION: /* 1 byte: return: 0 SPI driver, 1 LLD SDHC driver */
*ptr = 0;
break;
/* << EST */
default:
result = RES_PARERR;
break;
}
return result;
}
DSTATUS sdspi_disk_status(uint8_t physicalDrive)
{
if (physicalDrive != SDSPIDISK)
{
return STA_NOINIT;
}
return 0;
}
DSTATUS sdspi_disk_initialize(uint8_t physicalDrive)
{
if (physicalDrive == SDSPIDISK)
{
spi_init();
sdspi_host_init();
SDSPI_Init(&g_card);
g_card.host = &g_host;
return 0;
}
return STA_NOINIT;
}
/*******************************************************************************
* Code - SPI interface
******************************************************************************/
void spi_init(void)
{
#if McuLib_CONFIG_CPU_VARIANT==McuLib_CONFIG_CPU_VARIANT_NXP_K22FN
uint32_t sourceClock;
dspi_master_config_t masterConfig;
/*Master config*/
masterConfig.whichCtar = DSPI_MASTER_CTAR;
masterConfig.ctarConfig.baudRate = DSPI_BUS_BAUDRATE;
masterConfig.ctarConfig.bitsPerFrame = 8;
masterConfig.ctarConfig.cpol = kDSPI_ClockPolarityActiveHigh;
masterConfig.ctarConfig.cpha = kDSPI_ClockPhaseFirstEdge;
masterConfig.ctarConfig.direction = kDSPI_MsbFirst;
masterConfig.ctarConfig.pcsToSckDelayInNanoSec = 0;
masterConfig.ctarConfig.lastSckToPcsDelayInNanoSec = 0;
masterConfig.ctarConfig.betweenTransferDelayInNanoSec = 0;
masterConfig.whichPcs = DSPI_MASTER_PCS_CONFIG;
masterConfig.pcsActiveHighOrLow = kDSPI_PcsActiveLow;
masterConfig.enableContinuousSCK = false;
masterConfig.enableRxFifoOverWrite = false;
masterConfig.enableModifiedTimingFormat = false;
masterConfig.samplePoint = kDSPI_SckToSin0Clock;
sourceClock = CLOCK_GetFreq(DSPI_MASTER_CLK_SRC);
DSPI_MasterInit((SPI_Type *)BOARD_SDSPI_SPI_BASE, &masterConfig, sourceClock);
#elif McuLib_CONFIG_CPU_VARIANT==McuLib_CONFIG_CPU_VARIANT_NXP_LPC55S16
spi_master_config_t userConfig = {0};
uint32_t srcFreq = 0;
status_t res;
SPI_MasterGetDefaultConfig(&userConfig);
srcFreq = SDSPI_SPI_MASTER_CLK_FREQ;
userConfig.sselNum = (spi_ssel_t)SDSPI_SPI_SSEL;
userConfig.sselPol = (spi_spol_t)SDSPI_SPI_SPOL;
userConfig.dataWidth = kSPI_Data8Bits;
userConfig.polarity = kSPI_ClockPolarityActiveHigh;
userConfig.phase = kSPI_ClockPhaseFirstEdge;
userConfig.direction = kSPI_MsbFirst;
userConfig.sselPol = kSPI_SpolActiveAllLow; /* low active CS */
res = SPI_MasterInit(SDSPI_SPI_MASTER, &userConfig, srcFreq);
if (res!=kStatus_Success) {
for(;;) {}
}
#else
#error "unknown device"
#endif
}
status_t spi_set_frequency(uint32_t frequency)
{
#if McuLib_CONFIG_CPU_VARIANT==McuLib_CONFIG_CPU_VARIANT_NXP_K22FN
uint32_t sourceClock;
sourceClock = CLOCK_GetFreq(DSPI_MASTER_CLK_SRC);
/* If returns 0, indicates failed. */
if (DSPI_MasterSetBaudRate((SPI_Type *)BOARD_SDSPI_SPI_BASE, DSPI_MASTER_CTAR, frequency, sourceClock))
{
return kStatus_Success;
}
return kStatus_Fail;
#elif McuLib_CONFIG_CPU_VARIANT==McuLib_CONFIG_CPU_VARIANT_NXP_LPC55S16
uint32_t sourceClock;
status_t res;
sourceClock = SDSPI_SPI_MASTER_CLK_FREQ;
/* If returns 0, indicates failed. */
res = SPI_MasterSetBaud((SPI_Type *)SDSPI_SPI_MASTER, frequency, sourceClock);
if (res!=kStatus_Success) {
for(;;) {}
}
return res;
#else
#error "unknown device"
#endif
}
status_t spi_exchange(uint8_t *in, uint8_t *out, uint32_t size)
{
#if McuLib_CONFIG_CPU_VARIANT==McuLib_CONFIG_CPU_VARIANT_NXP_K22FN
dspi_transfer_t masterTransfer;
masterTransfer.txData = in;
masterTransfer.rxData = out;
masterTransfer.dataSize = size;
masterTransfer.configFlags = (kDSPI_MasterCtar0 | DSPI_MASTER_PCS_TRANSFER | kDSPI_MasterPcsContinuous);
return DSPI_MasterTransferBlocking((SPI_Type *)BOARD_SDSPI_SPI_BASE, &masterTransfer);
#elif McuLib_CONFIG_CPU_VARIANT==McuLib_CONFIG_CPU_VARIANT_NXP_LPC55S16
spi_transfer_t xfer = {0};
xfer.txData = in;
xfer.rxData = out;
xfer.dataSize = size;
xfer.configFlags = kSPI_FrameAssert;
return SPI_MasterTransferBlocking(SDSPI_SPI_MASTER, &xfer);
#else
#error "unknown device"
#endif
}
#if 1 /* << EST */
static void sdspi_init(void) {
}
static void sdspi_deinit(void) {
}
static void sdspi_activePolarity(sdspi_cs_active_polarity_t polarity) { /* used to change clock polarity */
}
#endif
void sdspi_host_init(void)
{
/* Saves host state and callback. */
g_host.busBaudRate = DSPI_BUS_BAUDRATE;
g_host.setFrequency = spi_set_frequency;
g_host.exchange = spi_exchange;
#if 1 /* << EST */
g_host.init = sdspi_init;
g_host.deinit = sdspi_deinit;
g_host.csActivePolarity = sdspi_activePolarity;
#endif
/* Saves card state. */
g_card.host = &g_host;
}
#endif /* SDSPI_DISK_ENABLE */
#endif /* McuLib_CONFIG_USE_FAT_FS */

195
TSM_PicoW_Sensor/McuLib/FatFS/source/fsl_sdspi_disk/fsl_sdspi_disk.h Normal file
View File

@@ -0,0 +1,195 @@
/*
* Copyright (c) 2015, Freescale Semiconductor, Inc.
* Copyright 2016 NXP
* All rights reserved.
*
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef _FSL_SDSPI_DISK_H_
#define _FSL_SDSPI_DISK_H_
#include <stdint.h>
#include "ff.h"
#include "diskio.h"
#include "fsl_common.h"
#include "board.h"
/*!
* @addtogroup SD Disk over SPI
* @{
*/
/*******************************************************************************
* Definitions
******************************************************************************/
#if McuLib_CONFIG_CPU_VARIANT==McuLib_CONFIG_CPU_VARIANT_NXP_K22FN
/* DSPI clock source */
#if (BOARD_SDSPI_SPI_BASE == SPI0_BASE)
#define DSPI_MASTER_CLK_SRC (DSPI0_CLK_SRC)
#elif(BOARD_SDSPI_SPI_BASE == SPI1_BASE)
#define DSPI_MASTER_CLK_SRC (DSPI0_CLK_SRC)
#elif(BOARD_SDSPI_SPI_BASE == SPI2_BASE)
#define DSPI_MASTER_CLK_SRC (DSPI2_CLK_SRC)
#elif(BOARD_SDSPI_SPI_BASE == SPI3_BASE)
#define DSPI_MASTER_CLK_SRC (DSPI3_CLK_SRC)
#elif(BOARD_SDSPI_SPI_BASE == SPI4_BASE)
#define DSPI_MASTER_CLK_SRC (DSPI4_CLK_SRC)
#else
#error Should define the DSPI_MASTER_CLK_SRC!
#endif
/* Which PCS used to select the slave */
#if (BOARD_SDSPI_SPI_PCS_NUMBER == 0U)
#define DSPI_MASTER_PCS_CONFIG kDSPI_Pcs0
#define DSPI_MASTER_PCS_TRANSFER kDSPI_MasterPcs0
#elif(BOARD_SDSPI_SPI_PCS_NUMBER == 1U)
#define DSPI_MASTER_PCS_CONFIG kDSPI_Pcs1
#define DSPI_MASTER_PCS_TRANSFER kDSPI_MasterPcs1
#elif(BOARD_SDSPI_SPI_PCS_NUMBER == 2U)
#define DSPI_MASTER_PCS_CONFIG kDSPI_Pcs2
#define DSPI_MASTER_PCS_TRANSFER kDSPI_MasterPcs2
#elif(BOARD_SDSPI_SPI_PCS_NUMBER == 3U)
#define DSPI_MASTER_PCS_CONFIG kDSPI_Pcs3
#define DSPI_MASTER_PCS_TRANSFER kDSPI_MasterPcs3
#elif(BOARD_SDSPI_SPI_PCS_NUMBER == 4U)
#define DSPI_MASTER_PCS_CONFIG kDSPI_Pcs4
#define DSPI_MASTER_PCS_TRANSFER kDSPI_MasterPcs4
#elif(BOARD_SDSPI_SPI_PCS_NUMBER == 5U)
#define DSPI_MASTER_PCS_CONFIG kDSPI_Pcs5
#define DSPI_MASTER_PCS_TRANSFER kDSPI_MasterPcs5
#endif
#define DSPI_MASTER_CTAR (kDSPI_Ctar0) /* The CTAR to describe the transfer attribute */
#elif McuLib_CONFIG_CPU_VARIANT==McuLib_CONFIG_CPU_VARIANT_NXP_LPC55S16
#define SDSPI_SPI_MASTER SPI8
#define SDSPI_SPI_MASTER_IRQ FLEXCOMM8_IRQn
#define SDSPI_SPI_MASTER_CLK_SRC kCLOCK_Flexcomm8
#define SDSPI_SPI_MASTER_CLK_FREQ CLOCK_GetFlexCommClkFreq(8U)
#define SDSPI_SPI_SSEL 1
#define SDSPI_SPI_SPOL kSPI_SpolActiveAllLow
#else
#error "unknown device"
#endif /* McuLib_CONFIG_CPU_VARIANT */
#define DSPI_BUS_BAUDRATE (500000U) /* Transfer baudrate - 500k */
/*************************************************************************************************
* API - SD disk interface
************************************************************************************************/
#if defined(__cplusplus)
extern "C" {
#endif
/*!
* @name SD over SPI Disk Function
* @{
*/
/*!
* @brief Initializes SD disk over SPI.
*
* @param physicalDrive Physical drive number.
* @retval STA_NOINIT Failed.
* @retval RES_OK Success.
*/
DSTATUS sdspi_disk_initialize(uint8_t physicalDrive);
/*!
* Gets SD over SPI disk status
*
* @param physicalDrive Physical drive number.
* @retval STA_NOINIT Failed.
* @retval RES_OK Success.
*/
DSTATUS sdspi_disk_status(uint8_t physicalDrive);
/*!
* @brief Reads SD disk over SPI.
*
* @param physicalDrive Physical drive number.
* @param buffer The data buffer pointer to store read content.
* @param sector The start sector number to be read.
* @param count The sector count to be read.
* @retval RES_PARERR Failed.
* @retval RES_OK Success.
*/
DRESULT sdspi_disk_read(uint8_t physicalDrive, uint8_t *buffer, uint32_t sector, uint8_t count);
/*!
* @brief Writes to SD disk over SPI.
*
* @param physicalDrive Physical drive number.
* @param buffer The data buffer pointer to store write content.
* @param sector The start sector number to be written.
* @param count The sector count to be written.
* @retval RES_PARERR Failed.
* @retval RES_OK Success.
*/
DRESULT sdspi_disk_write(uint8_t physicalDrive, const uint8_t *buffer, uint32_t sector, uint8_t count);
/*!
* @brief SD over SPI disk IO operation.
*
* @param physicalDrive Physical drive number.
* @param command The command to be set.
* @param buffer The buffer to store command result.
* @retval RES_PARERR Failed.
* @retval RES_OK Success.
*/
DRESULT sdspi_disk_ioctl(uint8_t physicalDrive, uint8_t command, void *buffer);
/*************************************************************************************************
* API - SPI interface
************************************************************************************************/
/*!
* @brief Initializes the SPI.
*/
void spi_init(void);
/*!
* @brief Sets the SPI bus frequency.
*
* @param frequency The frequency to set.
* @retval kStatus_Success Success.
* @retval kStatus_Fail Failed.
*/
status_t spi_set_frequency(uint32_t frequency);
/*!
* @brief Transfers data over SPI bus in full-duplex way.
*
* @param in The buffer to save the data to be sent.
* @param out The buffer to save the data to be read.
* @param size The transfer data size.
* @return The status of the function DSPI_MasterTransferPolling().
*/
status_t spi_exchange(uint8_t *in, uint8_t *out, uint32_t size);
/*!
* @brief Initializes the timer to generator 1ms interrupt used to get current time in milliseconds.
*/
void timer_init(void);
/*!
* @brief Gets current time in milliseconds.
*
* @return Current time in milliseconds.
*/
uint32_t timer_get_current_milliseconds(void);
/*!
* @brief Initializes the host descriptor.
*/
void sdspi_host_init(void);
/* @} */
#if defined(__cplusplus)
}
#endif
#endif /* _FSL_SDSPI_DISK_H_ */

90
TSM_PicoW_Sensor/McuLib/FatFS/source/fsl_usb_disk/fsl_usb_disk.h Normal file
View File

@@ -0,0 +1,90 @@
/*
* Copyright (c) 2015, Freescale Semiconductor, Inc.
* Copyright 2016 NXP
* All rights reserved.
*
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef _MSD_DISKIO_H_
#define _MSD_DISKIO_H_
#include "usb_host_config.h"
#include "usb_host.h"
#include "usb_host_msd.h"
#include "ff.h"
#include "diskio.h"
/*******************************************************************************
* Definitions
******************************************************************************/
/*! @brief mass storage read/write retry time */
#define USB_HOST_FATFS_RW_RETRY_TIMES (2U)
/*******************************************************************************
* API
******************************************************************************/
/*!
* @brief fatfs call this function to initialize physical disk.
*
* @param pdrv Physical drive number.
*
* @retval 0x00 success.
*/
extern DSTATUS USB_HostMsdInitializeDisk(BYTE pdrv);
/*!
* @brief fatfs call this function to get physical disk status.
*
* @param pdrv Physical drive number.
*
* @retval 0x00 OK.
*/
extern DSTATUS USB_HostMsdGetDiskStatus(BYTE pdrv);
/*!
* @brief fatfs call this function to write data to physical disk.
*
* @param pdrv Physical drive number.
* @param buff Pointer to the data buffer to store read data.
* @param sector Start sector number.
* @param count Number of sectors to read.
*
* @retval RES_PARERR parameter error.
* @retval RES_ERROR usb stack driver error.
* @retval RES_NOTRDY read disk error.
*/
extern DRESULT USB_HostMsdReadDisk(BYTE pdrv, BYTE *buff, DWORD sector, UINT count);
/*!
* @brief fatfs call this function to write data to physical disk.
*
* @param pdrv Physical drive number.
* @param buff Pointer to the data buffer to be written.
* @param sector Start sector number.
* @param count Number of sectors to read.
*
* @retval RES_PARERR parameter error.
* @retval RES_ERROR usb stack driver error.
* @retval RES_NOTRDY write disk error.
*/
extern DRESULT USB_HostMsdWriteDisk(BYTE pdrv, const BYTE *buff, DWORD sector, UINT count);
/*!
* @brief fatfs call this function to write data to physical disk.
*
* @param pdrv Physical drive number.
* @param cmd ioctl command, please reference to diskio.h
* @param buff Parameter or data buffer.
*
* @retval RES_PARERR parameter error.
* @retval RES_ERROR usb stack driver error.
* @retval RES_NOTRDY write disk error.
*/
extern DRESULT USB_HostMsdIoctlDisk(BYTE pdrv, BYTE cmd, void *buff);
#endif /* _MSD_DISKIO_H_ */

386
TSM_PicoW_Sensor/McuLib/FatFS/source/fsl_usb_disk/fsl_usb_disk_bm.c Normal file
View File

@@ -0,0 +1,386 @@
/*
* Copyright (c) 2015, Freescale Semiconductor, Inc.
* Copyright 2016 NXP
* All rights reserved.
*
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#include "McuLib.h"
#if McuLib_CONFIG_USE_FAT_FS
#include "ffconf.h"
/* This fatfs subcomponent is disabled by default
* To enable it, define following macro in ffconf.h */
#ifdef USB_DISK_ENABLE
#include "fsl_usb_disk.h" /* FatFs lower layer API */
/*******************************************************************************
* Definitons
******************************************************************************/
/*******************************************************************************
* Prototypes
******************************************************************************/
/*!
* @brief host msd ufi command callback.
*
* This function is used as callback function for ufi command .
*
* @param param NULL.
* @param data data buffer pointer.
* @param dataLength data length.
* @status transfer result status.
*/
static void USB_HostMsdUfiCallback(void *param, uint8_t *data, uint32_t dataLength, usb_status_t status);
/*******************************************************************************
* Variables
******************************************************************************/
extern usb_host_handle g_HostHandle;
usb_host_class_handle g_UsbFatfsClassHandle;
static uint32_t s_FatfsSectorSize;
/* command on-going state. It should set to 1 when start command, it is set to 0 in the callback */
static volatile uint8_t ufiIng;
/* command callback status */
static volatile usb_status_t ufiStatus;
#if (defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) ||\
(defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE))
USB_DMA_NONINIT_DATA_ALIGN(USB_DATA_ALIGN_SIZE) static uint8_t s_UsbTransferBuffer[FF_MAX_SS];
#else
USB_DMA_NONINIT_DATA_ALIGN(USB_DATA_ALIGN_SIZE) static uint8_t s_UsbTransferBuffer[20];
#endif
/*******************************************************************************
* Code
******************************************************************************/
static void USB_HostMsdUfiCallback(void *param, uint8_t *data, uint32_t dataLength, usb_status_t status)
{
ufiIng = 0;
ufiStatus = status;
}
static inline void USB_HostControllerTaskFunction(usb_host_handle hostHandle)
{
#if ((defined USB_HOST_CONFIG_KHCI) && (USB_HOST_CONFIG_KHCI))
USB_HostKhciTaskFunction(hostHandle);
#endif /* USB_HOST_CONFIG_KHCI */
#if ((defined USB_HOST_CONFIG_EHCI) && (USB_HOST_CONFIG_EHCI))
USB_HostEhciTaskFunction(hostHandle);
#endif /* USB_HOST_CONFIG_EHCI */
#if ((defined USB_HOST_CONFIG_IP3516HS) && (USB_HOST_CONFIG_IP3516HS > 0U))
USB_HostIp3516HsTaskFunction(g_HostHandle);
#endif /* USB_HOST_CONFIG_IP3516HS */
#if ((defined USB_HOST_CONFIG_OHCI) && (USB_HOST_CONFIG_OHCI > 0U))
USB_HostOhciTaskFunction(g_HostHandle);
#endif /* USB_HOST_CONFIG_OHCI */
}
DSTATUS USB_HostMsdInitializeDisk(BYTE pdrv)
{
uint32_t address;
/* test unit ready */
ufiIng = 1;
if (g_UsbFatfsClassHandle == NULL)
{
return RES_ERROR;
}
if (USB_HostMsdTestUnitReady(g_UsbFatfsClassHandle, 0, USB_HostMsdUfiCallback, NULL) != kStatus_USB_Success)
{
return STA_NOINIT;
}
while (ufiIng) /* wait the command */
{
USB_HostControllerTaskFunction(g_HostHandle);
}
/*request sense */
ufiIng = 1;
if (g_UsbFatfsClassHandle == NULL)
{
return RES_ERROR;
}
if (USB_HostMsdRequestSense(g_UsbFatfsClassHandle, 0, s_UsbTransferBuffer, sizeof(usb_host_ufi_sense_data_t),
USB_HostMsdUfiCallback, NULL) != kStatus_USB_Success)
{
return STA_NOINIT;
}
while (ufiIng) /* wait the command */
{
USB_HostControllerTaskFunction(g_HostHandle);
}
/* get the sector size */
ufiIng = 1;
if (g_UsbFatfsClassHandle == NULL)
{
return RES_ERROR;
}
if (USB_HostMsdReadCapacity(g_UsbFatfsClassHandle, 0, s_UsbTransferBuffer, sizeof(usb_host_ufi_read_capacity_t),
USB_HostMsdUfiCallback, NULL) != kStatus_USB_Success)
{
return STA_NOINIT;
}
else
{
while (ufiIng)
{
USB_HostControllerTaskFunction(g_HostHandle);
}
if (ufiStatus == kStatus_USB_Success)
{
address = (uint32_t)&s_UsbTransferBuffer[0];
address = (uint32_t)((usb_host_ufi_read_capacity_t *)(address))->blockLengthInBytes;
s_FatfsSectorSize = USB_LONG_FROM_BIG_ENDIAN_ADDRESS(((uint8_t *)address));
}
else
{
s_FatfsSectorSize = 512;
}
}
return 0x00;
}
DSTATUS USB_HostMsdGetDiskStatus(BYTE pdrv)
{
return 0x00;
}
DRESULT USB_HostMsdReadDisk(BYTE pdrv, BYTE *buff, DWORD sector, UINT count)
{
DRESULT fatfs_code = RES_ERROR;
usb_status_t status = kStatus_USB_Success;
uint32_t retry = USB_HOST_FATFS_RW_RETRY_TIMES;
uint8_t *transferBuf;
uint32_t sectorCount;
uint32_t sectorIndex;
#if (defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) ||\
(defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE))
uint32_t index;
#endif
if (!count)
{
return RES_PARERR;
}
#if (defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) ||\
(defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE))
transferBuf = s_UsbTransferBuffer;
sectorCount = 1;
for (index = 0; index < count; ++index)
{
sectorIndex = sector + index;
#else
transferBuf = buff;
sectorCount = count;
sectorIndex = sector;
#endif
retry = USB_HOST_FATFS_RW_RETRY_TIMES;
while (retry--)
{
ufiIng = 1;
if (g_UsbFatfsClassHandle == NULL)
{
return RES_ERROR;
}
status = USB_HostMsdRead10(g_UsbFatfsClassHandle, 0, sectorIndex, (uint8_t *)transferBuf,
(uint32_t)(s_FatfsSectorSize * sectorCount), sectorCount, USB_HostMsdUfiCallback, NULL);
if (status != kStatus_USB_Success)
{
fatfs_code = RES_ERROR;
}
else
{
while (ufiIng)
{
USB_HostControllerTaskFunction(g_HostHandle);
}
if (ufiStatus == kStatus_USB_Success)
{
fatfs_code = RES_OK;
break;
}
else
{
fatfs_code = RES_NOTRDY;
}
}
}
#if (defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) ||\
(defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE))
memcpy(buff + index * s_FatfsSectorSize, s_UsbTransferBuffer, s_FatfsSectorSize);
}
#endif
return fatfs_code;
}
DRESULT USB_HostMsdWriteDisk(BYTE pdrv, const BYTE *buff, DWORD sector, UINT count)
{
DRESULT fatfs_code = RES_ERROR;
usb_status_t status = kStatus_USB_Success;
uint32_t retry = USB_HOST_FATFS_RW_RETRY_TIMES;
const uint8_t *transferBuf;
uint32_t sectorCount;
uint32_t sectorIndex;
#if (defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) ||\
(defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE))
uint32_t index;
#endif
if (!count)
{
return RES_PARERR;
}
#if (defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) ||\
(defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE))
transferBuf = (const uint8_t *)s_UsbTransferBuffer;
sectorCount = 1;
for (index = 0; index < count; ++index)
{
sectorIndex = sector + index;
memcpy(s_UsbTransferBuffer, buff + index * s_FatfsSectorSize, s_FatfsSectorSize);
#else
transferBuf = buff;
sectorCount = count;
sectorIndex = sector;
#endif
retry = USB_HOST_FATFS_RW_RETRY_TIMES;
while (retry--)
{
ufiIng = 1;
if (g_UsbFatfsClassHandle == NULL)
{
return RES_ERROR;
}
status = USB_HostMsdWrite10(g_UsbFatfsClassHandle, 0, sectorIndex, (uint8_t *)transferBuf,
(uint32_t)(s_FatfsSectorSize * sectorCount), sectorCount, USB_HostMsdUfiCallback, NULL);
if (status != kStatus_USB_Success)
{
fatfs_code = RES_ERROR;
}
else
{
while (ufiIng)
{
USB_HostControllerTaskFunction(g_HostHandle);
}
if (ufiStatus == kStatus_USB_Success)
{
fatfs_code = RES_OK;
break;
}
else
{
fatfs_code = RES_NOTRDY;
}
}
}
#if (defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) ||\
(defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE))
}
#endif
return fatfs_code;
}
DRESULT USB_HostMsdIoctlDisk(BYTE pdrv, BYTE cmd, void *buff)
{
uint32_t address;
DRESULT fatfs_code = RES_ERROR;
usb_status_t status = kStatus_USB_Success;
uint32_t value;
switch (cmd)
{
case GET_SECTOR_COUNT:
case GET_SECTOR_SIZE:
if (!buff)
{
return RES_ERROR;
}
ufiIng = 1;
if (g_UsbFatfsClassHandle == NULL)
{
return RES_ERROR;
}
status = USB_HostMsdReadCapacity(g_UsbFatfsClassHandle, 0, s_UsbTransferBuffer,
sizeof(usb_host_ufi_read_capacity_t), USB_HostMsdUfiCallback, NULL);
if (status != kStatus_USB_Success)
{
fatfs_code = RES_ERROR;
}
else
{
while (ufiIng)
{
USB_HostControllerTaskFunction(g_HostHandle);
}
if (ufiStatus == kStatus_USB_Success)
{
fatfs_code = RES_OK;
}
else
{
fatfs_code = RES_NOTRDY;
}
}
if (fatfs_code == RES_OK)
{
if (GET_SECTOR_COUNT == cmd) /* Get number of sectors on the disk (DWORD) */
{
address = (uint32_t)&s_UsbTransferBuffer[0];
address = (uint32_t)((usb_host_ufi_read_capacity_t *)(address))->lastLogicalBlockAddress;
value = USB_LONG_FROM_BIG_ENDIAN_ADDRESS(((uint8_t *)address));
((uint8_t *)buff)[0] = ((uint8_t*)&value)[0];
((uint8_t *)buff)[1] = ((uint8_t*)&value)[1];
((uint8_t *)buff)[2] = ((uint8_t*)&value)[2];
((uint8_t *)buff)[3] = ((uint8_t*)&value)[3];
}
else /* Get the sector size in byte */
{
address = (uint32_t)&s_UsbTransferBuffer[0];
address = (uint32_t)((usb_host_ufi_read_capacity_t *)(address))->blockLengthInBytes;
value = USB_LONG_FROM_BIG_ENDIAN_ADDRESS(((uint8_t *)address));
((uint8_t *)buff)[0] = ((uint8_t*)&value)[0];
((uint8_t *)buff)[1] = ((uint8_t*)&value)[1];
((uint8_t *)buff)[2] = ((uint8_t*)&value)[2];
((uint8_t *)buff)[3] = ((uint8_t*)&value)[3];
}
}
break;
case GET_BLOCK_SIZE:
if (!buff)
{
return RES_ERROR;
}
*(uint32_t *)buff = 0;
fatfs_code = RES_OK;
break;
case CTRL_SYNC:
fatfs_code = RES_OK;
break;
default:
fatfs_code = RES_PARERR;
break;
}
return fatfs_code;
}
#endif /* USB_DISK_ENABLE */
#endif /* McuLib_CONFIG_USE_FAT_FS */

376
TSM_PicoW_Sensor/McuLib/FatFS/source/fsl_usb_disk/fsl_usb_disk_freertos.c Normal file
View File

@@ -0,0 +1,376 @@
/*
* Copyright (c) 2015, Freescale Semiconductor, Inc.
* Copyright 2016 NXP
* All rights reserved.
*
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#include "McuLib.h"
#if McuLib_CONFIG_USE_FAT_FS
#include "ffconf.h"
/* This fatfs subcomponent is disabled by default
* To enable it, define following macro in ffconf.h */
#ifdef USB_DISK_ENABLE
#include "fsl_usb_disk.h" /* FatFs lower layer API */
/*******************************************************************************
* Definitons
******************************************************************************/
/*******************************************************************************
* Prototypes
******************************************************************************/
/*!
* @brief host msd ufi command callback.
*
* This function is used as callback function for ufi command .
*
* @param param NULL.
* @param data data buffer pointer.
* @param dataLength data length.
* @status transfer result status.
*/
static void USB_HostMsdUfiCallback(void *param, uint8_t *data, uint32_t dataLength, usb_status_t status);
/*******************************************************************************
* Variables
******************************************************************************/
extern usb_host_handle g_HostHandle;
usb_host_class_handle g_UsbFatfsClassHandle;
static uint32_t s_FatfsSectorSize;
static SemaphoreHandle_t s_CommandSemaphore;
/* command callback status */
static volatile usb_status_t ufiStatus;
#if (defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) ||\
(defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE))
USB_DMA_NONINIT_DATA_ALIGN(USB_DATA_ALIGN_SIZE) static uint8_t s_UsbTransferBuffer[FF_MAX_SS];
#else
USB_DMA_NONINIT_DATA_ALIGN(USB_DATA_ALIGN_SIZE) static uint8_t s_UsbTransferBuffer[20];
#endif
/*******************************************************************************
* Code
******************************************************************************/
static void USB_HostMsdUfiCallback(void *param, uint8_t *data, uint32_t dataLength, usb_status_t status)
{
xSemaphoreGive(s_CommandSemaphore);
ufiStatus = status;
}
DSTATUS USB_HostMsdInitializeDisk(BYTE pdrv)
{
uint32_t address;
if (s_CommandSemaphore == NULL)
{
s_CommandSemaphore = xSemaphoreCreateCounting(0x01U, 0x00U);
}
else
{
vSemaphoreDelete(s_CommandSemaphore);
s_CommandSemaphore = xSemaphoreCreateCounting(0x01U, 0x00U);
}
if (NULL == s_CommandSemaphore)
{
return RES_ERROR;
}
/* test unit ready */
if (g_UsbFatfsClassHandle == NULL)
{
return RES_ERROR;
}
if (USB_HostMsdTestUnitReady(g_UsbFatfsClassHandle, 0, USB_HostMsdUfiCallback, NULL) != kStatus_USB_Success)
{
return STA_NOINIT;
}
if (pdTRUE != xSemaphoreTake(s_CommandSemaphore, portMAX_DELAY)) /* wait the command */
{
return RES_ERROR;
}
/*request sense */
if (g_UsbFatfsClassHandle == NULL)
{
return RES_ERROR;
}
if (USB_HostMsdRequestSense(g_UsbFatfsClassHandle, 0, s_UsbTransferBuffer, sizeof(usb_host_ufi_sense_data_t),
USB_HostMsdUfiCallback, NULL) != kStatus_USB_Success)
{
return STA_NOINIT;
}
if (pdTRUE != xSemaphoreTake(s_CommandSemaphore, portMAX_DELAY)) /* wait the command */
{
return RES_ERROR;
}
/* get the sector size */
if (g_UsbFatfsClassHandle == NULL)
{
return RES_ERROR;
}
if (USB_HostMsdReadCapacity(g_UsbFatfsClassHandle, 0, s_UsbTransferBuffer, sizeof(usb_host_ufi_read_capacity_t),
USB_HostMsdUfiCallback, NULL) != kStatus_USB_Success)
{
return STA_NOINIT;
}
else
{
if (pdTRUE != xSemaphoreTake(s_CommandSemaphore, portMAX_DELAY)) /* wait the command */
{
return RES_ERROR;
}
if (ufiStatus == kStatus_USB_Success)
{
address = (uint32_t)&s_UsbTransferBuffer[0];
address = (uint32_t)((usb_host_ufi_read_capacity_t *)(address))->blockLengthInBytes;
s_FatfsSectorSize = USB_LONG_FROM_BIG_ENDIAN_ADDRESS(((uint8_t *)address));
}
else
{
s_FatfsSectorSize = 512;
}
}
return 0x00;
}
DSTATUS USB_HostMsdGetDiskStatus(BYTE pdrv)
{
return 0x00;
}
DRESULT USB_HostMsdReadDisk(BYTE pdrv, BYTE *buff, DWORD sector, UINT count)
{
DRESULT fatfs_code = RES_ERROR;
usb_status_t status = kStatus_USB_Success;
uint32_t retry = USB_HOST_FATFS_RW_RETRY_TIMES;
uint8_t *transferBuf;
uint32_t sectorCount;
uint32_t sectorIndex;
#if (defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) ||\
(defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE))
uint32_t index;
#endif
if (!count)
{
return RES_PARERR;
}
#if (defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) ||\
(defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE))
transferBuf = s_UsbTransferBuffer;
sectorCount = 1;
for (index = 0; index < count; ++index)
{
sectorIndex = sector + index;
#else
transferBuf = buff;
sectorCount = count;
sectorIndex = sector;
#endif
retry = USB_HOST_FATFS_RW_RETRY_TIMES;
while (retry--)
{
if (g_UsbFatfsClassHandle == NULL)
{
return RES_ERROR;
}
status = USB_HostMsdRead10(g_UsbFatfsClassHandle, 0, sectorIndex, (uint8_t *)transferBuf,
(uint32_t)(s_FatfsSectorSize * sectorCount), sectorCount, USB_HostMsdUfiCallback, NULL);
if (status != kStatus_USB_Success)
{
fatfs_code = RES_ERROR;
}
else
{
if (pdTRUE != xSemaphoreTake(s_CommandSemaphore, portMAX_DELAY)) /* wait the command */
{
return RES_ERROR;
}
if (ufiStatus == kStatus_USB_Success)
{
fatfs_code = RES_OK;
break;
}
else
{
fatfs_code = RES_NOTRDY;
}
}
}
#if (defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) ||\
(defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE))
memcpy(buff + index * s_FatfsSectorSize, s_UsbTransferBuffer, s_FatfsSectorSize);
}
#endif
return fatfs_code;
}
DRESULT USB_HostMsdWriteDisk(BYTE pdrv, const BYTE *buff, DWORD sector, UINT count)
{
DRESULT fatfs_code = RES_ERROR;
usb_status_t status = kStatus_USB_Success;
uint32_t retry = USB_HOST_FATFS_RW_RETRY_TIMES;
const uint8_t *transferBuf;
uint32_t sectorCount;
uint32_t sectorIndex;
#if (defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) ||\
(defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE))
uint32_t index;
#endif
if (!count)
{
return RES_PARERR;
}
#if (defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) ||\
(defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE))
transferBuf = (const uint8_t *)s_UsbTransferBuffer;
sectorCount = 1;
for (index = 0; index < count; ++index)
{
sectorIndex = sector + index;
memcpy(s_UsbTransferBuffer, buff + index * s_FatfsSectorSize, s_FatfsSectorSize);
#else
transferBuf = buff;
sectorCount = count;
sectorIndex = sector;
#endif
retry = USB_HOST_FATFS_RW_RETRY_TIMES;
while (retry--)
{
if (g_UsbFatfsClassHandle == NULL)
{
return RES_ERROR;
}
status = USB_HostMsdWrite10(g_UsbFatfsClassHandle, 0, sectorIndex, (uint8_t *)transferBuf,
(uint32_t)(s_FatfsSectorSize * sectorCount), sectorCount, USB_HostMsdUfiCallback, NULL);
if (status != kStatus_USB_Success)
{
fatfs_code = RES_ERROR;
}
else
{
if (pdTRUE != xSemaphoreTake(s_CommandSemaphore, portMAX_DELAY)) /* wait the command */
{
return RES_ERROR;
}
if (ufiStatus == kStatus_USB_Success)
{
fatfs_code = RES_OK;
break;
}
else
{
fatfs_code = RES_NOTRDY;
}
}
}
#if (defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) ||\
(defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE))
}
#endif
return fatfs_code;
}
DRESULT USB_HostMsdIoctlDisk(BYTE pdrv, BYTE cmd, void *buff)
{
uint32_t address;
DRESULT fatfs_code = RES_ERROR;
usb_status_t status = kStatus_USB_Success;
uint32_t value;
switch (cmd)
{
case GET_SECTOR_COUNT:
case GET_SECTOR_SIZE:
if (!buff)
{
return RES_ERROR;
}
if (g_UsbFatfsClassHandle == NULL)
{
return RES_ERROR;
}
status = USB_HostMsdReadCapacity(g_UsbFatfsClassHandle, 0, s_UsbTransferBuffer,
sizeof(usb_host_ufi_read_capacity_t), USB_HostMsdUfiCallback, NULL);
if (status != kStatus_USB_Success)
{
fatfs_code = RES_ERROR;
}
else
{
if (pdTRUE != xSemaphoreTake(s_CommandSemaphore, portMAX_DELAY)) /* wait the command */
{
return RES_ERROR;
}
if (ufiStatus == kStatus_USB_Success)
{
fatfs_code = RES_OK;
}
else
{
fatfs_code = RES_NOTRDY;
}
}
if (fatfs_code == RES_OK)
{
if (GET_SECTOR_COUNT == cmd) /* Get number of sectors on the disk (DWORD) */
{
address = (uint32_t)&s_UsbTransferBuffer[0];
address = (uint32_t)((usb_host_ufi_read_capacity_t *)(address))->lastLogicalBlockAddress;
value = USB_LONG_FROM_BIG_ENDIAN_ADDRESS(((uint8_t *)address));
((uint8_t *)buff)[0] = ((uint8_t*)&value)[0];
((uint8_t *)buff)[1] = ((uint8_t*)&value)[1];
((uint8_t *)buff)[2] = ((uint8_t*)&value)[2];
((uint8_t *)buff)[3] = ((uint8_t*)&value)[3];
}
else /* Get the sector size in byte */
{
address = (uint32_t)&s_UsbTransferBuffer[0];
address = (uint32_t)((usb_host_ufi_read_capacity_t *)(address))->blockLengthInBytes;
value = USB_LONG_FROM_BIG_ENDIAN_ADDRESS(((uint8_t *)address));
((uint8_t *)buff)[0] = ((uint8_t*)&value)[0];
((uint8_t *)buff)[1] = ((uint8_t*)&value)[1];
((uint8_t *)buff)[2] = ((uint8_t*)&value)[2];
((uint8_t *)buff)[3] = ((uint8_t*)&value)[3];
}
}
break;
case GET_BLOCK_SIZE:
if (!buff)
{
return RES_ERROR;
}
*(uint32_t *)buff = 0;
fatfs_code = RES_OK;
break;
case CTRL_SYNC:
fatfs_code = RES_OK;
break;
default:
fatfs_code = RES_PARERR;
break;
}
return fatfs_code;
}
#endif /* USB_DISK_ENABLE */
#endif /* McuLib_CONFIG_USE_FAT_FS */