Bootloaders/Incomplete/MassStorage/Lib/VirtualFAT.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2013.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2013  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaims all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 #include "VirtualFAT.h"
  32
  33 static const FATBootBlock_t BootBlock =
  34         {
  35                 .Bootstrap               = {0xEB, 0x3C, 0x90},
  36                 .Description             = "mkdosfs",
  37                 .SectorSize              = SECTOR_SIZE_BYTES,
  38                 .SectorsPerCluster       = SECTOR_PER_CLUSTER,
  39                 .ReservedSectors         = 1,
  40                 .FATCopies               = 2,
  41                 .RootDirectoryEntries    = (SECTOR_SIZE_BYTES / sizeof(FATDirectoryEntry_t)),
  42                 .TotalSectors16          = LUN_MEDIA_BLOCKS,
  43                 .MediaDescriptor         = 0xF8,
  44                 .SectorsPerFAT           = 1,
  45                 .SectorsPerTrack         = LUN_MEDIA_BLOCKS % 64,
  46                 .Heads                   = LUN_MEDIA_BLOCKS / 64,
  47                 .HiddenSectors           = 0,
  48                 .TotalSectors32          = 0,
  49                 .PhysicalDriveNum        = 0,
  50                 .ExtendedBootRecordSig   = 0x29,
  51                 .VolumeSerialNumber      = 0x12345678,
  52                 .VolumeLabel             = "LUFA BOOT  ",
  53                 .FilesystemIdentifier    = "FAT12   ",
  54                 .BootstrapProgram        = {0},
  55                 .MagicSignature          = 0xAA55,
  56         };
  57
  58 static FATDirectoryEntry_t FirmwareFileEntry =
  59         {
  60                 .Filename        = "FIRMWARE",
  61                 .Extension       = "BIN",
  62                 .Attributes      = 0,
  63                 .Reserved        = {0},
  64                 .CreationTime    = FAT_TIME(1, 1, 0),
  65                 .CreationDate    = FAT_DATE(14, 2, 1989),
  66                 .StartingCluster = 2,
  67                 .FileSizeBytes   = FIRMWARE_FILE_SIZE,
  68         };
  69
  70
  71 static void UpdateFAT12ClusterEntry(uint8_t* FATTable,
  72                                     const uint16_t Index,
  73                                     const uint16_t ChainEntry)
  74 {
  75         /* Calculate the starting offset of the cluster entry in the FAT12 table */
  76         uint8_t FATOffset   =   (Index * 3) / 2;
  77         bool    UpperNibble = (((Index * 3) % 2) != 0);
  78
  79         /* Check if the start of the entry is at an upper nibble of the byte, fill
  80          * out FAT12 entry as required */
  81         if (UpperNibble)
  82         {
  83                 FATTable[FATOffset]     = (FATTable[FATOffset] & 0x0F) | ((ChainEntry & 0x0F) << 4);
  84                 FATTable[FATOffset + 1] = (ChainEntry >> 4);
  85         }
  86         else
  87         {
  88                 FATTable[FATOffset]     = ChainEntry;
  89                 FATTable[FATOffset + 1] = (FATTable[FATOffset] & 0xF0) | (ChainEntry >> 8);
  90         }
  91 }
  92
  93 static void WriteBlock(const uint16_t BlockNumber)
  94 {
  95         uint8_t BlockBuffer[512];
  96
  97         /* Wait until endpoint is ready before continuing */
  98         if (Endpoint_WaitUntilReady())
  99           return;
 100
 101         Endpoint_Read_Stream_LE(BlockBuffer, sizeof(BlockBuffer), NULL);
 102         Endpoint_ClearOUT();
 103
 104         // TODO: Write to FLASH
 105 }
 106
 107 static void ReadBlock(const uint16_t BlockNumber)
 108 {
 109         uint8_t BlockBuffer[512];
 110         memset(BlockBuffer, 0x00, sizeof(BlockBuffer));
 111
 112         switch (BlockNumber)
 113         {
 114                 case 0:
 115                         memcpy(BlockBuffer, &BootBlock, sizeof(FATBootBlock_t));
 116                         break;
 117
 118                 case 1:
 119                 case 2:
 120                         /* Cluster 0: Media type/Reserved */
 121                         UpdateFAT12ClusterEntry(BlockBuffer, 0, 0xF00 | BootBlock.MediaDescriptor);
 122
 123                         /* Cluster 1: Reserved */
 124                         UpdateFAT12ClusterEntry(BlockBuffer, 1, 0xFFF);
 125
 126                         /* Cluster 2 onwards: Cluster chain of FIRMWARE.BIN */
 127                         for (uint16_t i = 0; i < FILE_CLUSTERS(FIRMWARE_FILE_SIZE); i++)
 128                           UpdateFAT12ClusterEntry(BlockBuffer, i+2, i+3);
 129
 130                         /* Mark last cluster as end of file */
 131                         UpdateFAT12ClusterEntry(BlockBuffer, FILE_CLUSTERS(FIRMWARE_FILE_SIZE) + 1, 0xFFF);
 132                         break;
 133
 134                 case 3:
 135                         memcpy(BlockBuffer, &FirmwareFileEntry, sizeof(FATDirectoryEntry_t));
 136                         break;
 137
 138                 default:
 139                         if ((BlockNumber >= 4) && (BlockNumber < (4 + (FIRMWARE_FILE_SIZE / SECTOR_SIZE_BYTES))))
 140                         {
 141                                 for (uint16_t i = 0; i < 512; i++)
 142                                   BlockBuffer[i] = 'A' + (i % 26);
 143                         }
 144
 145                         break;
 146         }
 147
 148         /* Wait until endpoint is ready before continuing */
 149         if (Endpoint_WaitUntilReady())
 150           return;
 151
 152         Endpoint_Write_Stream_LE(BlockBuffer, sizeof(BlockBuffer), NULL);
 153         Endpoint_ClearIN();
 154 }
 155
 156 void VirtualFAT_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo,
 157                             const uint32_t BlockAddress,
 158                             uint16_t TotalBlocks)
 159 {
 160         uint16_t CurrentBlock = (uint16_t)BlockAddress;
 161
 162         /* Emulated FAT is performed per-block, pass each requested block index
 163          * to the emulation function */
 164         while (TotalBlocks--)
 165           WriteBlock(CurrentBlock++);
 166 }
 167
 168 void VirtualFAT_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo,
 169                            const uint32_t BlockAddress,
 170                            uint16_t TotalBlocks)
 171 {
 172         uint16_t CurrentBlock = (uint16_t)BlockAddress;
 173
 174         /* Emulated FAT is performed per-block, pass each requested block index
 175          * to the emulation function */
 176         while (TotalBlocks--)
 177           ReadBlock(CurrentBlock++);
 178 }
 179