Subversion Repositories Projects

Rev

Rev 318 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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