EffsPT.h

#ifndef  __EFFSPT_H
#define  __EFFSPT_H
/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#include <basictypes.h>
/*******************************************************************************
 * This header defines the Partition Table structures used by both applications*
 *   and the boot monitor to mount the application File System in order to     *
 *   access the bootable image, configuration data, and user data.             *
 *******************************************************************************/
 
enum ePartType {
    PARTITION_TYPE_EMPTY = 0x00,
    PARTITION_TYPE_FAT12 = 0x01,
    PARTITION_TYPE_FAT16 = 0x04,
    PARTITION_TYPE_NTFS  = 0x07,
    PARTITION_TYPE_EXFAT = 0x07,
    PARTITION_TYPE_LINUX = 0x93,
 
    PARTITION_TYPE_EFFS  = 0x25,
};
 
enum ePartFlags {
    PARTITION_FLAG_FREE     = 0x00,
    PARTITION_FLAG_INUSE    = 0x01,
    PARTITION_FLAG_EXTENDED = 0x02,
    PARTITION_FLAG_BOOT     = 0x80,
};
 
enum ePartError {
    PARTITION_ERROR_NOERR   = 0,
 
    PARTITION_ERROR_OVERLAP = -1,
    PARTITION_ERROR_TOOBIG  = -2,
    PARTITION_ERROR_IDX     = -3,
    PARTITION_ERROR_TYPE    = -4,
    PARTITION_ERROR_TABLE_FULL= -5,
    PARTITION_ERROR_BOUNDS  = -6,
    PARTITION_ERROR_UNKNOWN = -255,
};
 
// Note: sectorCount and firstSector have special meaning if the MSB is set.
//  If MSB is set, the format is as follows:
//   realSectorCount = (2**(sectorCount[22:18]+4)*(sectorCount[17:0])
//   realFirstSector = (2**(firstSector[22:18]+4)*(firstSector[17:0])
struct PartitionEntry {
    uint32_t flags : 8; // Any special flags for the partition
    uint32_t sectorCount : 24; // How many sectors are in this partition
    uint32_t partitionType : 8; // What type of filesystem is this partition
    uint32_t firstSector : 24; // Index of first sector for this partition
 
    uint64_t start();
    uint64_t end();
    uint64_t startAddr(uint32_t sectorSize);
    uint64_t endAddr(uint32_t sectorSize);
    uint64_t sectors();
    uint64_t setStart(uint64_t startSector);
    uint64_t setSectors(uint64_t sCount);
};
 
// Note: totalSectors has special meaning if the MSB is set.
//  If MSB is set, the format is as follows:
//   realSectorCount = (2**(sectorCount[30:27]+4))*(sectorCount[26:0])
struct PartitionTable {
    union {
        struct {
            uint8_t bootExe[422]; // If direct execution is ever supported...
            uint8_t tableLenExp;  // Table Length => 2**tableLenExp: 2**8 => 256 bytes
            uint8_t sectorLenExp; // Sector Length, see Table Length
            uint32_t totalSectors; // Total sectors available, see
            PartitionEntry part[8]; // Partition entries
            uint8_t csums[16];    // Hamming code csum of 31 byte blocks comprising the Table
        };
        uint8_t pAsBytePtr[];
    };
    uint64_t sectors();
    uint64_t setSectors(uint64_t sCount);
 
    inline uint64_t sectorLen() { return 2ull << sectorLenExp; }
};
 
struct Effs_Cfg {
    union {
        struct {
            uint16_t maxblock;              /* maximum number of block can be used */
            uint8_t sSizeExp;              /* sector size wanted to use (less than block size */
            uint8_t blSizeExp;               /* block size in bytes */
            uint8_t dSizeExp;                /* max size of fat+directory+block index */
            uint8_t cacheSizeExp;             /* write cache size */
            uint8_t separatedir;             /* if directory used separatelly from FAT (NAND) */
            uint8_t csum;               // hamming code csum of struct
        };
        uint8_t pAsBytePtr[];
    };
};
 
uint32_t hamming_checksum(const uint8_t *dat, uint32_t datBits, uint8_t codeLen);
int hamming_validate(const uint8_t *dat, uint32_t datBits, uint32_t checksum, uint8_t codeLen);
int hamming_validateOrFix(const uint8_t *dat, uint32_t datBits, uint32_t checksum, uint8_t codeLen);
int hamming_anneal(uint8_t *dat, uint32_t datBits, uint32_t checksum, uint8_t codeLen, uint8_t errBit);
 
 
#endif   /* ----- #ifndef __EFFSPT_H  ----- */