Skip to content
Snippets Groups Projects
Commit 0f257fb2 authored by Fang Lu's avatar Fang Lu
Browse files

Merge attempt 

* SDCard not working
parent 1205ea46
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 223 additions and 24880 deletions
audio_hw.tcl
+ 5
− 5
View file @ 0f257fb2
# TCL File Generated by Component Editor 17.1
# Thu Nov 30 01:24:47 CST 2017
# Thu Dec 07 00:06:04 CST 2017
# DO NOT MODIFY
#
# audio "audio" v1.0
# 2017.11.30.01:24:47
#
# 2017.12.07.00:06:04
# Audio DAC Driver
#
#
......@@ -18,12 +18,12 @@ package require -exact qsys 16.1
#
# module audio
#
set_module_property DESCRIPTION ""
set_module_property DESCRIPTION "Audio DAC Driver"
set_module_property NAME audio
set_module_property VERSION 1.0
set_module_property INTERNAL false
set_module_property OPAQUE_ADDRESS_MAP true
set_module_property GROUP "Final-osu Custom IPs "
set_module_property GROUP otofpga
set_module_property AUTHOR ""
set_module_property DISPLAY_NAME audio
set_module_property INSTANTIATE_IN_SYSTEM_MODULE true
......
final_sd_interface_hw.tcl
+ 5
− 5
View file @ 0f257fb2
# TCL File Generated by Component Editor 17.1
# Mon Dec 04 00:24:12 CST 2017
# Thu Dec 07 00:05:42 CST 2017
# DO NOT MODIFY
#
# final_sd_interface "final_sd_interface" v1.0
# 2017.12.04.00:24:12
#
# 2017.12.07.00:05:42
# SDCard Driver (4-bit mode)
#
#
......@@ -18,12 +18,12 @@ package require -exact qsys 16.1
#
# module final_sd_interface
#
set_module_property DESCRIPTION ""
set_module_property DESCRIPTION "SDCard Driver (4-bit mode)"
set_module_property NAME final_sd_interface
set_module_property VERSION 1.0
set_module_property INTERNAL false
set_module_property OPAQUE_ADDRESS_MAP true
set_module_property GROUP "Final-osu Custom IPs"
set_module_property GROUP otofpga
set_module_property AUTHOR ""
set_module_property DISPLAY_NAME final_sd_interface
set_module_property INSTANTIATE_IN_SYSTEM_MODULE true
......
osu_fpga_toplevel.qsf
+ 70
− 290
View file @ 0f257fb2
This diff is collapsed.
osu_fpga_toplevel.sv
+ 16
− 9
View file @ 0f257fb2
......@@ -41,8 +41,6 @@ module osu_fpga_toplevel (
output logic FL_CE_N, FL_OE_N, FL_WE_N, FL_RESET_N, FL_WP_N,
input logic FL_RY,
// sdcard
// PS/2
inout wire PS2_KBCLK, PS2_KBDAT,
......@@ -50,16 +48,22 @@ module osu_fpga_toplevel (
inout wire [15:0] OTG_DATA,
output logic [1:0] OTG_ADDR,
output logic OTG_CS_N, OTG_OE_N, OTG_WE_N, OTG_RST_N,
input logic[1:0] OTG_INT,
input logic [1:0] OTG_INT,
// VGA
output logic VGA_CLK,
output logic [7:0] VGA_R, VGA_G, VGA_B,
output logic VGA_SYNC_N, VGA_BLANK_N, VGA_VS, VGA_HS
output logic VGA_SYNC_N, VGA_BLANK_N, VGA_VS, VGA_HS,
// Audio
// Debug GPIO
// inout wire [35:0] GPIO
output logic AUD_XCK, AUD_DACDAT, I2C_SCLK,
input logic AUD_ADCDAT,
inout wire AUD_BCLK, AUD_ADCLRCK, AUD_DACLRCK, I2C_SDAT,
// SDCard
output logic SD_CLK,
inout wire [3:0] SD_DAT,
inout wire SD_CMD
);
// Synchronizers
logic Reset_h, Clk;
......@@ -67,8 +71,7 @@ module osu_fpga_toplevel (
Reset_h <= ~(KEY[0]); // The push buttons are active low
end
// Additional wires for Flash
// Additional wires
assign FL_WP_N = 1'b1;
// HPI wrapper
......@@ -158,7 +161,11 @@ module osu_fpga_toplevel (
.vga_hs (VGA_HS),
.vga_vs (VGA_VS),
.vga_blank_n (VGA_BLANK_N),
.vga_sync_n (VGA_SYNC_N)
.vga_sync_n (VGA_SYNC_N),
// SDCard
.sd_sd_dat (SD_DAT),
.sd_sd_cmd (SD_CMD),
.sd_sd_clk (SD_CLK)
);
......
otogame.qsys
+ 127
− 502
View file @ 0f257fb2
This diff is collapsed.
software/audio_sd/main.c deleted 100644 → 0
+ 0
− 91
View file @ 1205ea46
/*
* main.c
*
* Created on: Nov 20, 2017
* Author: noman
*/
#include <stdio.h>
#include <inttypes.h>
#include <unistd.h>
#include "system.h"
#include <ctype.h>
#include <time.h>
//#include "terasic_includes.h"
//#include ".\terasic_fat\FatFileSystem.h"
#include "sdcard\ff.h"
//#include ".\mp3lib\mad.h"
//#include ".\mp3lib\minimad.h"
//#include "xab.h"
#define AUDIO_BASE ((uint32_t*)AUDIO_0_BASE)
volatile uint32_t *audioData = AUDIO_BASE;
volatile uint32_t *audioVol = AUDIO_BASE+1;
volatile uint32_t *VolReset = AUDIO_BASE+2;
volatile uint32_t *audioReady = AUDIO_BASE+3;
int main() {
printf("Hello world\n");
//from 00000 to 11111
*audioVol = 0xff;
//notice: must reset to start the I2C config
*VolReset = 1;
//short int fileP;
char filename[256];
FIL* fileP;
unsigned long fileSize;
unsigned int actualRead;
//unsigned char audioBuffer[32768];
FATFS FatFs;
AUDIO:
if (f_mount(&FatFs, "", 0)!=FR_OK) {
printf("SD Card Mount failed");
goto AUDIO;
}
printf("please enter file name\n");
scanf("%s",filename);
if (f_open(fileP,filename,FA_READ)!=FR_OK){
printf("file open failed\n");
goto AUDIO;
}
//pin point the beginning of file
fileSize = f_size(fileP);
uint32_t* audioDataInDram = malloc(fileSize);
memset(audioDataInDram,0xCC,fileSize);
//start mp3 decoding
printf("start decoding mp3\n");
//decode(audioBuffer,2048,fileP,audioDataInDram);
size_t start = clock();
int result = f_read(fileP,audioDataInDram,fileSize,&actualRead);
if(result!=FR_OK){
printf("read file failed!\n");
//free(audioDataInDram);
//goto AUDIO;
}
size_t end = clock();
printf("mp3 decoding finished!\n %d ms used!\n",end-start);
unsigned int ptr=0;
while (ptr < (fileSize>>2)){
if (*audioReady){
*audioData = audioDataInDram[ptr];
++ptr;
}
if (audioDataInDram[ptr]==0xCCCCCCCC){
printf("%x",ptr);
break;
}
}
printf("Playback completed\n");
goto AUDIO;
}
software/audio_sd/sdcard/crc7.c deleted 100644 → 0
+ 0
− 68
View file @ 1205ea46
/*
* crc7.c
*
* This source code is licensed under the GNU General Public License,
* Version 2. See the file COPYING for more details.
*/
#include "terasic_includes.h"
#include "crc7.h"
/* Table for CRC-7 (polynomial x^7 + x^3 + 1) */
static const alt_u8 crc7_syndrome_table[256] = {
0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f,
0x48, 0x41, 0x5a, 0x53, 0x6c, 0x65, 0x7e, 0x77,
0x19, 0x10, 0x0b, 0x02, 0x3d, 0x34, 0x2f, 0x26,
0x51, 0x58, 0x43, 0x4a, 0x75, 0x7c, 0x67, 0x6e,
0x32, 0x3b, 0x20, 0x29, 0x16, 0x1f, 0x04, 0x0d,
0x7a, 0x73, 0x68, 0x61, 0x5e, 0x57, 0x4c, 0x45,
0x2b, 0x22, 0x39, 0x30, 0x0f, 0x06, 0x1d, 0x14,
0x63, 0x6a, 0x71, 0x78, 0x47, 0x4e, 0x55, 0x5c,
0x64, 0x6d, 0x76, 0x7f, 0x40, 0x49, 0x52, 0x5b,
0x2c, 0x25, 0x3e, 0x37, 0x08, 0x01, 0x1a, 0x13,
0x7d, 0x74, 0x6f, 0x66, 0x59, 0x50, 0x4b, 0x42,
0x35, 0x3c, 0x27, 0x2e, 0x11, 0x18, 0x03, 0x0a,
0x56, 0x5f, 0x44, 0x4d, 0x72, 0x7b, 0x60, 0x69,
0x1e, 0x17, 0x0c, 0x05, 0x3a, 0x33, 0x28, 0x21,
0x4f, 0x46, 0x5d, 0x54, 0x6b, 0x62, 0x79, 0x70,
0x07, 0x0e, 0x15, 0x1c, 0x23, 0x2a, 0x31, 0x38,
0x41, 0x48, 0x53, 0x5a, 0x65, 0x6c, 0x77, 0x7e,
0x09, 0x00, 0x1b, 0x12, 0x2d, 0x24, 0x3f, 0x36,
0x58, 0x51, 0x4a, 0x43, 0x7c, 0x75, 0x6e, 0x67,
0x10, 0x19, 0x02, 0x0b, 0x34, 0x3d, 0x26, 0x2f,
0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c,
0x3b, 0x32, 0x29, 0x20, 0x1f, 0x16, 0x0d, 0x04,
0x6a, 0x63, 0x78, 0x71, 0x4e, 0x47, 0x5c, 0x55,
0x22, 0x2b, 0x30, 0x39, 0x06, 0x0f, 0x14, 0x1d,
0x25, 0x2c, 0x37, 0x3e, 0x01, 0x08, 0x13, 0x1a,
0x6d, 0x64, 0x7f, 0x76, 0x49, 0x40, 0x5b, 0x52,
0x3c, 0x35, 0x2e, 0x27, 0x18, 0x11, 0x0a, 0x03,
0x74, 0x7d, 0x66, 0x6f, 0x50, 0x59, 0x42, 0x4b,
0x17, 0x1e, 0x05, 0x0c, 0x33, 0x3a, 0x21, 0x28,
0x5f, 0x56, 0x4d, 0x44, 0x7b, 0x72, 0x69, 0x60,
0x0e, 0x07, 0x1c, 0x15, 0x2a, 0x23, 0x38, 0x31,
0x46, 0x4f, 0x54, 0x5d, 0x62, 0x6b, 0x70, 0x79
};
alt_u8 crc7_byte(alt_u8 crc, alt_u8 data)
{
return crc7_syndrome_table[(crc << 1) ^ data];
}
/**
* crc7 - update the CRC7 for the data buffer
* @crc: previous CRC7 value
* @buffer: data pointer
* @len: number of bytes in the buffer
* Context: any
*
* Returns the updated CRC7 value.
*/
alt_u8 crc7(alt_u8 crc, const alt_u8 *buffer, int len)
{
while (len--)
crc = crc7_byte(crc, *buffer++);
return crc;
}
software/audio_sd/sdcard/diskio.c deleted 100644 → 0
+ 0
− 112
View file @ 1205ea46
/*-----------------------------------------------------------------------*/
/* 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 */
#include "sd_hal.h"
#include "sd_lib.h"
/* Definitions of physical drive number for each drive */
#define DEV_RAM 0 /* Example: Map Ramdisk to physical drive 0 */
#define DEV_MMC 1 /* Example: Map MMC/SD card to physical drive 1 */
#define DEV_USB 2 /* Example: Map USB MSD to physical drive 2 */
/*-----------------------------------------------------------------------*/
/* Get Drive Status */
/*-----------------------------------------------------------------------*/
DSTATUS osu_sd_status=STA_NOINIT;
DSTATUS disk_status (
BYTE pdrv /* Physical drive nmuber to identify the drive */
)
{
// osu_sd_status;
return osu_sd_status;
}
/*-----------------------------------------------------------------------*/
/* Inidialize a Drive */
/*-----------------------------------------------------------------------*/
DSTATUS disk_initialize (
BYTE pdrv /* Physical drive nmuber to identify the drive */
)
{
//DSTATUS osu_sd_status;
if (SDLIB_Init())
osu_sd_status = STA_PROTECT;
else
osu_sd_status = STA_NOINIT;
return osu_sd_status;
}
/*-----------------------------------------------------------------------*/
/* 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 */
)
{
unsigned int i;
DRESULT result=RES_OK;
for (i=0;i<count;++i){
if (SDLIB_ReadBlock512(sector+i, buff))
buff += 512;
else
result = RES_ERROR;
}
return result;
}
/*-----------------------------------------------------------------------*/
/* 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 */
)
{
return RES_WRPRT;
}
/*-----------------------------------------------------------------------*/
/* Miscellaneous Functions */
/*-----------------------------------------------------------------------*/
DRESULT disk_ioctl (
BYTE pdrv, /* Physical drive nmuber (0..) */
BYTE cmd, /* Control code */
void *buff /* Buffer to send/receive control data */
)
{
return RES_WRPRT;
}
DWORD get_fattime (){
return 1;
}
software/audio_sd/sdcard/diskio.h deleted 100644 → 0
+ 0
− 80
View file @ 1205ea46
/*-----------------------------------------------------------------------/
/ Low level disk interface modlue include file (C)ChaN, 2014 /
/-----------------------------------------------------------------------*/
#ifndef _DISKIO_DEFINED
#define _DISKIO_DEFINED
#ifdef __cplusplus
extern "C" {
#endif
#include "integer.h"
/* Status of Disk Functions */
typedef BYTE DSTATUS;
/* Results of Disk Functions */
typedef enum {
RES_OK = 0, /* 0: Successful */
RES_ERROR, /* 1: R/W Error */
RES_WRPRT, /* 2: Write Protected */
RES_NOTRDY, /* 3: Not Ready */
RES_PARERR /* 4: Invalid Parameter */
} DRESULT;
/*---------------------------------------*/
/* Prototypes for disk control functions */
DSTATUS disk_initialize (BYTE pdrv);
DSTATUS disk_status (BYTE pdrv);
DRESULT disk_read (BYTE pdrv, BYTE* buff, DWORD sector, UINT count);
DRESULT disk_write (BYTE pdrv, const BYTE* buff, DWORD sector, UINT count);
DRESULT disk_ioctl (BYTE pdrv, BYTE cmd, void* buff);
DWORD get_fattime (void);
/* Disk Status Bits (DSTATUS) */
#define STA_NOINIT 0x01 /* Drive not initialized */
#define STA_NODISK 0x02 /* No medium in the drive */
#define STA_PROTECT 0x04 /* Write protected */
/* Command code for disk_ioctrl 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 */
#ifdef __cplusplus
}
#endif
#endif
software/audio_sd/sdcard/ff.c deleted 100644 → 0
+ 0
− 6564
View file @ 1205ea46
This diff is collapsed.
software/audio_sd/sdcard/ff.h deleted 100644 → 0
+ 0
− 366
View file @ 1205ea46
/*----------------------------------------------------------------------------/
/ FatFs - Generic FAT Filesystem module R0.13a /
/-----------------------------------------------------------------------------/
/
/ 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 89352 /* 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 */
#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 < 0 || FF_LFN_UNICODE > 2)
#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
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[] */
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[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 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 */
#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 */
software/audio_sd/sdcard/ffconf.h deleted 100644 → 0
+ 0
− 283
View file @ 1205ea46
/*---------------------------------------------------------------------------/
/ FatFs - Configuration file
/---------------------------------------------------------------------------*/
#define FFCONF_DEF 89352 /* 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: Basic functions are fully 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 0
/* 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 0
/* 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 0
/* 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 0
/* 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 932
/* 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
#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, ffunicode.c needs to be added to the project. The LFN function
/ requiers certain internal working buffer occupies (FF_MAX_LFN + 1) * 2 bytes and
/ additional (FF_MAX_LFN + 44) / 15 * 32 bytes when exFAT is enabled.
/ The FF_MAX_LFN defines size of the working buffer in UTF-16 code unit and it can
/ be in range of 12 to 255. It is recommended to be set 255 to fully support LFN
/ specification.
/ 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() in ffsystem.c, need to be added to the project. */
#define FF_LFN_UNICODE 0
/* This option switches the character encoding on the API when LFN is enabled.
/
/ 0: ANSI/OEM in current CP (TCHAR = char)
/ 1: Unicode in UTF-16 (TCHAR = WCHAR)
/ 2: Unicode in UTF-8 (TCHAR = char)
/
/ 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_LFN_BUF 255
#define FF_SFN_BUF 12
/* This set of options defines size of file name members in the FILINFO structure
/ which is used to read out directory items. These values should be suffcient for
/ the file names to read. The maximum possible length of the read file name depends
/ on character encoding. When LFN is not enabled, these options have 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 in current CP
/ 1: Unicode in UTF-16LE
/ 2: Unicode in UTF-16BE
/ 3: Unicode in UTF-8
*/
#define FF_FS_RPATH 0
/* 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 1
/* Number of volumes (logical drives) to be used. (1-10) */
#define FF_STR_VOLUME_ID 0
#define FF_VOLUME_STRS "RAM","NAND","CF","SD","SD2","USB","USB2","USB3"
/* 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 512
/* 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 0
#define FF_NORTC_MON 1
#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 0
#define FF_FS_TIMEOUT 1000
#define FF_SYNC_t HANDLE
/* 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 ---*/
software/audio_sd/sdcard/ffsystem.c deleted 100644 → 0
+ 0
− 171
View file @ 1205ea46
/*------------------------------------------------------------------------*/
/* Sample Code of OS Dependent Functions for FatFs */
/* (C)ChaN, 2017 */
/*------------------------------------------------------------------------*/
#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 on 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 for null) */
)
{
free(mblock); /* Free the memory block with POSIX API */
}
#endif
#if 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]; /* CMSIS-RTOS */
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
software/audio_sd/sdcard/ffunicode.c deleted 100644 → 0
+ 0
− 15586
View file @ 1205ea46
This diff is collapsed.
software/audio_sd/sdcard/integer.h deleted 100644 → 0
+ 0
− 38
View file @ 1205ea46
/*-------------------------------------------*/
/* 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
software/audio_sd/sdcard/sd_hal.c deleted 100644 → 0
+ 0
− 237
View file @ 1205ea46
// --------------------------------------------------------------------
// Copyright (c) 2010 by Terasic Technologies Inc.
// --------------------------------------------------------------------
//
// Permission:
//
// Terasic grants permission to use and modify this code for use
// in synthesis for all Terasic Development Boards and Altera Development
// Kits made by Terasic. Other use of this code, including the selling
// ,duplication, or modification of any portion is strictly prohibited.
//
// Disclaimer:
//
// This VHDL/Verilog or C/C++ source code is intended as a design reference
// which illustrates how these types of functions can be implemented.
// It is the user's responsibility to verify their design for
// consistency and functionality through the use of formal
// verification methods. Terasic provides no warranty regarding the use
// or functionality of this code.
//
// --------------------------------------------------------------------
//
// Terasic Technologies Inc
// 356 Fu-Shin E. Rd Sec. 1. JhuBei City,
// HsinChu County, Taiwan
// 302
//
// web: http://www.terasic.com/
// email: support@terasic.com
//
// --------------------------------------------------------------------
#include "terasic_includes.h"
#include "sd_hal.h"
#include "sd_hw.h"
//#include "crc16.h"
#include <inttypes.h>
#include "system.h"
//#define SD_BASE (uint32_t*(FINAL_SD_INTERFACE_0_BASE))
#define SD_BASE ((uint32_t*)0x10001000)
volatile uint32_t* InterfaceCmd = SD_BASE + 0x81;
volatile uint32_t* SDCmd = SD_BASE + 0x88;
volatile uint32_t* SDResponse = SD_BASE + 0x82;
volatile uint32_t* InterfaceStatus = SD_BASE + 0x84;
volatile uint32_t* SDData = SD_BASE;
bool SDHAL_IsSupport4Bits(void){
bool bYes = FALSE;
#ifdef SD_4BIT_MODE
bYes = TRUE;
#endif
return bYes;
}
void SDHAL_Init(void){
// SD_CMD_OUT;
// SD_DAT_IN;
// SD_CLK_HIGH;
// SD_CMD_HIGH;
// SD_DAT_LOW;
*InterfaceCmd = 7;
}
void SDHAL_SendCmd(alt_u8 szCommand[6], int nCmdLen){
int i;
//alt_u8 Mask, Data;
//SD_CMD_OUT;
// for(i=0;i<nCmdLen;i++){
// Mask = 0x80;
// Data = szCommand[i];
// for(k=0;k<8;k++){
// SD_CLK_LOW;
// if (Data & Mask)
// SD_CMD_HIGH;
// else
// SD_CMD_LOW;
// SD_CLK_HIGH;
// //
// Mask >>= 1;
// // usleep(1);
// }
// }
for (i=0;i<6;++i){
*(SDCmd+i) = szCommand[i];
//printf("%c sent, %c receive\n",szCommand[i],*(SDCmd+i));
}
*InterfaceCmd = 1;
}
bool SDHAL_GetResponse(alt_u8 szResponse[], int nLen){
// bool bDone, bTimeout;
// const int nMaxCnt = 20; // !!!! Note. the value should be large than 8
// int nCnt, nBitCnt, nIndex;
// alt_u8 Value;
int i;
*InterfaceCmd = 6;
while (!(*InterfaceStatus));
if (*InterfaceStatus == 3){
printf("Response Timeout\n");
return 0;}
szResponse[0] = *SDResponse;
for (i=1;i<nLen;++i){
*InterfaceCmd = 2;
while (!(*InterfaceStatus));
szResponse[i] = *SDResponse;
}
// SD_CMD_IN;
// //===== check start bit == 0
// nCnt = 0;
// bDone = FALSE;
// bTimeout = FALSE;
// while(!bDone && !bTimeout){
// SD_CLK_LOW;
// SD_CLK_HIGH;
// if(!(SD_TEST_CMD))
// bDone = TRUE;
// else if(nCnt++ > nMaxCnt)
// bTimeout = TRUE;
// }
// if (!bDone || bTimeout)
// return FALSE;
// //===== check transmitter bit == 0
// SD_CLK_LOW;
// SD_CLK_HIGH;
// if (SD_TEST_CMD)
// return FALSE; // 0 is expected
// //===== read content + CRC + end-bits ======
// nIndex = 2;
// nBitCnt = nLen*8;
// bDone = FALSE;
// Value = 0;
// while(nIndex < nBitCnt){
// SD_CLK_LOW;
// SD_CLK_HIGH;
// if (SD_TEST_CMD){
// Value |= 0x80 >> (nIndex % 8);
// }
// if (nIndex%8 == 7){
// szResponse[nIndex/8] = Value;
// Value = 0;
// }
// nIndex++;
// }
// A command with response. 8 clocks after the card response end bit.
*InterfaceCmd = 4;
return 1;
}
bool SDHAL_ReadData(alt_u8 szBuf[], int nBufLen){
// bool bSuccess = TRUE;
// int nTry = 0;
// const int nMaxTry = 5000;
// int i, j,k,n=0;
// alt_u8 DataTemp;
// alt_u8 Data8;
// #ifndef SD_4BIT_MODE
// alt_u16 DataCrc16, MyCrc16;
// #else
// alt_u8 szBuf_0[128],szBuf_1[128],szBuf_2[128],szBuf_3[128];
// alt_u16 DataCrc16_0,DataCrc16_1,DataCrc16_2,DataCrc16_3;
// alt_u16 MyCrc16_0,MyCrc16_1,MyCrc16_2,MyCrc16_3;
// alt_u8 Data8_0,Data8_1,Data8_2,Data8_3;
// #endif
// wait start bits (zero)
// while(1){
// SD_CLK_LOW;
// SD_CLK_HIGH;
// #ifdef SD_4BIT_MODE
// if((SD_TEST_DAT & 0x0F) == 0x00) // check start bits (zero is expected)
// #else
// if((SD_TEST_DAT & 0x01) == 0x00) // check start bits (zero is expected)
// #endif
// break;
// if (nTry++ > nMaxTry)
// return FALSE;
// }
int i;
*InterfaceCmd = 3;
while (!(*InterfaceStatus));
for (i=0;i<128;++i){
((uint32_t*)szBuf)[i] = *(SDData+i);
}
//===== CRC16 and end-bit check (each channel is seperated)
// check end bit (value 'one' is expected
// to provide8 (eight) clock cycles for the card to complete the operation before shutting down the clock
//SDHAL_DummyClock(8);
*InterfaceCmd = 5;
//*InterfaceCmd = 4;
//Jump 16 + 1 + 8 = 25 cycles
return 1;
}
bool SDHAL_WriteData(alt_u8 szDataWrite[], int nDataLen){
// to provide8 (eight) clock cycles for the card to complete the operation before shutting down the clock
//SDHAL_DummyClock(8);
/*
//
for(i=0; i<16; i++){
SD_CLK_LOW;
SD_CLK_HIGH;
}*/
return 1;
}
void SDHAL_DummyClock(int nClockCnt){
*InterfaceCmd = 4;
}
software/audio_sd/sdcard/sd_hal.h deleted 100644 → 0
+ 0
− 46
View file @ 1205ea46
// --------------------------------------------------------------------
// Copyright (c) 2009 by Terasic Technologies Inc.
// --------------------------------------------------------------------
//
// Permission:
//
// Terasic grants permission to use and modify this code for use
// in synthesis for all Terasic Development Boards and Altera Development
// Kits made by Terasic. Other use of this code, including the selling
// ,duplication, or modification of any portion is strictly prohibited.
//
// Disclaimer:
//
// This VHDL/Verilog or C/C++ source code is intended as a design reference
// which illustrates how these types of functions can be implemented.
// It is the user's responsibility to verify their design for
// consistency and functionality through the use of formal
// verification methods. Terasic provides no warranty regarding the use
// or functionality of this code.
//
// --------------------------------------------------------------------
//
// Terasic Technologies Inc
// 356 Fu-Shin E. Rd Sec. 1. JhuBei City,
// HsinChu County, Taiwan
// 302
//
// web: http://www.terasic.com/
// email: support@terasic.com
//
// --------------------------------------------------------------------
#ifndef SD_HAL_H_
#define SD_HAL_H_
#include "terasic_includes.h"
void SDHAL_Init(void);
bool SDHAL_IsSupport4Bits(void);
void SDHAL_SendCmd(alt_u8 szCommand[6], int nCmdLen);
bool SDHAL_GetResponse(alt_u8 szResponse[], int nLen);
bool SDHAL_ReadData(alt_u8 szBuf[], int nBufLen);
bool SDHAL_WriteData(alt_u8 szDataWrite[], int nDataLen);
void SDHAL_DummyClock(int nClockCnt);
#endif /*SD_HAL_H_*/
software/audio_sd/sdcard/sd_hw.h deleted 100644 → 0
+ 0
− 63
View file @ 1205ea46
// --------------------------------------------------------------------
// Copyright (c) 2009 by Terasic Technologies Inc.
// --------------------------------------------------------------------
//
// Permission:
//
// Terasic grants permission to use and modify this code for use
// in synthesis for all Terasic Development Boards and Altera Development
// Kits made by Terasic. Other use of this code, including the selling
// ,duplication, or modification of any portion is strictly prohibited.
//
// Disclaimer:
//
// This VHDL/Verilog or C/C++ source code is intended as a design reference
// which illustrates how these types of functions can be implemented.
// It is the user's responsibility to verify their design for
// consistency and functionality through the use of formal
// verification methods. Terasic provides no warranty regarding the use
// or functionality of this code.
//
// --------------------------------------------------------------------
//
// Terasic Technologies Inc
// 356 Fu-Shin E. Rd Sec. 1. JhuBei City,
// HsinChu County, Taiwan
// 302
//
// web: http://www.terasic.com/
// email: support@terasic.com
//
// --------------------------------------------------------------------
#ifndef SD_HW_H_
#define SD_HW_H_
#include "terasic_includes.h"
#include "alt_types.h" // alt_u32
#include "io.h"
#include "system.h"
#define SD_4BIT_MODE
// direction control
#define SD_CMD_IN IOWR_ALTERA_AVALON_PIO_DIRECTION(SD_CMD_BASE, ALTERA_AVALON_PIO_DIRECTION_INPUT)
#define SD_CMD_OUT IOWR_ALTERA_AVALON_PIO_DIRECTION(SD_CMD_BASE, ALTERA_AVALON_PIO_DIRECTION_OUTPUT)
#define SD_DAT_IN IOWR_ALTERA_AVALON_PIO_DIRECTION(SD_DAT_BASE, ALTERA_AVALON_PIO_DIRECTION_INPUT)
#define SD_DAT_OUT IOWR_ALTERA_AVALON_PIO_DIRECTION(SD_DAT_BASE, ALTERA_AVALON_PIO_DIRECTION_OUTPUT)
// SD Card Output High/Low
#define SD_CMD_LOW IOWR_ALTERA_AVALON_PIO_DATA(SD_CMD_BASE, 0)
#define SD_CMD_HIGH IOWR_ALTERA_AVALON_PIO_DATA(SD_CMD_BASE, 1)
#define SD_CLK_LOW IOWR_ALTERA_AVALON_PIO_DATA(SD_CLK_BASE, 0)
#define SD_CLK_HIGH IOWR_ALTERA_AVALON_PIO_DATA(SD_CLK_BASE, 1)
#define SD_DAT_LOW IOWR_ALTERA_AVALON_PIO_DATA(SD_DAT_BASE, 0)
#define SD_DAT_HIGH IOWR_ALTERA_AVALON_PIO_DATA(SD_DAT_BASE, 1)
#define SD_DAT_WRITE(data4) IOWR_ALTERA_AVALON_PIO_DATA(SD_DAT_BASE, data4)
// SD Card Input Read
#define SD_TEST_CMD IORD_ALTERA_AVALON_PIO_DATA(SD_CMD_BASE)
#define SD_TEST_DAT IORD_ALTERA_AVALON_PIO_DATA(SD_DAT_BASE)
#endif /*DW_HW_H_*/
software/audio_sd/sdcard/sd_lib.c deleted 100644 → 0
+ 0
− 316
View file @ 1205ea46
// --------------------------------------------------------------------
// Copyright (c) 2010 by Terasic Technologies Inc.
// --------------------------------------------------------------------
//
// Permission:
//
// Terasic grants permission to use and modify this code for use
// in synthesis for all Terasic Development Boards and Altera Development
// Kits made by Terasic. Other use of this code, including the selling
// ,duplication, or modification of any portion is strictly prohibited.
//
// Disclaimer:
//
// This VHDL/Verilog or C/C++ source code is intended as a design reference
// which illustrates how these types of functions can be implemented.
// It is the user's responsibility to verify their design for
// consistency and functionality through the use of formal
// verification methods. Terasic provides no warranty regarding the use
// or functionality of this code.
//
// --------------------------------------------------------------------
//
// Terasic Technologies Inc
// 356 Fu-Shin E. Rd Sec. 1. JhuBei City,
// HsinChu County, Taiwan
// 302
//
// web: http://www.terasic.com/
// email: support@terasic.com
//
// --------------------------------------------------------------------
// Revision:
// 2.0:
// 1. Support SDHC (SDCARD >= 4GB)
// 2. Support Single Block Write API
// 3. Add crc16 check for data
//
// --------------------------------------------------------------------
#include <unistd.h> // usleep
#include <stdio.h>
#include "sd_lib.h"
#include "sd_protocol.h"
#ifdef DEBUG_SDCARD
#define SDCARD_TRACE(x) {DEBUG(("[SD_LIB]")); DEBUG(x);}
#define SDCARD_DEBUG(x) {DEBUG(("[SD_LIB]")); DEBUG(x);}
#define SDCARD_ERROR(x) {DEBUG(("[SD_LIB]ERR:")); DEBUG(x);}
#else
#define SDCARD_DEBUG(x)
#define SDCARD_TRACE(x)
#define SDCARD_ERROR(x)
#endif
#define DEBUG_SDCARD_HEX //DEBUG_HEX_PRINTF
//alt_u8 gszCSD[17];
//alt_u8 gszCID[17];
//bool gbActive = FALSE;
//void DumpCsdInfo(alt_u8 szCSD[]);
//-------------------------------------------------------------------------
// sdcard info
typedef struct{
bool bSupport4Bits;
bool bVer2;
bool bSDHC;
alt_u32 HostOCR32;
alt_u32 OCR32;
alt_u16 RCA16;
alt_u8 szCID[16+1];
alt_u8 szCSD[16+1];
}SD_INFO;
static SD_INFO gSdInfo;
//-------------------------------------------------------------------------
bool SDLIB_Init(void)
{
bool bSuccess = FALSE, bTimeout = FALSE;
alt_u8 szThisCID[16];
const int nTimeout = alt_ticks_per_second();
alt_u32 TimeStart;
// alt_u8 x,y;
memset(&gSdInfo, 0, sizeof(gSdInfo));
gSdInfo.bSupport4Bits = SD_IsSupport4Bits();
SDCARD_DEBUG(("--- Power On, Card Identification Mode, Idle State\r\n"));
SDCARD_DEBUG(("sd %d-bit mode\r\n", gSdInfo.bSupport4Bits?4:1));
usleep(74*10);
SD_Init();
//========================== CMD0 (None Response) ========
// Reset all cards to idle state
SD_CMD0();
usleep(100*1000);
//========================== CMD8 (Response R7) ==========
//Sends SD Memory Card interface condition (Added in SDHC 2.0)
if (SD_CMD8(SD_VHS_2V7_3V6, CMD8_DEFAULT_TEST_PATTERN)){
// OCR: Operation Condistions Register
//gSdInfo.HostOCR32 = 0x01 << 30; //argument=0x40FF8000; // support HC
gSdInfo.HostOCR32 = 0x40FF8000;
gSdInfo.bVer2 = TRUE;
gSdInfo.bSDHC = TRUE;
SDCARD_DEBUG((" 2.0 \r\n"));
}else{
gSdInfo.HostOCR32 = 0x00040000;
SDCARD_TRACE(("CMD8 not supported\r\n"));
// Reset cards to idle state
SD_CMD0();
usleep(100*1000);
}
//========================== ACMD41 (CMD55) ==============
TimeStart = alt_nticks();
while(!bSuccess && !bTimeout){
if (!SD_CMD55(gSdInfo.RCA16, SD_STATE_IDLE)){ // execute cmd55 before execute and ACMD
SDCARD_ERROR(("CMD55 NG\r\n"));
return FALSE;
}else{
bSuccess = SD_ACMD41(gSdInfo.HostOCR32, &gSdInfo.OCR32);
if (bSuccess && gSdInfo.bSDHC && ((gSdInfo.OCR32 & 0x40000000) == 0x00)){
gSdInfo.bSDHC = FALSE;
}
// check timeout
if (!bSuccess){
if ((alt_nticks() - TimeStart) > nTimeout){
SDCARD_ERROR(("ACMD41[SD_APP_OP_COND] fail\r\n"));
bTimeout = TRUE;
}else{
usleep(10*1000);
}
}
}
}
if (!bSuccess){
return FALSE;
}
//========================== CMD2 ========================
// issue cmd2 & wait response
// ALL_SEND_CID (CMD2): Asks any card to send the CID numbers on the CMD line
if (!SD_CMD2(gSdInfo.szCID, sizeof(gSdInfo.szCID))){
SDCARD_ERROR(("CMD2 fail\r\n"));
return FALSE;
}
SDCARD_TRACE(("--- Power On, Card Identification Mode, Identification State\r\n"));
//========================== CMD3 ========================
// issue cmd3 & wait response, finally get RCA
// CMD3 (SEND_RELATIVE_ADDR): Ask the card to publish a new relative address (RCA)
if (!SD_CMD3(&gSdInfo.RCA16)){
SDCARD_ERROR(("CMD3 fail\r\n"));
return FALSE;
}
// above is Card Identification Mode
//*************** now, wer are in Data Transfer Mode ********************************/
//### Standby-by state in Data-transfer mode
//========================== CMD9 ========================
SDCARD_DEBUG(("--- enter data-transfer mode, Standby state\r\n"));
// issue cmd9 with given RCA & wait response
if (!SD_CMD9(gSdInfo.RCA16, gSdInfo.szCSD, sizeof(gSdInfo.szCSD))){
SDCARD_DEBUG(("CMD9 fail\r\n"));
return FALSE;
}
//========================== CMD10 ========================
// richard add (query card identification)
if (!SD_CMD10(gSdInfo.RCA16, szThisCID, sizeof(szThisCID))){
SDCARD_DEBUG(("CMD10 fail\r\n"));
return FALSE;
}
// can issue cmd 4, 9, 10, in (stdandby state)
// issue cmd9 with given RCA & wait response
//========================== CMD7 ========================
// richard: issue cmd7 to enter transfer state
// cmd7: toggle between Standy-by and Trasfer State
if (!SD_CMD7(gSdInfo.RCA16)){
SDCARD_DEBUG(("CMD7 fail\r\n"));
return FALSE;
}
//### Transfer state in Data-transfer mode
SDCARD_DEBUG(("--- enter data-transfer mode, Transfer state\r\n"));
//========================== CMD16 ========================
// issue cmd16 (select a block length) & wait response
if (!SD_CMD16(512)){ // 512 bytes
SDCARD_DEBUG(("CMD16 fail\r\n"));
return FALSE;
}
if (gSdInfo.bSupport4Bits){
// richard add: set bus width
// Note. This command is valid only in "transfer state", i.e. after CMD7 is issued
if (!SD_CMD55(gSdInfo.RCA16, SD_STATE_TRAN)){ // execute cmd55 before execute and ACMD, RCA = 0
SDCARD_DEBUG(("CMD55 NG\r\n"));
return FALSE;
}
SDCARD_DEBUG(("ACMD6[SET_BUS_WIDTH], 4-bit\r\n"));
if (!SD_ACMD6(TRUE, SD_STATE_TRAN)){ // 4-bit mode
SDCARD_DEBUG(("ACMD6 NG\r\n"));
return FALSE;
}
//
if (!SD_CMD55(gSdInfo.RCA16, SD_STATE_TRAN)){ // execute cmd55 before execute and ACMD, RCA = 0
SDCARD_DEBUG(("CMD55 NG\r\n"));
return FALSE;
}
SDCARD_DEBUG(("ACMD42[SET_CLR_CARD_DETECT], connect card\r\n"));
if (!SD_ACMD42(TRUE, SD_STATE_TRAN)){ // connect card
SDCARD_DEBUG(("ACMD42 NG\r\n"));
return FALSE;
}
}
//
#if 0
int i;
bool test_ok;
alt_u8 szWrite[512];
for(i=0;i<512;i++)
szWrite[i] = i;
test_ok = SDLIB_WriteBlock512(100, szWrite);
if (!test_ok)
printf("!!!!!SDLIB_WriteBlock512 ng\r\n");
if (test_ok){
test_ok = SDLIB_ReadBlock512(100, szWrite);
if (!test_ok)
printf("!!!!!SDLIB_ReadBlock512 ng\r\n");
}
if (test_ok && szWrite[1] == 1)
printf("!!!!!write success\r\n");
else
printf("!!!!!write ng\r\n");
#endif
SDCARD_DEBUG(("SDLIB_Init success\r\n"));
return TRUE;
}
bool SDLIB_ReadBlock512(alt_u32 block_number, alt_u8 *buff)
{
// buffer size muse be 512 byte
bool bSuccess;
alt_u32 addr;
// issue cmd17 for 'Single Block Read'. parameter: block address
if (gSdInfo.bSDHC)
addr = block_number; // note. for SDHC, argument for addr of CMD7 is block number
else
addr = block_number * 512;
if (!SD_CMD17(addr, SD_STATE_TRAN)){ // 4-bit mode
SDCARD_DEBUG(("CMD17 NG\r\n"));
return FALSE;
}
//
bSuccess = SD_ReadData(buff, 512); // read 512 bytes
//
return bSuccess;
}
// bool SDLIB_WriteBlock512(alt_u32 block_number, alt_u8 *szDataWrite)
// {
// // buffer size muse be 512 byte
// bool bSuccess;
// alt_u32 addr;
// // issue cmd24 for 'Single Block write'. parameter: block address
// if (gSdInfo.bSDHC)
// addr = block_number; // note. for SDHC, argument for addr of CMD7 is block number
// else
// addr = block_number * 512;
// if (!SD_CMD24(addr, SD_STATE_TRAN)){
// SDCARD_DEBUG(("CMD24 NG\r\n"));
// return FALSE;
// }
// //
// bSuccess = SD_WriteData(szDataWrite, 512); // Write 512 bytes
// //
// return bSuccess;
// }
software/audio_sd/sdcard/sd_lib.h deleted 100644 → 0
+ 0
− 48
View file @ 1205ea46
// --------------------------------------------------------------------
// Copyright (c) 2009 by Terasic Technologies Inc.
// --------------------------------------------------------------------
//
// Permission:
//
// Terasic grants permission to use and modify this code for use
// in synthesis for all Terasic Development Boards and Altera Development
// Kits made by Terasic. Other use of this code, including the selling
// ,duplication, or modification of any portion is strictly prohibited.
//
// Disclaimer:
//
// This VHDL/Verilog or C/C++ source code is intended as a design reference
// which illustrates how these types of functions can be implemented.
// It is the user's responsibility to verify their design for
// consistency and functionality through the use of formal
// verification methods. Terasic provides no warranty regarding the use
// or functionality of this code.
//
// --------------------------------------------------------------------
//
// Terasic Technologies Inc
// 356 Fu-Shin E. Rd Sec. 1. JhuBei City,
// HsinChu County, Taiwan
// 302
//
// web: http://www.terasic.com/
// email: support@terasic.com
//
// --------------------------------------------------------------------
#ifndef SD_CARD_LIB_H_
#define SD_CARD_LIB_H_
#include "terasic_includes.h"
bool SDLIB_Init(void);
bool SDLIB_ReadBlock512(alt_u32 block_number, alt_u8 *buff);
//bool SDLIB_WriteBlock512(alt_u32 block_number, alt_u8 szDataWrite[]);
//bool SD_GetCSD(alt_u8 szCSD[], alt_u8 len);
//bool SD_GetCID(alt_u8 szCID[], alt_u8 len);
#endif /*SD_CARD_LIB_H_*/
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment