Subversion Repositories openrisc

/*
	DOSFS Embedded FAT-Compatible Filesystem
	(C) 2005 Lewin A.R.W. Edwards (sysadm@zws.com)
*/
 
#ifndef _DOSFS_H
#define _DOSFS_H
//#include <stdio.h>
//#include <sys/types.h>
//#include <stdint.h>
#include "board.h"
#include "typedefs.h"
 
#include "spr-defs.h"
#include "support.h"
//#include <stdlib.h>
 
#include "int.h"
#include "uart.h"
#include "screen.h"
//===================================================================
char *strcpy2(char *dest,  char* src);
int memcmp2(const void *s1, const void *s2, size_t  n);
int strcmp2(const char * s1, const char * s2);
 
 typedef struct
        {
           long int quot;
           long int rem;   
        } ldiv_t;
 
 typedef struct
        {
          int quot;
         int rem;   
        } div_t;
 
 
#define SECTOR_TO_BLOCK(a) ( (a) << 9)
unsigned long int DFS_ReadSector(unsigned char unit, unsigned char *buffer, unsigned long int sector, unsigned long int  count);
unsigned long int DFS_WriteSector(unsigned char unit, unsigned char *buffer, unsigned long int sector, unsigned long int  count);
 
 
 ldiv_t ldiv (long int numer, long int denom);
div_t div ( int numer,  int denom);
 
//===================================================================
// Configurable items
#define MAX_PATH		64		// Maximum path length (increasing this will
								// GREATLY increase stack requirements!)
#define DIR_SEPARATOR	'/'		// character separating directory components
 
// End of configurable items
//===================================================================
 
//===================================================================
// 32-bit error codes
#define DFS_OK			0			// no error
#define DFS_EOF			1			// end of file (not an error)
#define DFS_WRITEPROT	2			// volume is write protected
#define DFS_NOTFOUND	3			// path or file not found
#define DFS_PATHLEN		4			// path too long
#define DFS_ALLOCNEW	5			// must allocate new directory cluster
#define DFS_ERRMISC		0xffffffff	// generic error
 
//===================================================================
// File access modes
#define DFS_READ		1			// read-only
#define DFS_WRITE		2			// write-only
 
//===================================================================
// Miscellaneous constants
#define SECTOR_SIZE		512		// sector size in bytes
 
//===================================================================
// Internal subformat identifiers
#define FAT12			0
#define FAT16			1
#define FAT32			2
 
//===================================================================
// DOS attribute bits
#define ATTR_READ_ONLY	0x01
#define ATTR_HIDDEN		0x02
#define ATTR_SYSTEM		0x04
#define ATTR_VOLUME_ID	0x08
#define ATTR_DIRECTORY	0x10
#define ATTR_ARCHIVE	0x20
#define ATTR_LONG_NAME	(ATTR_READ_ONLY | ATTR_HIDDEN | ATTR_SYSTEM | ATTR_VOLUME_ID)
 
 
/*
	Directory entry structure
	note: if name[0] == 0xe5, this is a free dir entry
	      if name[0] == 0x00, this is a free entry and all subsequent entries are free
		  if name[0] == 0x05, the first character of the name is 0xe5 [a kanji nicety]
 
	Date format: bit 0-4  = day of month (1-31)
	             bit 5-8  = month, 1=Jan..12=Dec
				 bit 9-15 =	count of years since 1980 (0-127)
	Time format: bit 0-4  = 2-second count, (0-29)
	             bit 5-10 = minutes (0-59)
				 bit 11-15= hours (0-23)
*/
typedef struct _tagDIRENT {
	unsigned char name[11];			// filename
	unsigned char attr;				// attributes (see ATTR_* constant definitions)
	unsigned char reserved;			// reserved, must be 0
	unsigned char crttimetenth;		// create time, 10ths of a second (0-199 are valid)
	unsigned char crttime_l;			// creation time low byte
	unsigned char crttime_h;			// creation time high byte
	unsigned char crtdate_l;			// creation date low byte
	unsigned char crtdate_h;			// creation date high byte
	unsigned char lstaccdate_l;		// last access date low byte
	unsigned char lstaccdate_h;		// last access date high byte
	unsigned char startclus_h_l;		// high word of first cluster, low byte (FAT32)
	unsigned char startclus_h_h;		// high word of first cluster, high byte (FAT32)
	unsigned char wrttime_l;			// last write time low byte
	unsigned char wrttime_h;			// last write time high byte
	unsigned char wrtdate_l;			// last write date low byte
	unsigned char wrtdate_h;			// last write date high byte
	unsigned char startclus_l_l;		// low word of first cluster, low byte
	unsigned char startclus_l_h;		// low word of first cluster, high byte
	unsigned char filesize_0;			// file size, low byte
	unsigned char filesize_1;			//
	unsigned char filesize_2;			//
	unsigned char filesize_3;			// file size, high byte
} DIRENT, *PDIRENT;
 
