WebSVN - NaviCtrl - Blame - Rev 171

Rev	Author	Line No.	Line
1	ingob	1	/#######################################################################################/
		2	/* !!! THIS IS NOT FREE SOFTWARE !!! */
		3	/#######################################################################################/
		4	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		5	// + Copyright (c) 2008 Ingo Busker, Holger Buss
171	ingob	6	// + Nur f�r den privaten Gebrauch / NON-COMMERCIAL USE ONLY
1	ingob	7	// + FOR NON COMMERCIAL USE ONLY
		8	// + www.MikroKopter.com
		9	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
88	killagreg	10	// + Es gilt f�r das gesamte Projekt (Hardware, Software, Bin�rfiles, Sourcecode und Dokumentation),
		11	// + dass eine Nutzung (auch auszugsweise) nur f�r den privaten (nicht-kommerziellen) Gebrauch zul�ssig ist.
		12	// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
		13	// + bzgl. der Nutzungsbedingungen aufzunehmen.
1	ingob	14	// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Best�ckung und Verkauf von Platinen oder Baus�tzen,
		15	// + Verkauf von Luftbildaufnahmen, usw.
		16	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
88	killagreg	17	// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder ver�ffentlicht,
1	ingob	18	// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright m�ssen dann beiliegen
		19	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		20	// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
		21	// + auf anderen Webseiten oder sonstigen Medien ver�ffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
		22	// + eindeutig als Ursprung verlinkt werden
		23	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		24	// + Keine Gew�hr auf Fehlerfreiheit, Vollst�ndigkeit oder Funktion
		25	// + Benutzung auf eigene Gefahr
		26	// + Wir �bernehmen keinerlei Haftung f�r direkte oder indirekte Personen- oder Sachsch�den
		27	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
171	ingob	28	// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
1	ingob	29	// + mit unserer Zustimmung zul�ssig
		30	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		31	// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
		32	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
88	killagreg	33	// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
1	ingob	34	// + this list of conditions and the following disclaimer.
		35	// + * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
		36	// + from this software without specific prior written permission.
88	killagreg	37	// + * The use of this project (hardware, software, binary files, sources and documentation) is only permitted
1	ingob	38	// + for non-commercial use (directly or indirectly)
88	killagreg	39	// + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
1	ingob	40	// + with our written permission
88	killagreg	41	// + * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
		42	// + clearly linked as origin
171	ingob	43	// + * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed
1	ingob	44	//
		45	// + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
		46	// + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		47	// + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
		48	// + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
		49	// + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		50	// + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		51	// + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		52	// + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		53	// + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		54	// + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
88	killagreg	55	// + POSSIBILITY OF SUCH DAMAGE.
1	ingob	56	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
41	ingob	57	#include <stdio.h>
		58	#include "91x_lib.h"
119	killagreg	59	#include "timer1.h"
41	ingob	60	#include "fat16.h"
		61	#include "sdc.h"
		62	#include "uart1.h"
1	ingob	63
		64
		65	//________________________________________________________________________________________________________________________________________
88	killagreg	66	// Module name: fat16.c
1	ingob	67	// Compiler used: avr-gcc 3.4.5
41	ingob	68	// Last Modifikation: 16.06.2008
		69	// Version: 2.00
88	killagreg	70	// Authors: Stephan Busker & Gregor Stobrawa
41	ingob	71	// Description: Source files for FAT16 implementation with read and write-access
		72	// Copyright (C) 2008 Stephan Busker & Gregor Stobrawa
1	ingob	73	//........................................................................................................................................
41	ingob	74	// Functions: extern s16 Fat16_Init(void);
88	killagreg	75	// extern s16 Fat16_Deinit(void);
41	ingob	76	// extern File_t * fopen_(const u8 *filename, const s8 mode);
		77	// extern s16 fclose_(File_t *File);
		78	// extern s16 fflush_(File_t *File);
		79	// extern s16 fseek_(File_t *File, s32 offset, s16 origin);
		80	// extern s16 fgetc_(File_t *File);
		81	// extern s16 fputc_(u8 c, File_t *File);
88	killagreg	82	// extern u32 fread_(void buffer, u32 size, u32 count, File_t File);
41	ingob	83	// extern u32 fwrite_(void buffer, u32 size, u32 count, File_t File);
		84	// extern s16 fputs_(const u8 string, File_t File);
		85	// extern u8 * fgets_(u8 string, s16 length, File_t File);
1	ingob	86	//........................................................................................................................................
41	ingob	87	// ext. functions: extern SD_Result_t SDC_Init(void;)
		88	// extern SD_Result_t SDC_Deinit(void);
88	killagreg	89	// extern SD_Result_t SDC_GetSector (u32,u8 *);
41	ingob	90	// extern SD_Result_t SDC_PutSector (u32,u8 *);
1	ingob	91	//........................................................................................................................................
		92	//
		93	// URL: www.Mikro-Control.de
		94	// mailto: stephan.busker@mikro-control.de
		95	//________________________________________________________________________________________________________________________________________
		96
41	ingob	97	/*
		98	FAT16 Drive Layout:
		99	Description Offset
		100	Volume Boot Sector Start of Partition
		101	Fat Tables Start + # of Reserved Sectors
		102	Root Directory Entry Start + # of Reserved + (# of Sectors Per FAT * 2)
		103	Data Area (Starts with Cluster #2) Start + # of Reserved + (# of Sectors Per FAT * 2) + ((Maximum Root Directory Entries * 32) / Bytes per Sector)
		104	*/
1	ingob	105
		106
41	ingob	107	/*
		108	________________________________________________________________________________________________________________________________________
88	killagreg	109
		110	Structure of an partition entry
41	ingob	111	________________________________________________________________________________________________________________________________________
1	ingob	112
41	ingob	113	Partition Entry is 16 bytes long
		114	*/
		115	typedef struct
		116	{
		117	u8 PartitionState; // Current State of Partition (00h=Inactive, 80h=Active)
		118	u8 BeginningHead; // Beginning of Partition - Head
		119	u16 BeginningCylSec; // Beginning of Partition - Cylinder/Sector (See Below)
		120	u8 Type; // Type of Partition (See List Below)
		121	u8 EndHead; // End of Partition - Head
		122	u16 EndCylSec; // End of Partition - Cylinder/Sector
		123	u32 NoSectorsBeforePartition; // Number of Sectors between the MBR and the First Sector in the Partition
		124	u32 NoSectorsPartition ; // Number of Sectors in the Partition
88	killagreg	125	} __attribute__((packed)) PartitionEntry_t;
1	ingob	126
41	ingob	127	/*
		128	Coding of Cylinder/Sector words
1	ingob	129
41	ingob	130	Cylinder is 10 bits: [7:0] at [15:8] and [9:8] at [7:6]
88	killagreg	131	Sector is 5 bits: [5:0] at [5:0]
41	ingob	132	*/
1	ingob	133
41	ingob	134	// Partition Types:
		135	#define PART_TYPE_UNKNOWN 0x00
		136	#define PART_TYPE_FAT12 0x01
		137	#define PART_TYPE_XENIX 0x02
		138	#define PART_TYPE_FAT16_ST_32_MB 0x04
		139	#define PART_TYPE_EXTDOS 0x05
		140	#define PART_TYPE_FAT16_LT_32_MB 0x06
		141	#define PART_TYPE_NTFS 0x07
		142	#define PART_TYPE_FAT32 0x0B
		143	#define PART_TYPE_FAT32LBA 0x0C
		144	#define PART_TYPE_FAT16LBA 0x0E
		145	#define PART_TYPE_EXTDOSLBA 0x0F
		146	#define PART_TYPE_EISA 0x12
		147	#define PART_TYPE_ONTRACK 0x33
		148	#define PART_TYPE_NOVELL 0x40
		149	#define PART_TYPE_DYNAMIC 0x42
		150	#define PART_TYPE_PCIX 0x4B
		151	#define PART_TYPE_LINUX_SWAP 0x82
		152	#define PART_TYPE_LINUX_NATIVE 0x83
		153	#define PART_TYPE_LINUX_LVM 0x8E
		154	#define PART_TYPE_PHOENIXSAVE 0xA0
		155	#define PART_TYPE_FREEBSD 0xA5
		156	#define PART_TYPE_OPENBSD 0xA6
		157	#define PART_TYPE_NETNBSD 0xA9
		158	#define PART_TYPE_CPM 0xDB
		159	#define PART_TYPE_DBFS 0xE0
		160	#define PART_TYPE_BBT 0xFF
1	ingob	161
		162
41	ingob	163	/*
		164	________________________________________________________________________________________________________________________________________
88	killagreg	165
		166	Structure of the MasterBootRecord
41	ingob	167	________________________________________________________________________________________________________________________________________
1	ingob	168
41	ingob	169	Master Boot Record is 512 bytes long
		170	The Master Boot Record is the same for pretty much all Operating Systems.
		171	It is located on the first Sector of the Hard Drive, at Cylinder 0, Head 0, Sector 1
		172	*/
		173	typedef struct
		174	{
88	killagreg	175	u8 ExecutableCode[446]; // 446 bytes for machine start code
		176	PartitionEntry_t PartitionEntry1; // 16 bytes for partition entry 1
		177	PartitionEntry_t PartitionEntry2; // 16 bytes for partition entry 2
		178	PartitionEntry_t PartitionEntry3; // 16 bytes for partition entry 3
		179	PartitionEntry_t PartitionEntry4; // 16 bytes for partition entry 4
		180	u16 ExecutableMarker; // BIOS-Signature (0x55 0xAA)
		181	} __attribute__((packed)) MBR_Entry_t;
1	ingob	182
		183
41	ingob	184	/*
		185	________________________________________________________________________________________________________________________________________
88	killagreg	186
		187	Structure of the VolumeBootRecord
41	ingob	188	________________________________________________________________________________________________________________________________________
24	StephanB	189
41	ingob	190	The Volume Boot Record is 512 bytes long
		191	This information is located in the first sector of every partition.
		192	*/
		193	typedef struct
		194	{
		195	u8 JumpCode[3]; // Jump Code + NOP
88	killagreg	196	s8 OEMName[8]; // OEM Name
41	ingob	197	u16 BytesPerSector; // Bytes Per Sector
		198	u8 SectorsPerCluster; // Sectors Per Cluster
		199	u16 ReservedSectors; // Reserved Sectors
		200	u8 NoFATCopies; // Number of Copies of FAT
88	killagreg	201	u16 MaxRootEntries; // Maximum Root Directory Entries
41	ingob	202	u16 NoSectorsInPartSml32MB; // Number of Sectors in Partition Smaller than 32 MB
		203	u8 MediaDescriptor; // Media Descriptor (0xF8 for Hard Disks)
		204	u16 SectorsPerFAT; // Sectors Per FAT
		205	u16 SectorsPerTrack; // Sectors Per Track
		206	u16 NoHeads; // Number of Heads
		207	u32 NoHiddenSectors; // Number of Hidden Sectors in Partition
		208	u32 NoSectors; // Number of Sectors in Partition
		209	u16 DriveNo; // Logical Drive Number of Partition
		210	u8 ExtendedSig; // Extended Signature (0x29)
		211	u32 SerialNo; // Serial Number of the Partition
		212	s8 VolumeName[11]; // Volume Name of the Partititon
		213	s8 FATName[8]; // FAT Name (FAT16)
88	killagreg	214	u8 ExecutableCode[446]; // 446 bytes for machine start code
		215	u16 ExecutableMarker; // Executable Marker (0x55 0xAA)
		216	} __attribute__((packed)) VBR_Entry_t;
