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         printf("WRITE %d\r\n", BlockNumber);
 105         // TODO: Write to FLASH
 106 }
 107
 108 static void ReadBlock(const uint16_t BlockNumber)
 109 {
 110         uint8_t BlockBuffer[512];
 111         memset(BlockBuffer, 0x00, sizeof(BlockBuffer));
 112
 113         switch (BlockNumber)
 114         {
 115                 case 0:
 116                         memcpy(BlockBuffer, &BootBlock, sizeof(FATBootBlock_t));
 117                         break;
 118
 119                 case 1:
 120                 case 2:
 121                         /* Cluster 0: Media type/Reserved */
 122                         UpdateFAT12ClusterEntry(BlockBuffer, 0, 0xF00 | BootBlock.MediaDescriptor);
 123
 124                         /* Cluster 1: Reserved */
 125                         UpdateFAT12ClusterEntry(BlockBuffer, 1, 0xFFF);
 126
 127                         /* Cluster 2 onwards: Cluster chain of FIRMWARE.BIN */
 128                         for (uint16_t i = 0; i < FILE_CLUSTERS(FIRMWARE_FILE_SIZE); i++)
 129                           UpdateFAT12ClusterEntry(BlockBuffer, i+2, i+3);
 130
 131                         /* Mark last cluster as end of file */
 132                         UpdateFAT12ClusterEntry(BlockBuffer, FILE_CLUSTERS(FIRMWARE_FILE_SIZE) + 1, 0xFFF);
 133                         break;
 134
 135                 case 3:
 136                         memcpy(BlockBuffer, &FirmwareFileEntry, sizeof(FATDirectoryEntry_t));
 137                         break;
 138
 139                 default:
 140                         if ((BlockNumber >= 4) && (BlockNumber < (4 + (FIRMWARE_FILE_SIZE / SECTOR_SIZE_BYTES))))
 141                         {
 142 //                              printf("<D>\r\n");
 143
 144                                 for (uint16_t i = 0; i < 512; i++)
 145                                   BlockBuffer[i] = 'A' + (i % 26);
 146                         }
 147                         else
 148                         {
 149                                 printf("INVALID %d\r\n", BlockNumber);
 150                         }
 151
 152                         break;
 153         }
 154
 155         /* Wait until endpoint is ready before continuing */
 156         if (Endpoint_WaitUntilReady())
 157           return;
 158
 159         Endpoint_Write_Stream_LE(BlockBuffer, sizeof(BlockBuffer), NULL);
 160         Endpoint_ClearIN();
 161 }
 162
 163 void VirtualFAT_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo,
 164                             const uint32_t BlockAddress,
 165                             uint16_t TotalBlocks)
 166 {
 167         uint16_t CurrentBlock = (uint16_t)BlockAddress;
 168
 169         /* Emulated FAT is performed per-block, pass each requested block index
 170          * to the emulation function */
 171         while (TotalBlocks--)
 172           WriteBlock(CurrentBlock++);
 173 }
 174
 175 void VirtualFAT_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo,
 176                            const uint32_t BlockAddress,
 177                            uint16_t TotalBlocks)
 178 {
 179         uint16_t CurrentBlock = (uint16_t)BlockAddress;
 180
 181         /* Emulated FAT is performed per-block, pass each requested block index
 182          * to the emulation function */
 183         while (TotalBlocks--)
 184           ReadBlock(CurrentBlock++);
 185 }
 186