WebSVN - NaviCtrl - Blame - Rev 210

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
210	killagreg	301	u8 VolumeLabel[12]; // the volume label
41	ingob	302	} Partition_t;
1	ingob	303
41	ingob	304	Partition_t Partition; // Structure holds partition information
1	ingob	305
41	ingob	306	File_t FilePointer[FILE_MAX_OPEN]; // Allocate Memmoryspace for each filepointer used.
1	ingob	307
41	ingob	308
		309	/****************************************************************************************************************************************/
		310	/* Function: FileDateTime(DateTime_t ); /
		311	/* */
		312	/* Description: This function calculates the DOS date time from a pointer to a time structure. */
		313	/* */
		314	/* Returnvalue: Returns the DOS date time. */
		315	/****************************************************************************************************************************************/
		316
		317	u32 FileDateTime(DateTime_t * pTimeStruct)
1	ingob	318	{
41	ingob	319	u32 datetime = 0;
		320	if((pTimeStruct == 0) \|\| !(pTimeStruct->Valid)) return datetime;
24	StephanB	321
41	ingob	322	datetime \|= (0x0000007FL & (u32)(pTimeStruct->Year - 1980))<<25; // set year
		323	datetime \|= (0x0000000FL & (u32)(pTimeStruct->Month))<<21; // set month
		324	datetime \|= (0x0000001FL & (u32)(pTimeStruct->Day))<<16;
		325	datetime \|= (0x0000001FL & (u32)(pTimeStruct->Hour))<<11;
		326	datetime \|= (0x0000003FL & (u32)(pTimeStruct->Min))<<5;
		327	datetime \|= (0x0000001FL & (u32)(pTimeStruct->Sec/2));
		328	return datetime;
1	ingob	329	}
		330
		331
41	ingob	332	/****************************************************************************************************************************************/
		333	/* Function: LockFilePointer(); */
		334	/* */
		335	/* Description: This function trys to lock a free file pointer. */
		336	/* */
		337	/* Returnvalue: Returns the Filepointer on success or 0. */
		338	/****************************************************************************************************************************************/
		339	File_t * LockFilePointer(void)
1	ingob	340	{
41	ingob	341	u8 i;
		342	File_t * File = 0;
		343	for(i = 0; i < FILE_MAX_OPEN; i++)
1	ingob	344	{
88	killagreg	345	if(FilePointer[i].State == FSTATE_UNUSED) // found an unused one
1	ingob	346	{
88	killagreg	347	File = &FilePointer[i]; // set pointer to that entry
41	ingob	348	FilePointer[i].State = FSTATE_USED; // mark it as used
		349	break;
1	ingob	350	}
41	ingob	351	}
		352	return(File);
1	ingob	353	}
		354
41	ingob	355	/****************************************************************************************************************************************/
		356	/* Function: UnlockFilePointer(file_t ); /
		357	/* */
		358	/* Description: This function trys to unlock a file pointer. */
		359	/* */
		360	/* Returnvalue: Returns 1 if file pointer was freed else 0. */
		361	/****************************************************************************************************************************************/
		362	u8 UnlockFilePointer(File_t * file)
1	ingob	363	{
41	ingob	364	u8 cnt;
		365	if(file == NULL) return(0);
		366	for(cnt = 0; cnt < FILE_MAX_OPEN; cnt++)
1	ingob	367	{
41	ingob	368	if(&FilePointer[cnt] == file) // filepointer to be freed found?
1	ingob	369	{
88	killagreg	370	file->State = FSTATE_UNUSED;
		371	file->FirstSectorOfFirstCluster = 0; // Sectorpointer to the first sector of the first datacluster of the file.
41	ingob	372	file->FirstSectorOfCurrCluster = 0;
		373	file->SectorOfCurrCluster = 0; // Pointer to the cluster which is edited at the moment.
		374	file->SectorOfCurrCluster = 0; // The sector which is edited at the moment (cluster_pointer + sector_index).
		375	file->ByteOfCurrSector = 0; // The bytelocation within the current sector (cluster_pointer + sector_index + byte_index).
		376	file->Mode = 0; // mode of fileoperation (read,write)
		377	file->Size = 0; // the size of the opend file in bytes.
		378	file->Position = 0; // pointer to a character within the file 0 < fileposition < filesize
		379	file->SectorInCache = 0; // the last sector read, wich is still in the sectorbuffer.
		380	file->DirectorySector = 0; // the sectorposition where the directoryentry has been made.
		381	file->DirectoryIndex = 0; // the index to the directoryentry within the specified sector.
		382	file->Attribute = 0; // the attribute of the file opened.
88	killagreg	383	file = NULL;
41	ingob	384	return(1);
1	ingob	385	}
41	ingob	386	}
		387	return(0);
		388	}
1	ingob	389
41	ingob	390	/****************************************************************************************************************************************/
		391	/* Function: SeperateDirName(s8, s8); */
		392	/* */
		393	/* Description: This function seperates the first dirname from filepath and brings them */
		394	/* into the needed format ('test.txt' -> 'TEST TXT') */
210	killagreg	395	/* The subpath is the pointer to the remaining substring of the filepath */
41	ingob	396	/* */
		397	/* Returnvalue: Return NULL on error or pointer to subpath */
		398	/****************************************************************************************************************************************/
		399	s8* SeperateDirName(const s8 filepath, s8 dirname)
		400	{
		401	s8* subpath = NULL;
		402	u8 readpointer = 0;
		403	u8 writepointer = 0;
1	ingob	404
88	killagreg	405	// search subpath from beginning of filepath
41	ingob	406	subpath = NULL;
		407	readpointer = 0;
		408	if(filepath[0] == '/') readpointer = 1; // ignore first '/'
88	killagreg	409	while(subpath == NULL) // search the filepath until a subpath was found.
1	ingob	410	{
88	killagreg	411	if(((filepath[readpointer] == 0) \|\| (filepath[readpointer] == '/'))) // if '/' found or end of filepath reached
		412	{
41	ingob	413	subpath = (s8*)&filepath[readpointer]; // store the position of the first "/" found after the beginning of the filenpath
		414	}
		415	readpointer++;
		416	}
1	ingob	417
41	ingob	418	// clear dirname with spaces
		419	dirname[11] = 0; // terminate dirname
		420	for(writepointer = 0; writepointer < 11; writepointer++) dirname[writepointer] = ' ';
		421	writepointer = 0;
		422	// start seperating the dirname from the filepath.
		423	readpointer = 0;
		424	if(filepath[0] == '/') readpointer = 1; // ignore first '/'
		425	while( &filepath[readpointer] < subpath)
1	ingob	426	{
41	ingob	427	if(writepointer >= 11) return(NULL); // dirname to long
		428	if(filepath[readpointer] == '.') // seperating dirname and extension.
1	ingob	429	{
41	ingob	430	if(writepointer <= 8)
1	ingob	431	{
41	ingob	432	readpointer++; // next character in filename
		433	writepointer = 8; // jump to start of extension
1	ingob	434	}
88	killagreg	435	else return(NULL); // dirbasename to long
41	ingob	436	}
		437	else
		438	{
		439	if((0x60 < filepath[readpointer]) && (filepath[readpointer] < 0x7B))
		440	{
		441	dirname[writepointer] = (filepath[readpointer] - 0x20); // all characters must be upper case.
		442	}
1	ingob	443	else
		444	{
41	ingob	445	dirname[writepointer] = filepath[readpointer];
88	killagreg	446	}
41	ingob	447	readpointer++;
		448	writepointer++;
1	ingob	449	}
41	ingob	450	}
88	killagreg	451	return(subpath);
1	ingob	452	}
		453
		454
41	ingob	455	/*************************************************************************************************************************************+/
		456	/* Function: Fat16ClusterToSector( u16 cluster); */
		457	/* */
		458	/* Description: This function converts a cluster number given by the fat to the corresponding */
		459	/* sector that points to the start of the data area that is represented by the cluster number. */
		460	/* */
		461	/* Returnvalue: The sector number with the data area of the given cluster */
		462	/****************************************************************************************************************************************/
		463	u32 Fat16ClusterToSector(u16 cluster)
		464	{
		465	if(!Partition.IsValid) return 0;
88	killagreg	466	if (cluster < 2) cluster = 2; // the 0. and 1. cluster in the fat are used for the media descriptor
41	ingob	467	return ( (cluster - 2) * Partition.SectorsPerCluster) + Partition.FirstDataSector; // the first data sector is represented by the 2nd cluster
		468	}
		469
		470	/****************************************************************************************************************************************/
		471	/* Function: SectorToFat16Cluster( u32 sector); */
		472	/* */
		473	/* Description: This function converts a given sector number given to the corresponding */
		474	/* cluster number in the fat that represents this data area. */
		475	/* */
		476	/* Returnvalue: The cluster number representing the data area of the sector. */
		477	/****************************************************************************************************************************************/
		478	u16 SectorToFat16Cluster(u32 sector)
		479	{
		480	if(!Partition.IsValid) return 0;
		481	return ((u16)((sector - Partition.FirstDataSector) / Partition.SectorsPerCluster) + 2);
		482	}
		483
		484
		485	/****************************************************************************************************************************************/
210	killagreg	486	/* Function: Fat16_IsValid(void); */
90	killagreg	487	/* */
210	killagreg	488	/* Description: This function return the Fat 16 filesystem state */
90	killagreg	489	/* */
		490	/* Returnvalue: The function returns "1" on success */
		491	/****************************************************************************************************************************************/
		492	u8 Fat16_IsValid(void)
		493	{
		494	return(Partition.IsValid);
		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
210	killagreg	521	Partition.VolumeLabel[0]='\0';
146	killagreg	522	UART1_PutString("ok");
41	ingob	523	return(returnvalue);
1	ingob	524	}
		525