/*
	Partition table entry structure
*/
typedef struct _tagPTINFO {
	unsigned char		active;			// 0x80 if partition active
	unsigned char		start_h;		// starting head
	unsigned char		start_cs_l;		// starting cylinder and sector (low byte)
	unsigned char		start_cs_h;		// starting cylinder and sector (high byte)
	unsigned char		type;			// type ID byte
	unsigned char		end_h;			// ending head
	unsigned char		end_cs_l;		// ending cylinder and sector (low byte)
	unsigned char		end_cs_h;		// ending cylinder and sector (high byte)
	unsigned char		start_0;		// starting sector# (low byte)
	unsigned char		start_1;		//
	unsigned char		start_2;		//
	unsigned char		start_3;		// starting sector# (high byte)
	unsigned char		size_0;			// size of partition (low byte)
	unsigned char		size_1;			//
	unsigned char		size_2;			//
	unsigned char		size_3;			// size of partition (high byte)
} PTINFO, *PPTINFO;
 
/*
	Master Boot Record structure
*/
typedef struct _tagMBR {
	unsigned char bootcode[0x1be];	// boot sector
	PTINFO ptable[4] __attribute__((__packed__));
;			// four partition table structures
	unsigned char sig_55;				// 0x55 signature byte
	unsigned char sig_aa;				// 0xaa signature byte
} MBR, *PMBR;
 
/*
	BIOS Parameter Block structure (FAT12/16)
*/
typedef struct _tagBPB {
	unsigned char bytepersec_l;		// bytes per sector low byte (0x00)
	unsigned char bytepersec_h;		// bytes per sector high byte (0x02)
	unsigned char	secperclus;			// sectors per cluster (1,2,4,8,16,32,64,128 are valid)
	unsigned char reserved_l;			// reserved sectors low byte
	unsigned char reserved_h;			// reserved sectors high byte
	unsigned char numfats;			// number of FAT copies (2)
	unsigned char rootentries_l;		// number of root dir entries low byte (0x00 normally)
	unsigned char rootentries_h;		// number of root dir entries high byte (0x02 normally)
	unsigned char sectors_s_l;		// small num sectors low byte
	unsigned char sectors_s_h;		// small num sectors high byte
	unsigned char mediatype;			// media descriptor byte
	unsigned char secperfat_l;		// sectors per FAT low byte
	unsigned char secperfat_h;		// sectors per FAT high byte
	unsigned char secpertrk_l;		// sectors per track low byte
	unsigned char secpertrk_h;		// sectors per track high byte
	unsigned char heads_l;			// heads low byte
	unsigned char heads_h;			// heads high byte
	unsigned char hidden_0;			// hidden sectors low byte
	unsigned char hidden_1;			// (note - this is the number of MEDIA sectors before
	unsigned char hidden_2;			// first sector of VOLUME - we rely on the MBR instead)
	unsigned char hidden_3;			// hidden sectors high byte
	unsigned char sectors_l_0;		// large num sectors low byte
	unsigned char sectors_l_1;		//
	unsigned char sectors_l_2;		//
	unsigned char sectors_l_3;		// large num sectors high byte
} BPB, *PBPB;
 
 
 
 
/*
	Extended BIOS Parameter Block structure (FAT12/16)
*/
typedef struct _tagEBPB {
	unsigned char unit;				// int 13h drive#
	unsigned char head;				// archaic, used by Windows NT-class OSes for flags
	unsigned char signature;			// 0x28 or 0x29
	unsigned char serial_0;			// serial#
	unsigned char serial_1;			// serial#
	unsigned char serial_2;			// serial#
	unsigned char serial_3;			// serial#
	unsigned char label[11];			// volume label
	unsigned char system[8];			// filesystem ID
} EBPB, *PEBPB;
 