1	ingob	217
		218
		219
41	ingob	220	/*
		221	________________________________________________________________________________________________________________________________________
		222
88	killagreg	223	Structure of an directory entry
41	ingob	224	________________________________________________________________________________________________________________________________________
		225
		226	Directory entry is 32 bytes.
		227	*/
		228	typedef struct
1	ingob	229	{
41	ingob	230	s8 Name[8]; // 8 bytes name, padded with spaces.
		231	u8 Extension[3]; // 3 bytes extension, padded with spaces.
		232	u8 Attribute; // attribute of the directory entry (unused,archive,read-only,system,directory,volume)
		233	u8 Reserved[10]; // reserved bytes within the directory entry.
		234	u32 DateTime; // date and time of last write access to the file or directory.
		235	u16 StartCluster; // first cluster of the file or directory.
		236	u32 Size; // size of the file or directory in bytes.
		237	} __attribute__((packed)) DirEntry_t;
1	ingob	238
41	ingob	239	#define SLOT_EMPTY 0x00 // slot has never been used
		240	#define SLOT_E5 0x05 // the real value is 0xe5
		241	#define SLOT_DELETED 0xE5 // file in this slot deleted
1	ingob	242
41	ingob	243	#define ATTR_NONE 0x00 // normal file
		244	#define ATTR_READONLY 0x01 // file is readonly
		245	#define ATTR_HIDDEN 0x02 // file is hidden
		246	#define ATTR_SYSTEM 0x04 // file is a system file
		247	#define ATTR_VOLUMELABEL 0x08 // entry is a volume label
		248	#define ATTR_LONG_FILENAME 0x0F // this is a long filename entry
		249	#define ATTR_SUBDIRECTORY 0x10 // entry is a directory name
		250	#define ATTR_ARCHIVE 0x20 // file is new or modified
24	StephanB	251
		252
41	ingob	253	/*
		254	________________________________________________________________________________________________________________________________________
88	killagreg	255
		256	Structure of an entry within the fileallocationtable.
41	ingob	257	________________________________________________________________________________________________________________________________________
		258	*/
		259	typedef struct
		260	{
		261	u16 NextCluster; // the next cluster of the file.
		262	} __attribute__((packed)) Fat16Entry_t;
1	ingob	263
41	ingob	264	// secial fat entries
		265	#define FAT16_CLUSTER_FREE 0x0000
		266	#define FAT16_CLUSTER_RESERVED 0x0001
		267	#define FAT16_CLUSTER_USED_MIN 0x0002
		268	#define FAT16_CLUSTER_USED_MAX 0xFFEF
		269	#define FAT16_CLUSTER_ROOTDIR_MIN 0xFFF0
		270	#define FAT16_CLUSTER_ROOTDIR_MAX 0xFFF6
		271	#define FAT16_CLUSTER_BAD 0xFFF7
		272	#define FAT16_CLUSTER_LAST_MIN 0xFFF8
		273	#define FAT16_CLUSTER_LAST_MAX 0xFFFF
		274
88	killagreg	275	/*****************************************************************************************************************************************/
41	ingob	276	/* */
		277	/* Global variables needed for read- or write-acces to the FAT16- filesystem. */
		278	/* */
		279	/*****************************************************************************************************************************************/
		280
		281	#define MBR_SECTOR 0x00 // the masterboot record is located in sector 0.
		282	#define DIRENTRY_SIZE 32 //bytes
		283	#define DIRENTRIES_PER_SECTOR BYTES_PER_SECTOR/DIRENTRY_SIZE
		284	#define FAT16_BYTES 2
		285	#define FAT16_ENTRIES_PER_SECTOR BYTES_PER_SECTOR/FAT16_BYTES
		286
88	killagreg	287	#define FSTATE_UNUSED 0
41	ingob	288	#define FSTATE_USED 1
		289
		290	typedef struct
1	ingob	291	{
41	ingob	292	u8 IsValid; // 0 means invalid, else valid
		293	u8 SectorsPerCluster; // how many sectors does a cluster contain?
		294	u8 FatCopies; // Numbers of copies of the FAT
		295	u16 MaxRootEntries; // Possible number of entries in the root directory.
		296	u16 SectorsPerFat; // how many sectors does a fat16 contain?
		297	u32 FirstFatSector; // sector of the start of the fat
		298	u32 FirstRootDirSector; // sector of the rootdirectory
		299	u32 FirstDataSector; // sector of the first cluster containing data (cluster2).
		300	u32 LastDataSector; // the last data sector of the partition
		301	} Partition_t;
1	ingob	302
41	ingob	303	Partition_t Partition; // Structure holds partition information
1	ingob	304
41	ingob	305	File_t FilePointer[FILE_MAX_OPEN]; // Allocate Memmoryspace for each filepointer used.
1	ingob	306
41	ingob	307
		308	/****************************************************************************************************************************************/
		309	/* Function: FileDateTime(DateTime_t ); /
		310	/* */
		311	/* Description: This function calculates the DOS date time from a pointer to a time structure. */
		312	/* */
		313	/* Returnvalue: Returns the DOS date time. */
		314	/****************************************************************************************************************************************/
		315
		316	u32 FileDateTime(DateTime_t * pTimeStruct)
1	ingob	317	{
41	ingob	318	u32 datetime = 0;
		319	if((pTimeStruct == 0) \|\| !(pTimeStruct->Valid)) return datetime;
24	StephanB	320
41	ingob	321	datetime \|= (0x0000007FL & (u32)(pTimeStruct->Year - 1980))<<25; // set year
		322	datetime \|= (0x0000000FL & (u32)(pTimeStruct->Month))<<21; // set month
		323	datetime \|= (0x0000001FL & (u32)(pTimeStruct->Day))<<16;
		324	datetime \|= (0x0000001FL & (u32)(pTimeStruct->Hour))<<11;
		325	datetime \|= (0x0000003FL & (u32)(pTimeStruct->Min))<<5;
		326	datetime \|= (0x0000001FL & (u32)(pTimeStruct->Sec/2));
		327	return datetime;
1	ingob	328	}
		329
		330
41	ingob	331	/****************************************************************************************************************************************/
		332	/* Function: LockFilePointer(); */
		333	/* */
		334	/* Description: This function trys to lock a free file pointer. */
		335	/* */
		336	/* Returnvalue: Returns the Filepointer on success or 0. */
		337	/****************************************************************************************************************************************/
		338	File_t * LockFilePointer(void)
1	ingob	339	{
41	ingob	340	u8 i;
		341	File_t * File = 0;
		342	for(i = 0; i < FILE_MAX_OPEN; i++)
1	ingob	343	{
88	killagreg	344	if(FilePointer[i].State == FSTATE_UNUSED) // found an unused one
1	ingob	345	{
88	killagreg	346	File = &FilePointer[i]; // set pointer to that entry
41	ingob	347	FilePointer[i].State = FSTATE_USED; // mark it as used
		348	break;
1	ingob	349	}
41	ingob	350	}
		351	return(File);
1	ingob	352	}
		353
41	ingob	354	/****************************************************************************************************************************************/
		355	/* Function: UnlockFilePointer(file_t ); /
		356	/* */
		357	/* Description: This function trys to unlock a file pointer. */
		358	/* */
		359	/* Returnvalue: Returns 1 if file pointer was freed else 0. */
		360	/****************************************************************************************************************************************/
		361	u8 UnlockFilePointer(File_t * file)
1	ingob	362	{
41	ingob	363	u8 cnt;
		364	if(file == NULL) return(0);
		365	for(cnt = 0; cnt < FILE_MAX_OPEN; cnt++)
1	ingob	366	{
41	ingob	367	if(&FilePointer[cnt] == file) // filepointer to be freed found?
1	ingob	368	{
88	killagreg	369	file->State = FSTATE_UNUSED;
		370	file->FirstSectorOfFirstCluster = 0; // Sectorpointer to the first sector of the first datacluster of the file.
41	ingob	371	file->FirstSectorOfCurrCluster = 0;
		372	file->SectorOfCurrCluster = 0; // Pointer to the cluster which is edited at the moment.
		373	file->SectorOfCurrCluster = 0; // The sector which is edited at the moment (cluster_pointer + sector_index).
		374	file->ByteOfCurrSector = 0; // The bytelocation within the current sector (cluster_pointer + sector_index + byte_index).
		375	file->Mode = 0; // mode of fileoperation (read,write)
		376	file->Size = 0; // the size of the opend file in bytes.
		377	file->Position = 0; // pointer to a character within the file 0 < fileposition < filesize
		378	file->SectorInCache = 0; // the last sector read, wich is still in the sectorbuffer.
		379	file->DirectorySector = 0; // the sectorposition where the directoryentry has been made.
		380	file->DirectoryIndex = 0; // the index to the directoryentry within the specified sector.
		381	file->Attribute = 0; // the attribute of the file opened.
88	killagreg	382	file = NULL;
41	ingob	383	return(1);
1	ingob	384	}
41	ingob	385	}
		386	return(0);
		387	}
1	ingob	388
41	ingob	389	/****************************************************************************************************************************************/
		390	/* Function: SeperateDirName(s8, s8); */
		391	/* */
		392	/* Description: This function seperates the first dirname from filepath and brings them */
		393	/* into the needed format ('test.txt' -> 'TEST TXT') */
		394	/* The subpath is the pointer to the remaining substring if the filepath */
		395	/* */
		396	/* Returnvalue: Return NULL on error or pointer to subpath */
		397	/****************************************************************************************************************************************/
		398	s8* SeperateDirName(const s8 filepath, s8 dirname)
		399	{
		400	s8* subpath = NULL;
		401	u8 readpointer = 0;
		402	u8 writepointer = 0;
1	ingob	403
88	killagreg	404	// search subpath from beginning of filepath
41	ingob	405	subpath = NULL;
		406	readpointer = 0;
		407	if(filepath[0] == '/') readpointer = 1; // ignore first '/'
88	killagreg	408	while(subpath == NULL) // search the filepath until a subpath was found.
1	ingob	409	{
88	killagreg	410	if(((filepath[readpointer] == 0) \|\| (filepath[readpointer] == '/'))) // if '/' found or end of filepath reached
		411	{
41	ingob	412	subpath = (s8*)&filepath[readpointer]; // store the position of the first "/" found after the beginning of the filenpath
		413	}
		414	readpointer++;
		415	}
1	ingob	416
41	ingob	417	// clear dirname with spaces
		418	dirname[11] = 0; // terminate dirname
		419	for(writepointer = 0; writepointer < 11; writepointer++) dirname[writepointer] = ' ';
		420	writepointer = 0;
		421	// start seperating the dirname from the filepath.
		422	readpointer = 0;
		423	if(filepath[0] == '/') readpointer = 1; // ignore first '/'
		424	while( &filepath[readpointer] < subpath)
1	ingob	425	{
41	ingob	426	if(writepointer >= 11) return(NULL); // dirname to long
		427	if(filepath[readpointer] == '.') // seperating dirname and extension.
1	ingob	428	{
41	ingob	429	if(writepointer <= 8)
1	ingob	430	{
41	ingob	431	readpointer++; // next character in filename
		432	writepointer = 8; // jump to start of extension
1	ingob	433	}
88	killagreg	434	else return(NULL); // dirbasename to long
41	ingob	435	}
		436	else
		437	{
		438	if((0x60 < filepath[readpointer]) && (filepath[readpointer] < 0x7B))
		439	{
		440	dirname[writepointer] = (filepath[readpointer] - 0x20); // all characters must be upper case.
		441	}
1	ingob	442	else
		443	{
41	ingob	444	dirname[writepointer] = filepath[readpointer];
88	killagreg	445	}
41	ingob	446	readpointer++;
		447	writepointer++;
1	ingob	448	}
41	ingob	449	}
88	killagreg	450	return(subpath);
1	ingob	451	}
		452
		453