41	ingob	526	/****************************************************************************************************************************************/
		527	/* Function: Fat16_Init(void); */
		528	/* */
		529	/* Description: This function reads the Masterbootrecord and finds the position of the Volumebootrecord, the FAT and the Rootdir */
		530	/* and stores the information in global variables. */
		531	/* */
		532	/* Returnvalue: The function returns "0" if the filesystem is initialized. */
		533	/****************************************************************************************************************************************/
		534	u8 Fat16_Init(void)
88	killagreg	535	{
41	ingob	536	u8 cnt = 0;
		537	u32 partitionfirstsector;
88	killagreg	538	VBR_Entry_t *VBR;
41	ingob	539	MBR_Entry_t *MBR;
		540	File_t *file;
		541	u8 result = 0;
1	ingob	542
110	killagreg	543	UART1_PutString("\r\n FAT16 init...");
41	ingob	544	Partition.IsValid = 0;
		545
		546	// declare the filepointers as unused.
		547	for(cnt = 0; cnt < FILE_MAX_OPEN; cnt++)
1	ingob	548	{
88	killagreg	549	FilePointer[cnt].State = FSTATE_UNUSED;
1	ingob	550	}
41	ingob	551	// set current file pinter to first position in list
88	killagreg	552	file = &FilePointer[0];
		553
41	ingob	554	// try to initialise the sd-card.
88	killagreg	555	if(SD_SUCCESS != SDC_Init())
		556	{
110	killagreg	557	UART1_PutString("SD-Card could not be initialized.");
41	ingob	558	result = 1;
88	killagreg	559	goto end;
41	ingob	560	}
1	ingob	561
41	ingob	562	// SD-Card is initialized successfully
		563	if(SD_SUCCESS != SDC_GetSector((u32)MBR_SECTOR,file->Cache)) // Read the MasterBootRecord
1	ingob	564	{
110	killagreg	565	UART1_PutString("Error reading the MBR.");
41	ingob	566	result = 2;
88	killagreg	567	goto end;
1	ingob	568	}
41	ingob	569	MBR = (MBR_Entry_t *)file->Cache; // Enter the MBR using the structure MBR_Entry_t.
88	killagreg	570	if((MBR->PartitionEntry1.Type == PART_TYPE_FAT16_ST_32_MB) \|\|
41	ingob	571	(MBR->PartitionEntry1.Type == PART_TYPE_FAT16_LT_32_MB) \|\|
		572	(MBR->PartitionEntry1.Type == PART_TYPE_FAT16LBA))
1	ingob	573	{
41	ingob	574	// get sector offset 1st partition
		575	partitionfirstsector = MBR->PartitionEntry1.NoSectorsBeforePartition;
		576	// Start of Partition is the Volume Boot Sector
		577	if(SD_SUCCESS != SDC_GetSector(partitionfirstsector,file->Cache)) // Read the volume boot record
1	ingob	578	{
110	killagreg	579	UART1_PutString("Error reading the VBR.");
41	ingob	580	result = 3;
88	killagreg	581	goto end;
		582	}
1	ingob	583	}
41	ingob	584	else // maybe the medium has no partition assuming sector 0 is the vbr
		585	{
		586	partitionfirstsector = 0;
		587	}
88	killagreg	588
41	ingob	589	VBR = (VBR_Entry_t *) file->Cache; // Enter the VBR using the structure VBR_Entry_t.
		590	if(VBR->BytesPerSector != BYTES_PER_SECTOR)
		591	{
110	killagreg	592	UART1_PutString("VBR: Sector size not supported.");
41	ingob	593	result = 4;
88	killagreg	594	goto end;
41	ingob	595	}
		596	Partition.SectorsPerCluster = VBR->SectorsPerCluster; // Number of sectors per cluster. Depends on the memorysize of the sd-card.
		597	Partition.FatCopies = VBR->NoFATCopies; // Number of fatcopies.
		598	Partition.MaxRootEntries = VBR->MaxRootEntries; // How many Entries are possible in the rootdirectory (FAT16 allows max. 512 entries).
210	killagreg	599	Partition.SectorsPerFat = VBR->SectorsPerFAT; // The number of sectors per FAT // copy volume label
		600	Partition.VolumeLabel[0] = '\0'; // set string terminator
41	ingob	601
		602	/* Calculate the sectorpositon of the FAT, the Rootdirectory and the first Datacluster. */
88	killagreg	603	// Calculate the position of the FileAllocationTable:
41	ingob	604	// Start + # of Reserved Sectors
88	killagreg	605	Partition.FirstFatSector = (u32)(partitionfirstsector + (u32)(VBR->ReservedSectors));
		606	// Calculate the position of the Rootdirectory:
		607	// Start + # of Reserved Sectors + (# of Sectors Per FAT * # of FAT Copies)
41	ingob	608	Partition.FirstRootDirSector = Partition.FirstFatSector + (u32)((u32)Partition.SectorsPerFat*(u32)Partition.FatCopies);
		609	// Calculate the position of the first datacluster:
88	killagreg	610	// Start + # of Reserved + (# of Sectors Per FAT * # of FAT Copies) + ((Maximum Root Directory Entries * 32) / Bytes per Sector)
41	ingob	611	Partition.FirstDataSector = Partition.FirstRootDirSector + (u32)(Partition.MaxRootEntries>>4); // assuming 512 Byte Per Sector
		612	// Calculate the last data sector
		613	if(VBR->NoSectors == 0)
		614	{
110	killagreg	615	UART1_PutString("VBR: Bad number of sectors.");
41	ingob	616	result = 5;
88	killagreg	617	goto end;
41	ingob	618	}
		619	Partition.LastDataSector = Partition.FirstDataSector + VBR->NoSectors - 1;
		620	// check for FAT16 in VBR of first partition
		621	if(!((VBR->FATName[0]=='F') && (VBR->FATName[1]=='A') && (VBR->FATName[2]=='T') && (VBR->FATName[3]=='1')&&(VBR->FATName[4]=='6')))
		622	{
110	killagreg	623	UART1_PutString("VBR: Partition ist not FAT16 type.");
41	ingob	624	result = 6;
		625	goto end;
		626	}
		627	Partition.IsValid = 1; // mark data in partition structure as valid
		628	result = 0;
		629	end:
		630	if(result != 0) Fat16_Deinit();
110	killagreg	631	else UART1_PutString("ok");
88	killagreg	632	return(result);
1	ingob	633	}
		634
		635
41	ingob	636
		637	/****************************************************************************************************************************************/
		638	/* Function: ClearCurrCluster(File_t); /
		639	/* */
		640	/* Description: This function fills the current cluster with 0. */
		641	/* */
		642	/* Returnvalue: The function returns 1 on success else 0. */
		643	/****************************************************************************************************************************************/
		644	u8 ClearCurrCluster(File_t * file)
1	ingob	645	{
41	ingob	646	u8 retvalue = 1;
		647	u32 i;
88	killagreg	648
41	ingob	649	if((!Partition.IsValid) \|\| (file == NULL)) return(0);
		650
		651	for(i = 0; i < BYTES_PER_SECTOR; i++) file->Cache[i] = 0; // clear file cache
		652	for(i = 0; i < Partition.SectorsPerCluster; i++)
1	ingob	653	{
41	ingob	654	file->SectorInCache = file->FirstSectorOfCurrCluster + i;
		655	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))
		656	{
88	killagreg	657	Fat16_Deinit();
41	ingob	658	retvalue = 0;
		659	}
1	ingob	660	}
88	killagreg	661	return(retvalue);
1	ingob	662	}
		663
41	ingob	664	/*****************************************************************************************************************************************/
		665	/* Function: GetNextCluster(File_t* ); */
		666	/* */
		667	/* Description: This function finds the next datacluster of the file specified with File File. /
		668	/* */
		669	/* Returnvalue: The function returns the next cluster or 0 if the last cluster has already reached. */
		670	/*****************************************************************************************************************************************/
		671	u16 GetNextCluster(File_t * file)
1	ingob	672	{
41	ingob	673	u16 cluster = 0;
		674	u32 fat_byte_offset, sector, byte;
		675	Fat16Entry_t * fat;
88	killagreg	676
41	ingob	677	if((!Partition.IsValid) \|\| (file == NULL)) return(cluster);
		678	// if sector is within the data area
		679	if((Partition.FirstDataSector <= file->FirstSectorOfCurrCluster)&& (file->FirstSectorOfCurrCluster <= Partition.LastDataSector))
1	ingob	680	{
41	ingob	681	// determine current file cluster
		682	cluster = SectorToFat16Cluster(file->FirstSectorOfCurrCluster);
		683	// calculate byte offset in the fat for corresponding entry
		684	fat_byte_offset = ((u32)cluster)<<1; // two FAT bytes (16 bits) for every cluster
		685	// calculate the sector that contains the current cluster within the fat
		686	sector = Partition.FirstFatSector + ( fat_byte_offset / BYTES_PER_SECTOR);
		687	// calculate byte offset of the current cluster within that fat sector
		688	byte = fat_byte_offset % BYTES_PER_SECTOR;
		689	// read this sector to the file cache
		690	if(file->SectorInCache != sector)
1	ingob	691	{
41	ingob	692	file->SectorInCache = sector; // update sector stored in buffer
		693	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache)) // read sector from sd-card
24	StephanB	694	{
41	ingob	695	Fat16_Deinit();
		696	return (cluster);
88	killagreg	697	}
		698	}
41	ingob	699	// read the next cluster from cache
		700	fat = (Fat16Entry_t *)(&(file->Cache[byte]));
		701	cluster = fat->NextCluster;
88	killagreg	702	// if last cluster fat entry
41	ingob	703	if(FAT16_CLUSTER_LAST_MIN <= cluster)
		704	{
		705	cluster = 0;
1	ingob	706	}
24	StephanB	707	else
		708	{
41	ingob	709	file->FirstSectorOfCurrCluster = Fat16ClusterToSector(cluster);
		710	file->SectorOfCurrCluster = 0;
		711	file->ByteOfCurrSector = 0;
24	StephanB	712	}
88	killagreg	713	}
41	ingob	714	return(cluster);
1	ingob	715	}
		716
		717