/*
	Extended BIOS Parameter Block structure (FAT32)
*/
typedef struct _tagEBPB32 {
	unsigned char fatsize_0;			// big FAT size in sectors low byte
	unsigned char fatsize_1;			//
	unsigned char fatsize_2;			//
	unsigned char fatsize_3;			// big FAT size in sectors high byte
	unsigned char extflags_l;			// extended flags low byte
	unsigned char extflags_h;			// extended flags high byte
	unsigned char fsver_l;			// filesystem version (0x00) low byte
	unsigned char fsver_h;			// filesystem version (0x00) high byte
	unsigned char root_0;				// cluster of root dir, low byte
	unsigned char root_1;				//
	unsigned char root_2;				//
	unsigned char root_3;				// cluster of root dir, high byte
	unsigned char fsinfo_l;			// sector pointer to FSINFO within reserved area, low byte (2)
	unsigned char fsinfo_h;			// sector pointer to FSINFO within reserved area, high byte (0)
	unsigned char bkboot_l;			// sector pointer to backup boot sector within reserved area, low byte (6)
	unsigned char bkboot_h;			// sector pointer to backup boot sector within reserved area, high byte (0)
	unsigned char reserved[12];		// reserved, should be 0
 
	unsigned char unit;				// int 13h drive#
	unsigned char head;				// archaic, used by Windows NT-class OSes for flags
	unsigned char signature;			// 0x28 or 0x29
	unsigned char serial_0;			// serial#
	unsigned char serial_1;			// serial#
	unsigned char serial_2;			// serial#
	unsigned char serial_3;			// serial#
	unsigned char label[11];			// volume label
	unsigned char system[8];			// filesystem ID
} EBPB32, *PEBPB32;
 
/*
	Logical Boot Record structure (volume boot sector)
*/
typedef struct _tagLBR {
	unsigned char jump[3];			// JMP instruction
	unsigned char oemid[8];			// OEM ID, space-padded
	BPB bpb  __attribute__((__packed__));					// BIOS Parameter Block
	union {
		EBPB ebpb  __attribute__((__packed__));				// FAT12/16 Extended BIOS Parameter Block
		EBPB32 ebpb32  __attribute__((__packed__));			// FAT32 Extended BIOS Parameter Block
	} ebpb;
	unsigned char code[420];			// boot sector code
	unsigned char sig_55;				// 0x55 signature byte
	unsigned char sig_aa;				// 0xaa signature byte
} LBR, *PLBR;
 
/*
	Volume information structure (Internal to DOSFS)
*/
typedef struct _tagVOLINFO {
	unsigned char unit;				// unit on which this volume resides
	unsigned char filesystem;			// formatted filesystem
 
// These two fields aren't very useful, so support for them has been commented out to
// save memory. (Note that the "system" tag is not actually used by DOS to determine
// filesystem type - that decision is made entirely on the basis of how many clusters
// the drive contains. DOSFS works the same way).
// See tag: OEMID in dosfs.c
//	unsigned char oemid[9];			// OEM ID ASCIIZ
//	unsigned char system[9];			// system ID ASCIIZ
	unsigned char label[12];			// volume label ASCIIZ
	unsigned long int  startsector;		// starting sector of filesystem
	unsigned char secperclus;			// sectors per cluster
	unsigned short int reservedsecs;		// reserved sectors
	unsigned long int numsecs;			// number of sectors in volume
	unsigned long int secperfat;			// sectors per FAT
	unsigned short int rootentries;		// number of root dir entries
 
	unsigned long int numclusters;		// number of clusters on drive
 
	// The fields below are PHYSICAL SECTOR NUMBERS.
	unsigned long int fat1;				// starting sector# of FAT copy 1
	unsigned long int rootdir;			// starting sector# of root directory (FAT12/FAT16) or cluster (FAT32)
	unsigned long int dataarea;			// starting sector# of data area (cluster #2)
} VOLINFO, *PVOLINFO;
 
/*
	Flags in DIRINFO.flags
*/
#define DFS_DI_BLANKENT		0x01	// Searching for blank entry
 
/*
	Directory search structure (Internal to DOSFS)
*/
typedef struct _tagDIRINFO {
	unsigned long int currentcluster;	// current cluster in dir
	unsigned char currentsector;		// current sector in cluster
	unsigned char currententry;		// current dir entry in sector
	unsigned char *scratch;			// ptr to user-supplied scratch buffer (one sector)
	unsigned char flags;				// internal DOSFS flags
} DIRINFO, *PDIRINFO;
 