41	ingob	454	/*************************************************************************************************************************************+/
		455	/* Function: Fat16ClusterToSector( u16 cluster); */
		456	/* */
		457	/* Description: This function converts a cluster number given by the fat to the corresponding */
		458	/* sector that points to the start of the data area that is represented by the cluster number. */
		459	/* */
		460	/* Returnvalue: The sector number with the data area of the given cluster */
		461	/****************************************************************************************************************************************/
		462	u32 Fat16ClusterToSector(u16 cluster)
		463	{
		464	if(!Partition.IsValid) return 0;
88	killagreg	465	if (cluster < 2) cluster = 2; // the 0. and 1. cluster in the fat are used for the media descriptor
41	ingob	466	return ( (cluster - 2) * Partition.SectorsPerCluster) + Partition.FirstDataSector; // the first data sector is represented by the 2nd cluster
		467	}
		468
		469	/****************************************************************************************************************************************/
		470	/* Function: SectorToFat16Cluster( u32 sector); */
		471	/* */
		472	/* Description: This function converts a given sector number given to the corresponding */
		473	/* cluster number in the fat that represents this data area. */
		474	/* */
		475	/* Returnvalue: The cluster number representing the data area of the sector. */
		476	/****************************************************************************************************************************************/
		477	u16 SectorToFat16Cluster(u32 sector)
		478	{
		479	if(!Partition.IsValid) return 0;
		480	return ((u16)((sector - Partition.FirstDataSector) / Partition.SectorsPerCluster) + 2);
		481	}
		482
		483
		484	/****************************************************************************************************************************************/
90	killagreg	485	/* Function: Fat16_IsValid(void); */
		486	/* */
		487	/* Description: This function return the Fat 15 filesystem state */
		488	/* */
		489	/* Returnvalue: The function returns "1" on success */
		490	/****************************************************************************************************************************************/
		491	u8 Fat16_IsValid(void)
		492	{
		493	return(Partition.IsValid);
		494	}
		495
		496
		497	/****************************************************************************************************************************************/
41	ingob	498	/* Function: Fat16_Deinit(void); */
		499	/* */
		500	/* Description: This function uninitializes the fat 16 api */
		501	/* */
		502	/* Returnvalue: The function returns "0" on success */
		503	/****************************************************************************************************************************************/
		504	u8 Fat16_Deinit(void)
		505	{
		506	s16 returnvalue = 0;
		507	u8 cnt;
146	killagreg	508
		509	UART1_PutString("\r\n FAT16 deinit...");
41	ingob	510	// declare the filepointers as unused.
		511	for(cnt = 0; cnt < FILE_MAX_OPEN; cnt++)
1	ingob	512	{
41	ingob	513	if(FilePointer[cnt].State == FSTATE_USED)
1	ingob	514	{
41	ingob	515	returnvalue += fclose_(&FilePointer[cnt]); // try to close open file pointers
1	ingob	516	}
88	killagreg	517
1	ingob	518	}
41	ingob	519	SDC_Deinit(); // uninitialize interface to sd-card
		520	Partition.IsValid = 0; // mark data in partition structure as invalid
146	killagreg	521	UART1_PutString("ok");
41	ingob	522	return(returnvalue);
1	ingob	523	}
		524
41	ingob	525	/****************************************************************************************************************************************/
		526	/* Function: Fat16_Init(void); */
		527	/* */
		528	/* Description: This function reads the Masterbootrecord and finds the position of the Volumebootrecord, the FAT and the Rootdir */
		529	/* and stores the information in global variables. */
		530	/* */
		531	/* Returnvalue: The function returns "0" if the filesystem is initialized. */
		532	/****************************************************************************************************************************************/
		533	u8 Fat16_Init(void)
88	killagreg	534	{
41	ingob	535	u8 cnt = 0;
		536	u32 partitionfirstsector;
88	killagreg	537	VBR_Entry_t *VBR;
41	ingob	538	MBR_Entry_t *MBR;
		539	File_t *file;
		540	u8 result = 0;
1	ingob	541
110	killagreg	542	UART1_PutString("\r\n FAT16 init...");
41	ingob	543	Partition.IsValid = 0;
		544
		545	// declare the filepointers as unused.
		546	for(cnt = 0; cnt < FILE_MAX_OPEN; cnt++)
1	ingob	547	{
88	killagreg	548	FilePointer[cnt].State = FSTATE_UNUSED;
1	ingob	549	}
41	ingob	550	// set current file pinter to first position in list
88	killagreg	551	file = &FilePointer[0];
		552
41	ingob	553	// try to initialise the sd-card.
88	killagreg	554	if(SD_SUCCESS != SDC_Init())
		555	{
110	killagreg	556	UART1_PutString("SD-Card could not be initialized.");
41	ingob	557	result = 1;
88	killagreg	558	goto end;
41	ingob	559	}
1	ingob	560
41	ingob	561	// SD-Card is initialized successfully
		562	if(SD_SUCCESS != SDC_GetSector((u32)MBR_SECTOR,file->Cache)) // Read the MasterBootRecord
1	ingob	563	{
110	killagreg	564	UART1_PutString("Error reading the MBR.");
41	ingob	565	result = 2;
88	killagreg	566	goto end;
1	ingob	567	}
41	ingob	568	MBR = (MBR_Entry_t *)file->Cache; // Enter the MBR using the structure MBR_Entry_t.
88	killagreg	569	if((MBR->PartitionEntry1.Type == PART_TYPE_FAT16_ST_32_MB) \|\|
41	ingob	570	(MBR->PartitionEntry1.Type == PART_TYPE_FAT16_LT_32_MB) \|\|
		571	(MBR->PartitionEntry1.Type == PART_TYPE_FAT16LBA))
1	ingob	572	{
41	ingob	573	// get sector offset 1st partition
		574	partitionfirstsector = MBR->PartitionEntry1.NoSectorsBeforePartition;
		575	// Start of Partition is the Volume Boot Sector
		576	if(SD_SUCCESS != SDC_GetSector(partitionfirstsector,file->Cache)) // Read the volume boot record
1	ingob	577	{
110	killagreg	578	UART1_PutString("Error reading the VBR.");
41	ingob	579	result = 3;
88	killagreg	580	goto end;
		581	}
1	ingob	582	}
41	ingob	583	else // maybe the medium has no partition assuming sector 0 is the vbr
		584	{
		585	partitionfirstsector = 0;
		586	}
88	killagreg	587
41	ingob	588	VBR = (VBR_Entry_t *) file->Cache; // Enter the VBR using the structure VBR_Entry_t.
		589	if(VBR->BytesPerSector != BYTES_PER_SECTOR)
		590	{
110	killagreg	591	UART1_PutString("VBR: Sector size not supported.");
41	ingob	592	result = 4;
88	killagreg	593	goto end;
41	ingob	594	}
		595	Partition.SectorsPerCluster = VBR->SectorsPerCluster; // Number of sectors per cluster. Depends on the memorysize of the sd-card.
		596	Partition.FatCopies = VBR->NoFATCopies; // Number of fatcopies.
		597	Partition.MaxRootEntries = VBR->MaxRootEntries; // How many Entries are possible in the rootdirectory (FAT16 allows max. 512 entries).
		598	Partition.SectorsPerFat = VBR->SectorsPerFAT; // The number of sectors per FAT.
		599
		600	/* Calculate the sectorpositon of the FAT, the Rootdirectory and the first Datacluster. */
88	killagreg	601	// Calculate the position of the FileAllocationTable:
41	ingob	602	// Start + # of Reserved Sectors
88	killagreg	603	Partition.FirstFatSector = (u32)(partitionfirstsector + (u32)(VBR->ReservedSectors));
		604	// Calculate the position of the Rootdirectory:
		605	// Start + # of Reserved Sectors + (# of Sectors Per FAT * # of FAT Copies)
41	ingob	606	Partition.FirstRootDirSector = Partition.FirstFatSector + (u32)((u32)Partition.SectorsPerFat*(u32)Partition.FatCopies);
		607	// Calculate the position of the first datacluster:
88	killagreg	608	// Start + # of Reserved + (# of Sectors Per FAT * # of FAT Copies) + ((Maximum Root Directory Entries * 32) / Bytes per Sector)
41	ingob	609	Partition.FirstDataSector = Partition.FirstRootDirSector + (u32)(Partition.MaxRootEntries>>4); // assuming 512 Byte Per Sector
		610	// Calculate the last data sector
		611	if(VBR->NoSectors == 0)
		612	{
110	killagreg	613	UART1_PutString("VBR: Bad number of sectors.");
41	ingob	614	result = 5;
88	killagreg	615	goto end;
41	ingob	616	}
		617	Partition.LastDataSector = Partition.FirstDataSector + VBR->NoSectors - 1;
		618	// check for FAT16 in VBR of first partition
		619	if(!((VBR->FATName[0]=='F') && (VBR->FATName[1]=='A') && (VBR->FATName[2]=='T') && (VBR->FATName[3]=='1')&&(VBR->FATName[4]=='6')))
		620	{
110	killagreg	621	UART1_PutString("VBR: Partition ist not FAT16 type.");
41	ingob	622	result = 6;
		623	goto end;
		624	}
		625	Partition.IsValid = 1; // mark data in partition structure as valid
		626	result = 0;
		627	end:
		628	if(result != 0) Fat16_Deinit();
110	killagreg	629	else UART1_PutString("ok");
88	killagreg	630	return(result);
1	ingob	631	}
		632
		633
41	ingob	634
		635	/****************************************************************************************************************************************/
		636	/* Function: ClearCurrCluster(File_t); /
		637	/* */
		638	/* Description: This function fills the current cluster with 0. */
		639	/* */
		640	/* Returnvalue: The function returns 1 on success else 0. */
		641	/****************************************************************************************************************************************/
		642	u8 ClearCurrCluster(File_t * file)
1	ingob	643	{
41	ingob	644	u8 retvalue = 1;
		645	u32 i;
88	killagreg	646
41	ingob	647	if((!Partition.IsValid) \|\| (file == NULL)) return(0);
		648
		649	for(i = 0; i < BYTES_PER_SECTOR; i++) file->Cache[i] = 0; // clear file cache
		650	for(i = 0; i < Partition.SectorsPerCluster; i++)
1	ingob	651	{
41	ingob	652	file->SectorInCache = file->FirstSectorOfCurrCluster + i;
		653	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))
		654	{
88	killagreg	655	Fat16_Deinit();
41	ingob	656	retvalue = 0;
		657	}
1	ingob	658	}
88	killagreg	659	return(retvalue);
1	ingob	660	}
		661
41	ingob	662	/*****************************************************************************************************************************************/
		663	/* Function: GetNextCluster(File_t* ); */
		664	/* */
		665	/* Description: This function finds the next datacluster of the file specified with File File. /
		666	/* */
		667	/* Returnvalue: The function returns the next cluster or 0 if the last cluster has already reached. */
		668	/*****************************************************************************************************************************************/
		669	u16 GetNextCluster(File_t * file)