41	ingob	718	/****************************************************************************************************************************************/
		719	/* Function: FindNextFreeCluster(File_t ); /
		720	/* */
		721	/* Description: This function looks in the fat to find the next free cluster */
		722	/* */
		723	/* Returnvalue: The function returns the cluster number of the next free cluster found within the fat. */
		724	/****************************************************************************************************************************************/
		725	u16 FindNextFreeCluster(File_t *file)
1	ingob	726	{
41	ingob	727	u32 fat_sector; // current sector within the fat relative to the first sector of the fat.
		728	u32 curr_sector; // current sector
		729	u16 fat_entry; // index to an fatentry within the actual sector (256 fatentries are possible within one sector).
		730	u16 free_cluster = 0; // next free cluster number.
		731	Fat16Entry_t * fat;
88	killagreg	732
41	ingob	733	if((!Partition.IsValid) \|\| (file == NULL)) return(0);
24	StephanB	734
41	ingob	735	// start searching for an empty cluster at the beginning of the fat.
88	killagreg	736	fat_sector = 0;
		737	do
1	ingob	738	{
41	ingob	739	curr_sector = Partition.FirstFatSector + fat_sector; // calculate sector to read
		740	file->SectorInCache = curr_sector; // upate the sector number of file cache.
		741	if( SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache)) // read sector of fat from sd-card.
		742	{
		743	Fat16_Deinit();
		744	return(free_cluster);
		745	}
		746
		747	fat = (Fat16Entry_t *)file->Cache; // set fat pointer to file cache
		748
88	killagreg	749	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	750	{
		751	if(fat[fat_entry].NextCluster == FAT16_CLUSTER_FREE) // empty cluster found!!
88	killagreg	752	{
		753	fat[fat_entry].NextCluster = FAT16_CLUSTER_LAST_MAX; // mark this fat-entry as used
41	ingob	754	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache)) // and save the sector at the sd-card.
		755	{
		756	Fat16_Deinit();
		757	return(free_cluster);
		758	}
88	killagreg	759	free_cluster = (u16)(fat_sector * FAT16_ENTRIES_PER_SECTOR + (u32)fat_entry);
41	ingob	760	fat_entry = FAT16_ENTRIES_PER_SECTOR; // terminate the search for a free cluster in this sector.
		761	}
		762	}
		763	fat_sector++; // continue the search in next fat sector
88	killagreg	764	// repeat until the end of the fat is reached and no free cluster has been found so far
41	ingob	765	}while((fat_sector < Partition.SectorsPerFat) && (!free_cluster));
		766	return(free_cluster);
1	ingob	767	}
		768
		769
41	ingob	770	/****************************************************************************************************************************************************/
		771	/* Function: s16 fseek_(File_t , s32 , u8) */
		772	/* */
		773	/* Description: This function sets the pointer of the stream relative to the position */
		774	/* specified by origin (SEEK_SET, SEEK_CUR, SEEK_END) */
		775	/* Returnvalue: Is 1 if seek was successful */
		776	/****************************************************************************************************************************************************/
		777	s16 fseek_(File_t *file, s32 offset, s16 origin)
1	ingob	778	{
41	ingob	779	s32 fposition = 0;
		780	s16 retvalue = 1;
88	killagreg	781
41	ingob	782	if((!Partition.IsValid) \|\| (file == NULL)) return(0);
		783	switch(origin)
		784	{
		785	case SEEK_SET: // Fileposition relative to the beginning of the file.
88	killagreg	786	fposition = 0;
41	ingob	787	break;
		788	case SEEK_END: // Fileposition relative to the end of the file.
		789	fposition = (s32)file->Size;
		790	break;
		791	case SEEK_CUR: // Fileposition relative to the current position of the file.
		792	default:
		793	fposition = file->Position;
		794	break;
1	ingob	795	}
41	ingob	796
		797	fposition += offset;
		798
		799	if((fposition >= 0) && (fposition <= (s32)file->Size)) // is the pointer still within the file?
1	ingob	800	{
41	ingob	801	// reset file position to start of the file
		802	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		803	file->SectorOfCurrCluster = 0;
		804	file->ByteOfCurrSector = 0;
		805	file->Position = 0;
1	ingob	806
41	ingob	807	while(file->Position < fposition) // repeat until the current position is less than target
1	ingob	808	{
41	ingob	809	file->Position++; // increment file position
88	killagreg	810	file->ByteOfCurrSector++; // next byte in current sector
		811	if(file->ByteOfCurrSector >= BYTES_PER_SECTOR)
41	ingob	812	{
		813	file->ByteOfCurrSector = 0; // reading at the beginning of new sector.
		814	file->SectorOfCurrCluster++; // continue reading in next sector
		815	if(file->SectorOfCurrCluster >= Partition.SectorsPerCluster) // if end of cluster is reached, the next datacluster has to be searched in the FAT.
		816	{
		817	if(GetNextCluster(file)) // Sets the clusterpointer of the file to the next datacluster.
		818	{
88	killagreg	819	file->SectorOfCurrCluster = 0;
41	ingob	820	}
		821	else // the last cluster was allready reached
		822	{
		823	file->SectorOfCurrCluster--; // jump back to the ast sector in the last cluster
		824	file->ByteOfCurrSector = BYTES_PER_SECTOR; // set ByteOfCurrSector one byte over sector end
		825	}
		826	}
88	killagreg	827	}
		828	}
1	ingob	829	}
88	killagreg	830	if(file->Position == fposition) retvalue = 0;
1	ingob	831	return(retvalue);
		832	}
		833
		834
41	ingob	835	/****************************************************************************************************************************************/
		836	/* Function: u16 DeleteClusterChain(File file); /
		837	/* */
		838	/* Description: This function trances along a cluster chain in the fat and frees all clusters visited. */
		839	/* */
		840	/****************************************************************************************************************************************/
		841	u8 DeleteClusterChain(u16 StartCluster)
1	ingob	842	{
88	killagreg	843	u16 cluster;
41	ingob	844	u32 fat_byte_offset, sector, byte;
		845	Fat16Entry_t * fat;
		846	u8 buffer[BYTES_PER_SECTOR];
		847	u32 sector_in_buffer = 0;
		848	u8 repeat = 0;
		849
		850	if(!Partition.IsValid) return 0;
210	killagreg	851	cluster = StartCluster; // init chain trace
		852	// if start cluster is equal to the last cluster we are done
		853	if(FAT16_CLUSTER_LAST_MIN <= cluster) return 1;
41	ingob	854
		855	// calculate byte offset in the fat for corresponding entry
		856	fat_byte_offset = ((u32)cluster)<<1; // two FAT bytes (16 bits) for every cluster
		857	// calculate the sector that contains the current cluster within the fat
		858	sector = Partition.FirstFatSector + ( fat_byte_offset / BYTES_PER_SECTOR);
		859	// calculate byte offset of the current cluster within that fat sector
		860	byte = fat_byte_offset % BYTES_PER_SECTOR;
88	killagreg	861	do
1	ingob	862	{
41	ingob	863	if(sector != sector_in_buffer)
1	ingob	864	{
41	ingob	865	// read this sector to buffer
		866	sector_in_buffer = sector;
		867	if(SD_SUCCESS != SDC_GetSector(sector_in_buffer, buffer)) return 0; // read sector from sd-card
88	killagreg	868	}
41	ingob	869	// read the next cluster from cache
		870	fat = (Fat16Entry_t *)(&(buffer[byte]));
		871	cluster = fat->NextCluster;
		872	if((FAT16_CLUSTER_USED_MIN <= cluster) && (cluster <= FAT16_CLUSTER_USED_MAX) ) repeat = 1;
		873	else repeat = 0;
		874
		875	fat->NextCluster = FAT16_CLUSTER_FREE; // mark current cluster as free
		876	// calculate byte offset in the fat for corresponding entry
		877	fat_byte_offset = ((u32)cluster)<<1; // two FAT bytes (16 bits) for every cluster
		878	// calculate the sector that contains the current cluster within the fat
		879	sector = Partition.FirstFatSector + ( fat_byte_offset / BYTES_PER_SECTOR);
		880	// calculate byte offset of the current cluster within that fat sector
		881	byte = fat_byte_offset % BYTES_PER_SECTOR;
		882	// if new sector is not the sector in buffer or the last cluster in the chain was traced
		883	if((sector != sector_in_buffer) \|\| !repeat)
		884	{ // write sector in buffer
210	killagreg	885	if(SD_SUCCESS != SDC_PutSector(sector_in_buffer,buffer))
146	killagreg	886	{
		887	Fat16_Deinit();
		888	return 0;
		889	}
1	ingob	890	}
41	ingob	891	}
		892	while(repeat);
		893
		894	return 1;
1	ingob	895	}
		896
		897
41	ingob	898	/****************************************************************************************************************************************/
		899	/* Function: u16 AppendCluster(File file); /
		900	/* */
		901	/* Description: This function looks in the fat to find the next free cluster and appends it to the file. */
		902	/* */
		903	/* Returnvalue: The function returns the appened cluster number or 0 of no cluster was appended. */
		904	/****************************************************************************************************************************************/
		905	u16 AppendCluster(File_t *file)