/*
	File handle structure (Internal to DOSFS)
*/
typedef struct _tagFILEINFO {
	PVOLINFO volinfo  __attribute__((__packed__));			// VOLINFO used to open this file
	unsigned long int dirsector;			// physical sector containing dir entry of this file
	unsigned char diroffset;			// # of this entry within the dir sector
	unsigned char mode;				// mode in which this file was opened
	unsigned long int firstcluster;		// first cluster of file
	unsigned long int filelen;			// byte length of file
 
	unsigned long int cluster;			// current cluster
	unsigned long int pointer;			// current (BYTE) pointer
} FILEINFO, *PFILEINFO;
 
/*
	Get starting sector# of specified partition on drive #unit
	NOTE: This code ASSUMES an MBR on the disk.
	scratchsector should point to a SECTOR_SIZE scratch area
	Returns 0xffffffff for any error.
	If pactive is non-NULL, this function also returns the partition active flag.
	If pptype is non-NULL, this function also returns the partition type.
	If psize is non-NULL, this function also returns the partition size.
*/
unsigned long int init_fat(VOLINFO *vis);
 
unsigned long int DFS_GetPtnStart(unsigned char unit, unsigned char *scratchsector, unsigned char pnum, unsigned char *pactive, unsigned char *pptype, unsigned long int *psize);
 
/*
	Retrieve volume info from BPB and store it in a VOLINFO structure
	You must provide the unit and starting sector of the filesystem, and
	a pointer to a sector buffer for scratch
	Attempts to read BPB and glean information about the FS from that.
	Returns 0 OK, nonzero for any error.
*/
unsigned long int DFS_GetVolInfo(unsigned char unit, unsigned char *scratchsector, unsigned long int startsector, PVOLINFO volinfo);
 
/*
	Open a directory for enumeration by DFS_GetNextDirEnt
	You must supply a populated VOLINFO (see DFS_GetVolInfo)
	The empty string or a string containing only the directory separator are
	considered to be the root directory.
	Returns 0 OK, nonzero for any error.
*/
unsigned long int DFS_OpenDir(PVOLINFO volinfo, unsigned char *dirname, PDIRINFO dirinfo);
 
/*
	Get next entry in opened directory structure. Copies fields into the dirent
	structure, updates dirinfo. Note that it is the _caller's_ responsibility to
	handle the '.' and '..' entries.
	A deleted file will be returned as a NULL entry (first char of filename=0)
	by this code. Filenames beginning with 0x05 will be translated to 0xE5
	automatically. Long file name entries will be returned as NULL.
	returns DFS_EOF if there are no more entries, DFS_OK if this entry is valid,
	or DFS_ERRMISC for a media error
*/
unsigned long int DFS_GetNext(PVOLINFO volinfo, PDIRINFO dirinfo, PDIRENT dirent);
 
/*
	Open a file for reading or writing. You supply populated VOLINFO, a path to the file,
	mode (DFS_READ or DFS_WRITE) and an empty fileinfo structure. You also need to
	provide a pointer to a sector-sized scratch buffer.
	Returns various DFS_* error states. If the result is DFS_OK, fileinfo can be used
	to access the file from this point on.
*/
unsigned long int DFS_OpenFile(PVOLINFO volinfo, unsigned char *path, unsigned char mode, unsigned char *scratch, PFILEINFO fileinfo);
 
/*
	Read an open file
	You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a
	pointer to a SECTOR_SIZE scratch buffer.
	Note that returning DFS_EOF is not an error condition. This function updates the
	successcount field with the number of bytes actually read.
*/
unsigned long int DFS_ReadFile(PFILEINFO fileinfo, unsigned char *scratch, unsigned char *buffer, unsigned long int *successcount, unsigned long int len);
 
/*
	Write an open file
	You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a
	pointer to a SECTOR_SIZE scratch buffer.
	This function updates the successcount field with the number of bytes actually written.
*/
unsigned long int DFS_WriteFile(PFILEINFO fileinfo, unsigned char *scratch, unsigned char *buffer, unsigned long int *successcount, unsigned long int len);
 
/*
	Seek file pointer to a given position
	This function does not return status - refer to the fileinfo->pointer value
	to see where the pointer wound up.
	Requires a SECTOR_SIZE scratch buffer
*/
void DFS_Seek(PFILEINFO fileinfo, unsigned long int offset, unsigned char *scratch);
 
/*
	Delete a file
	scratch must point to a sector-sized buffer
*/
unsigned long int DFS_UnlinkFile(PVOLINFO volinfo, unsigned char *path, unsigned char *scratch);
 
// If we are building a host-emulation version, include host support
#ifdef HOSTVER
#include "hostemu.h"
#endif
 
#endif // _DOSFS_H