1	ingob	670	{
41	ingob	671	u16 cluster = 0;
		672	u32 fat_byte_offset, sector, byte;
		673	Fat16Entry_t * fat;
88	killagreg	674
41	ingob	675	if((!Partition.IsValid) \|\| (file == NULL)) return(cluster);
		676	// if sector is within the data area
		677	if((Partition.FirstDataSector <= file->FirstSectorOfCurrCluster)&& (file->FirstSectorOfCurrCluster <= Partition.LastDataSector))
1	ingob	678	{
41	ingob	679	// determine current file cluster
		680	cluster = SectorToFat16Cluster(file->FirstSectorOfCurrCluster);
		681	// calculate byte offset in the fat for corresponding entry
		682	fat_byte_offset = ((u32)cluster)<<1; // two FAT bytes (16 bits) for every cluster
		683	// calculate the sector that contains the current cluster within the fat
		684	sector = Partition.FirstFatSector + ( fat_byte_offset / BYTES_PER_SECTOR);
		685	// calculate byte offset of the current cluster within that fat sector
		686	byte = fat_byte_offset % BYTES_PER_SECTOR;
		687	// read this sector to the file cache
		688	if(file->SectorInCache != sector)
1	ingob	689	{
41	ingob	690	file->SectorInCache = sector; // update sector stored in buffer
		691	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache)) // read sector from sd-card
24	StephanB	692	{
41	ingob	693	Fat16_Deinit();
		694	return (cluster);
88	killagreg	695	}
		696	}
41	ingob	697	// read the next cluster from cache
		698	fat = (Fat16Entry_t *)(&(file->Cache[byte]));
		699	cluster = fat->NextCluster;
88	killagreg	700	// if last cluster fat entry
41	ingob	701	if(FAT16_CLUSTER_LAST_MIN <= cluster)
		702	{
		703	cluster = 0;
1	ingob	704	}
24	StephanB	705	else
		706	{
41	ingob	707	file->FirstSectorOfCurrCluster = Fat16ClusterToSector(cluster);
		708	file->SectorOfCurrCluster = 0;
		709	file->ByteOfCurrSector = 0;
24	StephanB	710	}
88	killagreg	711	}
41	ingob	712	return(cluster);
1	ingob	713	}
		714
		715
41	ingob	716	/****************************************************************************************************************************************/
		717	/* Function: FindNextFreeCluster(File_t ); /
		718	/* */
		719	/* Description: This function looks in the fat to find the next free cluster */
		720	/* */
		721	/* Returnvalue: The function returns the cluster number of the next free cluster found within the fat. */
		722	/****************************************************************************************************************************************/
		723	u16 FindNextFreeCluster(File_t *file)
1	ingob	724	{
41	ingob	725	u32 fat_sector; // current sector within the fat relative to the first sector of the fat.
		726	u32 curr_sector; // current sector
		727	u16 fat_entry; // index to an fatentry within the actual sector (256 fatentries are possible within one sector).
		728	u16 free_cluster = 0; // next free cluster number.
		729	Fat16Entry_t * fat;
88	killagreg	730
41	ingob	731	if((!Partition.IsValid) \|\| (file == NULL)) return(0);
24	StephanB	732
41	ingob	733	// start searching for an empty cluster at the beginning of the fat.
88	killagreg	734	fat_sector = 0;
		735	do
1	ingob	736	{
41	ingob	737	curr_sector = Partition.FirstFatSector + fat_sector; // calculate sector to read
		738	file->SectorInCache = curr_sector; // upate the sector number of file cache.
		739	if( SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache)) // read sector of fat from sd-card.
		740	{
		741	Fat16_Deinit();
		742	return(free_cluster);
		743	}
		744
		745	fat = (Fat16Entry_t *)file->Cache; // set fat pointer to file cache
		746
88	killagreg	747	for(fat_entry = 0; fat_entry < FAT16_ENTRIES_PER_SECTOR; fat_entry++) // look for an free cluster at all entries in this sector of the fat.
41	ingob	748	{
		749	if(fat[fat_entry].NextCluster == FAT16_CLUSTER_FREE) // empty cluster found!!
88	killagreg	750	{
		751	fat[fat_entry].NextCluster = FAT16_CLUSTER_LAST_MAX; // mark this fat-entry as used
41	ingob	752	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache)) // and save the sector at the sd-card.
		753	{
		754	Fat16_Deinit();
		755	return(free_cluster);
		756	}
88	killagreg	757	free_cluster = (u16)(fat_sector * FAT16_ENTRIES_PER_SECTOR + (u32)fat_entry);
41	ingob	758	fat_entry = FAT16_ENTRIES_PER_SECTOR; // terminate the search for a free cluster in this sector.
		759	}
		760	}
		761	fat_sector++; // continue the search in next fat sector
88	killagreg	762	// repeat until the end of the fat is reached and no free cluster has been found so far
41	ingob	763	}while((fat_sector < Partition.SectorsPerFat) && (!free_cluster));
		764	return(free_cluster);
1	ingob	765	}
		766
		767
41	ingob	768	/****************************************************************************************************************************************************/
		769	/* Function: s16 fseek_(File_t , s32 , u8) */
		770	/* */
		771	/* Description: This function sets the pointer of the stream relative to the position */
		772	/* specified by origin (SEEK_SET, SEEK_CUR, SEEK_END) */
		773	/* Returnvalue: Is 1 if seek was successful */
		774	/****************************************************************************************************************************************************/
		775	s16 fseek_(File_t *file, s32 offset, s16 origin)
1	ingob	776	{
41	ingob	777	s32 fposition = 0;
		778	s16 retvalue = 1;
88	killagreg	779
41	ingob	780	if((!Partition.IsValid) \|\| (file == NULL)) return(0);
		781	switch(origin)
		782	{
		783	case SEEK_SET: // Fileposition relative to the beginning of the file.
88	killagreg	784	fposition = 0;
41	ingob	785	break;
		786	case SEEK_END: // Fileposition relative to the end of the file.
		787	fposition = (s32)file->Size;
		788	break;
		789	case SEEK_CUR: // Fileposition relative to the current position of the file.
		790	default:
		791	fposition = file->Position;
		792	break;
1	ingob	793	}
41	ingob	794
		795	fposition += offset;
		796
		797	if((fposition >= 0) && (fposition <= (s32)file->Size)) // is the pointer still within the file?
1	ingob	798	{
41	ingob	799	// reset file position to start of the file
		800	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		801	file->SectorOfCurrCluster = 0;
		802	file->ByteOfCurrSector = 0;
		803	file->Position = 0;
1	ingob	804
41	ingob	805	while(file->Position < fposition) // repeat until the current position is less than target
1	ingob	806	{
41	ingob	807	file->Position++; // increment file position
88	killagreg	808	file->ByteOfCurrSector++; // next byte in current sector
		809	if(file->ByteOfCurrSector >= BYTES_PER_SECTOR)
41	ingob	810	{
		811	file->ByteOfCurrSector = 0; // reading at the beginning of new sector.
		812	file->SectorOfCurrCluster++; // continue reading in next sector
		813	if(file->SectorOfCurrCluster >= Partition.SectorsPerCluster) // if end of cluster is reached, the next datacluster has to be searched in the FAT.
		814	{
		815	if(GetNextCluster(file)) // Sets the clusterpointer of the file to the next datacluster.
		816	{
88	killagreg	817	file->SectorOfCurrCluster = 0;
41	ingob	818	}
		819	else // the last cluster was allready reached
		820	{
		821	file->SectorOfCurrCluster--; // jump back to the ast sector in the last cluster
		822	file->ByteOfCurrSector = BYTES_PER_SECTOR; // set ByteOfCurrSector one byte over sector end
		823	}
		824	}
88	killagreg	825	}
		826	}
1	ingob	827	}
88	killagreg	828	if(file->Position == fposition) retvalue = 0;
1	ingob	829	return(retvalue);
		830	}
		831
		832
41	ingob	833	/****************************************************************************************************************************************/
		834	/* Function: u16 DeleteClusterChain(File file); /
		835	/* */
		836	/* Description: This function trances along a cluster chain in the fat and frees all clusters visited. */
		837	/* */
		838	/****************************************************************************************************************************************/
		839	u8 DeleteClusterChain(u16 StartCluster)
1	ingob	840	{
88	killagreg	841	u16 cluster;
41	ingob	842	u32 fat_byte_offset, sector, byte;
		843	Fat16Entry_t * fat;
		844	u8 buffer[BYTES_PER_SECTOR];
		845	u32 sector_in_buffer = 0;
		846	u8 repeat = 0;
		847
		848	if(!Partition.IsValid) return 0;
		849
		850	cluster = StartCluster; // init chain trace
		851	// calculate byte offset in the fat for corresponding entry
		852	fat_byte_offset = ((u32)cluster)<<1; // two FAT bytes (16 bits) for every cluster
		853	// calculate the sector that contains the current cluster within the fat
		854	sector = Partition.FirstFatSector + ( fat_byte_offset / BYTES_PER_SECTOR);
		855	// calculate byte offset of the current cluster within that fat sector
		856	byte = fat_byte_offset % BYTES_PER_SECTOR;
88	killagreg	857	do
1	ingob	858	{
41	ingob	859	if(sector != sector_in_buffer)
1	ingob	860	{
41	ingob	861	// read this sector to buffer
		862	sector_in_buffer = sector;
		863	if(SD_SUCCESS != SDC_GetSector(sector_in_buffer, buffer)) return 0; // read sector from sd-card
88	killagreg	864	}
41	ingob	865	// read the next cluster from cache
		866	fat = (Fat16Entry_t *)(&(buffer[byte]));
		867	cluster = fat->NextCluster;
		868	if((FAT16_CLUSTER_USED_MIN <= cluster) && (cluster <= FAT16_CLUSTER_USED_MAX) ) repeat = 1;
		869	else repeat = 0;
		870
		871	fat->NextCluster = FAT16_CLUSTER_FREE; // mark current cluster as free
		872	// calculate byte offset in the fat for corresponding entry
		873	fat_byte_offset = ((u32)cluster)<<1; // two FAT bytes (16 bits) for every cluster
		874	// calculate the sector that contains the current cluster within the fat
		875	sector = Partition.FirstFatSector + ( fat_byte_offset / BYTES_PER_SECTOR);
		876	// calculate byte offset of the current cluster within that fat sector
		877	byte = fat_byte_offset % BYTES_PER_SECTOR;
		878	// if new sector is not the sector in buffer or the last cluster in the chain was traced
		879	if((sector != sector_in_buffer) \|\| !repeat)
		880	{ // write sector in buffer
146	killagreg	881	if(SD_SUCCESS != SDC_PutSector(sector_in_buffer,buffer))
		882	{
		883	Fat16_Deinit();
		884	return 0;
		885	}
1	ingob	886	}
41	ingob	887	}
		888	while(repeat);
		889
		890	return 1;
1	ingob	891	}
		892
		893
41	ingob	894	/****************************************************************************************************************************************/
		895	/* Function: u16 AppendCluster(File file); /
		896	/* */
		897	/* Description: This function looks in the fat to find the next free cluster and appends it to the file. */
		898	/* */
		899	/* Returnvalue: The function returns the appened cluster number or 0 of no cluster was appended. */
		900	/****************************************************************************************************************************************/
		901	u16 AppendCluster(File_t *file)