1	ingob	906	{
88	killagreg	907	u16 last_cluster, new_cluster = 0;
41	ingob	908	u32 fat_byte_offset, sector, byte;
		909	Fat16Entry_t * fat;
88	killagreg	910
41	ingob	911	if((!Partition.IsValid) \|\| (file == NULL)) return(new_cluster);
1	ingob	912
41	ingob	913	new_cluster = FindNextFreeCluster(file); // the next free cluster found on the disk.
		914	if(new_cluster)
88	killagreg	915	{ // A free cluster was found and can be added to the end of the file.
41	ingob	916	fseek_(file, 0, SEEK_END); // jump to the end of the file
88	killagreg	917	last_cluster = SectorToFat16Cluster(file->FirstSectorOfCurrCluster); // determine current file cluster
41	ingob	918	fat_byte_offset = ((u32)last_cluster)<<1;
		919	sector = Partition.FirstFatSector + ( fat_byte_offset / BYTES_PER_SECTOR);
		920	byte = fat_byte_offset % BYTES_PER_SECTOR;
1	ingob	921
41	ingob	922	if(file->SectorInCache != sector)
		923	{
		924	file->SectorInCache = sector; // update sector stored in buffer
		925	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache)) // read sector from sd-card
		926	{
		927	Fat16_Deinit();
		928	return(0);
88	killagreg	929	}
		930	}
41	ingob	931	fat = (Fat16Entry_t *)(&(file->Cache[byte]));
		932	fat->NextCluster = new_cluster; // append the free cluster to the end of the file in the FAT.
		933	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache)) // save the modified sector to the FAT.
		934	{
		935	Fat16_Deinit();
		936	return(0);
		937	}
		938	file->FirstSectorOfCurrCluster = Fat16ClusterToSector(new_cluster);
		939	file->SectorOfCurrCluster = 0;
		940	file->ByteOfCurrSector = 0;
		941	}
		942	return(new_cluster);
1	ingob	943	}
		944
41	ingob	945	/****************************************************************************************************************************************************/
		946	/* Function: DirectoryEntryExist(s8 , u8, u8, File_t ) */
		947	/* */
		948	/* Description: This function searches all possible dir entries until the file or directory is found or the end of the directory is reached */
		949	/* */
		950	/* Returnvalue: This function returns 1 if the directory entry specified was found. */
		951	/****************************************************************************************************************************************************/
		952	u8 DirectoryEntryExist(s8 dirname, u8 attribfilter, u8 attribmask, File_t file)
		953	{
		954	u32 dir_sector, max_dir_sector, curr_sector;
		955	u16 dir_entry = 0;
24	StephanB	956
41	ingob	957	u16 end_of_directory_not_reached = 0;
		958	u8 i = 0;
		959	u8 direntry_exist = 0;
		960	DirEntry_t * dir;
24	StephanB	961
41	ingob	962	// if incomming pointers are useless return immediatly
88	killagreg	963	if((!Partition.IsValid) \|\| (file == NULL) \|\| (dirname == NULL)) return(direntry_exist);
41	ingob	964
88	killagreg	965	// dir entries can be searched only in filesclusters that have
		966	// a corresponding dir entry with adir-flag set in its attribute
41	ingob	967	// or direct within the root directory area
88	killagreg	968
41	ingob	969	file->FirstSectorOfFirstCluster = 0;
		970	// no current directory exist therefore assume searching in the root
		971	if(file->DirectorySector == 0)
24	StephanB	972	{
41	ingob	973	max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
		974	file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;
		975	}
		976	// within the root directory area we can read sectors sequentially until the end of this area
		977	else if((Partition.FirstRootDirSector <= file->DirectorySector) && (file->DirectorySector < Partition.FirstDataSector))
		978	{
		979	max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
		980	}
88	killagreg	981	// within the data clusters we can read sectors sequentially only within the cluster
41	ingob	982	else if((Partition.FirstDataSector <= file->DirectorySector) && (file->DirectorySector <= Partition.LastDataSector))
		983	{
		984	max_dir_sector = Partition.SectorsPerCluster; // limit max secters before next cluster
		985	}
		986	else return (direntry_exist); // bad sector range for directory sector of the file
		987	// if search area is not defined yet
		988	if(file->FirstSectorOfFirstCluster == 0)
		989	{
		990	// check if the directory entry of current file is existent and has the dir-flag set
		991	file->SectorInCache = file->DirectorySector; // update the sector number of file cache.
		992	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
24	StephanB	993	{
41	ingob	994	Fat16_Deinit();
		995	return(direntry_exist);
24	StephanB	996	}
41	ingob	997	dir = (DirEntry_t *)file->Cache; // set pointer to directory
		998	switch((u8)dir[file->DirectoryIndex].Name[0]) // check if current directory exist
24	StephanB	999	{
41	ingob	1000	case SLOT_EMPTY:
		1001	case SLOT_DELETED:
		1002	// the directrory pointer of this file points to a deleted or not existen directory
		1003	// therefore no file or subdirectory can be created
		1004	return (direntry_exist);
		1005	break;
88	killagreg	1006	default: // and is a real directory
41	ingob	1007	if((dir[file->DirectoryIndex].Attribute & ATTR_SUBDIRECTORY) != ATTR_SUBDIRECTORY)
		1008	{ // current file is not a directory therefore no file or subdirectory can be created here
		1009	return (direntry_exist);
		1010	}
		1011	break;
24	StephanB	1012	}
41	ingob	1013	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(dir[file->DirectoryIndex].StartCluster);
24	StephanB	1014	}
		1015
41	ingob	1016	// update current file data area position to start of first cluster
88	killagreg	1017	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		1018	file->SectorOfCurrCluster = 0;
41	ingob	1019	file->ByteOfCurrSector = 0;
24	StephanB	1020
41	ingob	1021	do // loop over all data clusters of the current directory entry
88	killagreg	1022	{
41	ingob	1023	dir_sector = 0; // reset sector counter within a new cluster
		1024	do // loop over all sectors of a cluster or all sectors of the root directory
88	killagreg	1025	{
41	ingob	1026	curr_sector = file->FirstSectorOfCurrCluster + dir_sector; // calculate sector number
		1027	file->SectorInCache = curr_sector; // upate the sector number of file cache.
		1028	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read the sector
		1029	{
		1030	Fat16_Deinit();
88	killagreg	1031	return(direntry_exist);
41	ingob	1032	}
		1033	dir = (DirEntry_t *)file->Cache; // set pointer to directory
		1034	// search all directory entries within that sector
		1035	for(dir_entry = 0; dir_entry < DIRENTRIES_PER_SECTOR; dir_entry++)
		1036	{ // check for existing dir entry
		1037	switch((u8)dir[dir_entry].Name[0])
		1038	{
		1039	case SLOT_EMPTY:
		1040	case SLOT_DELETED:
		1041	// ignore empty or deleted dir entries
		1042	break;
		1043	default:
		1044	// if existing check attributes before names are compared will safe performance
		1045	if ((dir[dir_entry].Attribute & attribmask) != attribfilter) break; // attribute must match
		1046	// then compare the name to the giveb dirname (first 11 characters include 8 chars of basename and 3 chars extension.)
		1047	i = 0;
		1048	while((i < 11) && (dir[dir_entry].Name[i] == dirname[i])) i++;
		1049	if (i < 10) break; // names does not match
		1050	// if dirname and attribute have matched
		1051	file->Attribute = dir[dir_entry].Attribute; // store attribute of found dir entry
88	killagreg	1052	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(dir[dir_entry].StartCluster); // set sector of first data cluster
41	ingob	1053	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		1054	file->SectorOfCurrCluster = 0;
		1055	file->ByteOfCurrSector = 0;
		1056	file->DirectorySector = curr_sector; // current sector
		1057	file->DirectoryIndex = dir_entry; // current direntry in current sector
88	killagreg	1058	file->Size = dir[dir_entry].Size;
		1059	direntry_exist = 1; // mark as found
		1060	dir_entry = DIRENTRIES_PER_SECTOR; // stop for-loop
41	ingob	1061	} // end of first byte of name check
		1062	}
		1063	dir_sector++; // search next sector
		1064	// stop if we reached the end of the cluster or the end of the root dir
		1065	}while((dir_sector < max_dir_sector) && (!direntry_exist));
1	ingob	1066
41	ingob	1067	// if we are seaching in the data area and the file not found in this cluster so take next cluster.
88	killagreg	1068	if(!direntry_exist && ( Partition.FirstDataSector <= file->FirstSectorOfCurrCluster))
41	ingob	1069	{
		1070	end_of_directory_not_reached = GetNextCluster(file); // updates File->FirstSectorOfCurrCluster
		1071	}
		1072	}while((end_of_directory_not_reached) && (!direntry_exist)); // repeat until a next cluster exist an no
		1073	return(direntry_exist);
1	ingob	1074	}
		1075
		1076
41	ingob	1077	/****************************************************************************************************************************************/
		1078	/* Function: CreateDirectoryEntry(s8 , u16, File_t ) */
		1079	/* */
		1080	/* Description: This function looks for the next free position in the directory and creates an entry. */
		1081	/* The type of an directory entry is specified by the file attribute. */
		1082	/* */
		1083	/* Returnvalue: Return 0 on error */
		1084	/****************************************************************************************************************************************/
		1085	u8 CreateDirectoryEntry(s8 dirname, u8 attrib, File_t file)