1	ingob	902	{
88	killagreg	903	u16 last_cluster, new_cluster = 0;
41	ingob	904	u32 fat_byte_offset, sector, byte;
		905	Fat16Entry_t * fat;
88	killagreg	906
41	ingob	907	if((!Partition.IsValid) \|\| (file == NULL)) return(new_cluster);
1	ingob	908
41	ingob	909	new_cluster = FindNextFreeCluster(file); // the next free cluster found on the disk.
		910	if(new_cluster)
88	killagreg	911	{ // A free cluster was found and can be added to the end of the file.
41	ingob	912	fseek_(file, 0, SEEK_END); // jump to the end of the file
88	killagreg	913	last_cluster = SectorToFat16Cluster(file->FirstSectorOfCurrCluster); // determine current file cluster
41	ingob	914	fat_byte_offset = ((u32)last_cluster)<<1;
		915	sector = Partition.FirstFatSector + ( fat_byte_offset / BYTES_PER_SECTOR);
		916	byte = fat_byte_offset % BYTES_PER_SECTOR;
1	ingob	917
41	ingob	918	if(file->SectorInCache != sector)
		919	{
		920	file->SectorInCache = sector; // update sector stored in buffer
		921	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache)) // read sector from sd-card
		922	{
		923	Fat16_Deinit();
		924	return(0);
88	killagreg	925	}
		926	}
41	ingob	927	fat = (Fat16Entry_t *)(&(file->Cache[byte]));
		928	fat->NextCluster = new_cluster; // append the free cluster to the end of the file in the FAT.
		929	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache)) // save the modified sector to the FAT.
		930	{
		931	Fat16_Deinit();
		932	return(0);
		933	}
		934	file->FirstSectorOfCurrCluster = Fat16ClusterToSector(new_cluster);
		935	file->SectorOfCurrCluster = 0;
		936	file->ByteOfCurrSector = 0;
		937	}
		938	return(new_cluster);
1	ingob	939	}
		940
41	ingob	941	/****************************************************************************************************************************************************/
		942	/* Function: DirectoryEntryExist(s8 , u8, u8, File_t ) */
		943	/* */
		944	/* Description: This function searches all possible dir entries until the file or directory is found or the end of the directory is reached */
		945	/* */
		946	/* Returnvalue: This function returns 1 if the directory entry specified was found. */
		947	/****************************************************************************************************************************************************/
		948	u8 DirectoryEntryExist(s8 dirname, u8 attribfilter, u8 attribmask, File_t file)
		949	{
		950	u32 dir_sector, max_dir_sector, curr_sector;
		951	u16 dir_entry = 0;
24	StephanB	952
41	ingob	953	u16 end_of_directory_not_reached = 0;
		954	u8 i = 0;
		955	u8 direntry_exist = 0;
		956	DirEntry_t * dir;
24	StephanB	957
41	ingob	958	// if incomming pointers are useless return immediatly
88	killagreg	959	if((!Partition.IsValid) \|\| (file == NULL) \|\| (dirname == NULL)) return(direntry_exist);
41	ingob	960
88	killagreg	961	// dir entries can be searched only in filesclusters that have
		962	// a corresponding dir entry with adir-flag set in its attribute
41	ingob	963	// or direct within the root directory area
88	killagreg	964
41	ingob	965	file->FirstSectorOfFirstCluster = 0;
		966	// no current directory exist therefore assume searching in the root
		967	if(file->DirectorySector == 0)
24	StephanB	968	{
41	ingob	969	max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
		970	file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;
		971	}
		972	// within the root directory area we can read sectors sequentially until the end of this area
		973	else if((Partition.FirstRootDirSector <= file->DirectorySector) && (file->DirectorySector < Partition.FirstDataSector))
		974	{
		975	max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
		976	}
88	killagreg	977	// within the data clusters we can read sectors sequentially only within the cluster
41	ingob	978	else if((Partition.FirstDataSector <= file->DirectorySector) && (file->DirectorySector <= Partition.LastDataSector))
		979	{
		980	max_dir_sector = Partition.SectorsPerCluster; // limit max secters before next cluster
		981	}
		982	else return (direntry_exist); // bad sector range for directory sector of the file
		983	// if search area is not defined yet
		984	if(file->FirstSectorOfFirstCluster == 0)
		985	{
		986	// check if the directory entry of current file is existent and has the dir-flag set
		987	file->SectorInCache = file->DirectorySector; // update the sector number of file cache.
		988	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
24	StephanB	989	{
41	ingob	990	Fat16_Deinit();
		991	return(direntry_exist);
24	StephanB	992	}
41	ingob	993	dir = (DirEntry_t *)file->Cache; // set pointer to directory
		994	switch((u8)dir[file->DirectoryIndex].Name[0]) // check if current directory exist
24	StephanB	995	{
41	ingob	996	case SLOT_EMPTY:
		997	case SLOT_DELETED:
		998	// the directrory pointer of this file points to a deleted or not existen directory
		999	// therefore no file or subdirectory can be created
		1000	return (direntry_exist);
		1001	break;
88	killagreg	1002	default: // and is a real directory
41	ingob	1003	if((dir[file->DirectoryIndex].Attribute & ATTR_SUBDIRECTORY) != ATTR_SUBDIRECTORY)
		1004	{ // current file is not a directory therefore no file or subdirectory can be created here
		1005	return (direntry_exist);
		1006	}
		1007	break;
24	StephanB	1008	}
41	ingob	1009	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(dir[file->DirectoryIndex].StartCluster);
24	StephanB	1010	}
		1011
41	ingob	1012	// update current file data area position to start of first cluster
88	killagreg	1013	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		1014	file->SectorOfCurrCluster = 0;
41	ingob	1015	file->ByteOfCurrSector = 0;
24	StephanB	1016
41	ingob	1017	do // loop over all data clusters of the current directory entry
88	killagreg	1018	{
41	ingob	1019	dir_sector = 0; // reset sector counter within a new cluster
		1020	do // loop over all sectors of a cluster or all sectors of the root directory
88	killagreg	1021	{
41	ingob	1022	curr_sector = file->FirstSectorOfCurrCluster + dir_sector; // calculate sector number
		1023	file->SectorInCache = curr_sector; // upate the sector number of file cache.
		1024	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read the sector
		1025	{
		1026	Fat16_Deinit();
88	killagreg	1027	return(direntry_exist);
41	ingob	1028	}
		1029	dir = (DirEntry_t *)file->Cache; // set pointer to directory
		1030	// search all directory entries within that sector
		1031	for(dir_entry = 0; dir_entry < DIRENTRIES_PER_SECTOR; dir_entry++)
		1032	{ // check for existing dir entry
		1033	switch((u8)dir[dir_entry].Name[0])
		1034	{
		1035	case SLOT_EMPTY:
		1036	case SLOT_DELETED:
		1037	// ignore empty or deleted dir entries
		1038	break;
		1039	default:
		1040	// if existing check attributes before names are compared will safe performance
		1041	if ((dir[dir_entry].Attribute & attribmask) != attribfilter) break; // attribute must match
		1042	// then compare the name to the giveb dirname (first 11 characters include 8 chars of basename and 3 chars extension.)
		1043	i = 0;
		1044	while((i < 11) && (dir[dir_entry].Name[i] == dirname[i])) i++;
		1045	if (i < 10) break; // names does not match
		1046	// if dirname and attribute have matched
		1047	file->Attribute = dir[dir_entry].Attribute; // store attribute of found dir entry
88	killagreg	1048	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(dir[dir_entry].StartCluster); // set sector of first data cluster
41	ingob	1049	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		1050	file->SectorOfCurrCluster = 0;
		1051	file->ByteOfCurrSector = 0;
		1052	file->DirectorySector = curr_sector; // current sector
		1053	file->DirectoryIndex = dir_entry; // current direntry in current sector
88	killagreg	1054	file->Size = dir[dir_entry].Size;
		1055	direntry_exist = 1; // mark as found
		1056	dir_entry = DIRENTRIES_PER_SECTOR; // stop for-loop
41	ingob	1057	} // end of first byte of name check
		1058	}
		1059	dir_sector++; // search next sector
		1060	// stop if we reached the end of the cluster or the end of the root dir
		1061	}while((dir_sector < max_dir_sector) && (!direntry_exist));
1	ingob	1062
41	ingob	1063	// if we are seaching in the data area and the file not found in this cluster so take next cluster.
88	killagreg	1064	if(!direntry_exist && ( Partition.FirstDataSector <= file->FirstSectorOfCurrCluster))
41	ingob	1065	{
		1066	end_of_directory_not_reached = GetNextCluster(file); // updates File->FirstSectorOfCurrCluster
		1067	}
		1068	}while((end_of_directory_not_reached) && (!direntry_exist)); // repeat until a next cluster exist an no
		1069	return(direntry_exist);
1	ingob	1070	}
		1071
		1072
41	ingob	1073	/****************************************************************************************************************************************/
		1074	/* Function: CreateDirectoryEntry(s8 , u16, File_t ) */
		1075	/* */
		1076	/* Description: This function looks for the next free position in the directory and creates an entry. */
		1077	/* The type of an directory entry is specified by the file attribute. */
		1078	/* */
		1079	/* Returnvalue: Return 0 on error */
		1080	/****************************************************************************************************************************************/
		1081	u8 CreateDirectoryEntry(s8 dirname, u8 attrib, File_t file)
1	ingob	1082	{
41	ingob	1083	u32 dir_sector, max_dir_sector, curr_sector;
		1084	u16 dir_entry = 0;
		1085	u16 subdircluster, dircluster = 0;
		1086	u16 end_of_directory_not_reached = 0;
		1087	u8 i = 0;
88	killagreg	1088	u8 retvalue = 0;
41	ingob	1089	DirEntry_t *dir;
		1090
		1091	if((!Partition.IsValid) \|\| (file == NULL) \|\| (dirname == NULL)) return (retvalue);
		1092	// It is not checked here that the dir entry that should be created is already existent!
88	killagreg	1093
		1094	// Dir entries can be created only in file-clusters that have
41	ingob	1095	// the dir-flag set in its attribute or within the root directory
88	killagreg	1096
41	ingob	1097	file->FirstSectorOfFirstCluster = 0;
		1098	// no current directory exist therefore assume creating in the root
		1099	if(file->DirectorySector == 0)
24	StephanB	1100	{
41	ingob	1101	max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
		1102	dircluster = 0;
		1103	file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;
		1104	}
		1105	// within the root directory area we can read sectors sequentially until the end of this area
		1106	else if((Partition.FirstRootDirSector <= file->DirectorySector) && (file->DirectorySector < Partition.FirstDataSector))
		1107	{
		1108	max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
		1109	}
88	killagreg	1110	// within the data clusters we can read sectors sequentially only within the cluster
41	ingob	1111	else if((Partition.FirstDataSector <= file->DirectorySector) && (file->DirectorySector <= Partition.LastDataSector))
		1112	{
		1113	max_dir_sector = Partition.SectorsPerCluster;
		1114	}
88	killagreg	1115	else return (retvalue); // bad sector range for directory sector of the file
41	ingob	1116	// if search area is not defined yet
		1117	if(file->FirstSectorOfFirstCluster == 0)
		1118	{
		1119	// check if the directory entry of current file is existent and has the dir-flag set
		1120	file->SectorInCache = file->DirectorySector; // update the sector number of file cache.
88	killagreg	1121	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
41	ingob	1122	{
		1123	Fat16_Deinit();
		1124	return(retvalue);
88	killagreg	1125	}
41	ingob	1126	dir = (DirEntry_t *)file->Cache; // set pointer to directory
		1127	switch((u8)dir[file->DirectoryIndex].Name[0]) // check if current directory exist
		1128	{
		1129	case SLOT_EMPTY:
		1130	case SLOT_DELETED:
		1131	return (retvalue);
		1132	break;
88	killagreg	1133	default: // and is a real directory
41	ingob	1134	if((dir[file->DirectoryIndex].Attribute & ATTR_SUBDIRECTORY) != ATTR_SUBDIRECTORY)
		1135	{ // current file is not a directory therefore no file or subdirectory can be created here
		1136	return (retvalue);
		1137	}
		1138	break;
		1139	}
		1140	dircluster = dir[file->DirectoryIndex].StartCluster;
88	killagreg	1141	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(dircluster);
41	ingob	1142	}
88	killagreg	1143
41	ingob	1144	subdircluster = FindNextFreeCluster(file); // get the next free cluster on the disk and mark it as used.
		1145	if(subdircluster)
		1146	{
		1147	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		1148	file->SectorOfCurrCluster = 0;
		1149	do // loop over all clusters of current directory
88	killagreg	1150	{
41	ingob	1151	dir_sector = 0; // reset sector counter within a new cluster
		1152	do // loop over all sectors of a cluster or all sectors of the root directory
1	ingob	1153	{
88	killagreg	1154	curr_sector = file->FirstSectorOfCurrCluster + dir_sector; // calculate sector number
41	ingob	1155	file->SectorInCache = curr_sector; // upate the sector number of file cache.
88	killagreg	1156	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
24	StephanB	1157	{
41	ingob	1158	Fat16_Deinit();
		1159	return(retvalue);
88	killagreg	1160	}
41	ingob	1161	dir = (DirEntry_t *)file->Cache; // set pointer to directory
		1162	// search all directory entries of a sector
		1163	for(dir_entry = 0; dir_entry < DIRENTRIES_PER_SECTOR; dir_entry++)
		1164	{ // check if current direntry is available
		1165	if(((u8)dir[dir_entry].Name[0] == SLOT_EMPTY) \|\| ((u8)dir[dir_entry].Name[0] == SLOT_DELETED))
88	killagreg	1166	{ // a free direntry was found
41	ingob	1167	for(i = 0; i < 11; i++) dir[dir_entry].Name[i] = dirname[i]; // Set dir name
		1168	dir[dir_entry].Attribute = attrib; // Set the attribute of the new directoryentry.
		1169	dir[dir_entry].StartCluster = subdircluster; // copy the location of the first datacluster to the directoryentry.
		1170	dir[dir_entry].DateTime = FileDateTime(&SystemTime); // set date/time
		1171	dir[dir_entry].Size = 0; // the new createted file has no content yet.
		1172	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache)) // write back to card
		1173	{
		1174	Fat16_Deinit();
		1175	return(retvalue);
		1176	}
		1177	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(subdircluster); // Calculate absolute sectorposition of first datacluster.
		1178	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster; // Start reading the file with the first sector of the first datacluster.
		1179	file->SectorOfCurrCluster = 0; // reset sector of cureen cluster
		1180	file->ByteOfCurrSector = 0; // reset the byte location within the current sector
		1181	file->Attribute = attrib; // set file attribute to dir attribute
		1182	file->Size = 0; // new file has no size
		1183	file->DirectorySector = curr_sector;
		1184	file->DirectoryIndex = dir_entry;
88	killagreg	1185	if((attrib & ATTR_SUBDIRECTORY) == ATTR_SUBDIRECTORY) // if a new directory was created then initilize the data area
		1186	{
41	ingob	1187	ClearCurrCluster(file); // fill cluster with zeros
		1188	file->SectorInCache = file->FirstSectorOfFirstCluster;
88	killagreg	1189	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
41	ingob	1190	{
		1191	Fat16_Deinit();
		1192	return(retvalue);
88	killagreg	1193	}
41	ingob	1194	dir = (DirEntry_t *)file->Cache;
		1195	// create direntry "." to current dir
		1196	dir[0].Name[0] = 0x2E;
		1197	for(i = 1; i < 11; i++) dir[0].Name[i] = ' ';
		1198	dir[0].Attribute = ATTR_SUBDIRECTORY;
		1199	dir[0].StartCluster = subdircluster;
		1200	dir[0].DateTime = 0;
		1201	dir[0].Size = 0;
		1202	// create direntry ".." to the upper dir
		1203	dir[1].Name[0] = 0x2E;
		1204	dir[1].Name[1] = 0x2E;
		1205	for(i = 2; i < 11; i++) dir[1].Name[i] = ' ';
		1206	dir[1].Attribute = ATTR_SUBDIRECTORY;
		1207	dir[1].StartCluster = dircluster;
		1208	dir[1].DateTime = 0;
		1209	dir[1].Size = 0;
88	killagreg	1210	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))// read in the sector.
41	ingob	1211	{
		1212	Fat16_Deinit();
		1213	return(retvalue);
88	killagreg	1214	}
		1215	}
41	ingob	1216	retvalue = 1;
88	killagreg	1217	dir_entry = DIRENTRIES_PER_SECTOR; // stop for-loop
41	ingob	1218	}
88	killagreg	1219	}
41	ingob	1220	dir_sector++; // search next sector
		1221	// stop if we reached the end of the cluster or the end of the root dir
		1222	}while((dir_sector < max_dir_sector) && (!retvalue));
88	killagreg	1223
41	ingob	1224	// if we are seaching in the data area and the file not found in this cluster so take next cluster.
88	killagreg	1225	if(!retvalue && ( Partition.FirstDataSector <= file->FirstSectorOfCurrCluster))
24	StephanB	1226	{
41	ingob	1227	end_of_directory_not_reached = GetNextCluster(file); // updates File->FirstSectorOfCurrCluster
24	StephanB	1228	}
41	ingob	1229	}while((end_of_directory_not_reached) && (!retvalue));
		1230	// Perhaps we are at the end of the last cluster of a directory file an have no free direntry found.
		1231	// Then we would need to add a cluster to that file and create the new direntry there.
		1232	// This code is not implemented yet, because its occurs only if more that 32*32=1024 direntries are
		1233	// within a subdirectory of root.
1	ingob	1234	}
41	ingob	1235	return(retvalue); // return 1 if file has been created otherwise return 0.
1	ingob	1236	}
		1237
41	ingob	1238	/********************************************************************************************************************************************/
		1239	/* Function: FileExist(const s8* filename, u8 attribfilter, u8 attribmask, File_t file); /
		1240	/* */
		1241	/* Description: This function looks for the specified file including its subdirectories beginning */
		1242	/* in the rootdirectory of the drive. If the file is found the Filepointer properties are */
		1243	/* updated. */
		1244	/* */
		1245	/* Returnvalue: 1 if file is found else 0. */
		1246	/********************************************************************************************************************************************/
		1247	u8 FileExist(const s8* filename, const u8 attribfilter, const u8 attribmask, File_t *file)
1	ingob	1248	{
41	ingob	1249	s8* path = 0;
		1250	s8* subpath = 0;
		1251	u8 af, am, file_exist = 0;
		1252	s8 dirname[12]; // 8+3 + temination character
1	ingob	1253
41	ingob	1254	// if incomming pointers are useless return immediatly
		1255	if ((filename == NULL) \|\| (file == NULL) \|\| (!Partition.IsValid)) return 0;
1	ingob	1256
41	ingob	1257	// trace along the filepath
		1258	path = (s8*)filename; // start a the beginning of the filename string
		1259	file->DirectorySector = 0; // start at RootDirectory with file search
88	killagreg	1260	file->DirectoryIndex = 0;
41	ingob	1261	// as long as the file was not found and the remaining path is not empty
		1262	while((*path != 0) && !file_exist)
		1263	{ // separate dirname and subpath from filepath string
		1264	subpath = SeperateDirName(path, dirname);
		1265	if(subpath != NULL)
88	killagreg	1266	{
		1267	if(*subpath == 0)
41	ingob	1268	{ // empty subpath indicates last element of dir chain
		1269	af = attribfilter;
		1270	am = attribmask;
		1271	}
		1272	else // it must be a subdirectory and no volume label
1	ingob	1273	{
41	ingob	1274	af = ATTR_SUBDIRECTORY;
		1275	am = ATTR_SUBDIRECTORY\|ATTR_VOLUMELABEL;
		1276	}
		1277	if(!DirectoryEntryExist(dirname, af, am, file))
		1278	{
		1279	return (file_exist); // subdirectory does not exist
		1280	}
88	killagreg	1281	else
		1282	{
41	ingob	1283	if (*subpath == 0)
24	StephanB	1284	{
41	ingob	1285	file_exist = 1; // last element of path chain was found with the given attribute filter
24	StephanB	1286	}
1	ingob	1287	}
		1288	}
41	ingob	1289	else // error seperating the subpath
1	ingob	1290	{
41	ingob	1291	return file_exist; // bad subdir format
1	ingob	1292	}
41	ingob	1293	path = subpath;
		1294	subpath = 0;
1	ingob	1295	}
41	ingob	1296	return (file_exist);
1	ingob	1297	}
		1298
24	StephanB	1299
41	ingob	1300	/********************************************************************************************************************************************/
		1301	/* Function: FileCreate(const s8* filename, u8 attrib, File_t file); /
		1302	/* */
		1303	/* Description: This function looks for the specified file including its subdirectories beginning */
		1304	/* in the rootdirectory of the partition. If the file is found the Filepointer properties are */
88	killagreg	1305	/* updated. If file or its subdirectories are not found they will be created */
41	ingob	1306	/* */
		1307	/* Returnvalue: 1 if file was created else 0. */
		1308	/********************************************************************************************************************************************/
		1309	u8 FileCreate(const s8* filename, const u8 attrib, File_t *file)
		1310	{
		1311	s8 *path = 0;
		1312	s8 *subpath = 0;
		1313	u8 af, am, file_created = 0;
		1314	s8 dirname[12];
24	StephanB	1315
41	ingob	1316	// if incomming pointers are useless return immediatly
		1317	if ((filename == NULL) \|\| (file == NULL) \|\| (!Partition.IsValid)) return 0;
1	ingob	1318
41	ingob	1319	// trace along the filepath
		1320	path = (s8*)filename; // start a the beginning of the filename string
		1321	file->DirectorySector = 0; // start at RootDirectory with file search
		1322	file->DirectoryIndex = 0;
		1323	// as long as the file was not created and the remaining file path is not empty
		1324	while((*path != 0) && !file_created)
		1325	{ // separate dirname and subpath from filepath string
		1326	subpath = SeperateDirName(path, dirname);
		1327	if(subpath != NULL)
24	StephanB	1328	{
88	killagreg	1329	if(*subpath == 0)
41	ingob	1330	{ // empty subpath indicates last element of dir chain
		1331	af = ATTR_NONE;
		1332	am = ATTR_SUBDIRECTORY\|ATTR_VOLUMELABEL; // any file that is no subdir or volume label
24	StephanB	1333	}
41	ingob	1334	else // it must be a subdirectory and no volume label
24	StephanB	1335	{
41	ingob	1336	af = ATTR_SUBDIRECTORY;
		1337	am = ATTR_SUBDIRECTORY\|ATTR_VOLUMELABEL;
24	StephanB	1338	}
41	ingob	1339	if(!DirectoryEntryExist(dirname, af, am, file)) // if subdir or file is not existent
		1340	{ // try to create subdir or file
		1341	if(*subpath == 0) af = attrib; // if last element in dir chain take the given attribute
		1342	if(!CreateDirectoryEntry(dirname, af, file))
		1343	{ // could not be created
88	killagreg	1344	return(file_created);
		1345	}
41	ingob	1346	else if (*subpath == 0) file_created = 1; // last element of path chain was created
24	StephanB	1347	}
		1348	}
41	ingob	1349	else // error seperating the subpath
24	StephanB	1350	{
41	ingob	1351	return file_created; // bad subdir format
24	StephanB	1352	}
41	ingob	1353	path = subpath;
		1354	subpath = 0;
		1355	}
		1356	return (file_created);
24	StephanB	1357	}
1	ingob	1358
24	StephanB	1359
41	ingob	1360	/********************************************************************************************************************************************/
		1361	/* Function: File_t * fopen_(s8* filename, s8 mode); */
		1362	/* */
		1363	/* Description: This function looks for the specified file in the rootdirectory of the drive. If the file is found the number of the */
		1364	/* corrosponding filepointer is returned. Only modes 'r' (reading) and 'a' append are implemented yet. */
		1365	/* */
		1366	/* Returnvalue: The filepointer to the file or 0 if faild. */
		1367	/********************************************************************************************************************************************/