1	ingob	1086	{
41	ingob	1087	u32 dir_sector, max_dir_sector, curr_sector;
		1088	u16 dir_entry = 0;
		1089	u16 subdircluster, dircluster = 0;
		1090	u16 end_of_directory_not_reached = 0;
		1091	u8 i = 0;
88	killagreg	1092	u8 retvalue = 0;
41	ingob	1093	DirEntry_t *dir;
		1094
		1095	if((!Partition.IsValid) \|\| (file == NULL) \|\| (dirname == NULL)) return (retvalue);
		1096	// It is not checked here that the dir entry that should be created is already existent!
88	killagreg	1097
		1098	// Dir entries can be created only in file-clusters that have
41	ingob	1099	// the dir-flag set in its attribute or within the root directory
88	killagreg	1100
41	ingob	1101	file->FirstSectorOfFirstCluster = 0;
		1102	// no current directory exist therefore assume creating in the root
		1103	if(file->DirectorySector == 0)
24	StephanB	1104	{
41	ingob	1105	max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
		1106	dircluster = 0;
		1107	file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;
		1108	}
		1109	// within the root directory area we can read sectors sequentially until the end of this area
		1110	else if((Partition.FirstRootDirSector <= file->DirectorySector) && (file->DirectorySector < Partition.FirstDataSector))
		1111	{
		1112	max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
		1113	}
88	killagreg	1114	// within the data clusters we can read sectors sequentially only within the cluster
41	ingob	1115	else if((Partition.FirstDataSector <= file->DirectorySector) && (file->DirectorySector <= Partition.LastDataSector))
		1116	{
		1117	max_dir_sector = Partition.SectorsPerCluster;
		1118	}
88	killagreg	1119	else return (retvalue); // bad sector range for directory sector of the file
41	ingob	1120	// if search area is not defined yet
		1121	if(file->FirstSectorOfFirstCluster == 0)
		1122	{
		1123	// check if the directory entry of current file is existent and has the dir-flag set
		1124	file->SectorInCache = file->DirectorySector; // update the sector number of file cache.
88	killagreg	1125	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
41	ingob	1126	{
		1127	Fat16_Deinit();
		1128	return(retvalue);
88	killagreg	1129	}
41	ingob	1130	dir = (DirEntry_t *)file->Cache; // set pointer to directory
		1131	switch((u8)dir[file->DirectoryIndex].Name[0]) // check if current directory exist
		1132	{
		1133	case SLOT_EMPTY:
		1134	case SLOT_DELETED:
		1135	return (retvalue);
		1136	break;
88	killagreg	1137	default: // and is a real directory
41	ingob	1138	if((dir[file->DirectoryIndex].Attribute & ATTR_SUBDIRECTORY) != ATTR_SUBDIRECTORY)
		1139	{ // current file is not a directory therefore no file or subdirectory can be created here
		1140	return (retvalue);
		1141	}
		1142	break;
		1143	}
		1144	dircluster = dir[file->DirectoryIndex].StartCluster;
88	killagreg	1145	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(dircluster);
41	ingob	1146	}
88	killagreg	1147
41	ingob	1148	subdircluster = FindNextFreeCluster(file); // get the next free cluster on the disk and mark it as used.
		1149	if(subdircluster)
		1150	{
		1151	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		1152	file->SectorOfCurrCluster = 0;
		1153	do // loop over all clusters of current directory
88	killagreg	1154	{
41	ingob	1155	dir_sector = 0; // reset sector counter within a new cluster
		1156	do // loop over all sectors of a cluster or all sectors of the root directory
1	ingob	1157	{
88	killagreg	1158	curr_sector = file->FirstSectorOfCurrCluster + dir_sector; // calculate sector number
41	ingob	1159	file->SectorInCache = curr_sector; // upate the sector number of file cache.
88	killagreg	1160	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
24	StephanB	1161	{
41	ingob	1162	Fat16_Deinit();
		1163	return(retvalue);
88	killagreg	1164	}
41	ingob	1165	dir = (DirEntry_t *)file->Cache; // set pointer to directory
		1166	// search all directory entries of a sector
		1167	for(dir_entry = 0; dir_entry < DIRENTRIES_PER_SECTOR; dir_entry++)
		1168	{ // check if current direntry is available
		1169	if(((u8)dir[dir_entry].Name[0] == SLOT_EMPTY) \|\| ((u8)dir[dir_entry].Name[0] == SLOT_DELETED))
88	killagreg	1170	{ // a free direntry was found
41	ingob	1171	for(i = 0; i < 11; i++) dir[dir_entry].Name[i] = dirname[i]; // Set dir name
		1172	dir[dir_entry].Attribute = attrib; // Set the attribute of the new directoryentry.
		1173	dir[dir_entry].StartCluster = subdircluster; // copy the location of the first datacluster to the directoryentry.
		1174	dir[dir_entry].DateTime = FileDateTime(&SystemTime); // set date/time
		1175	dir[dir_entry].Size = 0; // the new createted file has no content yet.
		1176	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache)) // write back to card
		1177	{
		1178	Fat16_Deinit();
		1179	return(retvalue);
		1180	}
		1181	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(subdircluster); // Calculate absolute sectorposition of first datacluster.
		1182	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster; // Start reading the file with the first sector of the first datacluster.
		1183	file->SectorOfCurrCluster = 0; // reset sector of cureen cluster
		1184	file->ByteOfCurrSector = 0; // reset the byte location within the current sector
		1185	file->Attribute = attrib; // set file attribute to dir attribute
		1186	file->Size = 0; // new file has no size
		1187	file->DirectorySector = curr_sector;
		1188	file->DirectoryIndex = dir_entry;
88	killagreg	1189	if((attrib & ATTR_SUBDIRECTORY) == ATTR_SUBDIRECTORY) // if a new directory was created then initilize the data area
		1190	{
41	ingob	1191	ClearCurrCluster(file); // fill cluster with zeros
		1192	file->SectorInCache = file->FirstSectorOfFirstCluster;
88	killagreg	1193	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
41	ingob	1194	{
		1195	Fat16_Deinit();
		1196	return(retvalue);
88	killagreg	1197	}
41	ingob	1198	dir = (DirEntry_t *)file->Cache;
		1199	// create direntry "." to current dir
		1200	dir[0].Name[0] = 0x2E;
		1201	for(i = 1; i < 11; i++) dir[0].Name[i] = ' ';
		1202	dir[0].Attribute = ATTR_SUBDIRECTORY;
		1203	dir[0].StartCluster = subdircluster;
		1204	dir[0].DateTime = 0;
		1205	dir[0].Size = 0;
		1206	// create direntry ".." to the upper dir
		1207	dir[1].Name[0] = 0x2E;
		1208	dir[1].Name[1] = 0x2E;
		1209	for(i = 2; i < 11; i++) dir[1].Name[i] = ' ';
		1210	dir[1].Attribute = ATTR_SUBDIRECTORY;
		1211	dir[1].StartCluster = dircluster;
		1212	dir[1].DateTime = 0;
		1213	dir[1].Size = 0;
88	killagreg	1214	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))// read in the sector.
41	ingob	1215	{
		1216	Fat16_Deinit();
		1217	return(retvalue);
88	killagreg	1218	}
		1219	}
41	ingob	1220	retvalue = 1;
88	killagreg	1221	dir_entry = DIRENTRIES_PER_SECTOR; // stop for-loop
41	ingob	1222	}
88	killagreg	1223	}
41	ingob	1224	dir_sector++; // search next sector
		1225	// stop if we reached the end of the cluster or the end of the root dir
		1226	}while((dir_sector < max_dir_sector) && (!retvalue));
88	killagreg	1227
41	ingob	1228	// if we are seaching in the data area and the file not found in this cluster so take next cluster.
88	killagreg	1229	if(!retvalue && ( Partition.FirstDataSector <= file->FirstSectorOfCurrCluster))
24	StephanB	1230	{
41	ingob	1231	end_of_directory_not_reached = GetNextCluster(file); // updates File->FirstSectorOfCurrCluster
24	StephanB	1232	}
41	ingob	1233	}while((end_of_directory_not_reached) && (!retvalue));
		1234	// Perhaps we are at the end of the last cluster of a directory file an have no free direntry found.
		1235	// Then we would need to add a cluster to that file and create the new direntry there.
		1236	// This code is not implemented yet, because its occurs only if more that 32*32=1024 direntries are
		1237	// within a subdirectory of root.
1	ingob	1238	}
41	ingob	1239	return(retvalue); // return 1 if file has been created otherwise return 0.
1	ingob	1240	}
		1241
41	ingob	1242	/********************************************************************************************************************************************/
		1243	/* Function: FileExist(const s8* filename, u8 attribfilter, u8 attribmask, File_t file); /
		1244	/* */
		1245	/* Description: This function looks for the specified file including its subdirectories beginning */
		1246	/* in the rootdirectory of the drive. If the file is found the Filepointer properties are */
		1247	/* updated. */
		1248	/* */
		1249	/* Returnvalue: 1 if file is found else 0. */
		1250	/********************************************************************************************************************************************/
		1251	u8 FileExist(const s8* filename, const u8 attribfilter, const u8 attribmask, File_t *file)
1	ingob	1252	{
41	ingob	1253	s8* path = 0;
		1254	s8* subpath = 0;
		1255	u8 af, am, file_exist = 0;
		1256	s8 dirname[12]; // 8+3 + temination character
1	ingob	1257
41	ingob	1258	// if incomming pointers are useless return immediatly
		1259	if ((filename == NULL) \|\| (file == NULL) \|\| (!Partition.IsValid)) return 0;
1	ingob	1260
41	ingob	1261	// trace along the filepath
		1262	path = (s8*)filename; // start a the beginning of the filename string
		1263	file->DirectorySector = 0; // start at RootDirectory with file search
88	killagreg	1264	file->DirectoryIndex = 0;
41	ingob	1265	// as long as the file was not found and the remaining path is not empty
		1266	while((*path != 0) && !file_exist)
		1267	{ // separate dirname and subpath from filepath string
		1268	subpath = SeperateDirName(path, dirname);
		1269	if(subpath != NULL)
88	killagreg	1270	{
		1271	if(*subpath == 0)
41	ingob	1272	{ // empty subpath indicates last element of dir chain
		1273	af = attribfilter;
		1274	am = attribmask;
		1275	}
		1276	else // it must be a subdirectory and no volume label
1	ingob	1277	{
41	ingob	1278	af = ATTR_SUBDIRECTORY;
		1279	am = ATTR_SUBDIRECTORY\|ATTR_VOLUMELABEL;
		1280	}
		1281	if(!DirectoryEntryExist(dirname, af, am, file))
		1282	{
		1283	return (file_exist); // subdirectory does not exist
		1284	}
88	killagreg	1285	else
		1286	{
41	ingob	1287	if (*subpath == 0)
24	StephanB	1288	{
41	ingob	1289	file_exist = 1; // last element of path chain was found with the given attribute filter
24	StephanB	1290	}
1	ingob	1291	}
		1292	}
41	ingob	1293	else // error seperating the subpath
1	ingob	1294	{
41	ingob	1295	return file_exist; // bad subdir format
1	ingob	1296	}
41	ingob	1297	path = subpath;
		1298	subpath = 0;
1	ingob	1299	}
41	ingob	1300	return (file_exist);
1	ingob	1301	}
		1302