89	killagreg	1368	File_t * fopen_(s8 * const filename, const s8 mode)
88	killagreg	1369	{
41	ingob	1370	File_t *file = 0;
88	killagreg	1371
41	ingob	1372	if((!Partition.IsValid) \|\| (filename == 0)) return(file);
		1373
		1374	// Look for an unused filepointer in the file pointer list?
		1375	file = LockFilePointer();
		1376	// if no unused file pointer was found return 0
		1377	if(file == NULL) return(file);
		1378
		1379	// now we have found a free filepointer and claimed it
		1380	// so let initiate its property values
88	killagreg	1381	file->FirstSectorOfFirstCluster = 0; // Sectorpointer to the first sector of the first datacluster of the file.
41	ingob	1382	file->FirstSectorOfCurrCluster = 0; // Pointer to the cluster which is edited at the moment.
		1383	file->SectorOfCurrCluster = 0; // The sector which is edited at the moment (cluster_pointer + sector_index).
		1384	file->ByteOfCurrSector = 0; // The bytelocation within the current sector (cluster_pointer + sector_index + byte_index).
		1385	file->Mode = mode; // mode of fileoperation (read,write)
		1386	file->Size = 0; // the size of the opened file in bytes.
		1387	file->Position = 0; // pointer to a byte within the file 0 < fileposition < filesize
		1388	file->SectorInCache = 0; // the last sector read, wich is still in the sectorbuffer.
		1389	file->DirectorySector = 0; // the sectorposition where the directoryentry has been made.
		1390	file->DirectoryIndex = 0; // the index to the directoryentry within the specified sector.
		1391	file->Attribute = 0; // the attribute of the file opened.
		1392
		1393	// check if a real file (no directory) to the given filename exist
88	killagreg	1394	if(FileExist(filename, ATTR_NONE, ATTR_SUBDIRECTORY\|ATTR_VOLUMELABEL, file))
41	ingob	1395	{ // file exist
		1396	switch(mode) // check mode
1	ingob	1397	{
41	ingob	1398	case 'a': // if mode is: append to file
		1399	if((file->Attribute & ATTR_READONLY) == ATTR_READONLY)
		1400	{ // file is marked as readonly --> do not open this file
		1401	fclose_(file);
		1402	file = NULL;
		1403	}
		1404	else
		1405	{ // file is not marked as read only --> goto end of file
		1406	fseek_(file, 0, SEEK_END); // point to the end of the file
		1407	}
		1408	break;
		1409	case 'w': // if mode is: write to file
		1410	if((file->Attribute & ATTR_READONLY) == ATTR_READONLY)
		1411	{ // file is marked as readonly --> do not open this file
		1412	fclose_(file);
		1413	file = NULL;
		1414	}
		1415	else
		1416	{ // file is not marked as read only --> goto start of file
		1417	// free all clusters of that file
		1418	DeleteClusterChain(SectorToFat16Cluster(file->FirstSectorOfFirstCluster));
		1419	// mar an empy cluster as the last one and store the corresponding sector
		1420	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(FindNextFreeCluster(file));
		1421	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		1422	file->SectorOfCurrCluster = 0;
		1423	file->ByteOfCurrSector = 0;
		1424	file->Size = 0;
		1425	file->Position = 0;
		1426	fseek_(file, 0, SEEK_SET);
		1427	}
		1428	break;
		1429	case 'r': // if mode is: read from file
88	killagreg	1430	// goto end of file
41	ingob	1431	fseek_(file, 0, SEEK_SET);
		1432	break;
		1433	default: // other modes are not supported
		1434	fclose_(file);
		1435	file = NULL;
24	StephanB	1436	break;
1	ingob	1437	}
88	killagreg	1438	return(file);
1	ingob	1439	}
41	ingob	1440	else // file does not exist
		1441	{
		1442	switch(mode) // check mode
		1443	{
		1444	case 'a':
		1445	case 'w': // if mode is write or append
		1446	// try to create the file
		1447	if(!FileCreate(filename, ATTR_ARCHIVE, file))
		1448	{ // if it could not be created
		1449	fclose_(file);
		1450	file = NULL;
		1451	}
		1452	break;
		1453	case 'r': // else opened for 'r'
		1454	default: // of unsupported mode
		1455	fclose_(file);
		1456	file = NULL;
88	killagreg	1457	break;
41	ingob	1458	}
88	killagreg	1459	return(file);
41	ingob	1460	}
		1461	// we should never come to this point
		1462	fclose_(file);
		1463	file = NULL;
24	StephanB	1464	return(file);
		1465	}
		1466
41	ingob	1467	/****************************************************************************************************************************************************/
		1468	/* Function: fflush_(File ); /
		1469	/* */
		1470	/* Description: This function writes the data already in the buffer but not yet written to the file. */
		1471	/* */
		1472	/* Returnvalue: 0 on success EOF on error */
		1473	/****************************************************************************************************************************************************/
		1474	s16 fflush_(File_t *file)
24	StephanB	1475	{
88	killagreg	1476	DirEntry_t *dir;
		1477
41	ingob	1478	if((file == NULL) \|\| (!Partition.IsValid)) return (EOF);
88	killagreg	1479
41	ingob	1480	switch(file->Mode)
24	StephanB	1481	{
41	ingob	1482	case 'a':
		1483	case 'w':
88	killagreg	1484	if(file->ByteOfCurrSector > 0) // has data been added to the file?
41	ingob	1485	{
88	killagreg	1486	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))// save the data still in the buffer
41	ingob	1487	{
88	killagreg	1488	Fat16_Deinit();
		1489	return(EOF);
		1490	}
41	ingob	1491	}
		1492	file->SectorInCache = file->DirectorySector;
		1493	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache)) // read the directory entry for this file.
		1494	{
		1495	Fat16_Deinit();
88	killagreg	1496	return(EOF);
41	ingob	1497	}
88	killagreg	1498
41	ingob	1499	dir = (DirEntry_t *)file->Cache;
		1500	dir[file->DirectoryIndex].Size = file->Size; // update file size
		1501	dir[file->DirectoryIndex].DateTime = FileDateTime(&SystemTime); // update date time
		1502	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache)) // write back to sd-card
		1503	{
		1504	Fat16_Deinit();
		1505	return(EOF);
		1506	}
		1507	break;
		1508	case 'r':
		1509	default:
		1510	return(EOF);
		1511	break;
		1512
24	StephanB	1513	}
41	ingob	1514	return(0);
24	StephanB	1515	}
1	ingob	1516
41	ingob	1517	/****************************************************************************************************************************************/
		1518	/* Function: fclose_(File file); /
		1519	/* */
		1520	/* Description: This function closes the open file by writing the remaining data */
		1521	/* from the buffer to the device and entering the filesize in the directory entry. */
		1522	/* */
		1523	/* Returnvalue: 0 on success EOF on error */
		1524	/****************************************************************************************************************************************/
		1525	s16 fclose_(File_t *file)
24	StephanB	1526	{
41	ingob	1527	s16 returnvalue = EOF;
24	StephanB	1528
41	ingob	1529	if(file == NULL) return(returnvalue);
		1530	returnvalue = fflush_(file);
		1531	UnlockFilePointer(file);
		1532	return(returnvalue);
24	StephanB	1533	}
		1534
41	ingob	1535	/********************************************************************************************************************************************/
		1536	/* Function: fgetc_(File file); /
		1537	/* */
		1538	/* Description: This function reads and returns one character from the specified file. Is the end of the actual sector reached the */
		1539	/* next sector of the cluster is read. If the last sector of the cluster read the next cluster will be searched in FAT. */
		1540	/* */
		1541	/* Returnvalue: The function returns the character read from the specified memorylocation as u8 casted to s16 or EOF. */
		1542	/********************************************************************************************************************************************/
		1543	s16 fgetc_(File_t *file)
88	killagreg	1544	{
41	ingob	1545	s16 c = EOF;
		1546	u32 curr_sector;
88	killagreg	1547
41	ingob	1548	if( (!Partition.IsValid) \|\| (file == NULL)) return(c);
		1549	// if the end of the file is not reached, get the next character.
88	killagreg	1550	if((0 < file->Size) && ((file->Position+1) < file->Size) )
1	ingob	1551	{
41	ingob	1552	curr_sector = file->FirstSectorOfCurrCluster; // calculate the sector of the next character to be read.
88	killagreg	1553	curr_sector += file->SectorOfCurrCluster;
		1554
41	ingob	1555	if(file->SectorInCache != curr_sector)
1	ingob	1556	{
41	ingob	1557	file->SectorInCache = curr_sector;
		1558	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache,file->Cache))
		1559	{
		1560	Fat16_Deinit();
		1561	return(c);
88	killagreg	1562	}
		1563	}
41	ingob	1564	c = (s16) file->Cache[file->ByteOfCurrSector];
		1565	file->Position++; // increment file position
88	killagreg	1566	file->ByteOfCurrSector++; // goto next byte in sector
41	ingob	1567	if(file->ByteOfCurrSector >= BYTES_PER_SECTOR) // if end of sector
24	StephanB	1568	{
41	ingob	1569	file->ByteOfCurrSector = 0; // reset byte location
		1570	file->SectorOfCurrCluster++; // next sector
		1571	if(file->SectorOfCurrCluster >= Partition.SectorsPerCluster) // if end of cluster is reached, the next datacluster has to be searched in the FAT.
24	StephanB	1572	{
88	killagreg	1573
41	ingob	1574	if(GetNextCluster(file)) // Sets the clusterpointer of the file to the next datacluster.
24	StephanB	1575	{
41	ingob	1576	file->SectorOfCurrCluster = 0; // start reading new cluster at first sector of the cluster.
		1577	}
		1578	else // the last cluster was allready reached
		1579	{
		1580	file->SectorOfCurrCluster--; // jump back to the last sector in the last cluster
		1581	file->ByteOfCurrSector = BYTES_PER_SECTOR; // set ByteOfCurrSector one byte over sector end
		1582	}
1	ingob	1583	}
24	StephanB	1584	}
		1585	}
41	ingob	1586	return(c);
24	StephanB	1587	}
		1588
41	ingob	1589	/********************************************************************************************************************************************/
		1590	/* Function: fputc_( const s8 c, File file); /
		1591	/* */
		1592	/* Description: This function writes a byte to the specified file and takes care of writing the necessary FAT- Entries. */
		1593	/* next sector of the cluster is read. If the last sector of the cluster read the next cluster will be searched in FAT. */
		1594	/* */
		1595	/* Returnvalue: The function returns the character written to the stream or EOF on error. */
		1596	/********************************************************************************************************************************************/
		1597	s16 fputc_(const s8 c, File_t *file)