24	StephanB	1303
41	ingob	1304	/********************************************************************************************************************************************/
		1305	/* Function: FileCreate(const s8* filename, u8 attrib, File_t file); /
		1306	/* */
		1307	/* Description: This function looks for the specified file including its subdirectories beginning */
		1308	/* in the rootdirectory of the partition. If the file is found the Filepointer properties are */
88	killagreg	1309	/* updated. If file or its subdirectories are not found they will be created */
41	ingob	1310	/* */
		1311	/* Returnvalue: 1 if file was created else 0. */
		1312	/********************************************************************************************************************************************/
		1313	u8 FileCreate(const s8* filename, const u8 attrib, File_t *file)
		1314	{
		1315	s8 *path = 0;
		1316	s8 *subpath = 0;
		1317	u8 af, am, file_created = 0;
		1318	s8 dirname[12];
24	StephanB	1319
41	ingob	1320	// if incomming pointers are useless return immediatly
		1321	if ((filename == NULL) \|\| (file == NULL) \|\| (!Partition.IsValid)) return 0;
1	ingob	1322
41	ingob	1323	// trace along the filepath
		1324	path = (s8*)filename; // start a the beginning of the filename string
		1325	file->DirectorySector = 0; // start at RootDirectory with file search
		1326	file->DirectoryIndex = 0;
		1327	// as long as the file was not created and the remaining file path is not empty
		1328	while((*path != 0) && !file_created)
		1329	{ // separate dirname and subpath from filepath string
		1330	subpath = SeperateDirName(path, dirname);
		1331	if(subpath != NULL)
24	StephanB	1332	{
88	killagreg	1333	if(*subpath == 0)
41	ingob	1334	{ // empty subpath indicates last element of dir chain
		1335	af = ATTR_NONE;
		1336	am = ATTR_SUBDIRECTORY\|ATTR_VOLUMELABEL; // any file that is no subdir or volume label
24	StephanB	1337	}
41	ingob	1338	else // it must be a subdirectory and no volume label
24	StephanB	1339	{
41	ingob	1340	af = ATTR_SUBDIRECTORY;
		1341	am = ATTR_SUBDIRECTORY\|ATTR_VOLUMELABEL;
24	StephanB	1342	}
41	ingob	1343	if(!DirectoryEntryExist(dirname, af, am, file)) // if subdir or file is not existent
		1344	{ // try to create subdir or file
		1345	if(*subpath == 0) af = attrib; // if last element in dir chain take the given attribute
		1346	if(!CreateDirectoryEntry(dirname, af, file))
		1347	{ // could not be created
88	killagreg	1348	return(file_created);
		1349	}
41	ingob	1350	else if (*subpath == 0) file_created = 1; // last element of path chain was created
24	StephanB	1351	}
		1352	}
41	ingob	1353	else // error seperating the subpath
24	StephanB	1354	{
41	ingob	1355	return file_created; // bad subdir format
24	StephanB	1356	}
41	ingob	1357	path = subpath;
		1358	subpath = 0;
		1359	}
		1360	return (file_created);
24	StephanB	1361	}
1	ingob	1362
24	StephanB	1363
41	ingob	1364	/********************************************************************************************************************************************/
		1365	/* Function: File_t * fopen_(s8* filename, s8 mode); */
		1366	/* */
		1367	/* Description: This function looks for the specified file in the rootdirectory of the drive. If the file is found the number of the */
		1368	/* corrosponding filepointer is returned. Only modes 'r' (reading) and 'a' append are implemented yet. */
		1369	/* */
		1370	/* Returnvalue: The filepointer to the file or 0 if faild. */
		1371	/********************************************************************************************************************************************/
89	killagreg	1372	File_t * fopen_(s8 * const filename, const s8 mode)
88	killagreg	1373	{
41	ingob	1374	File_t *file = 0;
88	killagreg	1375
41	ingob	1376	if((!Partition.IsValid) \|\| (filename == 0)) return(file);
		1377
		1378	// Look for an unused filepointer in the file pointer list?
		1379	file = LockFilePointer();
		1380	// if no unused file pointer was found return 0
		1381	if(file == NULL) return(file);
		1382
		1383	// now we have found a free filepointer and claimed it
		1384	// so let initiate its property values
88	killagreg	1385	file->FirstSectorOfFirstCluster = 0; // Sectorpointer to the first sector of the first datacluster of the file.
41	ingob	1386	file->FirstSectorOfCurrCluster = 0; // Pointer to the cluster which is edited at the moment.
		1387	file->SectorOfCurrCluster = 0; // The sector which is edited at the moment (cluster_pointer + sector_index).
		1388	file->ByteOfCurrSector = 0; // The bytelocation within the current sector (cluster_pointer + sector_index + byte_index).
		1389	file->Mode = mode; // mode of fileoperation (read,write)
		1390	file->Size = 0; // the size of the opened file in bytes.
		1391	file->Position = 0; // pointer to a byte within the file 0 < fileposition < filesize
		1392	file->SectorInCache = 0; // the last sector read, wich is still in the sectorbuffer.
		1393	file->DirectorySector = 0; // the sectorposition where the directoryentry has been made.
		1394	file->DirectoryIndex = 0; // the index to the directoryentry within the specified sector.
		1395	file->Attribute = 0; // the attribute of the file opened.
		1396
		1397	// check if a real file (no directory) to the given filename exist
88	killagreg	1398	if(FileExist(filename, ATTR_NONE, ATTR_SUBDIRECTORY\|ATTR_VOLUMELABEL, file))
41	ingob	1399	{ // file exist
		1400	switch(mode) // check mode
1	ingob	1401	{
41	ingob	1402	case 'a': // if mode is: append to file
		1403	if((file->Attribute & ATTR_READONLY) == ATTR_READONLY)
		1404	{ // file is marked as readonly --> do not open this file
		1405	fclose_(file);
		1406	file = NULL;
		1407	}
		1408	else
		1409	{ // file is not marked as read only --> goto end of file
		1410	fseek_(file, 0, SEEK_END); // point to the end of the file
		1411	}
		1412	break;
		1413	case 'w': // if mode is: write to file
		1414	if((file->Attribute & ATTR_READONLY) == ATTR_READONLY)
		1415	{ // file is marked as readonly --> do not open this file
		1416	fclose_(file);
		1417	file = NULL;
		1418	}
		1419	else
		1420	{ // file is not marked as read only --> goto start of file
		1421	// free all clusters of that file
		1422	DeleteClusterChain(SectorToFat16Cluster(file->FirstSectorOfFirstCluster));
210	killagreg	1423	// mark an empy cluster as the last one and store the corresponding sector
41	ingob	1424	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(FindNextFreeCluster(file));
		1425	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		1426	file->SectorOfCurrCluster = 0;
		1427	file->ByteOfCurrSector = 0;
		1428	file->Size = 0;
		1429	file->Position = 0;
		1430	fseek_(file, 0, SEEK_SET);
		1431	}
		1432	break;
		1433	case 'r': // if mode is: read from file
88	killagreg	1434	// goto end of file
41	ingob	1435	fseek_(file, 0, SEEK_SET);
		1436	break;
		1437	default: // other modes are not supported
		1438	fclose_(file);
		1439	file = NULL;
24	StephanB	1440	break;
1	ingob	1441	}
88	killagreg	1442	return(file);
1	ingob	1443	}
41	ingob	1444	else // file does not exist
		1445	{
		1446	switch(mode) // check mode
		1447	{
		1448	case 'a':
		1449	case 'w': // if mode is write or append
		1450	// try to create the file
		1451	if(!FileCreate(filename, ATTR_ARCHIVE, file))
		1452	{ // if it could not be created
		1453	fclose_(file);
		1454	file = NULL;
		1455	}
		1456	break;
		1457	case 'r': // else opened for 'r'
		1458	default: // of unsupported mode
		1459	fclose_(file);
		1460	file = NULL;
88	killagreg	1461	break;
41	ingob	1462	}
88	killagreg	1463	return(file);
41	ingob	1464	}
		1465	// we should never come to this point
		1466	fclose_(file);
		1467	file = NULL;
24	StephanB	1468	return(file);
		1469	}
		1470
41	ingob	1471	/****************************************************************************************************************************************************/
		1472	/* Function: fflush_(File ); /
		1473	/* */
		1474	/* Description: This function writes the data already in the buffer but not yet written to the file. */
		1475	/* */
		1476	/* Returnvalue: 0 on success EOF on error */
		1477	/****************************************************************************************************************************************************/
		1478	s16 fflush_(File_t *file)
24	StephanB	1479	{
88	killagreg	1480	DirEntry_t *dir;
		1481
41	ingob	1482	if((file == NULL) \|\| (!Partition.IsValid)) return (EOF);
88	killagreg	1483
41	ingob	1484	switch(file->Mode)
24	StephanB	1485	{
41	ingob	1486	case 'a':
		1487	case 'w':
88	killagreg	1488	if(file->ByteOfCurrSector > 0) // has data been added to the file?
41	ingob	1489	{
88	killagreg	1490	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))// save the data still in the buffer
41	ingob	1491	{
88	killagreg	1492	Fat16_Deinit();
		1493	return(EOF);
		1494	}
41	ingob	1495	}
		1496	file->SectorInCache = file->DirectorySector;
		1497	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache)) // read the directory entry for this file.
		1498	{
		1499	Fat16_Deinit();
88	killagreg	1500	return(EOF);
41	ingob	1501	}
88	killagreg	1502
41	ingob	1503	dir = (DirEntry_t *)file->Cache;
		1504	dir[file->DirectoryIndex].Size = file->Size; // update file size
		1505	dir[file->DirectoryIndex].DateTime = FileDateTime(&SystemTime); // update date time
		1506	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache)) // write back to sd-card
		1507	{
		1508	Fat16_Deinit();
		1509	return(EOF);
		1510	}
		1511	break;
		1512	case 'r':
		1513	default:
		1514	return(EOF);
		1515	break;
		1516