88	killagreg	1598	{
41	ingob	1599	u32 curr_sector = 0;
88	killagreg	1600
41	ingob	1601	if((!Partition.IsValid) \|\| (file == NULL)) return(EOF);
24	StephanB	1602
41	ingob	1603	// If file position equals to file size, then the end of file has reached.
88	killagreg	1604	// In this chase it has to be checked that the ByteOfCurrSector is BYTES_PER_SECTOR
41	ingob	1605	// and a new cluster should be appended.
		1606	if((file->Position >= file->Size) && (file->ByteOfCurrSector >= BYTES_PER_SECTOR))
		1607	{
		1608	if(!AppendCluster(file)) return(EOF);
		1609	}
24	StephanB	1610
41	ingob	1611	curr_sector = file->FirstSectorOfCurrCluster;
		1612	curr_sector += file->SectorOfCurrCluster;
		1613	if(file->SectorInCache != curr_sector)
		1614	{
		1615	file->SectorInCache = curr_sector;
		1616	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))
24	StephanB	1617	{
41	ingob	1618	Fat16_Deinit();
		1619	return(EOF);
88	killagreg	1620	}
41	ingob	1621	}
		1622
		1623	file->Cache[file->ByteOfCurrSector] = (u8)c; // write databyte into the buffer. The byte will be written to the device at once
		1624	if(file->Size == file->Position) file->Size++; // a character has been written to the file so the size is incremented only when the character has been added at the end of the file.
		1625	file->Position++; // the actual positon within the file.
88	killagreg	1626	file->ByteOfCurrSector++; // goto next byte in sector
41	ingob	1627	if(file->ByteOfCurrSector >= BYTES_PER_SECTOR) // if the end of this sector is reached yet
		1628	{ // save the sector to the sd-card
		1629	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))
		1630	{
		1631	Fat16_Deinit();
		1632	return(EOF);
		1633	}
		1634	file->ByteOfCurrSector = 0; // reset byte location
		1635	file->SectorOfCurrCluster++; // next sector
		1636	if(file->SectorOfCurrCluster >= Partition.SectorsPerCluster)// if end of cluster is reached, the next datacluster has to be searched in the FAT.
		1637	{
		1638	if(!GetNextCluster(file)) // Sets the clusterpointer of the file to the next datacluster.
		1639	{ // if current cluster was the last cluster of the file
		1640	if(!AppendCluster(file)) // append a new and free cluster at the end of the file.
24	StephanB	1641	{
41	ingob	1642	file->SectorOfCurrCluster--; // jump back to last sector of last cluster
		1643	file->ByteOfCurrSector = BYTES_PER_SECTOR; // set byte location to 1 byte over sector len
		1644	return(EOF);
24	StephanB	1645	}
1	ingob	1646	}
41	ingob	1647	else // next cluster
24	StephanB	1648	{
41	ingob	1649	file->SectorOfCurrCluster = 0; // start reading new cluster at first sector of the cluster.
88	killagreg	1650	}
1	ingob	1651	}
		1652	}
41	ingob	1653	return(0);
24	StephanB	1654	}
		1655
		1656
41	ingob	1657	/****************************************************************************************************************************************/
		1658	/* Function: fread_(void buffer, s32 size, s32 count, File File); */
		1659	/* */
		1660	/* Description: This function reads count objects of the specified size */
		1661	/* from the actual position of the file to the specified buffer. */
		1662	/* */
		1663	/* Returnvalue: The function returns the number of objects (not bytes) read from the file. */
		1664	/****************************************************************************************************************************************/
		1665	u32 fread_(void buffer, u32 size, u32 count, File_t file)
		1666	{
		1667	u32 object_cnt = 0; // count the number of objects read from the file.
		1668	u32 object_size = 0; // count the number of bytes read from the actual object.
		1669	u8 *pbuff = 0; // a pointer to the actual bufferposition.
		1670	u8 success = 1; // no error occured during read operation to the file.
88	killagreg	1671	s16 c;
24	StephanB	1672
41	ingob	1673	if((!Partition.IsValid) \|\| (file == NULL) \|\| (buffer == NULL)) return(0);
24	StephanB	1674
41	ingob	1675	pbuff = (u8 ) buffer; // cast the void pointer to an u8
88	killagreg	1676
41	ingob	1677	while((object_cnt < count) && success)
24	StephanB	1678	{
41	ingob	1679	object_size = size;
		1680	while((size > 0) && success)
		1681	{
		1682	c = fgetc_(file);
		1683	if(c != EOF)
		1684	{
		1685	*pbuff = (u8)c; // read a byte from the buffer to the opened file.
		1686	pbuff++;
		1687	size--;
		1688	}
		1689	else // error or end of file reached
		1690	{
88	killagreg	1691	success = 0;
41	ingob	1692	}
		1693	}
		1694	if(success) object_cnt++;
88	killagreg	1695	}
41	ingob	1696	return(object_cnt); // return the number of objects succesfully read from the file
1	ingob	1697	}
		1698
24	StephanB	1699
41	ingob	1700	/****************************************************************************************************************************************/
		1701	/* Function: fwrite_(void buffer, s32 size, s32 count, File file); */
		1702	/* */
		1703	/* Description: This function writes count objects of the specified size */
		1704	/* from the buffer pointer to the actual position in the file. */
		1705	/* */
		1706	/* Returnvalue: The function returns the number of objects (not bytes) read from the file. */
		1707	/****************************************************************************************************************************************/
		1708	u32 fwrite_(void buffer, u32 size, u32 count, File_t file)
1	ingob	1709	{
41	ingob	1710	u32 object_cnt = 0; // count the number of objects written to the file.
		1711	u32 object_size = 0; // count the number of bytes written from the actual object.
		1712	u8 *pbuff = 0; // a pointer to the actual bufferposition.
		1713	u8 success = 1; // no error occured during write operation to the file.
88	killagreg	1714	s16 c;
24	StephanB	1715
41	ingob	1716	if((!Partition.IsValid) \|\| (file == NULL) \|\| (buffer == NULL)) return(0);
		1717
		1718	pbuff = (u8 ) buffer; // cast the void pointer to an u8
88	killagreg	1719
41	ingob	1720	while((object_cnt < count) && success)
1	ingob	1721	{
41	ingob	1722	object_size = size;
		1723	while((size > 0) && success)
1	ingob	1724	{
41	ingob	1725	c = fputc_(*pbuff, file); // write a byte from the buffer to the opened file.
		1726	if(c != EOF)
24	StephanB	1727	{
41	ingob	1728	pbuff++;
		1729	size--;
24	StephanB	1730	}
41	ingob	1731	else
24	StephanB	1732	{
41	ingob	1733	success = 0;
24	StephanB	1734	}
1	ingob	1735	}
41	ingob	1736	if(success) object_cnt++;
88	killagreg	1737	}
		1738
41	ingob	1739	return(object_cnt); // return the number of objects succesfully written to the file
88	killagreg	1740	}
1	ingob	1741
24	StephanB	1742
41	ingob	1743	/****************************************************************************************************************************************/
		1744	/* Function: fputs_(const s8 string, File_t File); */
		1745	/* */
		1746	/* Description: This function writes a string to the specified file. */
		1747	/* */
		1748	/* Returnvalue: The function returns a no negative value or EOF on error. */
		1749	/****************************************************************************************************************************************/
89	killagreg	1750	s16 fputs_(s8 * const string, File_t * const file)
24	StephanB	1751	{
41	ingob	1752	u8 i=0;
		1753	s16 c = 0;
88	killagreg	1754
41	ingob	1755	if((!Partition.IsValid) \|\| (file == NULL) \|\| (string == NULL)) return(0);
24	StephanB	1756
41	ingob	1757	while((string[i] != 0)&& (c != EOF))
24	StephanB	1758	{
41	ingob	1759	c = fputc_(string[i], file);
		1760	i++;
24	StephanB	1761	}
41	ingob	1762	return(c);
24	StephanB	1763	}
		1764
41	ingob	1765	/****************************************************************************************************************************************/
		1766	/* Function: fgets_(s8 , s16 , File_t ); */
		1767	/* */
		1768	/* Description: This function reads a string from the file to the specifies string. */
		1769	/* */
		1770	/* Returnvalue: A pointer to the string read from the file or 0 on error. */
		1771	/****************************************************************************************************************************************/
89	killagreg	1772	s8 * fgets_(s8 * const string, s16 const length, File_t * const file)
24	StephanB	1773	{
89	killagreg	1774	s8 *pbuff;
		1775	s16 c = 0, bytecount;
88	killagreg	1776
89	killagreg	1777	if((!Partition.IsValid) \|\| (file == NULL) \|\| (string == NULL) \|\| (length < 1)) return (0);
		1778	bytecount = length;
		1779	pbuff = string; // set write pointer to start of string
		1780	while(bytecount > 1) // read the length-1 characters from the file to the string.
24	StephanB	1781	{
41	ingob	1782	c = fgetc_(file); // read a character from the opened file.
		1783	switch(c)
1	ingob	1784	{
89	killagreg	1785	case 0x0A: // new line
		1786	*pbuff = 0; // set string terminator
		1787	return(string); // return normal
88	killagreg	1788
41	ingob	1789	case EOF:
89	killagreg	1790	*pbuff = 0; // set string terminator
		1791	return(0);
		1792
		1793	default:
		1794	*pbuff++ = (s8)c; // copy byte to string
		1795	bytecount--;
88	killagreg	1796	break;
1	ingob	1797	}
24	StephanB	1798	}
89	killagreg	1799	*pbuff = 0; // set string terminator
41	ingob	1800	return(string);
24	StephanB	1801	}
		1802
41	ingob	1803	/****************************************************************************************************************************************/
		1804	/* Function: fexist_(const u8); /
		1805	/* */
		1806	/* Description: This function checks if a file already exist. */
		1807	/* */
		1808	/* Returnvalue: 1 if the file exist else 0. */
		1809	/****************************************************************************************************************************************/
89	killagreg	1810	u8 fexist_(s8 * const filename)
24	StephanB	1811	{
41	ingob	1812	u8 exist = 0;
		1813	File_t *file = 0;
		1814	file = LockFilePointer();
		1815	exist = FileExist(filename, ATTR_NONE, ATTR_SUBDIRECTORY\|ATTR_VOLUMELABEL, file);
		1816	UnlockFilePointer(file);
		1817	return(exist);
1	ingob	1818	}
24	StephanB	1819
41	ingob	1820	/****************************************************************************************************************************************/
		1821	/* Function: feof_(File_t File); /
		1822	/* */
		1823	/* Description: This function checks wether the end of the file has been reached. */
		1824	/* */
		1825	/* Returnvalue: 0 if the end of the file was not reached otherwise 1. */
		1826	/****************************************************************************************************************************************/
		1827	u8 feof_(File_t *file)
88	killagreg	1828	{
41	ingob	1829	if(((file->Position)+1) < (file->Size))
24	StephanB	1830	{
		1831	return(0);
		1832	}
88	killagreg	1833	else
24	StephanB	1834	{
88	killagreg	1835	return(1);
24	StephanB	1836	}
		1837	}
41	ingob	1838
		1839

Subversion Repositories NaviCtrl

(root)/tags/V0.18c/fat16.c @ 240 - Rev 171