24	StephanB	1517	}
41	ingob	1518	return(0);
24	StephanB	1519	}
1	ingob	1520
41	ingob	1521	/****************************************************************************************************************************************/
		1522	/* Function: fclose_(File file); /
		1523	/* */
		1524	/* Description: This function closes the open file by writing the remaining data */
		1525	/* from the buffer to the device and entering the filesize in the directory entry. */
		1526	/* */
		1527	/* Returnvalue: 0 on success EOF on error */
		1528	/****************************************************************************************************************************************/
		1529	s16 fclose_(File_t *file)
24	StephanB	1530	{
41	ingob	1531	s16 returnvalue = EOF;
24	StephanB	1532
41	ingob	1533	if(file == NULL) return(returnvalue);
		1534	returnvalue = fflush_(file);
		1535	UnlockFilePointer(file);
		1536	return(returnvalue);
24	StephanB	1537	}
		1538
41	ingob	1539	/********************************************************************************************************************************************/
		1540	/* Function: fgetc_(File file); /
		1541	/* */
		1542	/* Description: This function reads and returns one character from the specified file. Is the end of the actual sector reached the */
		1543	/* next sector of the cluster is read. If the last sector of the cluster read the next cluster will be searched in FAT. */
		1544	/* */
		1545	/* Returnvalue: The function returns the character read from the specified memorylocation as u8 casted to s16 or EOF. */
		1546	/********************************************************************************************************************************************/
		1547	s16 fgetc_(File_t *file)
88	killagreg	1548	{
41	ingob	1549	s16 c = EOF;
		1550	u32 curr_sector;
88	killagreg	1551
41	ingob	1552	if( (!Partition.IsValid) \|\| (file == NULL)) return(c);
		1553	// if the end of the file is not reached, get the next character.
88	killagreg	1554	if((0 < file->Size) && ((file->Position+1) < file->Size) )
1	ingob	1555	{
41	ingob	1556	curr_sector = file->FirstSectorOfCurrCluster; // calculate the sector of the next character to be read.
88	killagreg	1557	curr_sector += file->SectorOfCurrCluster;
		1558
41	ingob	1559	if(file->SectorInCache != curr_sector)
1	ingob	1560	{
41	ingob	1561	file->SectorInCache = curr_sector;
		1562	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache,file->Cache))
		1563	{
		1564	Fat16_Deinit();
		1565	return(c);
88	killagreg	1566	}
		1567	}
41	ingob	1568	c = (s16) file->Cache[file->ByteOfCurrSector];
		1569	file->Position++; // increment file position
88	killagreg	1570	file->ByteOfCurrSector++; // goto next byte in sector
41	ingob	1571	if(file->ByteOfCurrSector >= BYTES_PER_SECTOR) // if end of sector
24	StephanB	1572	{
41	ingob	1573	file->ByteOfCurrSector = 0; // reset byte location
		1574	file->SectorOfCurrCluster++; // next sector
		1575	if(file->SectorOfCurrCluster >= Partition.SectorsPerCluster) // if end of cluster is reached, the next datacluster has to be searched in the FAT.
24	StephanB	1576	{
88	killagreg	1577
41	ingob	1578	if(GetNextCluster(file)) // Sets the clusterpointer of the file to the next datacluster.
24	StephanB	1579	{
41	ingob	1580	file->SectorOfCurrCluster = 0; // start reading new cluster at first sector of the cluster.
		1581	}
		1582	else // the last cluster was allready reached
		1583	{
		1584	file->SectorOfCurrCluster--; // jump back to the last sector in the last cluster
		1585	file->ByteOfCurrSector = BYTES_PER_SECTOR; // set ByteOfCurrSector one byte over sector end
		1586	}
1	ingob	1587	}
24	StephanB	1588	}
		1589	}
41	ingob	1590	return(c);
24	StephanB	1591	}
		1592
41	ingob	1593	/********************************************************************************************************************************************/
		1594	/* Function: fputc_( const s8 c, File file); /
		1595	/* */
		1596	/* Description: This function writes a byte to the specified file and takes care of writing the necessary FAT- Entries. */
		1597	/* next sector of the cluster is read. If the last sector of the cluster read the next cluster will be searched in FAT. */
		1598	/* */
		1599	/* Returnvalue: The function returns the character written to the stream or EOF on error. */
		1600	/********************************************************************************************************************************************/
		1601	s16 fputc_(const s8 c, File_t *file)
88	killagreg	1602	{
41	ingob	1603	u32 curr_sector = 0;
88	killagreg	1604
41	ingob	1605	if((!Partition.IsValid) \|\| (file == NULL)) return(EOF);
24	StephanB	1606
41	ingob	1607	// If file position equals to file size, then the end of file has reached.
88	killagreg	1608	// In this chase it has to be checked that the ByteOfCurrSector is BYTES_PER_SECTOR
41	ingob	1609	// and a new cluster should be appended.
		1610	if((file->Position >= file->Size) && (file->ByteOfCurrSector >= BYTES_PER_SECTOR))
		1611	{
		1612	if(!AppendCluster(file)) return(EOF);
		1613	}
24	StephanB	1614
41	ingob	1615	curr_sector = file->FirstSectorOfCurrCluster;
		1616	curr_sector += file->SectorOfCurrCluster;
		1617	if(file->SectorInCache != curr_sector)
		1618	{
		1619	file->SectorInCache = curr_sector;
		1620	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))
24	StephanB	1621	{
41	ingob	1622	Fat16_Deinit();
		1623	return(EOF);
88	killagreg	1624	}
41	ingob	1625	}
		1626
		1627	file->Cache[file->ByteOfCurrSector] = (u8)c; // write databyte into the buffer. The byte will be written to the device at once
		1628	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.
		1629	file->Position++; // the actual positon within the file.
88	killagreg	1630	file->ByteOfCurrSector++; // goto next byte in sector
41	ingob	1631	if(file->ByteOfCurrSector >= BYTES_PER_SECTOR) // if the end of this sector is reached yet
		1632	{ // save the sector to the sd-card
		1633	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))
		1634	{
		1635	Fat16_Deinit();
		1636	return(EOF);
		1637	}
		1638	file->ByteOfCurrSector = 0; // reset byte location
		1639	file->SectorOfCurrCluster++; // next sector
		1640	if(file->SectorOfCurrCluster >= Partition.SectorsPerCluster)// if end of cluster is reached, the next datacluster has to be searched in the FAT.
		1641	{
		1642	if(!GetNextCluster(file)) // Sets the clusterpointer of the file to the next datacluster.
		1643	{ // if current cluster was the last cluster of the file
		1644	if(!AppendCluster(file)) // append a new and free cluster at the end of the file.
24	StephanB	1645	{
41	ingob	1646	file->SectorOfCurrCluster--; // jump back to last sector of last cluster
		1647	file->ByteOfCurrSector = BYTES_PER_SECTOR; // set byte location to 1 byte over sector len
		1648	return(EOF);
24	StephanB	1649	}
1	ingob	1650	}
41	ingob	1651	else // next cluster
24	StephanB	1652	{
41	ingob	1653	file->SectorOfCurrCluster = 0; // start reading new cluster at first sector of the cluster.
88	killagreg	1654	}
1	ingob	1655	}
		1656	}
41	ingob	1657	return(0);
24	StephanB	1658	}
		1659
		1660
41	ingob	1661	/****************************************************************************************************************************************/
		1662	/* Function: fread_(void buffer, s32 size, s32 count, File File); */
		1663	/* */
		1664	/* Description: This function reads count objects of the specified size */
		1665	/* from the actual position of the file to the specified buffer. */
		1666	/* */
		1667	/* Returnvalue: The function returns the number of objects (not bytes) read from the file. */
		1668	/****************************************************************************************************************************************/
		1669	u32 fread_(void buffer, u32 size, u32 count, File_t file)
		1670	{
		1671	u32 object_cnt = 0; // count the number of objects read from the file.
		1672	u32 object_size = 0; // count the number of bytes read from the actual object.
		1673	u8 *pbuff = 0; // a pointer to the actual bufferposition.
		1674	u8 success = 1; // no error occured during read operation to the file.
88	killagreg	1675	s16 c;
24	StephanB	1676
41	ingob	1677	if((!Partition.IsValid) \|\| (file == NULL) \|\| (buffer == NULL)) return(0);
24	StephanB	1678
41	ingob	1679	pbuff = (u8 ) buffer; // cast the void pointer to an u8
88	killagreg	1680
41	ingob	1681	while((object_cnt < count) && success)
24	StephanB	1682	{
41	ingob	1683	object_size = size;
		1684	while((size > 0) && success)
		1685	{
		1686	c = fgetc_(file);
		1687	if(c != EOF)
		1688	{
		1689	*pbuff = (u8)c; // read a byte from the buffer to the opened file.
		1690	pbuff++;
		1691	size--;
		1692	}
		1693	else // error or end of file reached
		1694	{
88	killagreg	1695	success = 0;
41	ingob	1696	}
		1697	}
		1698	if(success) object_cnt++;
88	killagreg	1699	}
41	ingob	1700	return(object_cnt); // return the number of objects succesfully read from the file
1	ingob	1701	}
		1702
24	StephanB	1703
41	ingob	1704	/****************************************************************************************************************************************/
		1705	/* Function: fwrite_(void buffer, s32 size, s32 count, File file); */
		1706	/* */
		1707	/* Description: This function writes count objects of the specified size */
		1708	/* from the buffer pointer to the actual position in the file. */
		1709	/* */
		1710	/* Returnvalue: The function returns the number of objects (not bytes) read from the file. */
		1711	/****************************************************************************************************************************************/
		1712	u32 fwrite_(void buffer, u32 size, u32 count, File_t file)
1	ingob	1713	{
41	ingob	1714	u32 object_cnt = 0; // count the number of objects written to the file.
		1715	u32 object_size = 0; // count the number of bytes written from the actual object.
		1716	u8 *pbuff = 0; // a pointer to the actual bufferposition.
		1717	u8 success = 1; // no error occured during write operation to the file.
88	killagreg	1718	s16 c;
24	StephanB	1719
41	ingob	1720	if((!Partition.IsValid) \|\| (file == NULL) \|\| (buffer == NULL)) return(0);
		1721
		1722	pbuff = (u8 ) buffer; // cast the void pointer to an u8
88	killagreg	1723
41	ingob	1724	while((object_cnt < count) && success)
1	ingob	1725	{
41	ingob	1726	object_size = size;
		1727	while((size > 0) && success)
1	ingob	1728	{
41	ingob	1729	c = fputc_(*pbuff, file); // write a byte from the buffer to the opened file.
		1730	if(c != EOF)
24	StephanB	1731	{
41	ingob	1732	pbuff++;
		1733	size--;
24	StephanB	1734	}
41	ingob	1735	else
24	StephanB	1736	{
41	ingob	1737	success = 0;
24	StephanB	1738	}
1	ingob	1739	}
41	ingob	1740	if(success) object_cnt++;
88	killagreg	1741	}
		1742
41	ingob	1743	return(object_cnt); // return the number of objects succesfully written to the file
88	killagreg	1744	}
1	ingob	1745
24	StephanB	1746
41	ingob	1747	/****************************************************************************************************************************************/
		1748	/* Function: fputs_(const s8 string, File_t File); */
		1749	/* */
		1750	/* Description: This function writes a string to the specified file. */
		1751	/* */
		1752	/* Returnvalue: The function returns a no negative value or EOF on error. */
		1753	/****************************************************************************************************************************************/
89	killagreg	1754	s16 fputs_(s8 * const string, File_t * const file)
24	StephanB	1755	{
41	ingob	1756	u8 i=0;
		1757	s16 c = 0;
88	killagreg	1758
41	ingob	1759	if((!Partition.IsValid) \|\| (file == NULL) \|\| (string == NULL)) return(0);
24	StephanB	1760
41	ingob	1761	while((string[i] != 0)&& (c != EOF))
24	StephanB	1762	{
41	ingob	1763	c = fputc_(string[i], file);
		1764	i++;
24	StephanB	1765	}
41	ingob	1766	return(c);
24	StephanB	1767	}
		1768
41	ingob	1769	/****************************************************************************************************************************************/
		1770	/* Function: fgets_(s8 , s16 , File_t ); */
		1771	/* */
		1772	/* Description: This function reads a string from the file to the specifies string. */
		1773	/* */
		1774	/* Returnvalue: A pointer to the string read from the file or 0 on error. */
		1775	/****************************************************************************************************************************************/
89	killagreg	1776	s8 * fgets_(s8 * const string, s16 const length, File_t * const file)
24	StephanB	1777	{
89	killagreg	1778	s8 *pbuff;
		1779	s16 c = 0, bytecount;
88	killagreg	1780
89	killagreg	1781	if((!Partition.IsValid) \|\| (file == NULL) \|\| (string == NULL) \|\| (length < 1)) return (0);
		1782	bytecount = length;
		1783	pbuff = string; // set write pointer to start of string
		1784	while(bytecount > 1) // read the length-1 characters from the file to the string.
24	StephanB	1785	{
41	ingob	1786	c = fgetc_(file); // read a character from the opened file.
		1787	switch(c)
1	ingob	1788	{
89	killagreg	1789	case 0x0A: // new line
		1790	*pbuff = 0; // set string terminator
		1791	return(string); // return normal
88	killagreg	1792
41	ingob	1793	case EOF:
89	killagreg	1794	*pbuff = 0; // set string terminator
		1795	return(0);
		1796
		1797	default:
		1798	*pbuff++ = (s8)c; // copy byte to string
		1799	bytecount--;
88	killagreg	1800	break;
1	ingob	1801	}
24	StephanB	1802	}
89	killagreg	1803	*pbuff = 0; // set string terminator
41	ingob	1804	return(string);
24	StephanB	1805	}
		1806
41	ingob	1807	/****************************************************************************************************************************************/
		1808	/* Function: fexist_(const u8); /
		1809	/* */
		1810	/* Description: This function checks if a file already exist. */
		1811	/* */
		1812	/* Returnvalue: 1 if the file exist else 0. */
		1813	/****************************************************************************************************************************************/
89	killagreg	1814	u8 fexist_(s8 * const filename)
24	StephanB	1815	{
41	ingob	1816	u8 exist = 0;
		1817	File_t *file = 0;
		1818	file = LockFilePointer();
		1819	exist = FileExist(filename, ATTR_NONE, ATTR_SUBDIRECTORY\|ATTR_VOLUMELABEL, file);
		1820	UnlockFilePointer(file);
		1821	return(exist);
1	ingob	1822	}
24	StephanB	1823
41	ingob	1824	/****************************************************************************************************************************************/
		1825	/* Function: feof_(File_t File); /
		1826	/* */
		1827	/* Description: This function checks wether the end of the file has been reached. */
		1828	/* */
		1829	/* Returnvalue: 0 if the end of the file was not reached otherwise 1. */
		1830	/****************************************************************************************************************************************/
		1831	u8 feof_(File_t *file)
88	killagreg	1832	{
41	ingob	1833	if(((file->Position)+1) < (file->Size))
24	StephanB	1834	{
		1835	return(0);
		1836	}
88	killagreg	1837	else
24	StephanB	1838	{
88	killagreg	1839	return(1);
24	StephanB	1840	}
		1841	}
41	ingob	1842
210	killagreg	1843	/****************************************************************************************************************************************************/
		1844	/* Function: s8* FAT16_GetVolumeLabel(void) */
		1845	/* */
		1846	/* Description: This function returns the volume label */
		1847	/* */
		1848	/* Returnvalue: This function returns the pointer to the volume label or NULL if not found. */
		1849	/****************************************************************************************************************************************************/
		1850	s8* FAT16_GetVolumeLabel(void)
		1851	{
		1852	s8 *pVolumeLabel = NULL;
		1853	u32 dir_sector, max_dir_sector, curr_sector;
		1854	u16 dir_entry = 0;
		1855	u8 i = 0;
41	ingob	1856
210	killagreg	1857	DirEntry_t * dir;
		1858	File_t *file = NULL;
		1859
		1860	// if Partition is not valud return NULL
		1861	if(!Partition.IsValid) return(pVolumeLabel);
		1862	// if Volume label was read before return it
		1863	if(Partition.VolumeLabel[0]!= '\0') return (Partition.VolumeLabel);
		1864	// try to catch a file pointer
		1865	file = LockFilePointer();
		1866	if(file == NULL) return(pVolumeLabel);
		1867	// search dir entries direct within the root directory area
		1868	file->DirectorySector = 0;
		1869	max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
		1870	file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;
		1871
		1872	// update current file data area position to start of first cluster
		1873	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		1874	file->SectorOfCurrCluster = 0;
		1875	file->ByteOfCurrSector = 0;
		1876
		1877	dir_sector = 0; // reset sector counter within a new cluster
		1878	do // loop over all sectors of the root directory
		1879	{
		1880	curr_sector = file->FirstSectorOfCurrCluster + dir_sector; // calculate sector number
		1881	file->SectorInCache = curr_sector; // upate the sector number of file cache.
		1882	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read the sector
		1883	{
		1884	Fat16_Deinit();
		1885	return(pVolumeLabel);
		1886	}
		1887	dir = (DirEntry_t *)file->Cache; // set pointer to directory
		1888	// search all directory entries within that sector
		1889	for(dir_entry = 0; dir_entry < DIRENTRIES_PER_SECTOR; dir_entry++)
		1890	{ // check for existing dir entry
		1891	switch((u8)dir[dir_entry].Name[0])
		1892	{
		1893	case SLOT_EMPTY:
		1894	case SLOT_DELETED:
		1895	// ignore empty or deleted dir entries
		1896	break;
		1897	default:
		1898	// check attributes for volume label
		1899	if ((dir[dir_entry].Attribute & ATTR_VOLUMELABEL) != ATTR_VOLUMELABEL) break; // attribute must match
		1900	// (first 11 characters include 8 chars of basename and 3 chars extension.)
		1901	for(i = 0; i<11;i++) Partition.VolumeLabel[i] = dir[dir_entry].Name[i];
		1902	Partition.VolumeLabel[11] = '\0'; // terminate string
		1903	file->Attribute = dir[dir_entry].Attribute; // store attribute of found dir entry
		1904	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(dir[dir_entry].StartCluster); // set sector of first data cluster
		1905	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		1906	file->SectorOfCurrCluster = 0;
		1907	file->ByteOfCurrSector = 0;
		1908	file->DirectorySector = curr_sector; // current sector
		1909	file->DirectoryIndex = dir_entry; // current direntry in current sector
		1910	file->Size = dir[dir_entry].Size;
		1911	dir_entry = DIRENTRIES_PER_SECTOR; // stop for-loop
		1912	pVolumeLabel = Partition.VolumeLabel;
		1913	} // end of first byte of name check
		1914	}
		1915	dir_sector++; // search next sector
		1916	// stop if we reached the end of the cluster or the end of the root dir
		1917	}while((dir_sector < max_dir_sector) && (!pVolumeLabel));
		1918
		1919	UnlockFilePointer(file);
		1920	return(pVolumeLabel);
		1921	}

Subversion Repositories NaviCtrl

(root)/tags/V2.14a/fat16.c @ 741 - Rev 210