diff options
| author | Dean Camera <dean@fourwalledcubicle.com> | 2010-01-28 12:47:35 +0000 |
|---|---|---|
| committer | Dean Camera <dean@fourwalledcubicle.com> | 2010-01-28 12:47:35 +0000 |
| commit | d11ed10c5314c44dc01c06954d1d73d4894cbff8 (patch) | |
| tree | fb771919dd20943a820f37d62a9488e32d07950a /Projects | |
| parent | d26a9ed5fd6fc60a0dfa61d04f5ae2bd7163a85d (diff) | |
| download | lufa-d11ed10c5314c44dc01c06954d1d73d4894cbff8.tar.gz lufa-d11ed10c5314c44dc01c06954d1d73d4894cbff8.tar.bz2 lufa-d11ed10c5314c44dc01c06954d1d73d4894cbff8.zip | |
Add FatFS library to the Webserver project, extend the HTTP server so that it now serves files from the Dataflash. Add Mass Storage device mode class driver so that files can be loaded to the board Dataflash when inserted into a PC.
Diffstat (limited to 'Projects')
30 files changed, 9602 insertions, 464 deletions
diff --git a/Projects/TemperatureDataLogger/makefile b/Projects/TemperatureDataLogger/makefile index 990156f26..a3da35ff3 100644 --- a/Projects/TemperatureDataLogger/makefile +++ b/Projects/TemperatureDataLogger/makefile @@ -128,9 +128,9 @@ SRC = $(TARGET).c \ Descriptors.c \
Lib/DataflashManager.c \
Lib/SCSI.c \
+ Lib/DS1307.c \
Lib/FATFs/diskio.c \
Lib/FATFs/ff.c \
- Lib/DS1307.c \
$(LUFA_PATH)/LUFA/Drivers/Board/Temperature.c \
$(LUFA_PATH)/LUFA/Drivers/Peripheral/TWI.c \
$(LUFA_PATH)/LUFA/Drivers/USB/LowLevel/DevChapter9.c \
diff --git a/Projects/Webserver/Descriptors.c b/Projects/Webserver/Descriptors.c new file mode 100644 index 000000000..40ce620a6 --- /dev/null +++ b/Projects/Webserver/Descriptors.c @@ -0,0 +1,217 @@ +/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2010.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.fourwalledcubicle.com
+*/
+
+/*
+ Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that the copyright notice and this
+ permission notice and warranty disclaimer appear in supporting
+ documentation, and that the name of the author not be used in
+ advertising or publicity pertaining to distribution of the
+ software without specific, written prior permission.
+
+ The author disclaim all warranties with regard to this
+ software, including all implied warranties of merchantability
+ and fitness. In no event shall the author be liable for any
+ special, indirect or consequential damages or any damages
+ whatsoever resulting from loss of use, data or profits, whether
+ in an action of contract, negligence or other tortious action,
+ arising out of or in connection with the use or performance of
+ this software.
+*/
+
+/** \file
+ *
+ * USB Device Descriptors, for library use when in USB device mode. Descriptors are special
+ * computer-readable structures which the host requests upon device enumeration, to determine
+ * the device's capabilities and functions.
+ */
+
+#include "Descriptors.h"
+
+/* On some devices, there is a factory set internal serial number which can be automatically sent to the host as
+ * the device's serial number when the Device Descriptor's .SerialNumStrIndex entry is set to USE_INTERNAL_SERIAL.
+ * This allows the host to track a device across insertions on different ports, allowing them to retain allocated
+ * resources like COM port numbers and drivers. On demos using this feature, give a warning on unsupported devices
+ * so that the user can supply their own serial number descriptor instead or remove the USE_INTERNAL_SERIAL value
+ * from the Device Descriptor (forcing the host to generate a serial number for each device from the VID, PID and
+ * port location).
+ */
+#if (USE_INTERNAL_SERIAL == NO_DESCRIPTOR)
+ #warning USE_INTERNAL_SERIAL is not available on this AVR - please manually construct a device serial descriptor.
+#endif
+
+/** Device descriptor structure. This descriptor, located in FLASH memory, describes the overall
+ * device characteristics, including the supported USB version, control endpoint size and the
+ * number of device configurations. The descriptor is read out by the USB host when the enumeration
+ * process begins.
+ */
+USB_Descriptor_Device_t PROGMEM DeviceDescriptor =
+{
+ .Header = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
+
+ .USBSpecification = VERSION_BCD(01.10),
+ .Class = 0x00,
+ .SubClass = 0x00,
+ .Protocol = 0x00,
+
+ .Endpoint0Size = FIXED_CONTROL_ENDPOINT_SIZE,
+
+ .VendorID = 0x03EB,
+ .ProductID = 0x2045,
+ .ReleaseNumber = 0x0000,
+
+ .ManufacturerStrIndex = 0x01,
+ .ProductStrIndex = 0x02,
+ .SerialNumStrIndex = USE_INTERNAL_SERIAL,
+
+ .NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS
+};
+
+/** Configuration descriptor structure. This descriptor, located in FLASH memory, describes the usage
+ * of the device in one of its supported configurations, including information about any device interfaces
+ * and endpoints. The descriptor is read out by the USB host during the enumeration process when selecting
+ * a configuration so that the host may correctly communicate with the USB device.
+ */
+USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
+{
+ .Config =
+ {
+ .Header = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
+
+ .TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
+ .TotalInterfaces = 1,
+
+ .ConfigurationNumber = 1,
+ .ConfigurationStrIndex = NO_DESCRIPTOR,
+
+ .ConfigAttributes = USB_CONFIG_ATTR_BUSPOWERED,
+
+ .MaxPowerConsumption = USB_CONFIG_POWER_MA(100)
+ },
+
+ .Interface =
+ {
+ .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
+
+ .InterfaceNumber = 0,
+ .AlternateSetting = 0,
+
+ .TotalEndpoints = 2,
+
+ .Class = 0x08,
+ .SubClass = 0x06,
+ .Protocol = 0x50,
+
+ .InterfaceStrIndex = NO_DESCRIPTOR
+ },
+
+ .DataInEndpoint =
+ {
+ .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
+
+ .EndpointAddress = (ENDPOINT_DESCRIPTOR_DIR_IN | MASS_STORAGE_IN_EPNUM),
+ .Attributes = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
+ .EndpointSize = MASS_STORAGE_IO_EPSIZE,
+ .PollingIntervalMS = 0x00
+ },
+
+ .DataOutEndpoint =
+ {
+ .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
+
+ .EndpointAddress = (ENDPOINT_DESCRIPTOR_DIR_OUT | MASS_STORAGE_OUT_EPNUM),
+ .Attributes = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
+ .EndpointSize = MASS_STORAGE_IO_EPSIZE,
+ .PollingIntervalMS = 0x00
+ }
+};
+
+/** Language descriptor structure. This descriptor, located in FLASH memory, is returned when the host requests
+ * the string descriptor with index 0 (the first index). It is actually an array of 16-bit integers, which indicate
+ * via the language ID table available at USB.org what languages the device supports for its string descriptors.
+ */
+USB_Descriptor_String_t PROGMEM LanguageString =
+{
+ .Header = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},
+
+ .UnicodeString = {LANGUAGE_ID_ENG}
+};
+
+/** Manufacturer descriptor string. This is a Unicode string containing the manufacturer's details in human readable
+ * form, and is read out upon request by the host when the appropriate string ID is requested, listed in the Device
+ * Descriptor.
+ */
+USB_Descriptor_String_t PROGMEM ManufacturerString =
+{
+ .Header = {.Size = USB_STRING_LEN(11), .Type = DTYPE_String},
+
+ .UnicodeString = L"Dean Camera"
+};
+
+/** Product descriptor string. This is a Unicode string containing the product's details in human readable form,
+ * and is read out upon request by the host when the appropriate string ID is requested, listed in the Device
+ * Descriptor.
+ */
+USB_Descriptor_String_t PROGMEM ProductString =
+{
+ .Header = {.Size = USB_STRING_LEN(22), .Type = DTYPE_String},
+
+ .UnicodeString = L"LUFA Mass Storage Demo"
+};
+
+/** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"
+ * documentation) by the application code so that the address and size of a requested descriptor can be given
+ * to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function
+ * is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the
+ * USB host.
+ */
+uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue, const uint8_t wIndex, void** const DescriptorAddress)
+{
+ const uint8_t DescriptorType = (wValue >> 8);
+ const uint8_t DescriptorNumber = (wValue & 0xFF);
+
+ void* Address = NULL;
+ uint16_t Size = NO_DESCRIPTOR;
+
+ switch (DescriptorType)
+ {
+ case DTYPE_Device:
+ Address = (void*)&DeviceDescriptor;
+ Size = sizeof(USB_Descriptor_Device_t);
+ break;
+ case DTYPE_Configuration:
+ Address = (void*)&ConfigurationDescriptor;
+ Size = sizeof(USB_Descriptor_Configuration_t);
+ break;
+ case DTYPE_String:
+ switch (DescriptorNumber)
+ {
+ case 0x00:
+ Address = (void*)&LanguageString;
+ Size = pgm_read_byte(&LanguageString.Header.Size);
+ break;
+ case 0x01:
+ Address = (void*)&ManufacturerString;
+ Size = pgm_read_byte(&ManufacturerString.Header.Size);
+ break;
+ case 0x02:
+ Address = (void*)&ProductString;
+ Size = pgm_read_byte(&ProductString.Header.Size);
+ break;
+ }
+
+ break;
+ }
+
+ *DescriptorAddress = Address;
+ return Size;
+}
diff --git a/Projects/Webserver/Descriptors.h b/Projects/Webserver/Descriptors.h new file mode 100644 index 000000000..dcaaddaf7 --- /dev/null +++ b/Projects/Webserver/Descriptors.h @@ -0,0 +1,72 @@ +/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2010.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.fourwalledcubicle.com
+*/
+
+/*
+ Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that the copyright notice and this
+ permission notice and warranty disclaimer appear in supporting
+ documentation, and that the name of the author not be used in
+ advertising or publicity pertaining to distribution of the
+ software without specific, written prior permission.
+
+ The author disclaim all warranties with regard to this
+ software, including all implied warranties of merchantability
+ and fitness. In no event shall the author be liable for any
+ special, indirect or consequential damages or any damages
+ whatsoever resulting from loss of use, data or profits, whether
+ in an action of contract, negligence or other tortious action,
+ arising out of or in connection with the use or performance of
+ this software.
+*/
+
+/** \file
+ *
+ * Header file for Descriptors.c.
+ */
+
+#ifndef _DESCRIPTORS_H_
+#define _DESCRIPTORS_H_
+
+ /* Includes: */
+ #include <avr/pgmspace.h>
+
+ #include <LUFA/Drivers/USB/USB.h>
+ #include <LUFA/Drivers/USB/Class/MassStorage.h>
+
+ /* Macros: */
+ /** Endpoint number of the Mass Storage device-to-host data IN endpoint. */
+ #define MASS_STORAGE_IN_EPNUM 3
+
+ /** Endpoint number of the Mass Storage host-to-device data OUT endpoint. */
+ #define MASS_STORAGE_OUT_EPNUM 4
+
+ /** Size in bytes of the Mass Storage data endpoints. */
+ #define MASS_STORAGE_IO_EPSIZE 64
+
+ /* Type Defines: */
+ /** Type define for the device configuration descriptor structure. This must be defined in the
+ * application code, as the configuration descriptor contains several sub-descriptors which
+ * vary between devices, and which describe the device's usage to the host.
+ */
+ typedef struct
+ {
+ USB_Descriptor_Configuration_Header_t Config;
+ USB_Descriptor_Interface_t Interface;
+ USB_Descriptor_Endpoint_t DataInEndpoint;
+ USB_Descriptor_Endpoint_t DataOutEndpoint;
+ } USB_Descriptor_Configuration_t;
+
+ /* Function Prototypes: */
+ uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue, const uint8_t wIndex, void** const DescriptorAddress)
+ ATTR_WARN_UNUSED_RESULT ATTR_NON_NULL_PTR_ARG(3);
+
+#endif
diff --git a/Projects/Webserver/Lib/DataflashManager.c b/Projects/Webserver/Lib/DataflashManager.c new file mode 100644 index 000000000..1de866ede --- /dev/null +++ b/Projects/Webserver/Lib/DataflashManager.c @@ -0,0 +1,525 @@ +/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2010.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.fourwalledcubicle.com
+*/
+
+/*
+ Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that the copyright notice and this
+ permission notice and warranty disclaimer appear in supporting
+ documentation, and that the name of the author not be used in
+ advertising or publicity pertaining to distribution of the
+ software without specific, written prior permission.
+
+ The author disclaim all warranties with regard to this
+ software, including all implied warranties of merchantability
+ and fitness. In no event shall the author be liable for any
+ special, indirect or consequential damages or any damages
+ whatsoever resulting from loss of use, data or profits, whether
+ in an action of contract, negligence or other tortious action,
+ arising out of or in connection with the use or performance of
+ this software.
+*/
+
+/** \file
+ *
+ * Functions to manage the physical dataflash media, including reading and writing of
+ * blocks of data. These functions are called by the SCSI layer when data must be stored
+ * or retrieved to/from the physical storage media. If a different media is used (such
+ * as a SD card or EEPROM), functions similar to these will need to be generated.
+ */
+
+#define INCLUDE_FROM_DATAFLASHMANAGER_C
+#include "DataflashManager.h"
+
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+ * the pre-selected data OUT endpoint. This routine reads in OS sized blocks from the endpoint and writes
+ * them to the dataflash in Dataflash page sized blocks.
+ *
+ * \param[in] MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state
+ * \param[in] BlockAddress Data block starting address for the write sequence
+ * \param[in] TotalBlocks Number of blocks of data to write
+ */
+void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks)
+{
+ uint16_t CurrDFPage = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);
+ uint16_t CurrDFPageByte = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);
+ uint8_t CurrDFPageByteDiv16 = (CurrDFPageByte >> 4);
+ bool UsingSecondBuffer = false;
+
+ /* Select the correct starting Dataflash IC for the block requested */
+ Dataflash_SelectChipFromPage(CurrDFPage);
+
+#if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
+ /* Copy selected dataflash's current page contents to the dataflash buffer */
+ Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
+ Dataflash_SendAddressBytes(CurrDFPage, 0);
+ Dataflash_WaitWhileBusy();
+#endif
+
+ /* Send the dataflash buffer write command */
+ Dataflash_SendByte(DF_CMD_BUFF1WRITE);
+ Dataflash_SendAddressBytes(0, CurrDFPageByte);
+
+ /* Wait until endpoint is ready before continuing */
+ if (Endpoint_WaitUntilReady())
+ return;
+
+ while (TotalBlocks)
+ {
+ uint8_t BytesInBlockDiv16 = 0;
+
+ /* Write an endpoint packet sized data block to the dataflash */
+ while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
+ {
+ /* Check if the endpoint is currently empty */
+ if (!(Endpoint_IsReadWriteAllowed()))
+ {
+ /* Clear the current endpoint bank */
+ Endpoint_ClearOUT();
+
+ /* Wait until the host has sent another packet */
+ if (Endpoint_WaitUntilReady())
+ return;
+ }
+
+ /* Check if end of dataflash page reached */
+ if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
+ {
+ /* Write the dataflash buffer contents back to the dataflash page */
+ Dataflash_WaitWhileBusy();
+ Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
+ Dataflash_SendAddressBytes(CurrDFPage, 0);
+
+ /* Reset the dataflash buffer counter, increment the page counter */
+ CurrDFPageByteDiv16 = 0;
+ CurrDFPage++;
+
+ /* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+ if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
+ UsingSecondBuffer = !(UsingSecondBuffer);
+
+ /* Select the next dataflash chip based on the new dataflash page index */
+ Dataflash_SelectChipFromPage(CurrDFPage);
+
+#if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
+ /* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+ if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
+ {
+ /* Copy selected dataflash's current page contents to the dataflash buffer */
+ Dataflash_WaitWhileBusy();
+ Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
+ Dataflash_SendAddressBytes(CurrDFPage, 0);
+ Dataflash_WaitWhileBusy();
+ }
+#endif
+
+ /* Send the dataflash buffer write command */
+ Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2WRITE : DF_CMD_BUFF1WRITE);
+ Dataflash_SendAddressBytes(0, 0);
+ }
+
+ /* Write one 16-byte chunk of data to the dataflash */
+ Dataflash_SendByte(Endpoint_Read_Byte());
+ Dataflash_SendByte(Endpoint_Read_Byte());
+ Dataflash_SendByte(Endpoint_Read_Byte());
+ Dataflash_SendByte(Endpoint_Read_Byte());
+ Dataflash_SendByte(Endpoint_Read_Byte());
+ Dataflash_SendByte(Endpoint_Read_Byte());
+ Dataflash_SendByte(Endpoint_Read_Byte());
+ Dataflash_SendByte(Endpoint_Read_Byte());
+ Dataflash_SendByte(Endpoint_Read_Byte());
+ Dataflash_SendByte(Endpoint_Read_Byte());
+ Dataflash_SendByte(Endpoint_Read_Byte());
+ Dataflash_SendByte(Endpoint_Read_Byte());
+ Dataflash_SendByte(Endpoint_Read_Byte());
+ Dataflash_SendByte(Endpoint_Read_Byte());
+ Dataflash_SendByte(Endpoint_Read_Byte());
+ Dataflash_SendByte(Endpoint_Read_Byte());
+
+ /* Increment the dataflash page 16 byte block counter */
+ CurrDFPageByteDiv16++;
+
+ /* Increment the block 16 byte block counter */
+ BytesInBlockDiv16++;
+
+ /* Check if the current command is being aborted by the host */
+ if (MSInterfaceInfo->State.IsMassStoreReset)
+ return;
+ }
+
+ /* Decrement the blocks remaining counter and reset the sub block counter */
+ TotalBlocks--;
+ }
+
+ /* Write the dataflash buffer contents back to the dataflash page */
+ Dataflash_WaitWhileBusy();
+ Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
+ Dataflash_SendAddressBytes(CurrDFPage, 0x00);
+ Dataflash_WaitWhileBusy();
+
+ /* If the endpoint is empty, clear it ready for the next packet from the host */
+ if (!(Endpoint_IsReadWriteAllowed()))
+ Endpoint_ClearOUT();
+
+ /* Deselect all dataflash chips */
+ Dataflash_DeselectChip();
+}
+
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+ * the pre-selected data IN endpoint. This routine reads in Dataflash page sized blocks from the Dataflash
+ * and writes them in OS sized blocks to the endpoint.
+ *
+ * \param[in] MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state
+ * \param[in] BlockAddress Data block starting address for the read sequence
+ * \param[in] TotalBlocks Number of blocks of data to read
+ */
+void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks)
+{
+ uint16_t CurrDFPage = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);
+ uint16_t CurrDFPageByte = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);
+ uint8_t CurrDFPageByteDiv16 = (CurrDFPageByte >> 4);
+
+ /* Select the correct starting Dataflash IC for the block requested */
+ Dataflash_SelectChipFromPage(CurrDFPage);
+
+ /* Send the dataflash main memory page read command */
+ Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
+ Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
+ Dataflash_SendByte(0x00);
+ Dataflash_SendByte(0x00);
+ Dataflash_SendByte(0x00);
+ Dataflash_SendByte(0x00);
+
+ /* Wait until endpoint is ready before continuing */
+ if (Endpoint_WaitUntilReady())
+ return;
+
+ while (TotalBlocks)
+ {
+ uint8_t BytesInBlockDiv16 = 0;
+
+ /* Write an endpoint packet sized data block to the dataflash */
+ while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
+ {
+ /* Check if the endpoint is currently full */
+ if (!(Endpoint_IsReadWriteAllowed()))
+ {
+ /* Clear the endpoint bank to send its contents to the host */
+ Endpoint_ClearIN();
+
+ /* Wait until the endpoint is ready for more data */
+ if (Endpoint_WaitUntilReady())
+ return;
+ }
+
+ /* Check if end of dataflash page reached */
+ if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
+ {
+ /* Reset the dataflash buffer counter, increment the page counter */
+ CurrDFPageByteDiv16 = 0;
+ CurrDFPage++;
+
+ /* Select the next dataflash chip based on the new dataflash page index */
+ Dataflash_SelectChipFromPage(CurrDFPage);
+
+ /* Send the dataflash main memory page read command */
+ Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
+ Dataflash_SendAddressBytes(CurrDFPage, 0);
+ Dataflash_SendByte(0x00);
+ Dataflash_SendByte(0x00);
+ Dataflash_SendByte(0x00);
+ Dataflash_SendByte(0x00);
+ }
+
+ /* Read one 16-byte chunk of data from the dataflash */
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+ Endpoint_Write_Byte(Dataflash_ReceiveByte());
+
+ /* Increment the dataflash page 16 byte block counter */
+ CurrDFPageByteDiv16++;
+
+ /* Increment the block 16 byte block counter */
+ BytesInBlockDiv16++;
+
+ /* Check if the current command is being aborted by the host */
+ if (MSInterfaceInfo->State.IsMassStoreReset)
+ return;
+ }
+
+ /* Decrement the blocks remaining counter */
+ TotalBlocks--;
+ }
+
+ /* If the endpoint is full, send its contents to the host */
+ if (!(Endpoint_IsReadWriteAllowed()))
+ Endpoint_ClearIN();
+
+ /* Deselect all dataflash chips */
+ Dataflash_DeselectChip();
+}
+
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+ * the a given RAM buffer. This routine reads in OS sized blocks from the buffer and writes them to the
+ * dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
+ * dataflash.
+ *
+ * \param[in] BlockAddress Data block starting address for the write sequence
+ * \param[in] TotalBlocks Number of blocks of data to write
+ * \param[in] BufferPtr Pointer to the data source RAM buffer
+ */
+void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, const uint8_t* BufferPtr)
+{
+ uint16_t CurrDFPage = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);
+ uint16_t CurrDFPageByte = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);
+ uint8_t CurrDFPageByteDiv16 = (CurrDFPageByte >> 4);
+ bool UsingSecondBuffer = false;
+
+ /* Select the correct starting Dataflash IC for the block requested */
+ Dataflash_SelectChipFromPage(CurrDFPage);
+
+#if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
+ /* Copy selected dataflash's current page contents to the dataflash buffer */
+ Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
+ Dataflash_SendAddressBytes(CurrDFPage, 0);
+ Dataflash_WaitWhileBusy();
+#endif
+
+ /* Send the dataflash buffer write command */
+ Dataflash_SendByte(DF_CMD_BUFF1WRITE);
+ Dataflash_SendAddressBytes(0, CurrDFPageByte);
+
+ while (TotalBlocks)
+ {
+ uint8_t BytesInBlockDiv16 = 0;
+
+ /* Write an endpoint packet sized data block to the dataflash */
+ while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
+ {
+ /* Check if end of dataflash page reached */
+ if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
+ {
+ /* Write the dataflash buffer contents back to the dataflash page */
+ Dataflash_WaitWhileBusy();
+ Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
+ Dataflash_SendAddressBytes(CurrDFPage, 0);
+
+ /* Reset the dataflash buffer counter, increment the page counter */
+ CurrDFPageByteDiv16 = 0;
+ CurrDFPage++;
+
+ /* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+ if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
+ UsingSecondBuffer = !(UsingSecondBuffer);
+
+ /* Select the next dataflash chip based on the new dataflash page index */
+ Dataflash_SelectChipFromPage(CurrDFPage);
+
+#if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
+ /* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+ if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
+ {
+ /* Copy selected dataflash's current page contents to the dataflash buffer */
+ Dataflash_WaitWhileBusy();
+ Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
+ Dataflash_SendAddressBytes(CurrDFPage, 0);
+ Dataflash_WaitWhileBusy();
+ }
+#endif
+
+ /* Send the dataflash buffer write command */
+ Dataflash_ToggleSelectedChipCS();
+ Dataflash_SendByte(DF_CMD_BUFF1WRITE);
+ Dataflash_SendAddressBytes(0, 0);
+ }
+
+ /* Write one 16-byte chunk of data to the dataflash */
+ for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
+ Dataflash_SendByte(*(BufferPtr++));
+
+ /* Increment the dataflash page 16 byte block counter */
+ CurrDFPageByteDiv16++;
+
+ /* Increment the block 16 byte block counter */
+ BytesInBlockDiv16++;
+ }
+
+ /* Decrement the blocks remaining counter and reset the sub block counter */
+ TotalBlocks--;
+ }
+
+ /* Write the dataflash buffer contents back to the dataflash page */
+ Dataflash_WaitWhileBusy();
+ Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
+ Dataflash_SendAddressBytes(CurrDFPage, 0x00);
+ Dataflash_WaitWhileBusy();
+
+ /* Deselect all dataflash chips */
+ Dataflash_DeselectChip();
+}
+
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+ * the a preallocated RAM buffer. This routine reads in Dataflash page sized blocks from the Dataflash
+ * and writes them in OS sized blocks to the given buffer. This can be linked to FAT libraries to read
+ * the files stored on the dataflash.
+ *
+ * \param[in] BlockAddress Data block starting address for the read sequence
+ * \param[in] TotalBlocks Number of blocks of data to read
+ * \param[out] BufferPtr Pointer to the data destination RAM buffer
+ */
+void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, uint8_t* BufferPtr)
+{
+ uint16_t CurrDFPage = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);
+ uint16_t CurrDFPageByte = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);
+ uint8_t CurrDFPageByteDiv16 = (CurrDFPageByte >> 4);
+
+ /* Select the correct starting Dataflash IC for the block requested */
+ Dataflash_SelectChipFromPage(CurrDFPage);
+
+ /* Send the dataflash main memory page read command */
+ Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
+ Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
+ Dataflash_SendByte(0x00);
+ Dataflash_SendByte(0x00);
+ Dataflash_SendByte(0x00);
+ Dataflash_SendByte(0x00);
+
+ while (TotalBlocks)
+ {
+ uint8_t BytesInBlockDiv16 = 0;
+
+ /* Write an endpoint packet sized data block to the dataflash */
+ while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
+ {
+ /* Check if end of dataflash page reached */
+ if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
+ {
+ /* Reset the dataflash buffer counter, increment the page counter */
+ CurrDFPageByteDiv16 = 0;
+ CurrDFPage++;
+
+ /* Select the next dataflash chip based on the new dataflash page index */
+ Dataflash_SelectChipFromPage(CurrDFPage);
+
+ /* Send the dataflash main memory page read command */
+ Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
+ Dataflash_SendAddressBytes(CurrDFPage, 0);
+ Dataflash_SendByte(0x00);
+ Dataflash_SendByte(0x00);
+ Dataflash_SendByte(0x00);
+ Dataflash_SendByte(0x00);
+ }
+
+ /* Read one 16-byte chunk of data from the dataflash */
+ for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
+ *(BufferPtr++) = Dataflash_ReceiveByte();
+
+ /* Increment the dataflash page 16 byte block counter */
+ CurrDFPageByteDiv16++;
+
+ /* Increment the block 16 byte block counter */
+ BytesInBlockDiv16++;
+ }
+
+ /* Decrement the blocks remaining counter */
+ TotalBlocks--;
+ }
+
+ /* Deselect all dataflash chips */
+ Dataflash_DeselectChip();
+}
+
+/** Disables the dataflash memory write protection bits on the board Dataflash ICs, if enabled. */
+void DataflashManager_ResetDataflashProtections(void)
+{
+ /* Select first dataflash chip, send the read status register command */
+ Dataflash_SelectChip(DATAFLASH_CHIP1);
+ Dataflash_SendByte(DF_CMD_GETSTATUS);
+
+ /* Check if sector protection is enabled */
+ if (Dataflash_ReceiveByte() & DF_STATUS_SECTORPROTECTION_ON)
+ {
+ Dataflash_ToggleSelectedChipCS();
+
+ /* Send the commands to disable sector protection */
+ Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[0]);
+ Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[1]);
+ Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[2]);
+ Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[3]);
+ }
+
+ /* Select second dataflash chip (if present on selected board), send read status register command */
+ #if (DATAFLASH_TOTALCHIPS == 2)
+ Dataflash_SelectChip(DATAFLASH_CHIP2);
+ Dataflash_SendByte(DF_CMD_GETSTATUS);
+
+ /* Check if sector protection is enabled */
+ if (Dataflash_ReceiveByte() & DF_STATUS_SECTORPROTECTION_ON)
+ {
+ Dataflash_ToggleSelectedChipCS();
+
+ /* Send the commands to disable sector protection */
+ Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[0]);
+ Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[1]);
+ Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[2]);
+ Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[3]);
+ }
+ #endif
+
+ /* Deselect current dataflash chip */
+ Dataflash_DeselectChip();
+}
+
+/** Performs a simple test on the attached Dataflash IC(s) to ensure that they are working.
+ *
+ * \return Boolean true if all media chips are working, false otherwise
+ */
+bool DataflashManager_CheckDataflashOperation(void)
+{
+ uint8_t ReturnByte;
+
+ /* Test first Dataflash IC is present and responding to commands */
+ Dataflash_SelectChip(DATAFLASH_CHIP1);
+ Dataflash_SendByte(DF_CMD_READMANUFACTURERDEVICEINFO);
+ ReturnByte = Dataflash_ReceiveByte();
+ Dataflash_DeselectChip();
+
+ /* If returned data is invalid, fail the command */
+ if (ReturnByte != DF_MANUFACTURER_ATMEL)
+ return false;
+
+ #if (DATAFLASH_TOTALCHIPS == 2)
+ /* Test second Dataflash IC is present and responding to commands */
+ Dataflash_SelectChip(DATAFLASH_CHIP2);
+ Dataflash_SendByte(DF_CMD_READMANUFACTURERDEVICEINFO);
+ ReturnByte = Dataflash_ReceiveByte();
+ Dataflash_DeselectChip();
+
+ /* If returned data is invalid, fail the command */
+ if (ReturnByte != DF_MANUFACTURER_ATMEL)
+ return false;
+ #endif
+
+ return true;
+}
diff --git a/Projects/Webserver/Lib/DataflashManager.h b/Projects/Webserver/Lib/DataflashManager.h new file mode 100644 index 000000000..d3ea0ff50 --- /dev/null +++ b/Projects/Webserver/Lib/DataflashManager.h @@ -0,0 +1,80 @@ +/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2010.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.fourwalledcubicle.com
+*/
+
+/*
+ Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that the copyright notice and this
+ permission notice and warranty disclaimer appear in supporting
+ documentation, and that the name of the author not be used in
+ advertising or publicity pertaining to distribution of the
+ software without specific, written prior permission.
+
+ The author disclaim all warranties with regard to this
+ software, including all implied warranties of merchantability
+ and fitness. In no event shall the author be liable for any
+ special, indirect or consequential damages or any damages
+ whatsoever resulting from loss of use, data or profits, whether
+ in an action of contract, negligence or other tortious action,
+ arising out of or in connection with the use or performance of
+ this software.
+*/
+
+/** \file
+ *
+ * Header file for DataflashManager.c.
+ */
+
+#ifndef _DATAFLASH_MANAGER_H
+#define _DATAFLASH_MANAGER_H
+
+ /* Includes: */
+ #include <avr/io.h>
+ + #include "Descriptors.h"
+
+ #include <LUFA/Common/Common.h>
+ #include <LUFA/Drivers/USB/USB.h>
+ #include <LUFA/Drivers/USB/Class/MassStorage.h>
+ #include <LUFA/Drivers/Board/Dataflash.h>
+
+ /* Preprocessor Checks: */
+ #if (DATAFLASH_PAGE_SIZE % 16)
+ #error Dataflash page size must be a multiple of 16 bytes.
+ #endif
+
+ /* Defines: */
+ /** Total number of bytes of the storage medium, comprised of one or more dataflash ICs. */
+ #define VIRTUAL_MEMORY_BYTES ((uint32_t)DATAFLASH_PAGES * DATAFLASH_PAGE_SIZE * DATAFLASH_TOTALCHIPS)
+
+ /** Block size of the device. This is kept at 512 to remain compatible with the OS despite the underlying
+ * storage media (Dataflash) using a different native block size. Do not change this value.
+ */
+ #define VIRTUAL_MEMORY_BLOCK_SIZE 512
+
+ /** Total number of blocks of the virtual memory for reporting to the host as the device's total capacity. Do not
+ * change this value; change VIRTUAL_MEMORY_BYTES instead to alter the media size.
+ */
+ #define VIRTUAL_MEMORY_BLOCKS (VIRTUAL_MEMORY_BYTES / VIRTUAL_MEMORY_BLOCK_SIZE)
+
+ /* Function Prototypes: */
+ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress,
+ uint16_t TotalBlocks);
+ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress,
+ uint16_t TotalBlocks);
+ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks,
+ const uint8_t* BufferPtr) ATTR_NON_NULL_PTR_ARG(3);
+ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks,
+ uint8_t* BufferPtr) ATTR_NON_NULL_PTR_ARG(3);
+ void DataflashManager_ResetDataflashProtections(void);
+ bool DataflashManager_CheckDataflashOperation(void);
+
+#endif
diff --git a/Projects/Webserver/Lib/FATFs/00readme.txt b/Projects/Webserver/Lib/FATFs/00readme.txt new file mode 100644 index 000000000..295be3b9a --- /dev/null +++ b/Projects/Webserver/Lib/FATFs/00readme.txt @@ -0,0 +1,110 @@ +FatFs Module Source Files R0.07e (C)ChaN, 2010
+
+
+FILES
+
+ ffconf.h Configuration file for FatFs module.
+ ff.h Common include file for FatFs and application module.
+ ff.c FatFs module.
+ diskio.h Common include file for FatFs and disk I/O module.
+ diskio.c Skeleton of low level disk I/O module.
+ integer.h Alternative type definitions for integer variables.
+ option Optional external functions.
+
+ Low level disk I/O module is not included in this archive because the FatFs
+ module is only a generic file system layer and not depend on any specific
+ storage device. You have to provide a low level disk I/O module that written
+ to control your storage device.
+
+
+
+AGREEMENTS
+
+ FatFs module is an open source software to implement FAT file system to
+ small embedded systems. This is a free software and is opened for education,
+ research and commercial developments under license policy of following trems.
+
+ Copyright (C) 2010, ChaN, all right reserved.
+
+ * The FatFs module is a free software and there is NO WARRANTY.
+ * No restriction on use. You can use, modify and redistribute it for
+ personal, non-profit or commercial product UNDER YOUR RESPONSIBILITY.
+ * Redistributions of source code must retain the above copyright notice.
+
+
+
+REVISION HISTORY
+
+ Feb 26, 2006 R0.00 Prototype
+
+ Apr 29, 2006 R0.01 First release.
+
+ Jun 01, 2006 R0.02 Added FAT12.
+ Removed unbuffered mode.
+ Fixed a problem on small (<32M) patition.
+
+ Jun 10, 2006 R0.02a Added a configuration option _FS_MINIMUM.
+
+ Sep 22, 2006 R0.03 Added f_rename.
+ Changed option _FS_MINIMUM to _FS_MINIMIZE.
+
+ Dec 11, 2006 R0.03a Improved cluster scan algolithm to write files fast.
+ Fixed f_mkdir creates incorrect directory on FAT32.
+
+ Feb 04, 2007 R0.04 Supported multiple drive system. (FatFs)
+ Changed some APIs for multiple drive system.
+ Added f_mkfs. (FatFs)
+ Added _USE_FAT32 option. (Tiny-FatFs)
+
+ Apr 01, 2007 R0.04a Supported multiple partitions on a plysical drive. (FatFs)
+ Fixed an endian sensitive code in f_mkfs. (FatFs)
+ Added a capability of extending the file size to f_lseek.
+ Added minimization level 3.
+ Fixed a problem that can collapse a sector when recreate an
+ existing file in any sub-directory at non FAT32 cfg. (Tiny-FatFs)
+
+ May 05, 2007 R0.04b Added _USE_NTFLAG option.
+ Added FSInfo support.
+ Fixed some problems corresponds to FAT32. (Tiny-FatFs)
+ Fixed DBCS name can result FR_INVALID_NAME.
+ Fixed short seek (0 < ofs <= csize) collapses the file object.
+
+ Aug 25, 2007 R0.05 Changed arguments of f_read, f_write.
+ Changed arguments of f_mkfs. (FatFs)
+ Fixed f_mkfs on FAT32 creates incorrect FSInfo. (FatFs)
+ Fixed f_mkdir on FAT32 creates incorrect directory. (FatFs)
+
+ Feb 03, 2008 R0.05a Added f_truncate().
+ Added f_utime().
+ Fixed off by one error at FAT sub-type determination.
+ Fixed btr in f_read() can be mistruncated.
+ Fixed cached sector is not flushed when create and close without write.
+
+ Apr 01, 2008 R0.06 Added f_forward(). (Tiny-FatFs)
+ Added string functions: fputc(), fputs(), fprintf() and fgets().
+ Improved performance of f_lseek() on move to the same or following cluster.
+
+ Apr 01, 2010, R0.07 Merged Tiny-FatFs as a buffer configuration option.
+ Added long file name support.
+ Added multiple code page support.
+ Added re-entrancy for multitask operation.
+ Added auto cluster size selection to f_mkfs().
+ Added rewind option to f_readdir().
+ Changed result code of critical errors.
+ Renamed string functions to avoid name collision.
+
+ Apr 14, 2010, R0.07a Separated out OS dependent code on reentrant cfg.
+ Added multiple sector size support.
+
+ Jun 21, 2010, R0.07c Fixed f_unlink() may return FR_OK on error.
+ Fixed wrong cache control in f_lseek().
+ Added relative path feature.
+ Added f_chdir().
+ Added f_chdrive().
+ Added proper case conversion for extended characters.
+
+ Nov 03,'2010 R0.07e Separated out configuration options from ff.h to ffconf.h.
+ Added a configuration option, _LFN_UNICODE.
+ Fixed f_unlink() fails to remove a sub-dir on _FS_RPATH.
+ Fixed name matching error on the 13 char boundary.
+ Changed f_readdir() to return the SFN with always upper case on non-LFN cfg.
diff --git a/Projects/Webserver/Lib/FATFs/diskio.c b/Projects/Webserver/Lib/FATFs/diskio.c new file mode 100644 index 000000000..c7c837ba4 --- /dev/null +++ b/Projects/Webserver/Lib/FATFs/diskio.c @@ -0,0 +1,92 @@ +/*-----------------------------------------------------------------------*/
+/* Low level disk I/O module skeleton for FatFs (C)ChaN, 2007 */
+/*-----------------------------------------------------------------------*/
+/* This is a stub disk I/O module that acts as front end of the existing */
+/* disk I/O modules and attach it to FatFs module with common interface. */
+/*-----------------------------------------------------------------------*/
+
+#include "diskio.h"
+
+/*-----------------------------------------------------------------------*/
+/* Inidialize a Drive */
+
+DSTATUS disk_initialize (
+ BYTE drv /* Physical drive nmuber (0..) */
+)
+{
+ return FR_OK;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Return Disk Status */
+
+DSTATUS disk_status (
+ BYTE drv /* Physical drive nmuber (0..) */
+)
+{
+ return FR_OK;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read Sector(s) */
+
+DRESULT disk_read (
+ BYTE drv, /* Physical drive nmuber (0..) */
+ BYTE *buff, /* Data buffer to store read data */
+ DWORD sector, /* Sector address (LBA) */
+ BYTE count /* Number of sectors to read (1..255) */
+)
+{
+ DataflashManager_ReadBlocks_RAM(sector, count, buff);
+ return RES_OK;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Write Sector(s) */
+
+#if _READONLY == 0
+DRESULT disk_write (
+ BYTE drv, /* Physical drive nmuber (0..) */
+ const BYTE *buff, /* Data to be written */
+ DWORD sector, /* Sector address (LBA) */
+ BYTE count /* Number of sectors to write (1..255) */
+)
+{
+ DataflashManager_WriteBlocks_RAM(sector, count, buff);
+ return RES_OK;
+}
+#endif /* _READONLY */
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Miscellaneous Functions */
+
+DRESULT disk_ioctl (
+ BYTE drv, /* Physical drive nmuber (0..) */
+ BYTE ctrl, /* Control code */
+ void *buff /* Buffer to send/receive control data */
+)
+{
+ if (ctrl == CTRL_SYNC)
+ return RES_OK;
+ else
+ return RES_PARERR;
+}
+
+
+DWORD get_fattime (void)
+{
+ return ((DWORD)1 << 25) |
+ ((DWORD)1 << 21) |
+ ((DWORD)1 << 16) |
+ ((DWORD)1 << 11) |
+ ((DWORD)1 << 5) |
+ ((DWORD)1 << 0);
+}
diff --git a/Projects/Webserver/Lib/FATFs/diskio.h b/Projects/Webserver/Lib/FATFs/diskio.h new file mode 100644 index 000000000..3df93ae7a --- /dev/null +++ b/Projects/Webserver/Lib/FATFs/diskio.h @@ -0,0 +1,72 @@ +/*-----------------------------------------------------------------------
+/ Low level disk interface modlue include file R0.07 (C)ChaN, 2010
+/-----------------------------------------------------------------------*/
+
+#ifndef _DISKIO
+
+#define _READONLY 0 /* 1: Read-only mode */
+#define _USE_IOCTL 1
+
+#include "integer.h"
+#include "ff.h"
+
+#include "../DataflashManager.h"
+
+
+/* Status of Disk Functions */
+typedef BYTE DSTATUS;
+
+/* Results of Disk Functions */
+typedef enum {
+ RES_OK = 0, /* 0: Successful */
+ RES_ERROR, /* 1: R/W Error */
+ RES_WRPRT, /* 2: Write Protected */
+ RES_NOTRDY, /* 3: Not Ready */
+ RES_PARERR /* 4: Invalid Parameter */
+} DRESULT;
+
+
+/*---------------------------------------*/
+/* Prototypes for disk control functions */
+
+BOOL assign_drives (int argc, char *argv[]);
+DSTATUS disk_initialize (BYTE);
+DSTATUS disk_status (BYTE);
+DRESULT disk_read (BYTE, BYTE*, DWORD, BYTE);
+#if _READONLY == 0
+DRESULT disk_write (BYTE, const BYTE*, DWORD, BYTE);
+#endif
+DRESULT disk_ioctl (BYTE, BYTE, void*);
+
+
+/* Disk Status Bits (DSTATUS) */
+
+#define STA_NOINIT 0x01 /* Drive not initialized */
+#define STA_NODISK 0x02 /* No medium in the drive */
+#define STA_PROTECT 0x04 /* Write protected */
+
+
+/* Command code for disk_ioctrl() */
+
+/* Generic command */
+#define CTRL_SYNC 0 /* Mandatory for write functions */
+#define GET_SECTOR_COUNT 1 /* Mandatory for only f_mkfs() */
+#define GET_SECTOR_SIZE 2 /* Mandatory for multiple sector size cfg */
+#define GET_BLOCK_SIZE 3 /* Mandatory for only f_mkfs() */
+#define CTRL_POWER 4
+#define CTRL_LOCK 5
+#define CTRL_EJECT 6
+/* MMC/SDC command */
+#define MMC_GET_TYPE 10
+#define MMC_GET_CSD 11
+#define MMC_GET_CID 12
+#define MMC_GET_OCR 13
+#define MMC_GET_SDSTAT 14
+/* ATA/CF command */
+#define ATA_GET_REV 20
+#define ATA_GET_MODEL 21
+#define ATA_GET_SN 22
+
+
+#define _DISKIO
+#endif
diff --git a/Projects/Webserver/Lib/FATFs/diskio.lst b/Projects/Webserver/Lib/FATFs/diskio.lst new file mode 100644 index 000000000..d3e78054b --- /dev/null +++ b/Projects/Webserver/Lib/FATFs/diskio.lst @@ -0,0 +1,149 @@ + 1 .file "diskio.c"
+ 2 __SREG__ = 0x3f
+ 3 __SP_H__ = 0x3e
+ 4 __SP_L__ = 0x3d
+ 5 __CCP__ = 0x34
+ 6 __tmp_reg__ = 0
+ 7 __zero_reg__ = 1
+ 15 .Ltext0:
+ 16 .section .text.disk_initialize,"ax",@progbits
+ 17 .global disk_initialize
+ 19 disk_initialize:
+ 20 .LFB54:
+ 21 .LSM0:
+ 22 .LVL0:
+ 23 /* prologue: function */
+ 24 /* frame size = 0 */
+ 25 .LSM1:
+ 26 0000 80E0 ldi r24,lo8(0)
+ 27 .LVL1:
+ 28 /* epilogue start */
+ 29 0002 0895 ret
+ 30 .LFE54:
+ 32 .section .text.disk_status,"ax",@progbits
+ 33 .global disk_status
+ 35 disk_status:
+ 36 .LFB55:
+ 37 .LSM2:
+ 38 .LVL2:
+ 39 /* prologue: function */
+ 40 /* frame size = 0 */
+ 41 .LSM3:
+ 42 0000 80E0 ldi r24,lo8(0)
+ 43 .LVL3:
+ 44 /* epilogue start */
+ 45 0002 0895 ret
+ 46 .LFE55:
+ 48 .section .text.disk_ioctl,"ax",@progbits
+ 49 .global disk_ioctl
+ 51 disk_ioctl:
+ 52 .LFB58:
+ 53 .LSM4:
+ 54 .LVL4:
+ 55 /* prologue: function */
+ 56 /* frame size = 0 */
+ 57 .LSM5:
+ 58 0000 6623 tst r22
+ 59 0002 01F0 breq .L6
+ 60 0004 84E0 ldi r24,lo8(4)
+ 61 .LVL5:
+ 62 0006 0895 ret
+ 63 .LVL6:
+ 64 .L6:
+ 65 0008 80E0 ldi r24,lo8(0)
+ 66 .LVL7:
+ 67 .LSM6:
+ 68 000a 0895 ret
+ 69 .LFE58:
+ 71 .section .text.get_fattime,"ax",@progbits
+ 72 .global get_fattime
+ 74 get_fattime:
+ 75 .LFB59:
+ 76 .LSM7:
+ 77 /* prologue: function */
+ 78 /* frame size = 0 */
+ 79 .LSM8:
+ 80 0000 61E2 ldi r22,lo8(35719201)
+ 81 0002 78E0 ldi r23,hi8(35719201)
+ 82 0004 81E2 ldi r24,hlo8(35719201)
+ 83 0006 92E0 ldi r25,hhi8(35719201)
+ 84 /* epilogue start */
+ 85 0008 0895 ret
+ 86 .LFE59:
+ 88 .section .text.disk_write,"ax",@progbits
+ 89 .global disk_write
+ 91 disk_write:
+ 92 .LFB57:
+ 93 .LSM9:
+ 94 .LVL8:
+ 95 0000 0F93 push r16
+ 96 .LVL9:
+ 97 /* prologue: function */
+ 98 /* frame size = 0 */
+ 99 0002 FB01 movw r30,r22
+ 100 .LSM10:
+ 101 0004 CA01 movw r24,r20
+ 102 0006 B901 movw r22,r18
+ 103 .LVL10:
+ 104 0008 402F mov r20,r16
+ 105 .LVL11:
+ 106 000a 50E0 ldi r21,lo8(0)
+ 107 000c 9F01 movw r18,r30
+ 108 .LVL12:
+ 109 000e 0E94 0000 call DataflashManager_WriteBlocks_RAM
+ 110 .LVL13:
+ 111 .LSM11:
+ 112 0012 80E0 ldi r24,lo8(0)
+ 113 /* epilogue start */
+ 114 0014 0F91 pop r16
+ 115 .LVL14:
+ 116 0016 0895 ret
+ 117 .LFE57:
+ 119 .section .text.disk_read,"ax",@progbits
+ 120 .global disk_read
+ 122 disk_read:
+ 123 .LFB56:
+ 124 .LSM12:
+ 125 .LVL15:
+ 126 0000 0F93 push r16
+ 127 .LVL16:
+ 128 /* prologue: function */
+ 129 /* frame size = 0 */
+ 130 0002 FB01 movw r30,r22
+ 131 .LSM13:
+ 132 0004 CA01 movw r24,r20
+ 133 0006 B901 movw r22,r18
+ 134 .LVL17:
+ 135 0008 402F mov r20,r16
+ 136 .LVL18:
+ 137 000a 50E0 ldi r21,lo8(0)
+ 138 000c 9F01 movw r18,r30
+ 139 .LVL19:
+ 140 000e 0E94 0000 call DataflashManager_ReadBlocks_RAM
+ 141 .LVL20:
+ 142 .LSM14:
+ 143 0012 80E0 ldi r24,lo8(0)
+ 144 /* epilogue start */
+ 145 0014 0F91 pop r16
+ 146 .LVL21:
+ 147 0016 0895 ret
+ 148 .LFE56:
+ 214 .Letext0:
+DEFINED SYMBOLS
+ *ABS*:00000000 diskio.c
+C:\Users\Dean\AppData\Local\Temp/cc5TUdwu.s:2 *ABS*:0000003f __SREG__
+C:\Users\Dean\AppData\Local\Temp/cc5TUdwu.s:3 *ABS*:0000003e __SP_H__
+C:\Users\Dean\AppData\Local\Temp/cc5TUdwu.s:4 *ABS*:0000003d __SP_L__
+C:\Users\Dean\AppData\Local\Temp/cc5TUdwu.s:5 *ABS*:00000034 __CCP__
+C:\Users\Dean\AppData\Local\Temp/cc5TUdwu.s:6 *ABS*:00000000 __tmp_reg__
+C:\Users\Dean\AppData\Local\Temp/cc5TUdwu.s:7 *ABS*:00000001 __zero_reg__
+C:\Users\Dean\AppData\Local\Temp/cc5TUdwu.s:19 .text.disk_initialize:00000000 disk_initialize
+C:\Users\Dean\AppData\Local\Temp/cc5TUdwu.s:35 .text.disk_status:00000000 disk_status
+C:\Users\Dean\AppData\Local\Temp/cc5TUdwu.s:51 .text.disk_ioctl:00000000 disk_ioctl
+C:\Users\Dean\AppData\Local\Temp/cc5TUdwu.s:74 .text.get_fattime:00000000 get_fattime
+C:\Users\Dean\AppData\Local\Temp/cc5TUdwu.s:91 .text.disk_write:00000000 disk_write
+C:\Users\Dean\AppData\Local\Temp/cc5TUdwu.s:122 .text.disk_read:00000000 disk_read
+
+UNDEFINED SYMBOLS
+DataflashManager_WriteBlocks_RAM
+DataflashManager_ReadBlocks_RAM
diff --git a/Projects/Webserver/Lib/FATFs/ff.c b/Projects/Webserver/Lib/FATFs/ff.c new file mode 100644 index 000000000..6382fea1f --- /dev/null +++ b/Projects/Webserver/Lib/FATFs/ff.c @@ -0,0 +1,3153 @@ +/*----------------------------------------------------------------------------/
+/ FatFs - FAT file system module R0.07e (C)ChaN, 2010
+/-----------------------------------------------------------------------------/
+/ FatFs module is a generic FAT file system module for small embedded systems.
+/ This is a free software that opened for education, research and commercial
+/ developments under license policy of following trems.
+/
+/ Copyright (C) 2010, ChaN, all right reserved.
+/
+/ * The FatFs module is a free software and there is NO WARRANTY.
+/ * No restriction on use. You can use, modify and redistribute it for
+/ personal, non-profit or commercial products UNDER YOUR RESPONSIBILITY.
+/ * Redistributions of source code must retain the above copyright notice.
+/
+/-----------------------------------------------------------------------------/
+/ Feb 26,'06 R0.00 Prototype.
+/
+/ Apr 29,'06 R0.01 First stable version.
+/
+/ Jun 01,'06 R0.02 Added FAT12 support.
+/ Removed unbuffered mode.
+/ Fixed a problem on small (<32M) patition.
+/ Jun 10,'06 R0.02a Added a configuration option (_FS_MINIMUM).
+/
+/ Sep 22,'06 R0.03 Added f_rename().
+/ Changed option _FS_MINIMUM to _FS_MINIMIZE.
+/ Dec 11,'06 R0.03a Improved cluster scan algolithm to write files fast.
+/ Fixed f_mkdir() creates incorrect directory on FAT32.
+/
+/ Feb 04,'07 R0.04 Supported multiple drive system.
+/ Changed some interfaces for multiple drive system.
+/ Changed f_mountdrv() to f_mount().
+/ Added f_mkfs().
+/ Apr 01,'07 R0.04a Supported multiple partitions on a plysical drive.
+/ Added a capability of extending file size to f_lseek().
+/ Added minimization level 3.
+/ Fixed an endian sensitive code in f_mkfs().
+/ May 05,'07 R0.04b Added a configuration option _USE_NTFLAG.
+/ Added FSInfo support.
+/ Fixed DBCS name can result FR_INVALID_NAME.
+/ Fixed short seek (<= csize) collapses the file object.
+/
+/ Aug 25,'07 R0.05 Changed arguments of f_read(), f_write() and f_mkfs().
+/ Fixed f_mkfs() on FAT32 creates incorrect FSInfo.
+/ Fixed f_mkdir() on FAT32 creates incorrect directory.
+/ Feb 03,'08 R0.05a Added f_truncate() and f_utime().
+/ Fixed off by one error at FAT sub-type determination.
+/ Fixed btr in f_read() can be mistruncated.
+/ Fixed cached sector is not flushed when create and close
+/ without write.
+/
+/ Apr 01,'08 R0.06 Added fputc(), fputs(), fprintf() and fgets().
+/ Improved performance of f_lseek() on moving to the same
+/ or following cluster.
+/
+/ Apr 01,'09 R0.07 Merged Tiny-FatFs as a buffer configuration option.
+/ Added long file name support.
+/ Added multiple code page support.
+/ Added re-entrancy for multitask operation.
+/ Added auto cluster size selection to f_mkfs().
+/ Added rewind option to f_readdir().
+/ Changed result code of critical errors.
+/ Renamed string functions to avoid name collision.
+/ Apr 14,'09 R0.07a Separated out OS dependent code on reentrant cfg.
+/ Added multiple sector size support.
+/ Jun 21,'09 R0.07c Fixed f_unlink() can return FR_OK on error.
+/ Fixed wrong cache control in f_lseek().
+/ Added relative path feature.
+/ Added f_chdir() and f_chdrive().
+/ Added proper case conversion to extended char.
+/ Nov 03,'09 R0.07e Separated out configuration options from ff.h to ffconf.h.
+/ Fixed f_unlink() fails to remove a sub-dir on _FS_RPATH.
+/ Fixed name matching error on the 13 char boundary.
+/ Added a configuration option, _LFN_UNICODE.
+/ Changed f_readdir() to return the SFN with always upper
+/ case on non-LFN cfg.
+/---------------------------------------------------------------------------*/
+
+#include "ff.h" /* FatFs configurations and declarations */
+#include "diskio.h" /* Declarations of low level disk I/O functions */
+
+/*--------------------------------------------------------------------------
+
+ Module Private Definitions
+
+---------------------------------------------------------------------------*/
+
+#if _FATFS != 0x007E
+#error Wrong include file (ff.h).
+#endif
+
+#if _FS_REENTRANT
+#if _USE_LFN == 1
+#error Static LFN work area must not be used in re-entrant configuration.
+#endif
+#define ENTER_FF(fs) { if (!lock_fs(fs)) return FR_TIMEOUT; }
+#define LEAVE_FF(fs, res) { unlock_fs(fs, res); return res; }
+
+#else
+#define ENTER_FF(fs)
+#define LEAVE_FF(fs, res) return res
+
+#endif
+
+#define ABORT(fs, res) { fp->flag |= FA__ERROR; LEAVE_FF(fs, res); }
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+/* Name status flags */
+#define NS 11 /* Offset of name status byte */
+#define NS_LOSS 0x01 /* Out of 8.3 format */
+#define NS_LFN 0x02 /* Force to create LFN entry */
+#define NS_LAST 0x04 /* Last segment */
+#define NS_BODY 0x08 /* Lower case flag (body) */
+#define NS_EXT 0x10 /* Lower case flag (ext) */
+#define NS_DOT 0x20 /* Dot entry */
+
+
+
+
+/*--------------------------------------------------------------------------
+
+ Private Work Area
+
+---------------------------------------------------------------------------*/
+
+#if _DRIVES < 1 || _DRIVES > 9
+#error Number of drives must be 1-9.
+#endif
+static
+FATFS *FatFs[_DRIVES]; /* Pointer to the file system objects (logical drives) */
+
+static
+WORD Fsid; /* File system mount ID */
+
+#if _FS_RPATH
+static
+BYTE Drive; /* Current drive */
+#endif
+
+
+#if _USE_LFN == 1 /* LFN with static LFN working buffer */
+static
+WCHAR LfnBuf[_MAX_LFN + 1];
+#define NAMEBUF(sp,lp) BYTE sp[12]; WCHAR *lp = LfnBuf
+#define INITBUF(dj,sp,lp) dj.fn = sp; dj.lfn = lp
+
+#elif _USE_LFN > 1 /* LFN with dynamic LFN working buffer */
+#define NAMEBUF(sp,lp) BYTE sp[12]; WCHAR lbuf[_MAX_LFN + 1], *lp = lbuf
+#define INITBUF(dj,sp,lp) dj.fn = sp; dj.lfn = lp
+
+#else /* No LFN */
+#define NAMEBUF(sp,lp) BYTE sp[12]
+#define INITBUF(dj,sp,lp) dj.fn = sp
+
+#endif
+
+
+
+
+/*--------------------------------------------------------------------------
+
+ Module Private Functions
+
+---------------------------------------------------------------------------*/
+
+
+/*-----------------------------------------------------------------------*/
+/* String functions */
+/*-----------------------------------------------------------------------*/
+
+/* Copy memory to memory */
+static
+void mem_cpy (void* dst, const void* src, int cnt) {
+ char *d = (char*)dst;
+ const char *s = (const char *)src;
+ while (cnt--) *d++ = *s++;
+}
+
+/* Fill memory */
+static
+void mem_set (void* dst, int val, int cnt) {
+ char *d = (char*)dst;
+ while (cnt--) *d++ = (char)val;
+}
+
+/* Compare memory to memory */
+static
+int mem_cmp (const void* dst, const void* src, int cnt) {
+ const char *d = (const char *)dst, *s = (const char *)src;
+ int r = 0;
+ while (cnt-- && (r = *d++ - *s++) == 0) ;
+ return r;
+}
+
+/* Check if chr is contained in the string */
+static
+int chk_chr (const char* str, int chr) {
+ while (*str && *str != chr) str++;
+ return *str;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Request/Release grant to access the volume */
+/*-----------------------------------------------------------------------*/
+#if _FS_REENTRANT
+
+static
+BOOL lock_fs (
+ FATFS *fs /* File system object */
+)
+{
+ return ff_req_grant(fs->sobj);
+}
+
+
+static
+void unlock_fs (
+ FATFS *fs, /* File system object */
+ FRESULT res /* Result code to be returned */
+)
+{
+ if (res != FR_NOT_ENABLED &&
+ res != FR_INVALID_DRIVE &&
+ res != FR_INVALID_OBJECT &&
+ res != FR_TIMEOUT) {
+ ff_rel_grant(fs->sobj);
+ }
+}
+#endif
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Change window offset */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT move_window (
+ FATFS *fs, /* File system object */
+ DWORD sector /* Sector number to make apperance in the fs->win[] */
+) /* Move to zero only writes back dirty window */
+{
+ DWORD wsect;
+
+
+ wsect = fs->winsect;
+ if (wsect != sector) { /* Changed current window */
+#if !_FS_READONLY
+ if (fs->wflag) { /* Write back dirty window if needed */
+ if (disk_write(fs->drive, fs->win, wsect, 1) != RES_OK)
+ return FR_DISK_ERR;
+ fs->wflag = 0;
+ if (wsect < (fs->fatbase + fs->sects_fat)) { /* In FAT area */
+ BYTE nf;
+ for (nf = fs->n_fats; nf > 1; nf--) { /* Refrect the change to all FAT copies */
+ wsect += fs->sects_fat;
+ disk_write(fs->drive, fs->win, wsect, 1);
+ }
+ }
+ }
+#endif
+ if (sector) {
+ if (disk_read(fs->drive, fs->win, sector, 1) != RES_OK)
+ return FR_DISK_ERR;
+ fs->winsect = sector;
+ }
+ }
+
+ return FR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Clean-up cached data */
+/*-----------------------------------------------------------------------*/
+#if !_FS_READONLY
+static
+FRESULT sync ( /* FR_OK: successful, FR_DISK_ERR: failed */
+ FATFS *fs /* File system object */
+)
+{
+ FRESULT res;
+
+
+ res = move_window(fs, 0);
+ if (res == FR_OK) {
+ /* Update FSInfo sector if needed */
+ if (fs->fs_type == FS_FAT32 && fs->fsi_flag) {
+ fs->winsect = 0;
+ mem_set(fs->win, 0, 512);
+ ST_WORD(fs->win+BS_55AA, 0xAA55);
+ ST_DWORD(fs->win+FSI_LeadSig, 0x41615252);
+ ST_DWORD(fs->win+FSI_StrucSig, 0x61417272);
+ ST_DWORD(fs->win+FSI_Free_Count, fs->free_clust);
+ ST_DWORD(fs->win+FSI_Nxt_Free, fs->last_clust);
+ disk_write(fs->drive, fs->win, fs->fsi_sector, 1);
+ fs->fsi_flag = 0;
+ }
+ /* Make sure that no pending write process in the physical drive */
+ if (disk_ioctl(fs->drive, CTRL_SYNC, (void*)NULL) != RES_OK)
+ res = FR_DISK_ERR;
+ }
+
+ return res;
+}
+#endif
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* FAT access - Read value of a FAT entry */
+/*-----------------------------------------------------------------------*/
+
+
+DWORD get_fat ( /* 0xFFFFFFFF:Disk error, 1:Interal error, Else:Cluster status */
+ FATFS *fs, /* File system object */
+ DWORD clst /* Cluster# to get the link information */
+)
+{
+ UINT wc, bc;
+ DWORD fsect;
+
+
+ if (clst < 2 || clst >= fs->max_clust) /* Range check */
+ return 1;
+
+ fsect = fs->fatbase;
+ switch (fs->fs_type) {
+ case FS_FAT12 :
+ bc = clst; bc += bc / 2;
+ if (move_window(fs, fsect + (bc / SS(fs)))) break;
+ wc = fs->win[bc & (SS(fs) - 1)]; bc++;
+ if (move_window(fs, fsect + (bc / SS(fs)))) break;
+ wc |= (WORD)fs->win[bc & (SS(fs) - 1)] << 8;
+ return (clst & 1) ? (wc >> 4) : (wc & 0xFFF);
+
+ case FS_FAT16 :
+ if (move_window(fs, fsect + (clst / (SS(fs) / 2)))) break;
+ return LD_WORD(&fs->win[((WORD)clst * 2) & (SS(fs) - 1)]);
+
+ case FS_FAT32 :
+ if (move_window(fs, fsect + (clst / (SS(fs) / 4)))) break;
+ return LD_DWORD(&fs->win[((WORD)clst * 4) & (SS(fs) - 1)]) & 0x0FFFFFFF;
+ }
+
+ return 0xFFFFFFFF; /* An error occured at the disk I/O layer */
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* FAT access - Change value of a FAT entry */
+/*-----------------------------------------------------------------------*/
+#if !_FS_READONLY
+
+FRESULT put_fat (
+ FATFS *fs, /* File system object */
+ DWORD clst, /* Cluster# to be changed in range of 2 to fs->max_clust - 1 */
+ DWORD val /* New value to mark the cluster */
+)
+{
+ UINT bc;
+ BYTE *p;
+ DWORD fsect;
+ FRESULT res;
+
+
+ if (clst < 2 || clst >= fs->max_clust) { /* Range check */
+ res = FR_INT_ERR;
+
+ } else {
+ fsect = fs->fatbase;
+ switch (fs->fs_type) {
+ case FS_FAT12 :
+ bc = clst; bc += bc / 2;
+ res = move_window(fs, fsect + (bc / SS(fs)));
+ if (res != FR_OK) break;
+ p = &fs->win[bc & (SS(fs) - 1)];
+ *p = (clst & 1) ? ((*p & 0x0F) | ((BYTE)val << 4)) : (BYTE)val;
+ bc++;
+ fs->wflag = 1;
+ res = move_window(fs, fsect + (bc / SS(fs)));
+ if (res != FR_OK) break;
+ p = &fs->win[bc & (SS(fs) - 1)];
+ *p = (clst & 1) ? (BYTE)(val >> 4) : ((*p & 0xF0) | ((BYTE)(val >> 8) & 0x0F));
+ break;
+
+ case FS_FAT16 :
+ res = move_window(fs, fsect + (clst / (SS(fs) / 2)));
+ if (res != FR_OK) break;
+ ST_WORD(&fs->win[((WORD)clst * 2) & (SS(fs) - 1)], (WORD)val);
+ break;
+
+ case FS_FAT32 :
+ res = move_window(fs, fsect + (clst / (SS(fs) / 4)));
+ if (res != FR_OK) break;
+ ST_DWORD(&fs->win[((WORD)clst * 4) & (SS(fs) - 1)], val);
+ break;
+
+ default :
+ res = FR_INT_ERR;
+ }
+ fs->wflag = 1;
+ }
+
+ return res;
+}
+#endif /* !_FS_READONLY */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* FAT handling - Remove a cluster chain */
+/*-----------------------------------------------------------------------*/
+#if !_FS_READONLY
+static
+FRESULT remove_chain (
+ FATFS *fs, /* File system object */
+ DWORD clst /* Cluster# to remove a chain from */
+)
+{
+ FRESULT res;
+ DWORD nxt;
+
+
+ if (clst < 2 || clst >= fs->max_clust) { /* Check the range of cluster# */
+ res = FR_INT_ERR;
+
+ } else {
+ res = FR_OK;
+ while (clst < fs->max_clust) { /* Not a last link? */
+ nxt = get_fat(fs, clst); /* Get cluster status */
+ if (nxt == 0) break; /* Empty cluster? */
+ if (nxt == 1) { res = FR_INT_ERR; break; } /* Internal error? */
+ if (nxt == 0xFFFFFFFF) { res = FR_DISK_ERR; break; } /* Disk error? */
+ res = put_fat(fs, clst, 0); /* Mark the cluster "empty" */
+ if (res != FR_OK) break;
+ if (fs->free_clust != 0xFFFFFFFF) { /* Update FSInfo */
+ fs->free_clust++;
+ fs->fsi_flag = 1;
+ }
+ clst = nxt; /* Next cluster */
+ }
+ }
+
+ return res;
+}
+#endif
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* FAT handling - Stretch or Create a cluster chain */
+/*-----------------------------------------------------------------------*/
+#if !_FS_READONLY
+static
+DWORD create_chain ( /* 0:No free cluster, 1:Internal error, 0xFFFFFFFF:Disk error, >=2:New cluster# */
+ FATFS *fs, /* File system object */
+ DWORD clst /* Cluster# to stretch. 0 means create a new chain. */
+)
+{
+ DWORD cs, ncl, scl, mcl;
+
+
+ mcl = fs->max_clust;
+ if (clst == 0) { /* Create new chain */
+ scl = fs->last_clust; /* Get suggested start point */
+ if (scl == 0 || scl >= mcl) scl = 1;
+ }
+ else { /* Stretch existing chain */
+ cs = get_fat(fs, clst); /* Check the cluster status */
+ if (cs < 2) return 1; /* It is an invalid cluster */
+ if (cs < mcl) return cs; /* It is already followed by next cluster */
+ scl = clst;
+ }
+
+ ncl = scl; /* Start cluster */
+ for (;;) {
+ ncl++; /* Next cluster */
+ if (ncl >= mcl) { /* Wrap around */
+ ncl = 2;
+ if (ncl > scl) return 0; /* No free custer */
+ }
+ cs = get_fat(fs, ncl); /* Get the cluster status */
+ if (cs == 0) break; /* Found a free cluster */
+ if (cs == 0xFFFFFFFF || cs == 1)/* An error occured */
+ return cs;
+ if (ncl == scl) return 0; /* No free custer */
+ }
+
+ if (put_fat(fs, ncl, 0x0FFFFFFF)) /* Mark the new cluster "in use" */
+ return 0xFFFFFFFF;
+ if (clst != 0) { /* Link it to the previous one if needed */
+ if (put_fat(fs, clst, ncl))
+ return 0xFFFFFFFF;
+ }
+
+ fs->last_clust = ncl; /* Update FSINFO */
+ if (fs->free_clust != 0xFFFFFFFF) {
+ fs->free_clust--;
+ fs->fsi_flag = 1;
+ }
+
+ return ncl; /* Return new cluster number */
+}
+#endif /* !_FS_READONLY */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Get sector# from cluster# */
+/*-----------------------------------------------------------------------*/
+
+
+DWORD clust2sect ( /* !=0: Sector number, 0: Failed - invalid cluster# */
+ FATFS *fs, /* File system object */
+ DWORD clst /* Cluster# to be converted */
+)
+{
+ clst -= 2;
+ if (clst >= (fs->max_clust - 2)) return 0; /* Invalid cluster# */
+ return clst * fs->csize + fs->database;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Directory handling - Seek directory index */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_seek (
+ DIR *dj, /* Pointer to directory object */
+ WORD idx /* Directory index number */
+)
+{
+ DWORD clst;
+ WORD ic;
+
+
+ dj->index = idx;
+ clst = dj->sclust;
+ if (clst == 1 || clst >= dj->fs->max_clust) /* Check start cluster range */
+ return FR_INT_ERR;
+ if (!clst && dj->fs->fs_type == FS_FAT32) /* Replace cluster# 0 with root cluster# if in FAT32 */
+ clst = dj->fs->dirbase;
+
+ if (clst == 0) { /* Static table */
+ dj->clust = clst;
+ if (idx >= dj->fs->n_rootdir) /* Index is out of range */
+ return FR_INT_ERR;
+ dj->sect = dj->fs->dirbase + idx / (SS(dj->fs) / 32); /* Sector# */
+ }
+ else { /* Dynamic table */
+ ic = SS(dj->fs) / 32 * dj->fs->csize; /* Entries per cluster */
+ while (idx >= ic) { /* Follow cluster chain */
+ clst = get_fat(dj->fs, clst); /* Get next cluster */
+ if (clst == 0xFFFFFFFF) return FR_DISK_ERR; /* Disk error */
+ if (clst < 2 || clst >= dj->fs->max_clust) /* Reached to end of table or int error */
+ return FR_INT_ERR;
+ idx -= ic;
+ }
+ dj->clust = clst;
+ dj->sect = clust2sect(dj->fs, clst) + idx / (SS(dj->fs) / 32); /* Sector# */
+ }
+
+ dj->dir = dj->fs->win + (idx % (SS(dj->fs) / 32)) * 32; /* Ptr to the entry in the sector */
+
+ return FR_OK; /* Seek succeeded */
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Directory handling - Move directory index next */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_next ( /* FR_OK:Succeeded, FR_NO_FILE:End of table, FR_DENIED:EOT and could not streach */
+ DIR *dj, /* Pointer to directory object */
+ BOOL streach /* FALSE: Do not streach table, TRUE: Streach table if needed */
+)
+{
+ DWORD clst;
+ WORD i;
+
+
+ i = dj->index + 1;
+ if (!i || !dj->sect) /* Report EOT when index has reached 65535 */
+ return FR_NO_FILE;
+
+ if (!(i % (SS(dj->fs) / 32))) { /* Sector changed? */
+ dj->sect++; /* Next sector */
+
+ if (dj->clust == 0) { /* Static table */
+ if (i >= dj->fs->n_rootdir) /* Report EOT when end of table */
+ return FR_NO_FILE;
+ }
+ else { /* Dynamic table */
+ if (((i / (SS(dj->fs) / 32)) & (dj->fs->csize - 1)) == 0) { /* Cluster changed? */
+ clst = get_fat(dj->fs, dj->clust); /* Get next cluster */
+ if (clst <= 1) return FR_INT_ERR;
+ if (clst == 0xFFFFFFFF) return FR_DISK_ERR;
+ if (clst >= dj->fs->max_clust) { /* When it reached end of dynamic table */
+#if !_FS_READONLY
+ BYTE c;
+ if (!streach) return FR_NO_FILE; /* When do not streach, report EOT */
+ clst = create_chain(dj->fs, dj->clust); /* Streach cluster chain */
+ if (clst == 0) return FR_DENIED; /* No free cluster */
+ if (clst == 1) return FR_INT_ERR;
+ if (clst == 0xFFFFFFFF) return FR_DISK_ERR;
+ /* Clean-up streached table */
+ if (move_window(dj->fs, 0)) return FR_DISK_ERR; /* Flush active window */
+ mem_set(dj->fs->win, 0, SS(dj->fs)); /* Clear window buffer */
+ dj->fs->winsect = clust2sect(dj->fs, clst); /* Cluster start sector */
+ for (c = 0; c < dj->fs->csize; c++) { /* Fill the new cluster with 0 */
+ dj->fs->wflag = 1;
+ if (move_window(dj->fs, 0)) return FR_DISK_ERR;
+ dj->fs->winsect++;
+ }
+ dj->fs->winsect -= c; /* Rewind window address */
+#else
+ return FR_NO_FILE; /* Report EOT */
+#endif
+ }
+ dj->clust = clst; /* Initialize data for new cluster */
+ dj->sect = clust2sect(dj->fs, clst);
+ }
+ }
+ }
+
+ dj->index = i;
+ dj->dir = dj->fs->win + (i % (SS(dj->fs) / 32)) * 32;
+
+ return FR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* LFN handling - Test/Pick/Fit an LFN segment from/to directory entry */
+/*-----------------------------------------------------------------------*/
+#if _USE_LFN
+static
+const BYTE LfnOfs[] = {1,3,5,7,9,14,16,18,20,22,24,28,30}; /* Offset of LFN chars in the directory entry */
+
+
+static
+BOOL cmp_lfn ( /* TRUE:Matched, FALSE:Not matched */
+ WCHAR *lfnbuf, /* Pointer to the LFN to be compared */
+ BYTE *dir /* Pointer to the directory entry containing a part of LFN */
+)
+{
+ int i, s;
+ WCHAR wc, uc;
+
+
+ i = ((dir[LDIR_Ord] & 0xBF) - 1) * 13; /* Get offset in the LFN buffer */
+ s = 0; wc = 1;
+ do {
+ uc = LD_WORD(dir+LfnOfs[s]); /* Pick an LFN character from the entry */
+ if (wc) { /* Last char has not been processed */
+ wc = ff_wtoupper(uc); /* Convert it to upper case */
+ if (i >= _MAX_LFN || wc != ff_wtoupper(lfnbuf[i++])) /* Compare it */
+ return FALSE; /* Not matched */
+ } else {
+ if (uc != 0xFFFF) return FALSE; /* Check filler */
+ }
+ } while (++s < 13); /* Repeat until all chars in the entry are checked */
+
+ if ((dir[LDIR_Ord] & 0x40) && wc && lfnbuf[i]) /* Last segment matched but different length */
+ return FALSE;
+
+ return TRUE; /* The part of LFN matched */
+}
+
+
+
+static
+BOOL pick_lfn ( /* TRUE:Succeeded, FALSE:Buffer overflow */
+ WCHAR *lfnbuf, /* Pointer to the Unicode-LFN buffer */
+ BYTE *dir /* Pointer to the directory entry */
+)
+{
+ int i, s;
+ WCHAR wc, uc;
+
+
+ i = ((dir[LDIR_Ord] & 0x3F) - 1) * 13; /* Offset in the LFN buffer */
+
+ s = 0; wc = 1;
+ do {
+ uc = LD_WORD(dir+LfnOfs[s]); /* Pick an LFN character from the entry */
+ if (wc) { /* Last char has not been processed */
+ if (i >= _MAX_LFN) return FALSE; /* Buffer overflow? */
+ lfnbuf[i++] = wc = uc; /* Store it */
+ } else {
+ if (uc != 0xFFFF) return FALSE; /* Check filler */
+ }
+ } while (++s < 13); /* Read all character in the entry */
+
+ if (dir[LDIR_Ord] & 0x40) { /* Put terminator if it is the last LFN part */
+ if (i >= _MAX_LFN) return FALSE; /* Buffer overflow? */
+ lfnbuf[i] = 0;
+ }
+
+ return TRUE;
+}
+
+
+#if !_FS_READONLY
+static
+void fit_lfn (
+ const WCHAR *lfnbuf, /* Pointer to the LFN buffer */
+ BYTE *dir, /* Pointer to the directory entry */
+ BYTE ord, /* LFN order (1-20) */
+ BYTE sum /* SFN sum */
+)
+{
+ int i, s;
+ WCHAR wc;
+
+
+ dir[LDIR_Chksum] = sum; /* Set check sum */
+ dir[LDIR_Attr] = AM_LFN; /* Set attribute. LFN entry */
+ dir[LDIR_Type] = 0;
+ ST_WORD(dir+LDIR_FstClusLO, 0);
+
+ i = (ord - 1) * 13; /* Get offset in the LFN buffer */
+ s = wc = 0;
+ do {
+ if (wc != 0xFFFF) wc = lfnbuf[i++]; /* Get an effective char */
+ ST_WORD(dir+LfnOfs[s], wc); /* Put it */
+ if (!wc) wc = 0xFFFF; /* Padding chars following last char */
+ } while (++s < 13);
+ if (wc == 0xFFFF || !lfnbuf[i]) ord |= 0x40; /* Bottom LFN part is the start of LFN sequence */
+ dir[LDIR_Ord] = ord; /* Set the LFN order */
+}
+
+#endif
+#endif
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Create numbered name */
+/*-----------------------------------------------------------------------*/
+#if _USE_LFN
+void gen_numname (
+ BYTE *dst, /* Pointer to genartated SFN */
+ const BYTE *src, /* Pointer to source SFN to be modified */
+ const WCHAR *lfn, /* Pointer to LFN */
+ WORD num /* Sequense number */
+)
+{
+ char ns[8];
+ int i, j;
+
+
+ mem_cpy(dst, src, 11);
+
+ if (num > 5) { /* On many collisions, generate a hash number instead of sequencial number */
+ do num = (num >> 1) + (num << 15) + (WORD)*lfn++; while (*lfn);
+ }
+
+ /* itoa */
+ i = 7;
+ do {
+ ns[i--] = (num % 10) + '0';
+ num /= 10;
+ } while (num);
+ ns[i] = '~';
+
+ /* Append the number */
+ for (j = 0; j < i && dst[j] != ' '; j++) {
+ if (IsDBCS1(dst[j])) {
+ if (j == i - 1) break;
+ j++;
+ }
+ }
+ do {
+ dst[j++] = (i < 8) ? ns[i++] : ' ';
+ } while (j < 8);
+}
+#endif
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Calculate sum of an SFN */
+/*-----------------------------------------------------------------------*/
+#if _USE_LFN
+static
+BYTE sum_sfn (
+ const BYTE *dir /* Ptr to directory entry */
+)
+{
+ BYTE sum = 0;
+ int n = 11;
+
+ do sum = (sum >> 1) + (sum << 7) + *dir++; while (--n);
+ return sum;
+}
+#endif
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Directory handling - Find an object in the directory */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_find (
+ DIR *dj /* Pointer to the directory object linked to the file name */
+)
+{
+ FRESULT res;
+ BYTE c, *dir;
+#if _USE_LFN
+ BYTE a, ord, sum;
+#endif
+
+ res = dir_seek(dj, 0); /* Rewind directory object */
+ if (res != FR_OK) return res;
+
+#if _USE_LFN
+ ord = sum = 0xFF;
+#endif
+ do {
+ res = move_window(dj->fs, dj->sect);
+ if (res != FR_OK) break;
+ dir = dj->dir; /* Ptr to the directory entry of current index */
+ c = dir[DIR_Name];
+ if (c == 0) { res = FR_NO_FILE; break; } /* Reached to end of table */
+#if _USE_LFN /* LFN configuration */
+ a = dir[DIR_Attr] & AM_MASK;
+ if (c == 0xE5 || ((a & AM_VOL) && a != AM_LFN)) { /* An entry without valid data */
+ ord = 0xFF;
+ } else {
+ if (a == AM_LFN) { /* An LFN entry is found */
+ if (dj->lfn) {
+ if (c & 0x40) { /* Is it start of LFN sequence? */
+ sum = dir[LDIR_Chksum];
+ c &= 0xBF; ord = c; /* LFN start order */
+ dj->lfn_idx = dj->index;
+ }
+ /* Check validity of the LFN entry and compare it with given name */
+ ord = (c == ord && sum == dir[LDIR_Chksum] && cmp_lfn(dj->lfn, dir)) ? ord - 1 : 0xFF;
+ }
+ } else { /* An SFN entry is found */
+ if (!ord && sum == sum_sfn(dir)) break; /* LFN matched? */
+ ord = 0xFF; dj->lfn_idx = 0xFFFF; /* Reset LFN sequence */
+ if (!(dj->fn[NS] & NS_LOSS) && !mem_cmp(dir, dj->fn, 11)) break; /* SFN matched? */
+ }
+ }
+#else /* Non LFN configuration */
+ if (!(dir[DIR_Attr] & AM_VOL) && !mem_cmp(dir, dj->fn, 11)) /* Is it a valid entry? */
+ break;
+#endif
+ res = dir_next(dj, FALSE); /* Next entry */
+ } while (res == FR_OK);
+
+ return res;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read an object from the directory */
+/*-----------------------------------------------------------------------*/
+#if _FS_MINIMIZE <= 1
+static
+FRESULT dir_read (
+ DIR *dj /* Pointer to the directory object that pointing the entry to be read */
+)
+{
+ FRESULT res;
+ BYTE c, *dir;
+#if _USE_LFN
+ BYTE a, ord = 0xFF, sum = 0xFF;
+#endif
+
+ res = FR_NO_FILE;
+ while (dj->sect) {
+ res = move_window(dj->fs, dj->sect);
+ if (res != FR_OK) break;
+ dir = dj->dir; /* Ptr to the directory entry of current index */
+ c = dir[DIR_Name];
+ if (c == 0) { res = FR_NO_FILE; break; } /* Reached to end of table */
+#if _USE_LFN /* LFN configuration */
+ a = dir[DIR_Attr] & AM_MASK;
+ if (c == 0xE5 || (!_FS_RPATH && c == '.') || ((a & AM_VOL) && a != AM_LFN)) { /* An entry without valid data */
+ ord = 0xFF;
+ } else {
+ if (a == AM_LFN) { /* An LFN entry is found */
+ if (c & 0x40) { /* Is it start of LFN sequence? */
+ sum = dir[LDIR_Chksum];
+ c &= 0xBF; ord = c;
+ dj->lfn_idx = dj->index;
+ }
+ /* Check LFN validity and capture it */
+ ord = (c == ord && sum == dir[LDIR_Chksum] && pick_lfn(dj->lfn, dir)) ? ord - 1 : 0xFF;
+ } else { /* An SFN entry is found */
+ if (ord || sum != sum_sfn(dir)) /* Is there a valid LFN? */
+ dj->lfn_idx = 0xFFFF; /* It has no LFN. */
+ break;
+ }
+ }
+#else /* Non LFN configuration */
+ if (c != 0xE5 && (_FS_RPATH || c != '.') && !(dir[DIR_Attr] & AM_VOL)) /* Is it a valid entry? */
+ break;
+#endif
+ res = dir_next(dj, FALSE); /* Next entry */
+ if (res != FR_OK) break;
+ }
+
+ if (res != FR_OK) dj->sect = 0;
+
+ return res;
+}
+#endif
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Register an object to the directory */
+/*-----------------------------------------------------------------------*/
+#if !_FS_READONLY
+static
+FRESULT dir_register ( /* FR_OK:Successful, FR_DENIED:No free entry or too many SFN collision, FR_DISK_ERR:Disk error */
+ DIR *dj /* Target directory with object name to be created */
+)
+{
+ FRESULT res;
+ BYTE c, *dir;
+#if _USE_LFN /* LFN configuration */
+ WORD n, ne, is;
+ BYTE sn[12], *fn, sum;
+ WCHAR *lfn;
+
+
+ fn = dj->fn; lfn = dj->lfn;
+ mem_cpy(sn, fn, 12);
+
+ if (_FS_RPATH && (sn[NS] & NS_DOT)) return FR_INVALID_NAME; /* Cannot create dot entry */
+
+ if (sn[NS] & NS_LOSS) { /* When LFN is out of 8.3 format, generate a numbered name */
+ fn[NS] = 0; dj->lfn = NULL; /* Find only SFN */
+ for (n = 1; n < 100; n++) {
+ gen_numname(fn, sn, lfn, n); /* Generate a numbered name */
+ res = dir_find(dj); /* Check if the name collides with existing SFN */
+ if (res != FR_OK) break;
+ }
+ if (n == 100) return FR_DENIED; /* Abort if too many collisions */
+ if (res != FR_NO_FILE) return res; /* Abort if the result is other than 'not collided' */
+ fn[NS] = sn[NS]; dj->lfn = lfn;
+ }
+
+ if (sn[NS] & NS_LFN) { /* When LFN is to be created, reserve reserve an SFN + LFN entries. */
+ for (ne = 0; lfn[ne]; ne++) ;
+ ne = (ne + 25) / 13;
+ } else { /* Otherwise reserve only an SFN entry. */
+ ne = 1;
+ }
+
+ /* Reserve contiguous entries */
+ res = dir_seek(dj, 0);
+ if (res != FR_OK) return res;
+ n = is = 0;
+ do {
+ res = move_window(dj->fs, dj->sect);
+ if (res != FR_OK) break;
+ c = *dj->dir; /* Check the entry status */
+ if (c == 0xE5 || c == 0) { /* Is it a blank entry? */
+ if (n == 0) is = dj->index; /* First index of the contigulus entry */
+ if (++n == ne) break; /* A contiguous entry that requiered count is found */
+ } else {
+ n = 0; /* Not a blank entry. Restart to search */
+ }
+ res = dir_next(dj, TRUE); /* Next entry with table streach */
+ } while (res == FR_OK);
+
+ if (res == FR_OK && ne > 1) { /* Initialize LFN entry if needed */
+ res = dir_seek(dj, is);
+ if (res == FR_OK) {
+ sum = sum_sfn(dj->fn); /* Sum of the SFN tied to the LFN */
+ ne--;
+ do { /* Store LFN entries in bottom first */
+ res = move_window(dj->fs, dj->sect);
+ if (res != FR_OK) break;
+ fit_lfn(dj->lfn, dj->dir, (BYTE)ne, sum);
+ dj->fs->wflag = 1;
+ res = dir_next(dj, FALSE); /* Next entry */
+ } while (res == FR_OK && --ne);
+ }
+ }
+
+#else /* Non LFN configuration */
+ res = dir_seek(dj, 0);
+ if (res == FR_OK) {
+ do { /* Find a blank entry for the SFN */
+ res = move_window(dj->fs, dj->sect);
+ if (res != FR_OK) break;
+ c = *dj->dir;
+ if (c == 0xE5 || c == 0) break; /* Is it a blank entry? */
+ res = dir_next(dj, TRUE); /* Next entry with table streach */
+ } while (res == FR_OK);
+ }
+#endif
+
+ if (res == FR_OK) { /* Initialize the SFN entry */
+ res = move_window(dj->fs, dj->sect);
+ if (res == FR_OK) {
+ dir = dj->dir;
+ mem_set(dir, 0, 32); /* Clean the entry */
+ mem_cpy(dir, dj->fn, 11); /* Put SFN */
+ dir[DIR_NTres] = *(dj->fn+NS) & (NS_BODY | NS_EXT); /* Put NT flag */
+ dj->fs->wflag = 1;
+ }
+ }
+
+ return res;
+}
+#endif /* !_FS_READONLY */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Remove an object from the directory */
+/*-----------------------------------------------------------------------*/
+#if !_FS_READONLY && !_FS_MINIMIZE
+static
+FRESULT dir_remove ( /* FR_OK: Successful, FR_DISK_ERR: A disk error */
+ DIR *dj /* Directory object pointing the entry to be removed */
+)
+{
+ FRESULT res;
+#if _USE_LFN /* LFN configuration */
+ WORD i;
+
+ i = dj->index; /* SFN index */
+ res = dir_seek(dj, (WORD)((dj->lfn_idx == 0xFFFF) ? i : dj->lfn_idx)); /* Goto the SFN or top of the LFN entries */
+ if (res == FR_OK) {
+ do {
+ res = move_window(dj->fs, dj->sect);
+ if (res != FR_OK) break;
+ *dj->dir = 0xE5; /* Mark the entry "deleted" */
+ dj->fs->wflag = 1;
+ if (dj->index >= i) break; /* When reached SFN, all entries of the object has been deleted. */
+ res = dir_next(dj, FALSE); /* Next entry */
+ } while (res == FR_OK);
+ if (res == FR_NO_FILE) res = FR_INT_ERR;
+ }
+
+#else /* Non LFN configuration */
+ res = dir_seek(dj, dj->index);
+ if (res == FR_OK) {
+ res = move_window(dj->fs, dj->sect);
+ if (res == FR_OK) {
+ *dj->dir = 0xE5; /* Mark the entry "deleted" */
+ dj->fs->wflag = 1;
+ }
+ }
+#endif
+
+ return res;
+}
+#endif /* !_FS_READONLY */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Pick a segment and create the object name in directory form */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT create_name (
+ DIR *dj, /* Pointer to the directory object */
+ const XCHAR **path /* Pointer to pointer to the segment in the path string */
+)
+{
+#ifdef _EXCVT
+ static const BYTE cvt[] = _EXCVT;
+#endif
+
+#if _USE_LFN /* LFN configuration */
+ BYTE b, cf;
+ WCHAR w, *lfn;
+ int i, ni, si, di;
+ const XCHAR *p;
+
+ /* Create LFN in Unicode */
+ si = di = 0;
+ p = *path;
+ lfn = dj->lfn;
+ for (;;) {
+ w = p[si++]; /* Get a character */
+ if (w < ' ' || w == '/' || w == '\\') break; /* Break on end of segment */
+ if (di >= _MAX_LFN) /* Reject too long name */
+ return FR_INVALID_NAME;
+#if !_LFN_UNICODE
+ w &= 0xFF;
+ if (IsDBCS1(w)) { /* If it is a DBC 1st byte */
+ b = p[si++]; /* Get 2nd byte */
+ if (!IsDBCS2(b)) /* Reject invalid code for DBC */
+ return FR_INVALID_NAME;
+ w = (w << 8) + b;
+ }
+ w = ff_convert(w, 1); /* Convert OEM to Unicode */
+ if (!w) return FR_INVALID_NAME; /* Reject invalid code */
+#endif
+ if (w < 0x80 && chk_chr("\"*:<>\?|\x7F", w)) /* Reject illegal chars for LFN */
+ return FR_INVALID_NAME;
+ lfn[di++] = w; /* Store the Unicode char */
+ }
+ *path = &p[si]; /* Rerurn pointer to the next segment */
+ cf = (w < ' ') ? NS_LAST : 0; /* Set last segment flag if end of path */
+#if _FS_RPATH
+ if ((di == 1 && lfn[di - 1] == '.') || /* Is this a dot entry? */
+ (di == 2 && lfn[di - 1] == '.' && lfn[di - 2] == '.')) {
+ lfn[di] = 0;
+ for (i = 0; i < 11; i++)
+ dj->fn[i] = (i < di) ? '.' : ' ';
+ dj->fn[i] = cf | NS_DOT; /* This is a dot entry */
+ return FR_OK;
+ }
+#endif
+ while (di) { /* Strip trailing spaces and dots */
+ w = lfn[di - 1];
+ if (w != ' ' && w != '.') break;
+ di--;
+ }
+ if (!di) return FR_INVALID_NAME; /* Reject null string */
+
+ lfn[di] = 0; /* LFN is created */
+
+ /* Create SFN in directory form */
+ mem_set(dj->fn, ' ', 11);
+ for (si = 0; lfn[si] == ' ' || lfn[si] == '.'; si++) ; /* Strip leading spaces and dots */
+ if (si) cf |= NS_LOSS | NS_LFN;
+ while (di && lfn[di - 1] != '.') di--; /* Find extension (di<=si: no extension) */
+
+ b = i = 0; ni = 8;
+ for (;;) {
+ w = lfn[si++]; /* Get an LFN char */
+ if (!w) break; /* Break on enf of the LFN */
+ if (w == ' ' || (w == '.' && si != di)) { /* Remove spaces and dots */
+ cf |= NS_LOSS | NS_LFN; continue;
+ }
+
+ if (i >= ni || si == di) { /* Extension or end of SFN */
+ if (ni == 11) { /* Long extension */
+ cf |= NS_LOSS | NS_LFN; break;
+ }
+ if (si != di) cf |= NS_LOSS | NS_LFN; /* Out of 8.3 format */
+ if (si > di) break; /* No extension */
+ si = di; i = 8; ni = 11; /* Enter extension section */
+ b <<= 2; continue;
+ }
+
+ if (w >= 0x80) { /* Non ASCII char */
+#ifdef _EXCVT
+ w = ff_convert(w, 0); /* Unicode -> OEM code */
+ if (w) w = cvt[w - 0x80]; /* Convert extended char to upper (SBCS) */
+#else
+ w = ff_convert(ff_wtoupper(w), 0); /* Upper converted Unicode -> OEM code */
+#endif
+ cf |= NS_LFN; /* Force create LFN entry */
+ }
+
+ if (_DF1S && w >= 0x100) { /* Double byte char */
+ if (i >= ni - 1) {
+ cf |= NS_LOSS | NS_LFN; i = ni; continue;
+ }
+ dj->fn[i++] = (BYTE)(w >> 8);
+ } else { /* Single byte char */
+ if (!w || chk_chr("+,;[=]", w)) { /* Replace illegal chars for SFN */
+ w = '_'; cf |= NS_LOSS | NS_LFN; /* Lossy conversion */
+ } else {
+ if (IsUpper(w)) { /* ASCII large capital */
+ b |= 2;
+ } else {
+ if (IsLower(w)) { /* ASCII small capital */
+ b |= 1; w -= 0x20;
+ }
+ }
+ }
+ }
+ dj->fn[i++] = (BYTE)w;
+ }
+
+ if (dj->fn[0] == 0xE5) dj->fn[0] = 0x05; /* If the first char collides with deleted mark, replace it with 0x05 */
+
+ if (ni == 8) b <<= 2;
+ if ((b & 0x0C) == 0x0C || (b & 0x03) == 0x03) /* Create LFN entry when there are composite capitals */
+ cf |= NS_LFN;
+ if (!(cf & NS_LFN)) { /* When LFN is in 8.3 format without extended char, NT flags are created */
+ if ((b & 0x03) == 0x01) cf |= NS_EXT; /* NT flag (Extension has only small capital) */
+ if ((b & 0x0C) == 0x04) cf |= NS_BODY; /* NT flag (Filename has only small capital) */
+ }
+
+ dj->fn[NS] = cf; /* SFN is created */
+
+ return FR_OK;
+
+
+#else /* Non-LFN configuration */
+ BYTE b, c, d, *sfn;
+ int ni, si, i;
+ const char *p;
+
+ /* Create file name in directory form */
+ sfn = dj->fn;
+ mem_set(sfn, ' ', 11);
+ si = i = b = 0; ni = 8;
+ p = *path;
+#if _FS_RPATH
+ if (p[si] == '.') { /* Is this a dot entry? */
+ for (;;) {
+ c = p[si++];
+ if (c != '.' || si >= 3) break;
+ sfn[i++] = c;
+ }
+ if (c != '/' && c != '\\' && c > ' ') return FR_INVALID_NAME;
+ *path = &p[si]; /* Rerurn pointer to the next segment */
+ sfn[NS] = (c <= ' ') ? NS_LAST | NS_DOT : NS_DOT; /* Set last segment flag if end of path */
+ return FR_OK;
+ }
+#endif
+ for (;;) {
+ c = p[si++];
+ if (c <= ' ' || c == '/' || c == '\\') break; /* Break on end of segment */
+ if (c == '.' || i >= ni) {
+ if (ni != 8 || c != '.') return FR_INVALID_NAME;
+ i = 8; ni = 11;
+ b <<= 2; continue;
+ }
+ if (c >= 0x80) { /* Extended char */
+#ifdef _EXCVT
+ c = cvt[c - 0x80]; /* Convert extend char (SBCS) */
+#else
+ b |= 3; /* Eliminate NT flag if ext char is exist */
+#if !_DF1S /* ASCII only cfg */
+ return FR_INVALID_NAME;
+#endif
+#endif
+ }
+ if (IsDBCS1(c)) { /* DBC 1st byte? */
+ d = p[si++]; /* Get 2nd byte */
+ if (!IsDBCS2(d) || i >= ni - 1) /* Reject invalid DBC */
+ return FR_INVALID_NAME;
+ sfn[i++] = c;
+ sfn[i++] = d;
+ } else { /* Single byte code */
+ if (chk_chr(" \"*+,[=]|\x7F", c)) /* Reject illegal chrs for SFN */
+ return FR_INVALID_NAME;
+ if (IsUpper(c)) { /* ASCII large capital? */
+ b |= 2;
+ } else {
+ if (IsLower(c)) { /* ASCII small capital? */
+ b |= 1; c -= 0x20;
+ }
+ }
+ sfn[i++] = c;
+ }
+ }
+ *path = &p[si]; /* Rerurn pointer to the next segment */
+ c = (c <= ' ') ? NS_LAST : 0; /* Set last segment flag if end of path */
+
+ if (!i) return FR_INVALID_NAME; /* Reject null string */
+ if (sfn[0] == 0xE5) sfn[0] = 0x05; /* When first char collides with 0xE5, replace it with 0x05 */
+
+ if (ni == 8) b <<= 2;
+ if ((b & 0x03) == 0x01) c |= NS_EXT; /* NT flag (Extension has only small capital) */
+ if ((b & 0x0C) == 0x04) c |= NS_BODY; /* NT flag (Filename has only small capital) */
+
+ sfn[NS] = c; /* Store NT flag, File name is created */
+
+ return FR_OK;
+#endif
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Get file information from directory entry */
+/*-----------------------------------------------------------------------*/
+#if _FS_MINIMIZE <= 1
+static
+void get_fileinfo ( /* No return code */
+ DIR *dj, /* Pointer to the directory object */
+ FILINFO *fno /* Pointer to the file information to be filled */
+)
+{
+ int i;
+ BYTE c, nt, *dir;
+ char *p;
+
+
+ p = fno->fname;
+ if (dj->sect) {
+ dir = dj->dir;
+ nt = dir[DIR_NTres]; /* NT flag */
+ for (i = 0; i < 8; i++) { /* Copy name body */
+ c = dir[i];
+ if (c == ' ') break;
+ if (c == 0x05) c = 0xE5;
+ if (_USE_LFN && (nt & NS_BODY) && IsUpper(c)) c += 0x20;
+ *p++ = c;
+ }
+ if (dir[8] != ' ') { /* Copy name extension */
+ *p++ = '.';
+ for (i = 8; i < 11; i++) {
+ c = dir[i];
+ if (c == ' ') break;
+ if (_USE_LFN && (nt & NS_EXT) && IsUpper(c)) c += 0x20;
+ *p++ = c;
+ }
+ }
+ fno->fattrib = dir[DIR_Attr]; /* Attribute */
+ fno->fsize = LD_DWORD(dir+DIR_FileSize); /* Size */
+ fno->fdate = LD_WORD(dir+DIR_WrtDate); /* Date */
+ fno->ftime = LD_WORD(dir+DIR_WrtTime); /* Time */
+ }
+ *p = 0;
+
+#if _USE_LFN
+ if (fno->lfname) {
+ XCHAR *tp = fno->lfname;
+ WCHAR w, *lfn;
+
+ i = 0;
+ if (dj->sect && dj->lfn_idx != 0xFFFF) {/* Get LFN if available */
+ lfn = dj->lfn;
+ while ((w = *lfn++) != 0) { /* Get an LFN char */
+#if !_LFN_UNICODE
+ w = ff_convert(w, 0); /* Unicode -> OEM conversion */
+ if (!w) { i = 0; break; } /* Could not convert, no LFN */
+ if (_DF1S && w >= 0x100) /* Put 1st byte if it is a DBC */
+ tp[i++] = (XCHAR)(w >> 8);
+#endif
+ if (i >= fno->lfsize - 1) { i = 0; break; } /* Buffer overrun, no LFN */
+ tp[i++] = (XCHAR)w;
+ }
+ }
+ tp[i] = 0; /* Terminator */
+ }
+#endif
+}
+#endif /* _FS_MINIMIZE <= 1 */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Follow a file path */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT follow_path ( /* FR_OK(0): successful, !=0: error code */
+ DIR *dj, /* Directory object to return last directory and found object */
+ const XCHAR *path /* Full-path string to find a file or directory */
+)
+{
+ FRESULT res;
+ BYTE *dir, last;
+
+
+ while (!_USE_LFN && *path == ' ') path++; /* Skip leading spaces */
+#if _FS_RPATH
+ if (*path == '/' || *path == '\\') { /* There is a heading separator */
+ path++; dj->sclust = 0; /* Strip it and start from the root dir */
+ } else { /* No heading saparator */
+ dj->sclust = dj->fs->cdir; /* Start from the current dir */
+ }
+#else
+ if (*path == '/' || *path == '\\') /* Strip heading separator if exist */
+ path++;
+ dj->sclust = 0; /* Start from the root dir */
+#endif
+
+ if ((UINT)*path < ' ') { /* Null path means the start directory itself */
+ res = dir_seek(dj, 0);
+ dj->dir = NULL;
+
+ } else { /* Follow path */
+ for (;;) {
+ res = create_name(dj, &path); /* Get a segment */
+ if (res != FR_OK) break;
+ res = dir_find(dj); /* Find it */
+ last = *(dj->fn+NS) & NS_LAST;
+ if (res != FR_OK) { /* Could not find the object */
+ if (res == FR_NO_FILE && !last)
+ res = FR_NO_PATH;
+ break;
+ }
+ if (last) break; /* Last segment match. Function completed. */
+ dir = dj->dir; /* There is next segment. Follow the sub directory */
+ if (!(dir[DIR_Attr] & AM_DIR)) { /* Cannot follow because it is a file */
+ res = FR_NO_PATH; break;
+ }
+ dj->sclust = ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);
+ }
+ }
+
+ return res;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Load boot record and check if it is an FAT boot record */
+/*-----------------------------------------------------------------------*/
+
+static
+BYTE check_fs ( /* 0:The FAT boot record, 1:Valid boot record but not an FAT, 2:Not a boot record, 3:Error */
+ FATFS *fs, /* File system object */
+ DWORD sect /* Sector# (lba) to check if it is an FAT boot record or not */
+)
+{
+ if (disk_read(fs->drive, fs->win, sect, 1) != RES_OK) /* Load boot record */
+ return 3;
+ if (LD_WORD(&fs->win[BS_55AA]) != 0xAA55) /* Check record signature (always placed at offset 510 even if the sector size is >512) */
+ return 2;
+
+ if ((LD_DWORD(&fs->win[BS_FilSysType]) & 0xFFFFFF) == 0x544146) /* Check "FAT" string */
+ return 0;
+ if ((LD_DWORD(&fs->win[BS_FilSysType32]) & 0xFFFFFF) == 0x544146)
+ return 0;
+
+ return 1;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Make sure that the file system is valid */
+/*-----------------------------------------------------------------------*/
+
+
+FRESULT chk_mounted ( /* FR_OK(0): successful, !=0: any error occured */
+ const XCHAR **path, /* Pointer to pointer to the path name (drive number) */
+ FATFS **rfs, /* Pointer to pointer to the found file system object */
+ BYTE chk_wp /* !=0: Check media write protection for write access */
+)
+{
+ BYTE fmt, *tbl;
+ UINT vol;
+ DSTATUS stat;
+ DWORD bsect, fsize, tsect, mclst;
+ const XCHAR *p = *path;
+ FATFS *fs;
+
+ /* Get logical drive number from the path name */
+ vol = p[0] - '0'; /* Is there a drive number? */
+ if (vol <= 9 && p[1] == ':') { /* Found a drive number, get and strip it */
+ p += 2; *path = p; /* Return pointer to the path name */
+ } else { /* No drive number is given */
+#if _FS_RPATH
+ vol = Drive; /* Use current drive */
+#else
+ vol = 0; /* Use drive 0 */
+#endif
+ }
+
+ /* Check if the logical drive is valid or not */
+ if (vol >= _DRIVES) /* Is the drive number valid? */
+ return FR_INVALID_DRIVE;
+ *rfs = fs = FatFs[vol]; /* Returen pointer to the corresponding file system object */
+ if (!fs) return FR_NOT_ENABLED; /* Is the file system object available? */
+
+ ENTER_FF(fs); /* Lock file system */
+
+ if (fs->fs_type) { /* If the logical drive has been mounted */
+ stat = disk_status(fs->drive);
+ if (!(stat & STA_NOINIT)) { /* and the physical drive is kept initialized (has not been changed), */
+#if !_FS_READONLY
+ if (chk_wp && (stat & STA_PROTECT)) /* Check write protection if needed */
+ return FR_WRITE_PROTECTED;
+#endif
+ return FR_OK; /* The file system object is valid */
+ }
+ }
+
+ /* The logical drive must be mounted. Following code attempts to mount the volume */
+
+ fs->fs_type = 0; /* Clear the file system object */
+ fs->drive = (BYTE)LD2PD(vol); /* Bind the logical drive and a physical drive */
+ stat = disk_initialize(fs->drive); /* Initialize low level disk I/O layer */
+ if (stat & STA_NOINIT) /* Check if the drive is ready */
+ return FR_NOT_READY;
+#if _MAX_SS != 512 /* Get disk sector size if needed */
+ if (disk_ioctl(fs->drive, GET_SECTOR_SIZE, &SS(fs)) != RES_OK || SS(fs) > _MAX_SS)
+ return FR_NO_FILESYSTEM;
+#endif
+#if !_FS_READONLY
+ if (chk_wp && (stat & STA_PROTECT)) /* Check disk write protection if needed */
+ return FR_WRITE_PROTECTED;
+#endif
+ /* Search FAT partition on the drive */
+ fmt = check_fs(fs, bsect = 0); /* Check sector 0 as an SFD format */
+ if (fmt == 1) { /* Not an FAT boot record, it may be patitioned */
+ /* Check a partition listed in top of the partition table */
+ tbl = &fs->win[MBR_Table + LD2PT(vol) * 16]; /* Partition table */
+ if (tbl[4]) { /* Is the partition existing? */
+ bsect = LD_DWORD(&tbl[8]); /* Partition offset in LBA */
+ fmt = check_fs(fs, bsect); /* Check the partition */
+ }
+ }
+ if (fmt == 3) return FR_DISK_ERR;
+ if (fmt || LD_WORD(fs->win+BPB_BytsPerSec) != SS(fs)) /* No valid FAT patition is found */
+ return FR_NO_FILESYSTEM;
+
+ /* Initialize the file system object */
+ fsize = LD_WORD(fs->win+BPB_FATSz16); /* Number of sectors per FAT */
+ if (!fsize) fsize = LD_DWORD(fs->win+BPB_FATSz32);
+ fs->sects_fat = fsize;
+ fs->n_fats = fs->win[BPB_NumFATs]; /* Number of FAT copies */
+ fsize *= fs->n_fats; /* (Number of sectors in FAT area) */
+ fs->fatbase = bsect + LD_WORD(fs->win+BPB_RsvdSecCnt); /* FAT start sector (lba) */
+ fs->csize = fs->win[BPB_SecPerClus]; /* Number of sectors per cluster */
+ fs->n_rootdir = LD_WORD(fs->win+BPB_RootEntCnt); /* Nmuber of root directory entries */
+ tsect = LD_WORD(fs->win+BPB_TotSec16); /* Number of sectors on the volume */
+ if (!tsect) tsect = LD_DWORD(fs->win+BPB_TotSec32);
+ fs->max_clust = mclst = (tsect /* Last cluster# + 1 (Number of clusters + 2) */
+ - LD_WORD(fs->win+BPB_RsvdSecCnt) - fsize - fs->n_rootdir / (SS(fs)/32)
+ ) / fs->csize + 2;
+
+ fmt = FS_FAT12; /* Determine the FAT sub type */
+ if (mclst >= 0xFF7) fmt = FS_FAT16; /* Number of clusters >= 0xFF5 */
+ if (mclst >= 0xFFF7) fmt = FS_FAT32; /* Number of clusters >= 0xFFF5 */
+
+ if (fmt == FS_FAT32)
+ fs->dirbase = LD_DWORD(fs->win+BPB_RootClus); /* Root directory start cluster */
+ else
+ fs->dirbase = fs->fatbase + fsize; /* Root directory start sector (lba) */
+ fs->database = fs->fatbase + fsize + fs->n_rootdir / (SS(fs)/32); /* Data start sector (lba) */
+
+#if !_FS_READONLY
+ /* Initialize allocation information */
+ fs->free_clust = 0xFFFFFFFF;
+ fs->wflag = 0;
+ /* Get fsinfo if needed */
+ if (fmt == FS_FAT32) {
+ fs->fsi_flag = 0;
+ fs->fsi_sector = bsect + LD_WORD(fs->win+BPB_FSInfo);
+ if (disk_read(fs->drive, fs->win, fs->fsi_sector, 1) == RES_OK &&
+ LD_WORD(fs->win+BS_55AA) == 0xAA55 &&
+ LD_DWORD(fs->win+FSI_LeadSig) == 0x41615252 &&
+ LD_DWORD(fs->win+FSI_StrucSig) == 0x61417272) {
+ fs->last_clust = LD_DWORD(fs->win+FSI_Nxt_Free);
+ fs->free_clust = LD_DWORD(fs->win+FSI_Free_Count);
+ }
+ }
+#endif
+ fs->fs_type = fmt; /* FAT sub-type */
+ fs->winsect = 0; /* Invalidate sector cache */
+#if _FS_RPATH
+ fs->cdir = 0; /* Current directory (root dir) */
+#endif
+ fs->id = ++Fsid; /* File system mount ID */
+
+ return FR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Check if the file/dir object is valid or not */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT validate ( /* FR_OK(0): The object is valid, !=0: Invalid */
+ FATFS *fs, /* Pointer to the file system object */
+ WORD id /* Member id of the target object to be checked */
+)
+{
+ if (!fs || !fs->fs_type || fs->id != id)
+ return FR_INVALID_OBJECT;
+
+ ENTER_FF(fs); /* Lock file system */
+
+ if (disk_status(fs->drive) & STA_NOINIT)
+ return FR_NOT_READY;
+
+ return FR_OK;
+}
+
+
+
+
+/*--------------------------------------------------------------------------
+
+ Public Functions
+
+--------------------------------------------------------------------------*/
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Mount/Unmount a Locical Drive */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_mount (
+ BYTE vol, /* Logical drive number to be mounted/unmounted */
+ FATFS *fs /* Pointer to new file system object (NULL for unmount)*/
+)
+{
+ FATFS *rfs;
+
+
+ if (vol >= _DRIVES) /* Check if the drive number is valid */
+ return FR_INVALID_DRIVE;
+ rfs = FatFs[vol]; /* Get current fs object */
+
+ if (rfs) {
+#if _FS_REENTRANT /* Discard sync object of the current volume */
+ if (!ff_del_syncobj(rfs->sobj)) return FR_INT_ERR;
+#endif
+ rfs->fs_type = 0; /* Clear old fs object */
+ }
+
+ if (fs) {
+ fs->fs_type = 0; /* Clear new fs object */
+#if _FS_REENTRANT /* Create sync object for the new volume */
+ if (!ff_cre_syncobj(vol, &fs->sobj)) return FR_INT_ERR;
+#endif
+ }
+ FatFs[vol] = fs; /* Register new fs object */
+
+ return FR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Open or Create a File */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_open (
+ FIL *fp, /* Pointer to the blank file object */
+ const XCHAR *path, /* Pointer to the file name */
+ BYTE mode /* Access mode and file open mode flags */
+)
+{
+ FRESULT res;
+ DIR dj;
+ NAMEBUF(sfn, lfn);
+ BYTE *dir;
+
+
+ fp->fs = NULL; /* Clear file object */
+#if !_FS_READONLY
+ mode &= (FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW);
+ res = chk_mounted(&path, &dj.fs, (BYTE)(mode & (FA_WRITE | FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW)));
+#else
+ mode &= FA_READ;
+ res = chk_mounted(&path, &dj.fs, 0);
+#endif
+ if (res != FR_OK) LEAVE_FF(dj.fs, res);
+ INITBUF(dj, sfn, lfn);
+ res = follow_path(&dj, path); /* Follow the file path */
+
+#if !_FS_READONLY
+ /* Create or Open a file */
+ if (mode & (FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW)) {
+ DWORD ps, cl;
+
+ if (res != FR_OK) { /* No file, create new */
+ if (res == FR_NO_FILE) /* There is no file to open, create a new entry */
+ res = dir_register(&dj);
+ if (res != FR_OK) LEAVE_FF(dj.fs, res);
+ mode |= FA_CREATE_ALWAYS;
+ dir = dj.dir; /* Created entry (SFN entry) */
+ }
+ else { /* Any object is already existing */
+ if (mode & FA_CREATE_NEW) /* Cannot create new */
+ LEAVE_FF(dj.fs, FR_EXIST);
+ dir = dj.dir;
+ if (!dir || (dir[DIR_Attr] & (AM_RDO | AM_DIR))) /* Cannot overwrite it (R/O or DIR) */
+ LEAVE_FF(dj.fs, FR_DENIED);
+ if (mode & FA_CREATE_ALWAYS) { /* Resize it to zero on over write mode */
+ cl = ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO); /* Get start cluster */
+ ST_WORD(dir+DIR_FstClusHI, 0); /* cluster = 0 */
+ ST_WORD(dir+DIR_FstClusLO, 0);
+ ST_DWORD(dir+DIR_FileSize, 0); /* size = 0 */
+ dj.fs->wflag = 1;
+ ps = dj.fs->winsect; /* Remove the cluster chain */
+ if (cl) {
+ res = remove_chain(dj.fs, cl);
+ if (res) LEAVE_FF(dj.fs, res);
+ dj.fs->last_clust = cl - 1; /* Reuse the cluster hole */
+ }
+ res = move_window(dj.fs, ps);
+ if (res != FR_OK) LEAVE_FF(dj.fs, res);
+ }
+ }
+ if (mode & FA_CREATE_ALWAYS) {
+ dir[DIR_Attr] = 0; /* Reset attribute */
+ ps = get_fattime();
+ ST_DWORD(dir+DIR_CrtTime, ps); /* Created time */
+ dj.fs->wflag = 1;
+ mode |= FA__WRITTEN; /* Set file changed flag */
+ }
+ }
+ /* Open an existing file */
+ else {
+#endif /* !_FS_READONLY */
+ if (res != FR_OK) LEAVE_FF(dj.fs, res); /* Follow failed */
+ dir = dj.dir;
+ if (!dir || (dir[DIR_Attr] & AM_DIR)) /* It is a directory */
+ LEAVE_FF(dj.fs, FR_NO_FILE);
+#if !_FS_READONLY
+ if ((mode & FA_WRITE) && (dir[DIR_Attr] & AM_RDO)) /* R/O violation */
+ LEAVE_FF(dj.fs, FR_DENIED);
+ }
+ fp->dir_sect = dj.fs->winsect; /* Pointer to the directory entry */
+ fp->dir_ptr = dj.dir;
+#endif
+ fp->flag = mode; /* File access mode */
+ fp->org_clust = /* File start cluster */
+ ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);
+ fp->fsize = LD_DWORD(dir+DIR_FileSize); /* File size */
+ fp->fptr = 0; fp->csect = 255; /* File pointer */
+ fp->dsect = 0;
+ fp->fs = dj.fs; fp->id = dj.fs->id; /* Owner file system object of the file */
+
+ LEAVE_FF(dj.fs, FR_OK);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read File */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_read (
+ FIL *fp, /* Pointer to the file object */
+ void *buff, /* Pointer to data buffer */
+ UINT btr, /* Number of bytes to read */
+ UINT *br /* Pointer to number of bytes read */
+)
+{
+ FRESULT res;
+ DWORD clst, sect, remain;
+ UINT rcnt, cc;
+ BYTE *rbuff = buff;
+
+
+ *br = 0; /* Initialize bytes read */
+
+ res = validate(fp->fs, fp->id); /* Check validity of the object */
+ if (res != FR_OK) LEAVE_FF(fp->fs, res);
+ if (fp->flag & FA__ERROR) /* Check abort flag */
+ LEAVE_FF(fp->fs, FR_INT_ERR);
+ if (!(fp->flag & FA_READ)) /* Check access mode */
+ LEAVE_FF(fp->fs, FR_DENIED);
+ remain = fp->fsize - fp->fptr;
+ if (btr > remain) btr = (UINT)remain; /* Truncate btr by remaining bytes */
+
+ for ( ; btr; /* Repeat until all data transferred */
+ rbuff += rcnt, fp->fptr += rcnt, *br += rcnt, btr -= rcnt) {
+ if ((fp->fptr % SS(fp->fs)) == 0) { /* On the sector boundary? */
+ if (fp->csect >= fp->fs->csize) { /* On the cluster boundary? */
+ clst = (fp->fptr == 0) ? /* On the top of the file? */
+ fp->org_clust : get_fat(fp->fs, fp->curr_clust);
+ if (clst <= 1) ABORT(fp->fs, FR_INT_ERR);
+ if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
+ fp->curr_clust = clst; /* Update current cluster */
+ fp->csect = 0; /* Reset sector offset in the cluster */
+ }
+ sect = clust2sect(fp->fs, fp->curr_clust); /* Get current sector */
+ if (!sect) ABORT(fp->fs, FR_INT_ERR);
+ sect += fp->csect;
+ cc = btr / SS(fp->fs); /* When remaining bytes >= sector size, */
+ if (cc) { /* Read maximum contiguous sectors directly */
+ if (fp->csect + cc > fp->fs->csize) /* Clip at cluster boundary */
+ cc = fp->fs->csize - fp->csect;
+ if (disk_read(fp->fs->drive, rbuff, sect, (BYTE)cc) != RES_OK)
+ ABORT(fp->fs, FR_DISK_ERR);
+#if !_FS_READONLY && _FS_MINIMIZE <= 2
+#if _FS_TINY
+ if (fp->fs->wflag && fp->fs->winsect - sect < cc) /* Replace one of the read sectors with cached data if it contains a dirty sector */
+ mem_cpy(rbuff + ((fp->fs->winsect - sect) * SS(fp->fs)), fp->fs->win, SS(fp->fs));
+#else
+ if ((fp->flag & FA__DIRTY) && fp->dsect - sect < cc) /* Replace one of the read sectors with cached data if it contains a dirty sector */
+ mem_cpy(rbuff + ((fp->dsect - sect) * SS(fp->fs)), fp->buf, SS(fp->fs));
+#endif
+#endif
+ fp->csect += (BYTE)cc; /* Next sector address in the cluster */
+ rcnt = SS(fp->fs) * cc; /* Number of bytes transferred */
+ continue;
+ }
+#if !_FS_TINY
+#if !_FS_READONLY
+ if (fp->flag & FA__DIRTY) { /* Write sector I/O buffer if needed */
+ if (disk_write(fp->fs->drive, fp->buf, fp->dsect, 1) != RES_OK)
+ ABORT(fp->fs, FR_DISK_ERR);
+ fp->flag &= ~FA__DIRTY;
+ }
+#endif
+ if (fp->dsect != sect) { /* Fill sector buffer with file data */
+ if (disk_read(fp->fs->drive, fp->buf, sect, 1) != RES_OK)
+ ABORT(fp->fs, FR_DISK_ERR);
+ }
+#endif
+ fp->dsect = sect;
+ fp->csect++; /* Next sector address in the cluster */
+ }
+ rcnt = SS(fp->fs) - (fp->fptr % SS(fp->fs)); /* Get partial sector data from sector buffer */
+ if (rcnt > btr) rcnt = btr;
+#if _FS_TINY
+ if (move_window(fp->fs, fp->dsect)) /* Move sector window */
+ ABORT(fp->fs, FR_DISK_ERR);
+ mem_cpy(rbuff, &fp->fs->win[fp->fptr % SS(fp->fs)], rcnt); /* Pick partial sector */
+#else
+ mem_cpy(rbuff, &fp->buf[fp->fptr % SS(fp->fs)], rcnt); /* Pick partial sector */
+#endif
+ }
+
+ LEAVE_FF(fp->fs, FR_OK);
+}
+
+
+
+
+#if !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Write File */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_write (
+ FIL *fp, /* Pointer to the file object */
+ const void *buff, /* Pointer to the data to be written */
+ UINT btw, /* Number of bytes to write */
+ UINT *bw /* Pointer to number of bytes written */
+)
+{
+ FRESULT res;
+ DWORD clst, sect;
+ UINT wcnt, cc;
+ const BYTE *wbuff = buff;
+
+
+ *bw = 0; /* Initialize bytes written */
+
+ res = validate(fp->fs, fp->id); /* Check validity of the object */
+ if (res != FR_OK) LEAVE_FF(fp->fs, res);
+ if (fp->flag & FA__ERROR) /* Check abort flag */
+ LEAVE_FF(fp->fs, FR_INT_ERR);
+ if (!(fp->flag & FA_WRITE)) /* Check access mode */
+ LEAVE_FF(fp->fs, FR_DENIED);
+ if (fp->fsize + btw < fp->fsize) btw = 0; /* File size cannot reach 4GB */
+
+ for ( ; btw; /* Repeat until all data transferred */
+ wbuff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt) {
+ if ((fp->fptr % SS(fp->fs)) == 0) { /* On the sector boundary? */
+ if (fp->csect >= fp->fs->csize) { /* On the cluster boundary? */
+ if (fp->fptr == 0) { /* On the top of the file? */
+ clst = fp->org_clust; /* Follow from the origin */
+ if (clst == 0) /* When there is no cluster chain, */
+ fp->org_clust = clst = create_chain(fp->fs, 0); /* Create a new cluster chain */
+ } else { /* Middle or end of the file */
+ clst = create_chain(fp->fs, fp->curr_clust); /* Follow or streach cluster chain */
+ }
+ if (clst == 0) break; /* Could not allocate a new cluster (disk full) */
+ if (clst == 1) ABORT(fp->fs, FR_INT_ERR);
+ if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
+ fp->curr_clust = clst; /* Update current cluster */
+ fp->csect = 0; /* Reset sector address in the cluster */
+ }
+#if _FS_TINY
+ if (fp->fs->winsect == fp->dsect && move_window(fp->fs, 0)) /* Write back data buffer prior to following direct transfer */
+ ABORT(fp->fs, FR_DISK_ERR);
+#else
+ if (fp->flag & FA__DIRTY) { /* Write back data buffer prior to following direct transfer */
+ if (disk_write(fp->fs->drive, fp->buf, fp->dsect, 1) != RES_OK)
+ ABORT(fp->fs, FR_DISK_ERR);
+ fp->flag &= ~FA__DIRTY;
+ }
+#endif
+ sect = clust2sect(fp->fs, fp->curr_clust); /* Get current sector */
+ if (!sect) ABORT(fp->fs, FR_INT_ERR);
+ sect += fp->csect;
+ cc = btw / SS(fp->fs); /* When remaining bytes >= sector size, */
+ if (cc) { /* Write maximum contiguous sectors directly */
+ if (fp->csect + cc > fp->fs->csize) /* Clip at cluster boundary */
+ cc = fp->fs->csize - fp->csect;
+ if (disk_write(fp->fs->drive, wbuff, sect, (BYTE)cc) != RES_OK)
+ ABORT(fp->fs, FR_DISK_ERR);
+#if _FS_TINY
+ if (fp->fs->winsect - sect < cc) { /* Refill sector cache if it gets dirty by the direct write */
+ mem_cpy(fp->fs->win, wbuff + ((fp->fs->winsect - sect) * SS(fp->fs)), SS(fp->fs));
+ fp->fs->wflag = 0;
+ }
+#else
+ if (fp->dsect - sect < cc) { /* Refill sector cache if it gets dirty by the direct write */
+ mem_cpy(fp->buf, wbuff + ((fp->dsect - sect) * SS(fp->fs)), SS(fp->fs));
+ fp->flag &= ~FA__DIRTY;
+ }
+#endif
+ fp->csect += (BYTE)cc; /* Next sector address in the cluster */
+ wcnt = SS(fp->fs) * cc; /* Number of bytes transferred */
+ continue;
+ }
+#if _FS_TINY
+ if (fp->fptr >= fp->fsize) { /* Avoid silly buffer filling at growing edge */
+ if (move_window(fp->fs, 0)) ABORT(fp->fs, FR_DISK_ERR);
+ fp->fs->winsect = sect;
+ }
+#else
+ if (fp->dsect != sect) { /* Fill sector buffer with file data */
+ if (fp->fptr < fp->fsize &&
+ disk_read(fp->fs->drive, fp->buf, sect, 1) != RES_OK)
+ ABORT(fp->fs, FR_DISK_ERR);
+ }
+#endif
+ fp->dsect = sect;
+ fp->csect++; /* Next sector address in the cluster */
+ }
+ wcnt = SS(fp->fs) - (fp->fptr % SS(fp->fs)); /* Put partial sector into file I/O buffer */
+ if (wcnt > btw) wcnt = btw;
+#if _FS_TINY
+ if (move_window(fp->fs, fp->dsect)) /* Move sector window */
+ ABORT(fp->fs, FR_DISK_ERR);
+ mem_cpy(&fp->fs->win[fp->fptr % SS(fp->fs)], wbuff, wcnt); /* Fit partial sector */
+ fp->fs->wflag = 1;
+#else
+ mem_cpy(&fp->buf[fp->fptr % SS(fp->fs)], wbuff, wcnt); /* Fit partial sector */
+ fp->flag |= FA__DIRTY;
+#endif
+ }
+
+ if (fp->fptr > fp->fsize) fp->fsize = fp->fptr; /* Update file size if needed */
+ fp->flag |= FA__WRITTEN; /* Set file changed flag */
+
+ LEAVE_FF(fp->fs, FR_OK);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Synchronize the File Object */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_sync (
+ FIL *fp /* Pointer to the file object */
+)
+{
+ FRESULT res;
+ DWORD tim;
+ BYTE *dir;
+
+
+ res = validate(fp->fs, fp->id); /* Check validity of the object */
+ if (res == FR_OK) {
+ if (fp->flag & FA__WRITTEN) { /* Has the file been written? */
+#if !_FS_TINY /* Write-back dirty buffer */
+ if (fp->flag & FA__DIRTY) {
+ if (disk_write(fp->fs->drive, fp->buf, fp->dsect, 1) != RES_OK)
+ LEAVE_FF(fp->fs, FR_DISK_ERR);
+ fp->flag &= ~FA__DIRTY;
+ }
+#endif
+ /* Update the directory entry */
+ res = move_window(fp->fs, fp->dir_sect);
+ if (res == FR_OK) {
+ dir = fp->dir_ptr;
+ dir[DIR_Attr] |= AM_ARC; /* Set archive bit */
+ ST_DWORD(dir+DIR_FileSize, fp->fsize); /* Update file size */
+ ST_WORD(dir+DIR_FstClusLO, fp->org_clust); /* Update start cluster */
+ ST_WORD(dir+DIR_FstClusHI, fp->org_clust >> 16);
+ tim = get_fattime(); /* Updated time */
+ ST_DWORD(dir+DIR_WrtTime, tim);
+ fp->flag &= ~FA__WRITTEN;
+ fp->fs->wflag = 1;
+ res = sync(fp->fs);
+ }
+ }
+ }
+
+ LEAVE_FF(fp->fs, res);
+}
+
+#endif /* !_FS_READONLY */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Close File */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_close (
+ FIL *fp /* Pointer to the file object to be closed */
+)
+{
+ FRESULT res;
+
+
+#if _FS_READONLY
+ res = validate(fp->fs, fp->id);
+ if (res == FR_OK) fp->fs = NULL;
+ LEAVE_FF(fp->fs, res);
+#else
+ res = f_sync(fp);
+ if (res == FR_OK) fp->fs = NULL;
+ return res;
+#endif
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Change Current Drive/Directory */
+/*-----------------------------------------------------------------------*/
+
+#if _FS_RPATH
+
+FRESULT f_chdrive (
+ BYTE drv /* Drive number */
+)
+{
+ if (drv >= _DRIVES) return FR_INVALID_DRIVE;
+
+ Drive = drv;
+
+ return FR_OK;
+}
+
+
+
+
+FRESULT f_chdir (
+ const XCHAR *path /* Pointer to the directory path */
+)
+{
+ FRESULT res;
+ DIR dj;
+ NAMEBUF(sfn, lfn);
+ BYTE *dir;
+
+
+ res = chk_mounted(&path, &dj.fs, 0);
+ if (res == FR_OK) {
+ INITBUF(dj, sfn, lfn);
+ res = follow_path(&dj, path); /* Follow the file path */
+ if (res == FR_OK) { /* Follow completed */
+ dir = dj.dir; /* Pointer to the entry */
+ if (!dir) {
+ dj.fs->cdir = 0; /* No entry (root dir) */
+ } else {
+ if (dir[DIR_Attr] & AM_DIR) /* Reached to the dir */
+ dj.fs->cdir = ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);
+ else
+ res = FR_NO_PATH; /* Could not reach the dir (it is a file) */
+ }
+ }
+ if (res == FR_NO_FILE) res = FR_NO_PATH;
+ }
+
+ LEAVE_FF(dj.fs, res);
+}
+
+#endif
+
+
+
+#if _FS_MINIMIZE <= 2
+/*-----------------------------------------------------------------------*/
+/* Seek File R/W Pointer */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_lseek (
+ FIL *fp, /* Pointer to the file object */
+ DWORD ofs /* File pointer from top of file */
+)
+{
+ FRESULT res;
+ DWORD clst, bcs, nsect, ifptr;
+
+
+ res = validate(fp->fs, fp->id); /* Check validity of the object */
+ if (res != FR_OK) LEAVE_FF(fp->fs, res);
+ if (fp->flag & FA__ERROR) /* Check abort flag */
+ LEAVE_FF(fp->fs, FR_INT_ERR);
+ if (ofs > fp->fsize /* In read-only mode, clip offset with the file size */
+#if !_FS_READONLY
+ && !(fp->flag & FA_WRITE)
+#endif
+ ) ofs = fp->fsize;
+
+ ifptr = fp->fptr;
+ fp->fptr = nsect = 0; fp->csect = 255;
+ if (ofs > 0) {
+ bcs = (DWORD)fp->fs->csize * SS(fp->fs); /* Cluster size (byte) */
+ if (ifptr > 0 &&
+ (ofs - 1) / bcs >= (ifptr - 1) / bcs) { /* When seek to same or following cluster, */
+ fp->fptr = (ifptr - 1) & ~(bcs - 1); /* start from the current cluster */
+ ofs -= fp->fptr;
+ clst = fp->curr_clust;
+ } else { /* When seek to back cluster, */
+ clst = fp->org_clust; /* start from the first cluster */
+#if !_FS_READONLY
+ if (clst == 0) { /* If no cluster chain, create a new chain */
+ clst = create_chain(fp->fs, 0);
+ if (clst == 1) ABORT(fp->fs, FR_INT_ERR);
+ if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
+ fp->org_clust = clst;
+ }
+#endif
+ fp->curr_clust = clst;
+ }
+ if (clst != 0) {
+ while (ofs > bcs) { /* Cluster following loop */
+#if !_FS_READONLY
+ if (fp->flag & FA_WRITE) { /* Check if in write mode or not */
+ clst = create_chain(fp->fs, clst); /* Force streached if in write mode */
+ if (clst == 0) { /* When disk gets full, clip file size */
+ ofs = bcs; break;
+ }
+ } else
+#endif
+ clst = get_fat(fp->fs, clst); /* Follow cluster chain if not in write mode */
+ if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
+ if (clst <= 1 || clst >= fp->fs->max_clust) ABORT(fp->fs, FR_INT_ERR);
+ fp->curr_clust = clst;
+ fp->fptr += bcs;
+ ofs -= bcs;
+ }
+ fp->fptr += ofs;
+ fp->csect = (BYTE)(ofs / SS(fp->fs)); /* Sector offset in the cluster */
+ if (ofs % SS(fp->fs)) {
+ nsect = clust2sect(fp->fs, clst); /* Current sector */
+ if (!nsect) ABORT(fp->fs, FR_INT_ERR);
+ nsect += fp->csect;
+ fp->csect++;
+ }
+ }
+ }
+ if (fp->fptr % SS(fp->fs) && nsect != fp->dsect) {
+#if !_FS_TINY
+#if !_FS_READONLY
+ if (fp->flag & FA__DIRTY) { /* Write-back dirty buffer if needed */
+ if (disk_write(fp->fs->drive, fp->buf, fp->dsect, 1) != RES_OK)
+ ABORT(fp->fs, FR_DISK_ERR);
+ fp->flag &= ~FA__DIRTY;
+ }
+#endif
+ if (disk_read(fp->fs->drive, fp->buf, nsect, 1) != RES_OK)
+ ABORT(fp->fs, FR_DISK_ERR);
+#endif
+ fp->dsect = nsect;
+ }
+#if !_FS_READONLY
+ if (fp->fptr > fp->fsize) { /* Set changed flag if the file size is extended */
+ fp->fsize = fp->fptr;
+ fp->flag |= FA__WRITTEN;
+ }
+#endif
+
+ LEAVE_FF(fp->fs, res);
+}
+
+
+
+
+#if _FS_MINIMIZE <= 1
+/*-----------------------------------------------------------------------*/
+/* Create a Directroy Object */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_opendir (
+ DIR *dj, /* Pointer to directory object to create */
+ const XCHAR *path /* Pointer to the directory path */
+)
+{
+ FRESULT res;
+ NAMEBUF(sfn, lfn);
+ BYTE *dir;
+
+
+ res = chk_mounted(&path, &dj->fs, 0);
+ if (res == FR_OK) {
+ INITBUF((*dj), sfn, lfn);
+ res = follow_path(dj, path); /* Follow the path to the directory */
+ if (res == FR_OK) { /* Follow completed */
+ dir = dj->dir;
+ if (dir) { /* It is not the root dir */
+ if (dir[DIR_Attr] & AM_DIR) { /* The object is a directory */
+ dj->sclust = ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);
+ } else { /* The object is not a directory */
+ res = FR_NO_PATH;
+ }
+ }
+ if (res == FR_OK) {
+ dj->id = dj->fs->id;
+ res = dir_seek(dj, 0); /* Rewind dir */
+ }
+ }
+ if (res == FR_NO_FILE) res = FR_NO_PATH;
+ }
+
+ LEAVE_FF(dj->fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read Directory Entry in Sequense */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_readdir (
+ DIR *dj, /* Pointer to the open directory object */
+ FILINFO *fno /* Pointer to file information to return */
+)
+{
+ FRESULT res;
+ NAMEBUF(sfn, lfn);
+
+
+ res = validate(dj->fs, dj->id); /* Check validity of the object */
+ if (res == FR_OK) {
+ INITBUF((*dj), sfn, lfn);
+ if (!fno) {
+ res = dir_seek(dj, 0);
+ } else {
+ res = dir_read(dj);
+ if (res == FR_NO_FILE) {
+ dj->sect = 0;
+ res = FR_OK;
+ }
+ if (res == FR_OK) { /* A valid entry is found */
+ get_fileinfo(dj, fno); /* Get the object information */
+ res = dir_next(dj, FALSE); /* Increment index for next */
+ if (res == FR_NO_FILE) {
+ dj->sect = 0;
+ res = FR_OK;
+ }
+ }
+ }
+ }
+
+ LEAVE_FF(dj->fs, res);
+}
+
+
+
+#if _FS_MINIMIZE == 0
+/*-----------------------------------------------------------------------*/
+/* Get File Status */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_stat (
+ const XCHAR *path, /* Pointer to the file path */
+ FILINFO *fno /* Pointer to file information to return */
+)
+{
+ FRESULT res;
+ DIR dj;
+ NAMEBUF(sfn, lfn);
+
+
+ res = chk_mounted(&path, &dj.fs, 0);
+ if (res == FR_OK) {
+ INITBUF(dj, sfn, lfn);
+ res = follow_path(&dj, path); /* Follow the file path */
+ if (res == FR_OK) { /* Follwo completed */
+ if (dj.dir) /* Found an object */
+ get_fileinfo(&dj, fno);
+ else /* It is root dir */
+ res = FR_INVALID_NAME;
+ }
+ }
+
+ LEAVE_FF(dj.fs, res);
+}
+
+
+
+#if !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Get Number of Free Clusters */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_getfree (
+ const XCHAR *path, /* Pointer to the logical drive number (root dir) */
+ DWORD *nclst, /* Pointer to the variable to return number of free clusters */
+ FATFS **fatfs /* Pointer to pointer to corresponding file system object to return */
+)
+{
+ FRESULT res;
+ DWORD n, clst, sect, stat;
+ UINT i;
+ BYTE fat, *p;
+
+
+ /* Get drive number */
+ res = chk_mounted(&path, fatfs, 0);
+ if (res != FR_OK) LEAVE_FF(*fatfs, res);
+
+ /* If number of free cluster is valid, return it without cluster scan. */
+ if ((*fatfs)->free_clust <= (*fatfs)->max_clust - 2) {
+ *nclst = (*fatfs)->free_clust;
+ LEAVE_FF(*fatfs, FR_OK);
+ }
+
+ /* Get number of free clusters */
+ fat = (*fatfs)->fs_type;
+ n = 0;
+ if (fat == FS_FAT12) {
+ clst = 2;
+ do {
+ stat = get_fat(*fatfs, clst);
+ if (stat == 0xFFFFFFFF) LEAVE_FF(*fatfs, FR_DISK_ERR);
+ if (stat == 1) LEAVE_FF(*fatfs, FR_INT_ERR);
+ if (stat == 0) n++;
+ } while (++clst < (*fatfs)->max_clust);
+ } else {
+ clst = (*fatfs)->max_clust;
+ sect = (*fatfs)->fatbase;
+ i = 0; p = 0;
+ do {
+ if (!i) {
+ res = move_window(*fatfs, sect++);
+ if (res != FR_OK)
+ LEAVE_FF(*fatfs, res);
+ p = (*fatfs)->win;
+ i = SS(*fatfs);
+ }
+ if (fat == FS_FAT16) {
+ if (LD_WORD(p) == 0) n++;
+ p += 2; i -= 2;
+ } else {
+ if ((LD_DWORD(p) & 0x0FFFFFFF) == 0) n++;
+ p += 4; i -= 4;
+ }
+ } while (--clst);
+ }
+ (*fatfs)->free_clust = n;
+ if (fat == FS_FAT32) (*fatfs)->fsi_flag = 1;
+ *nclst = n;
+
+ LEAVE_FF(*fatfs, FR_OK);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Truncate File */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_truncate (
+ FIL *fp /* Pointer to the file object */
+)
+{
+ FRESULT res;
+ DWORD ncl;
+
+
+ res = validate(fp->fs, fp->id); /* Check validity of the object */
+ if (res != FR_OK) LEAVE_FF(fp->fs, res);
+ if (fp->flag & FA__ERROR) /* Check abort flag */
+ LEAVE_FF(fp->fs, FR_INT_ERR);
+ if (!(fp->flag & FA_WRITE)) /* Check access mode */
+ LEAVE_FF(fp->fs, FR_DENIED);
+
+ if (fp->fsize > fp->fptr) {
+ fp->fsize = fp->fptr; /* Set file size to current R/W point */
+ fp->flag |= FA__WRITTEN;
+ if (fp->fptr == 0) { /* When set file size to zero, remove entire cluster chain */
+ res = remove_chain(fp->fs, fp->org_clust);
+ fp->org_clust = 0;
+ } else { /* When truncate a part of the file, remove remaining clusters */
+ ncl = get_fat(fp->fs, fp->curr_clust);
+ res = FR_OK;
+ if (ncl == 0xFFFFFFFF) res = FR_DISK_ERR;
+ if (ncl == 1) res = FR_INT_ERR;
+ if (res == FR_OK && ncl < fp->fs->max_clust) {
+ res = put_fat(fp->fs, fp->curr_clust, 0x0FFFFFFF);
+ if (res == FR_OK) res = remove_chain(fp->fs, ncl);
+ }
+ }
+ }
+ if (res != FR_OK) fp->flag |= FA__ERROR;
+
+ LEAVE_FF(fp->fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Delete a File or Directory */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_unlink (
+ const XCHAR *path /* Pointer to the file or directory path */
+)
+{
+ FRESULT res;
+ DIR dj, sdj;
+ NAMEBUF(sfn, lfn);
+ BYTE *dir;
+ DWORD dclst;
+
+
+ res = chk_mounted(&path, &dj.fs, 1);
+ if (res != FR_OK) LEAVE_FF(dj.fs, res);
+
+ INITBUF(dj, sfn, lfn);
+ res = follow_path(&dj, path); /* Follow the file path */
+ if (_FS_RPATH && res == FR_OK && (dj.fn[NS] & NS_DOT))
+ res = FR_INVALID_NAME;
+ if (res != FR_OK) LEAVE_FF(dj.fs, res); /* Follow failed */
+
+ dir = dj.dir;
+ if (!dir) /* Is it the root directory? */
+ LEAVE_FF(dj.fs, FR_INVALID_NAME);
+ if (dir[DIR_Attr] & AM_RDO) /* Is it a R/O object? */
+ LEAVE_FF(dj.fs, FR_DENIED);
+ dclst = ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);
+
+ if (dir[DIR_Attr] & AM_DIR) { /* It is a sub-directory */
+ if (dclst < 2) LEAVE_FF(dj.fs, FR_INT_ERR);
+ mem_cpy(&sdj, &dj, sizeof(DIR)); /* Check if the sub-dir is empty or not */
+ sdj.sclust = dclst;
+ res = dir_seek(&sdj, 2);
+ if (res != FR_OK) LEAVE_FF(dj.fs, res);
+ res = dir_read(&sdj);
+ if (res == FR_OK) res = FR_DENIED; /* Not empty sub-dir */
+ if (res != FR_NO_FILE) LEAVE_FF(dj.fs, res);
+ }
+
+ res = dir_remove(&dj); /* Remove directory entry */
+ if (res == FR_OK) {
+ if (dclst)
+ res = remove_chain(dj.fs, dclst); /* Remove the cluster chain */
+ if (res == FR_OK) res = sync(dj.fs);
+ }
+
+ LEAVE_FF(dj.fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Create a Directory */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_mkdir (
+ const XCHAR *path /* Pointer to the directory path */
+)
+{
+ FRESULT res;
+ DIR dj;
+ NAMEBUF(sfn, lfn);
+ BYTE *dir, n;
+ DWORD dsect, dclst, pclst, tim;
+
+
+ res = chk_mounted(&path, &dj.fs, 1);
+ if (res != FR_OK) LEAVE_FF(dj.fs, res);
+
+ INITBUF(dj, sfn, lfn);
+ res = follow_path(&dj, path); /* Follow the file path */
+ if (res == FR_OK) res = FR_EXIST; /* Any file or directory is already existing */
+ if (_FS_RPATH && res == FR_NO_FILE && (dj.fn[NS] & NS_DOT))
+ res = FR_INVALID_NAME;
+ if (res != FR_NO_FILE) /* Any error occured */
+ LEAVE_FF(dj.fs, res);
+
+ dclst = create_chain(dj.fs, 0); /* Allocate a new cluster for new directory table */
+ res = FR_OK;
+ if (dclst == 0) res = FR_DENIED;
+ if (dclst == 1) res = FR_INT_ERR;
+ if (dclst == 0xFFFFFFFF) res = FR_DISK_ERR;
+ if (res == FR_OK)
+ res = move_window(dj.fs, 0);
+ if (res != FR_OK) LEAVE_FF(dj.fs, res);
+ dsect = clust2sect(dj.fs, dclst);
+
+ dir = dj.fs->win; /* Initialize the new directory table */
+ mem_set(dir, 0, SS(dj.fs));
+ mem_set(dir+DIR_Name, ' ', 8+3); /* Create "." entry */
+ dir[DIR_Name] = '.';
+ dir[DIR_Attr] = AM_DIR;
+ tim = get_fattime();
+ ST_DWORD(dir+DIR_WrtTime, tim);
+ ST_WORD(dir+DIR_FstClusLO, dclst);
+ ST_WORD(dir+DIR_FstClusHI, dclst >> 16);
+ mem_cpy(dir+32, dir, 32); /* Create ".." entry */
+ dir[33] = '.';
+ pclst = dj.sclust;
+ if (dj.fs->fs_type == FS_FAT32 && pclst == dj.fs->dirbase)
+ pclst = 0;
+ ST_WORD(dir+32+DIR_FstClusLO, pclst);
+ ST_WORD(dir+32+DIR_FstClusHI, pclst >> 16);
+ for (n = 0; n < dj.fs->csize; n++) { /* Write dot entries and clear left sectors */
+ dj.fs->winsect = dsect++;
+ dj.fs->wflag = 1;
+ res = move_window(dj.fs, 0);
+ if (res) LEAVE_FF(dj.fs, res);
+ mem_set(dir, 0, SS(dj.fs));
+ }
+
+ res = dir_register(&dj);
+ if (res != FR_OK) {
+ remove_chain(dj.fs, dclst);
+ } else {
+ dir = dj.dir;
+ dir[DIR_Attr] = AM_DIR; /* Attribute */
+ ST_DWORD(dir+DIR_WrtTime, tim); /* Crated time */
+ ST_WORD(dir+DIR_FstClusLO, dclst); /* Table start cluster */
+ ST_WORD(dir+DIR_FstClusHI, dclst >> 16);
+ dj.fs->wflag = 1;
+ res = sync(dj.fs);
+ }
+
+ LEAVE_FF(dj.fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Change File Attribute */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_chmod (
+ const XCHAR *path, /* Pointer to the file path */
+ BYTE value, /* Attribute bits */
+ BYTE mask /* Attribute mask to change */
+)
+{
+ FRESULT res;
+ DIR dj;
+ NAMEBUF(sfn, lfn);
+ BYTE *dir;
+
+
+ res = chk_mounted(&path, &dj.fs, 1);
+ if (res == FR_OK) {
+ INITBUF(dj, sfn, lfn);
+ res = follow_path(&dj, path); /* Follow the file path */
+ if (_FS_RPATH && res == FR_OK && (dj.fn[NS] & NS_DOT))
+ res = FR_INVALID_NAME;
+ if (res == FR_OK) {
+ dir = dj.dir;
+ if (!dir) { /* Is it a root directory? */
+ res = FR_INVALID_NAME;
+ } else { /* File or sub directory */
+ mask &= AM_RDO|AM_HID|AM_SYS|AM_ARC; /* Valid attribute mask */
+ dir[DIR_Attr] = (value & mask) | (dir[DIR_Attr] & (BYTE)~mask); /* Apply attribute change */
+ dj.fs->wflag = 1;
+ res = sync(dj.fs);
+ }
+ }
+ }
+
+ LEAVE_FF(dj.fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Change Timestamp */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_utime (
+ const XCHAR *path, /* Pointer to the file/directory name */
+ const FILINFO *fno /* Pointer to the timestamp to be set */
+)
+{
+ FRESULT res;
+ DIR dj;
+ NAMEBUF(sfn, lfn);
+ BYTE *dir;
+
+
+ res = chk_mounted(&path, &dj.fs, 1);
+ if (res == FR_OK) {
+ INITBUF(dj, sfn, lfn);
+ res = follow_path(&dj, path); /* Follow the file path */
+ if (_FS_RPATH && res == FR_OK && (dj.fn[NS] & NS_DOT))
+ res = FR_INVALID_NAME;
+ if (res == FR_OK) {
+ dir = dj.dir;
+ if (!dir) { /* Root directory */
+ res = FR_INVALID_NAME;
+ } else { /* File or sub-directory */
+ ST_WORD(dir+DIR_WrtTime, fno->ftime);
+ ST_WORD(dir+DIR_WrtDate, fno->fdate);
+ dj.fs->wflag = 1;
+ res = sync(dj.fs);
+ }
+ }
+ }
+
+ LEAVE_FF(dj.fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Rename File/Directory */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_rename (
+ const XCHAR *path_old, /* Pointer to the old name */
+ const XCHAR *path_new /* Pointer to the new name */
+)
+{
+ FRESULT res;
+ DIR dj_old, dj_new;
+ NAMEBUF(sfn, lfn);
+ BYTE buf[21], *dir;
+ DWORD dw;
+
+
+ INITBUF(dj_old, sfn, lfn);
+ res = chk_mounted(&path_old, &dj_old.fs, 1);
+ if (res == FR_OK) {
+ dj_new.fs = dj_old.fs;
+ res = follow_path(&dj_old, path_old); /* Check old object */
+ if (_FS_RPATH && res == FR_OK && (dj_old.fn[NS] & NS_DOT))
+ res = FR_INVALID_NAME;
+ }
+ if (res != FR_OK) LEAVE_FF(dj_old.fs, res); /* The old object is not found */
+
+ if (!dj_old.dir) LEAVE_FF(dj_old.fs, FR_NO_FILE); /* Is root dir? */
+ mem_cpy(buf, dj_old.dir+DIR_Attr, 21); /* Save the object information */
+
+ mem_cpy(&dj_new, &dj_old, sizeof(DIR));
+ res = follow_path(&dj_new, path_new); /* Check new object */
+ if (res == FR_OK) res = FR_EXIST; /* The new object name is already existing */
+ if (res == FR_NO_FILE) { /* Is it a valid path and no name collision? */
+ res = dir_register(&dj_new); /* Register the new object */
+ if (res == FR_OK) {
+ dir = dj_new.dir; /* Copy object information into new entry */
+ mem_cpy(dir+13, buf+2, 19);
+ dir[DIR_Attr] = buf[0] | AM_ARC;
+ dj_old.fs->wflag = 1;
+ if (dir[DIR_Attr] & AM_DIR) { /* Update .. entry in the directory if needed */
+ dw = clust2sect(dj_new.fs, (DWORD)LD_WORD(dir+DIR_FstClusHI) | LD_WORD(dir+DIR_FstClusLO));
+ if (!dw) {
+ res = FR_INT_ERR;
+ } else {
+ res = move_window(dj_new.fs, dw);
+ dir = dj_new.fs->win+32;
+ if (res == FR_OK && dir[1] == '.') {
+ dw = (dj_new.fs->fs_type == FS_FAT32 && dj_new.sclust == dj_new.fs->dirbase) ? 0 : dj_new.sclust;
+ ST_WORD(dir+DIR_FstClusLO, dw);
+ ST_WORD(dir+DIR_FstClusHI, dw >> 16);
+ dj_new.fs->wflag = 1;
+ }
+ }
+ }
+ if (res == FR_OK) {
+ res = dir_remove(&dj_old); /* Remove old entry */
+ if (res == FR_OK)
+ res = sync(dj_old.fs);
+ }
+ }
+ }
+
+ LEAVE_FF(dj_old.fs, res);
+}
+
+#endif /* !_FS_READONLY */
+#endif /* _FS_MINIMIZE == 0 */
+#endif /* _FS_MINIMIZE <= 1 */
+#endif /* _FS_MINIMIZE <= 2 */
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Forward data to the stream directly (Available on only _FS_TINY cfg) */
+/*-----------------------------------------------------------------------*/
+#if _USE_FORWARD && _FS_TINY
+
+FRESULT f_forward (
+ FIL *fp, /* Pointer to the file object */
+ UINT (*func)(const BYTE*,UINT), /* Pointer to the streaming function */
+ UINT btr, /* Number of bytes to forward */
+ UINT *bf /* Pointer to number of bytes forwarded */
+)
+{
+ FRESULT res;
+ DWORD remain, clst, sect;
+ UINT rcnt;
+
+
+ *bf = 0;
+
+ res = validate(fp->fs, fp->id); /* Check validity of the object */
+ if (res != FR_OK) LEAVE_FF(fp->fs, res);
+ if (fp->flag & FA__ERROR) /* Check error flag */
+ LEAVE_FF(fp->fs, FR_INT_ERR);
+ if (!(fp->flag & FA_READ)) /* Check access mode */
+ LEAVE_FF(fp->fs, FR_DENIED);
+
+ remain = fp->fsize - fp->fptr;
+ if (btr > remain) btr = (UINT)remain; /* Truncate btr by remaining bytes */
+
+ for ( ; btr && (*func)(NULL, 0); /* Repeat until all data transferred or stream becomes busy */
+ fp->fptr += rcnt, *bf += rcnt, btr -= rcnt) {
+ if ((fp->fptr % SS(fp->fs)) == 0) { /* On the sector boundary? */
+ if (fp->csect >= fp->fs->csize) { /* On the cluster boundary? */
+ clst = (fp->fptr == 0) ? /* On the top of the file? */
+ fp->org_clust : get_fat(fp->fs, fp->curr_clust);
+ if (clst <= 1) ABORT(fp->fs, FR_INT_ERR);
+ if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
+ fp->curr_clust = clst; /* Update current cluster */
+ fp->csect = 0; /* Reset sector address in the cluster */
+ }
+ fp->csect++; /* Next sector address in the cluster */
+ }
+ sect = clust2sect(fp->fs, fp->curr_clust); /* Get current data sector */
+ if (!sect) ABORT(fp->fs, FR_INT_ERR);
+ sect += fp->csect - 1;
+ if (move_window(fp->fs, sect)) /* Move sector window */
+ ABORT(fp->fs, FR_DISK_ERR);
+ fp->dsect = sect;
+ rcnt = SS(fp->fs) - (WORD)(fp->fptr % SS(fp->fs)); /* Forward data from sector window */
+ if (rcnt > btr) rcnt = btr;
+ rcnt = (*func)(&fp->fs->win[(WORD)fp->fptr % SS(fp->fs)], rcnt);
+ if (!rcnt) ABORT(fp->fs, FR_INT_ERR);
+ }
+
+ LEAVE_FF(fp->fs, FR_OK);
+}
+#endif /* _USE_FORWARD */
+
+
+
+#if _USE_MKFS && !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Create File System on the Drive */
+/*-----------------------------------------------------------------------*/
+#define N_ROOTDIR 512 /* Multiple of 32 and <= 2048 */
+#define N_FATS 1 /* 1 or 2 */
+#define MAX_SECTOR 131072000UL /* Maximum partition size */
+#define MIN_SECTOR 2000UL /* Minimum partition size */
+
+
+FRESULT f_mkfs (
+ BYTE drv, /* Logical drive number */
+ BYTE partition, /* Partitioning rule 0:FDISK, 1:SFD */
+ WORD allocsize /* Allocation unit size [bytes] */
+)
+{
+ static const DWORD sstbl[] = { 2048000, 1024000, 512000, 256000, 128000, 64000, 32000, 16000, 8000, 4000, 0 };
+ static const WORD cstbl[] = { 32768, 16384, 8192, 4096, 2048, 16384, 8192, 4096, 2048, 1024, 512 };
+ BYTE fmt, m, *tbl;
+ DWORD b_part, b_fat, b_dir, b_data; /* Area offset (LBA) */
+ DWORD n_part, n_rsv, n_fat, n_dir; /* Area size */
+ DWORD n_clst, d, n;
+ WORD as;
+ FATFS *fs;
+ DSTATUS stat;
+
+
+ /* Check validity of the parameters */
+ if (drv >= _DRIVES) return FR_INVALID_DRIVE;
+ if (partition >= 2) return FR_MKFS_ABORTED;
+
+ /* Check mounted drive and clear work area */
+ fs = FatFs[drv];
+ if (!fs) return FR_NOT_ENABLED;
+ fs->fs_type = 0;
+ drv = LD2PD(drv);
+
+ /* Get disk statics */
+ stat = disk_initialize(drv);
+ if (stat & STA_NOINIT) return FR_NOT_READY;
+ if (stat & STA_PROTECT) return FR_WRITE_PROTECTED;
+#if _MAX_SS != 512 /* Get disk sector size */
+ if (disk_ioctl(drv, GET_SECTOR_SIZE, &SS(fs)) != RES_OK
+ || SS(fs) > _MAX_SS)
+ return FR_MKFS_ABORTED;
+#endif
+ if (disk_ioctl(drv, GET_SECTOR_COUNT, &n_part) != RES_OK || n_part < MIN_SECTOR)
+ return FR_MKFS_ABORTED;
+ if (n_part > MAX_SECTOR) n_part = MAX_SECTOR;
+ b_part = (!partition) ? 63 : 0; /* Boot sector */
+ n_part -= b_part;
+ for (d = 512; d <= 32768U && d != allocsize; d <<= 1) ; /* Check validity of the allocation unit size */
+ if (d != allocsize) allocsize = 0;
+ if (!allocsize) { /* Auto selection of cluster size */
+ d = n_part;
+ for (as = SS(fs); as > 512U; as >>= 1) d >>= 1;
+ for (n = 0; d < sstbl[n]; n++) ;
+ allocsize = cstbl[n];
+ }
+ if (allocsize < SS(fs)) allocsize = SS(fs);
+
+ allocsize /= SS(fs); /* Number of sectors per cluster */
+
+ /* Pre-compute number of clusters and FAT type */
+ n_clst = n_part / allocsize;
+ fmt = FS_FAT12;
+ if (n_clst >= 0xFF5) fmt = FS_FAT16;
+ if (n_clst >= 0xFFF5) fmt = FS_FAT32;
+
+ /* Determine offset and size of FAT structure */
+ switch (fmt) {
+ case FS_FAT12:
+ n_fat = ((n_clst * 3 + 1) / 2 + 3 + SS(fs) - 1) / SS(fs);
+ n_rsv = 1 + partition;
+ n_dir = N_ROOTDIR * 32 / SS(fs);
+ break;
+ case FS_FAT16:
+ n_fat = ((n_clst * 2) + 4 + SS(fs) - 1) / SS(fs);
+ n_rsv = 1 + partition;
+ n_dir = N_ROOTDIR * 32 / SS(fs);
+ break;
+ default:
+ n_fat = ((n_clst * 4) + 8 + SS(fs) - 1) / SS(fs);
+ n_rsv = 33 - partition;
+ n_dir = 0;
+ }
+ b_fat = b_part + n_rsv; /* FATs start sector */
+ b_dir = b_fat + n_fat * N_FATS; /* Directory start sector */
+ b_data = b_dir + n_dir; /* Data start sector */
+
+ /* Align data start sector to erase block boundary (for flash memory media) */
+ if (disk_ioctl(drv, GET_BLOCK_SIZE, &n) != RES_OK) return FR_MKFS_ABORTED;
+ n = (b_data + n - 1) & ~(n - 1);
+ n_fat += (n - b_data) / N_FATS;
+ /* b_dir and b_data are no longer used below */
+
+ /* Determine number of cluster and final check of validity of the FAT type */
+ n_clst = (n_part - n_rsv - n_fat * N_FATS - n_dir) / allocsize;
+ if ( (fmt == FS_FAT16 && n_clst < 0xFF5)
+ || (fmt == FS_FAT32 && n_clst < 0xFFF5))
+ return FR_MKFS_ABORTED;
+
+ /* Create partition table if needed */
+ if (!partition) {
+ DWORD n_disk = b_part + n_part;
+
+ mem_set(fs->win, 0, SS(fs));
+ tbl = fs->win+MBR_Table;
+ ST_DWORD(tbl, 0x00010180); /* Partition start in CHS */
+ if (n_disk < 63UL * 255 * 1024) { /* Partition end in CHS */
+ n_disk = n_disk / 63 / 255;
+ tbl[7] = (BYTE)n_disk;
+ tbl[6] = (BYTE)((n_disk >> 2) | 63);
+ } else {
+ ST_WORD(&tbl[6], 0xFFFF);
+ }
+ tbl[5] = 254;
+ if (fmt != FS_FAT32) /* System ID */
+ tbl[4] = (n_part < 0x10000) ? 0x04 : 0x06;
+ else
+ tbl[4] = 0x0c;
+ ST_DWORD(tbl+8, 63); /* Partition start in LBA */
+ ST_DWORD(tbl+12, n_part); /* Partition size in LBA */
+ ST_WORD(tbl+64, 0xAA55); /* Signature */
+ if (disk_write(drv, fs->win, 0, 1) != RES_OK)
+ return FR_DISK_ERR;
+ partition = 0xF8;
+ } else {
+ partition = 0xF0;
+ }
+
+ /* Create boot record */
+ tbl = fs->win; /* Clear buffer */
+ mem_set(tbl, 0, SS(fs));
+ ST_DWORD(tbl+BS_jmpBoot, 0x90FEEB); /* Boot code (jmp $, nop) */
+ ST_WORD(tbl+BPB_BytsPerSec, SS(fs)); /* Sector size */
+ tbl[BPB_SecPerClus] = (BYTE)allocsize; /* Sectors per cluster */
+ ST_WORD(tbl+BPB_RsvdSecCnt, n_rsv); /* Reserved sectors */
+ tbl[BPB_NumFATs] = N_FATS; /* Number of FATs */
+ ST_WORD(tbl+BPB_RootEntCnt, SS(fs) / 32 * n_dir); /* Number of rootdir entries */
+ if (n_part < 0x10000) { /* Number of total sectors */
+ ST_WORD(tbl+BPB_TotSec16, n_part);
+ } else {
+ ST_DWORD(tbl+BPB_TotSec32, n_part);
+ }
+ tbl[BPB_Media] = partition; /* Media descripter */
+ ST_WORD(tbl+BPB_SecPerTrk, 63); /* Number of sectors per track */
+ ST_WORD(tbl+BPB_NumHeads, 255); /* Number of heads */
+ ST_DWORD(tbl+BPB_HiddSec, b_part); /* Hidden sectors */
+ n = get_fattime(); /* Use current time as a VSN */
+ if (fmt != FS_FAT32) {
+ ST_DWORD(tbl+BS_VolID, n); /* Volume serial number */
+ ST_WORD(tbl+BPB_FATSz16, n_fat); /* Number of secters per FAT */
+ tbl[BS_DrvNum] = 0x80; /* Drive number */
+ tbl[BS_BootSig] = 0x29; /* Extended boot signature */
+ mem_cpy(tbl+BS_VolLab, "NO NAME FAT ", 19); /* Volume lavel, FAT signature */
+ } else {
+ ST_DWORD(tbl+BS_VolID32, n); /* Volume serial number */
+ ST_DWORD(tbl+BPB_FATSz32, n_fat); /* Number of secters per FAT */
+ ST_DWORD(tbl+BPB_RootClus, 2); /* Root directory cluster (2) */
+ ST_WORD(tbl+BPB_FSInfo, 1); /* FSInfo record offset (bs+1) */
+ ST_WORD(tbl+BPB_BkBootSec, 6); /* Backup boot record offset (bs+6) */
+ tbl[BS_DrvNum32] = 0x80; /* Drive number */
+ tbl[BS_BootSig32] = 0x29; /* Extended boot signature */
+ mem_cpy(tbl+BS_VolLab32, "NO NAME FAT32 ", 19); /* Volume lavel, FAT signature */
+ }
+ ST_WORD(tbl+BS_55AA, 0xAA55); /* Signature */
+ if (SS(fs) > 512U) {
+ ST_WORD(tbl+SS(fs)-2, 0xAA55);
+ }
+ if (disk_write(drv, tbl, b_part+0, 1) != RES_OK)
+ return FR_DISK_ERR;
+ if (fmt == FS_FAT32)
+ disk_write(drv, tbl, b_part+6, 1);
+
+ /* Initialize FAT area */
+ for (m = 0; m < N_FATS; m++) {
+ mem_set(tbl, 0, SS(fs)); /* 1st sector of the FAT */
+ if (fmt != FS_FAT32) {
+ n = (fmt == FS_FAT12) ? 0x00FFFF00 : 0xFFFFFF00;
+ n |= partition;
+ ST_DWORD(tbl, n); /* Reserve cluster #0-1 (FAT12/16) */
+ } else {
+ ST_DWORD(tbl+0, 0xFFFFFFF8); /* Reserve cluster #0-1 (FAT32) */
+ ST_DWORD(tbl+4, 0xFFFFFFFF);
+ ST_DWORD(tbl+8, 0x0FFFFFFF); /* Reserve cluster #2 for root dir */
+ }
+ if (disk_write(drv, tbl, b_fat++, 1) != RES_OK)
+ return FR_DISK_ERR;
+ mem_set(tbl, 0, SS(fs)); /* Following FAT entries are filled by zero */
+ for (n = 1; n < n_fat; n++) {
+ if (disk_write(drv, tbl, b_fat++, 1) != RES_OK)
+ return FR_DISK_ERR;
+ }
+ }
+
+ /* Initialize Root directory */
+ m = (BYTE)((fmt == FS_FAT32) ? allocsize : n_dir);
+ do {
+ if (disk_write(drv, tbl, b_fat++, 1) != RES_OK)
+ return FR_DISK_ERR;
+ } while (--m);
+
+ /* Create FSInfo record if needed */
+ if (fmt == FS_FAT32) {
+ ST_WORD(tbl+BS_55AA, 0xAA55);
+ ST_DWORD(tbl+FSI_LeadSig, 0x41615252);
+ ST_DWORD(tbl+FSI_StrucSig, 0x61417272);
+ ST_DWORD(tbl+FSI_Free_Count, n_clst - 1);
+ ST_DWORD(tbl+FSI_Nxt_Free, 0xFFFFFFFF);
+ disk_write(drv, tbl, b_part+1, 1);
+ disk_write(drv, tbl, b_part+7, 1);
+ }
+
+ return (disk_ioctl(drv, CTRL_SYNC, (void*)NULL) == RES_OK) ? FR_OK : FR_DISK_ERR;
+}
+
+#endif /* _USE_MKFS && !_FS_READONLY */
+
+
+
+
+#if _USE_STRFUNC
+/*-----------------------------------------------------------------------*/
+/* Get a string from the file */
+/*-----------------------------------------------------------------------*/
+char* f_gets (
+ char* buff, /* Pointer to the string buffer to read */
+ int len, /* Size of string buffer */
+ FIL* fil /* Pointer to the file object */
+)
+{
+ int i = 0;
+ char *p = buff;
+ UINT rc;
+
+
+ while (i < len - 1) { /* Read bytes until buffer gets filled */
+ f_read(fil, p, 1, &rc);
+ if (rc != 1) break; /* Break when no data to read */
+#if _USE_STRFUNC >= 2
+ if (*p == '\r') continue; /* Strip '\r' */
+#endif
+ i++;
+ if (*p++ == '\n') break; /* Break when reached end of line */
+ }
+ *p = 0;
+ return i ? buff : NULL; /* When no data read (eof or error), return with error. */
+}
+
+
+
+#if !_FS_READONLY
+#include <stdarg.h>
+/*-----------------------------------------------------------------------*/
+/* Put a character to the file */
+/*-----------------------------------------------------------------------*/
+int f_putc (
+ int chr, /* A character to be output */
+ FIL* fil /* Ponter to the file object */
+)
+{
+ UINT bw;
+ char c;
+
+
+#if _USE_STRFUNC >= 2
+ if (chr == '\n') f_putc ('\r', fil); /* LF -> CRLF conversion */
+#endif
+ if (!fil) { /* Special value may be used to switch the destination to any other device */
+ /* put_console(chr); */
+ return chr;
+ }
+ c = (char)chr;
+ f_write(fil, &c, 1, &bw); /* Write a byte to the file */
+ return bw ? chr : EOF; /* Return the result */
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Put a string to the file */
+/*-----------------------------------------------------------------------*/
+int f_puts (
+ const char* str, /* Pointer to the string to be output */
+ FIL* fil /* Pointer to the file object */
+)
+{
+ int n;
+
+
+ for (n = 0; *str; str++, n++) {
+ if (f_putc(*str, fil) == EOF) return EOF;
+ }
+ return n;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Put a formatted string to the file */
+/*-----------------------------------------------------------------------*/
+int f_printf (
+ FIL* fil, /* Pointer to the file object */
+ const char* str, /* Pointer to the format string */
+ ... /* Optional arguments... */
+)
+{
+ va_list arp;
+ UCHAR c, f, r;
+ ULONG val;
+ char s[16];
+ int i, w, res, cc;
+
+
+ va_start(arp, str);
+
+ for (cc = res = 0; cc != EOF; res += cc) {
+ c = *str++;
+ if (c == 0) break; /* End of string */
+ if (c != '%') { /* Non escape cahracter */
+ cc = f_putc(c, fil);
+ if (cc != EOF) cc = 1;
+ continue;
+ }
+ w = f = 0;
+ c = *str++;
+ if (c == '0') { /* Flag: '0' padding */
+ f = 1; c = *str++;
+ }
+ while (c >= '0' && c <= '9') { /* Precision */
+ w = w * 10 + (c - '0');
+ c = *str++;
+ }
+ if (c == 'l') { /* Prefix: Size is long int */
+ f |= 2; c = *str++;
+ }
+ if (c == 's') { /* Type is string */
+ cc = f_puts(va_arg(arp, char*), fil);
+ continue;
+ }
+ if (c == 'c') { /* Type is character */
+ cc = f_putc(va_arg(arp, int), fil);
+ if (cc != EOF) cc = 1;
+ continue;
+ }
+ r = 0;
+ if (c == 'd') r = 10; /* Type is signed decimal */
+ if (c == 'u') r = 10; /* Type is unsigned decimal */
+ if (c == 'X') r = 16; /* Type is unsigned hexdecimal */
+ if (r == 0) break; /* Unknown type */
+ if (f & 2) { /* Get the value */
+ val = (ULONG)va_arg(arp, long);
+ } else {
+ val = (c == 'd') ? (ULONG)(long)va_arg(arp, int) : (ULONG)va_arg(arp, unsigned int);
+ }
+ /* Put numeral string */
+ if (c == 'd') {
+ if (val & 0x80000000) {
+ val = 0 - val;
+ f |= 4;
+ }
+ }
+ i = sizeof(s) - 1; s[i] = 0;
+ do {
+ c = (UCHAR)(val % r + '0');
+ if (c > '9') c += 7;
+ s[--i] = c;
+ val /= r;
+ } while (i && val);
+ if (i && (f & 4)) s[--i] = '-';
+ w = sizeof(s) - 1 - w;
+ while (i && i > w) s[--i] = (f & 1) ? '0' : ' ';
+ cc = f_puts(&s[i], fil);
+ }
+
+ va_end(arp);
+ return (cc == EOF) ? cc : res;
+}
+
+#endif /* !_FS_READONLY */
+#endif /* _USE_STRFUNC */
diff --git a/Projects/Webserver/Lib/FATFs/ff.h b/Projects/Webserver/Lib/FATFs/ff.h new file mode 100644 index 000000000..41e136ee5 --- /dev/null +++ b/Projects/Webserver/Lib/FATFs/ff.h @@ -0,0 +1,596 @@ +/*---------------------------------------------------------------------------/
+/ FatFs - FAT file system module include file R0.07e (C)ChaN, 2010
+/----------------------------------------------------------------------------/
+/ FatFs module is a generic FAT file system module for small embedded systems.
+/ This is a free software that opened for education, research and commercial
+/ developments under license policy of following trems.
+/
+/ Copyright (C) 2010, ChaN, all right reserved.
+/
+/ * The FatFs module is a free software and there is NO WARRANTY.
+/ * No restriction on use. You can use, modify and redistribute it for
+/ personal, non-profit or commercial product UNDER YOUR RESPONSIBILITY.
+/ * Redistributions of source code must retain the above copyright notice.
+/----------------------------------------------------------------------------*/
+
+#ifndef _FATFS
+#define _FATFS 0x007E
+
+#include "integer.h" /* Basic integer types */
+#include "ffconf.h" /* FatFs configuration options */
+
+#if _FATFS != _FFCONFIG
+#error Wrong configuration file (ffconf.h).
+#endif
+
+
+/* DBCS code ranges and SBCS extend char conversion table */
+
+#if _CODE_PAGE == 932 /* Japanese Shift-JIS */
+#define _DF1S 0x81 /* DBC 1st byte range 1 start */
+#define _DF1E 0x9F /* DBC 1st byte range 1 end */
+#define _DF2S 0xE0 /* DBC 1st byte range 2 start */
+#define _DF2E 0xFC /* DBC 1st byte range 2 end */
+#define _DS1S 0x40 /* DBC 2nd byte range 1 start */
+#define _DS1E 0x7E /* DBC 2nd byte range 1 end */
+#define _DS2S 0x80 /* DBC 2nd byte range 2 start */
+#define _DS2E 0xFC /* DBC 2nd byte range 2 end */
+
+#elif _CODE_PAGE == 936 /* Simplified Chinese GBK */
+#define _DF1S 0x81
+#define _DF1E 0xFE
+#define _DS1S 0x40
+#define _DS1E 0x7E
+#define _DS2S 0x80
+#define _DS2E 0xFE
+
+#elif _CODE_PAGE == 949 /* Korean */
+#define _DF1S 0x81
+#define _DF1E 0xFE
+#define _DS1S 0x41
+#define _DS1E 0x5A
+#define _DS2S 0x61
+#define _DS2E 0x7A
+#define _DS3S 0x81
+#define _DS3E 0xFE
+
+#elif _CODE_PAGE == 950 /* Traditional Chinese Big5 */
+#define _DF1S 0x81
+#define _DF1E 0xFE
+#define _DS1S 0x40
+#define _DS1E 0x7E
+#define _DS2S 0xA1
+#define _DS2E 0xFE
+
+#elif _CODE_PAGE == 437 /* U.S. (OEM) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x9A,0x90,0x41,0x8E,0x41,0x8F,0x80,0x45,0x45,0x45,0x49,0x49,0x49,0x8E,0x8F,0x90,0x92,0x92,0x4F,0x99,0x4F,0x55,0x55,0x59,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+ 0x41,0x49,0x4F,0x55,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 720 /* Arabic (OEM) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x81,0x45,0x41,0x84,0x41,0x86,0x43,0x45,0x45,0x45,0x49,0x49,0x8D,0x8E,0x8F,0x90,0x92,0x92,0x93,0x94,0x95,0x49,0x49,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 737 /* Greek (OEM) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x92,0x92,0x93,0x94,0x95,0x96,0x97,0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87, \
+ 0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0xAA,0x92,0x93,0x94,0x95,0x96,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0x97,0xEA,0xEB,0xEC,0xE4,0xED,0xEE,0xE7,0xE8,0xF1,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 775 /* Baltic (OEM) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x9A,0x91,0xA0,0x8E,0x95,0x8F,0x80,0xAD,0xED,0x8A,0x8A,0xA1,0x8D,0x8E,0x8F,0x90,0x92,0x92,0xE2,0x99,0x95,0x96,0x97,0x97,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9F, \
+ 0xA0,0xA1,0xE0,0xA3,0xA3,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xB5,0xB6,0xB7,0xB8,0xBD,0xBE,0xC6,0xC7,0xA5,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE3,0xE8,0xE8,0xEA,0xEA,0xEE,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 850 /* Multilingual Latin 1 (OEM) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x9A,0x90,0xB6,0x8E,0xB7,0x8F,0x80,0xD2,0xD3,0xD4,0xD8,0xD7,0xDE,0x8E,0x8F,0x90,0x92,0x92,0xE2,0x99,0xE3,0xEA,0xEB,0x59,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9F, \
+ 0xB5,0xD6,0xE0,0xE9,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE7,0xE7,0xE9,0xEA,0xEB,0xED,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 852 /* Latin 2 (OEM) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x9A,0x90,0xB6,0x8E,0xDE,0x8F,0x80,0x9D,0xD3,0x8A,0x8A,0xD7,0x8D,0x8E,0x8F,0x90,0x91,0x91,0xE2,0x99,0x95,0x95,0x97,0x97,0x99,0x9A,0x9B,0x9B,0x9D,0x9E,0x9F, \
+ 0xB5,0xD6,0xE0,0xE9,0xA4,0xA4,0xA6,0xA6,0xA8,0xA8,0xAA,0x8D,0xAC,0xB8,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBD,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC6,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD1,0xD1,0xD2,0xD3,0xD2,0xD5,0xD6,0xD7,0xB7,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xE0,0xE1,0xE2,0xE3,0xE3,0xD5,0xE6,0xE6,0xE8,0xE9,0xE8,0xEB,0xED,0xED,0xDD,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xEB,0xFC,0xFC,0xFE,0xFF}
+
+#elif _CODE_PAGE == 855 /* Cyrillic (OEM) */
+#define _DF1S 0
+#define _EXCVT {0x81,0x81,0x83,0x83,0x85,0x85,0x87,0x87,0x89,0x89,0x8B,0x8B,0x8D,0x8D,0x8F,0x8F,0x91,0x91,0x93,0x93,0x95,0x95,0x97,0x97,0x99,0x99,0x9B,0x9B,0x9D,0x9D,0x9F,0x9F, \
+ 0xA1,0xA1,0xA3,0xA3,0xA5,0xA5,0xA7,0xA7,0xA9,0xA9,0xAB,0xAB,0xAD,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB6,0xB6,0xB8,0xB8,0xB9,0xBA,0xBB,0xBC,0xBE,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD1,0xD1,0xD3,0xD3,0xD5,0xD5,0xD7,0xD7,0xDD,0xD9,0xDA,0xDB,0xDC,0xDD,0xE0,0xDF, \
+ 0xE0,0xE2,0xE2,0xE4,0xE4,0xE6,0xE6,0xE8,0xE8,0xEA,0xEA,0xEC,0xEC,0xEE,0xEE,0xEF,0xF0,0xF2,0xF2,0xF4,0xF4,0xF6,0xF6,0xF8,0xF8,0xFA,0xFA,0xFC,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 857 /* Turkish (OEM) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x9A,0x90,0xB6,0x8E,0xB7,0x8F,0x80,0xD2,0xD3,0xD4,0xD8,0xD7,0x98,0x8E,0x8F,0x90,0x92,0x92,0xE2,0x99,0xE3,0xEA,0xEB,0x98,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9E, \
+ 0xB5,0xD6,0xE0,0xE9,0xA5,0xA5,0xA6,0xA6,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xDE,0x59,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 858 /* Multilingual Latin 1 + Euro (OEM) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x9A,0x90,0xB6,0x8E,0xB7,0x8F,0x80,0xD2,0xD3,0xD4,0xD8,0xD7,0xDE,0x8E,0x8F,0x90,0x92,0x92,0xE2,0x99,0xE3,0xEA,0xEB,0x59,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9F, \
+ 0xB5,0xD6,0xE0,0xE9,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD1,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE7,0xE7,0xE9,0xEA,0xEB,0xED,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 862 /* Hebrew (OEM) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+ 0x41,0x49,0x4F,0x55,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 866 /* Russian (OEM) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+ 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0x90,0x91,0x92,0x93,0x9d,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,0xF0,0xF0,0xF2,0xF2,0xF4,0xF4,0xF6,0xF6,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 874 /* Thai (OEM, Windows) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 1250 /* Central Europe (Windows) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x8A,0x9B,0x8C,0x8D,0x8E,0x8F, \
+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xA3,0xB4,0xB5,0xB6,0xB7,0xB8,0xA5,0xAA,0xBB,0xBC,0xBD,0xBC,0xAF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xFF}
+
+#elif _CODE_PAGE == 1251 /* Cyrillic (Windows) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x81,0x82,0x82,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x80,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x8A,0x9B,0x8C,0x8D,0x8E,0x8F, \
+ 0xA0,0xA2,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB2,0xA5,0xB5,0xB6,0xB7,0xA8,0xB9,0xAA,0xBB,0xA3,0xBD,0xBD,0xAF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF}
+
+#elif _CODE_PAGE == 1252 /* Latin 1 (Windows) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xAd,0x9B,0x8C,0x9D,0xAE,0x9F, \
+ 0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0x9F}
+
+#elif _CODE_PAGE == 1253 /* Greek (Windows) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xA2,0xB8,0xB9,0xBA, \
+ 0xE0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xF2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xFB,0xBC,0xFD,0xBF,0xFF}
+
+#elif _CODE_PAGE == 1254 /* Turkish (Windows) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x8A,0x9B,0x8C,0x9D,0x9E,0x9F, \
+ 0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0x9F}
+
+#elif _CODE_PAGE == 1255 /* Hebrew (Windows) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+ 0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 1256 /* Arabic (Windows) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x8C,0x9D,0x9E,0x9F, \
+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0x41,0xE1,0x41,0xE3,0xE4,0xE5,0xE6,0x43,0x45,0x45,0x45,0x45,0xEC,0xED,0x49,0x49,0xF0,0xF1,0xF2,0xF3,0x4F,0xF5,0xF6,0xF7,0xF8,0x55,0xFA,0x55,0x55,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 1257 /* Baltic (Windows) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xA8,0xB9,0xAA,0xBB,0xBC,0xBD,0xBE,0xAF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xFF}
+
+#elif _CODE_PAGE == 1258 /* Vietnam (OEM, Windows) */
+#define _DF1S 0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0xAC,0x9D,0x9E,0x9F, \
+ 0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xEC,0xCD,0xCE,0xCF,0xD0,0xD1,0xF2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xFE,0x9F}
+
+#elif _CODE_PAGE == 1 /* ASCII (for only non-LFN cfg) */
+#define _DF1S 0
+
+#else
+#error Unknown code page
+
+#endif
+
+
+
+/* Character code support macros */
+
+#define IsUpper(c) (((c)>='A')&&((c)<='Z'))
+#define IsLower(c) (((c)>='a')&&((c)<='z'))
+
+#if _DF1S /* DBCS configuration */
+
+#ifdef _DF2S /* Two 1st byte areas */
+#define IsDBCS1(c) (((BYTE)(c) >= _DF1S && (BYTE)(c) <= _DF1E) || ((BYTE)(c) >= _DF2S && (BYTE)(c) <= _DF2E))
+#else /* One 1st byte area */
+#define IsDBCS1(c) ((BYTE)(c) >= _DF1S && (BYTE)(c) <= _DF1E)
+#endif
+
+#ifdef _DS3S /* Three 2nd byte areas */
+#define IsDBCS2(c) (((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E) || ((BYTE)(c) >= _DS3S && (BYTE)(c) <= _DS3E))
+#else /* Two 2nd byte areas */
+#define IsDBCS2(c) (((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E))
+#endif
+
+#else /* SBCS configuration */
+
+#define IsDBCS1(c) 0
+#define IsDBCS2(c) 0
+
+#endif /* _DF1S */
+
+
+
+/* Definitions corresponds to multi partition */
+
+#if _MULTI_PARTITION /* Multiple partition configuration */
+
+typedef struct _PARTITION {
+ BYTE pd; /* Physical drive# */
+ BYTE pt; /* Partition # (0-3) */
+} PARTITION;
+
+extern
+const PARTITION Drives[]; /* Logical drive# to physical location conversion table */
+#define LD2PD(drv) (Drives[drv].pd) /* Get physical drive# */
+#define LD2PT(drv) (Drives[drv].pt) /* Get partition# */
+
+#else /* Single partition configuration */
+
+#define LD2PD(drv) (drv) /* Physical drive# is equal to the logical drive# */
+#define LD2PT(drv) 0 /* Always mounts the 1st partition */
+
+#endif
+
+
+
+/* Definitions corresponds to multiple sector size */
+
+#if _MAX_SS == 512 /* Single sector size */
+#define SS(fs) 512U
+
+#elif _MAX_SS == 1024 || _MAX_SS == 2048 || _MAX_SS == 4096 /* Multiple sector size */
+#define SS(fs) ((fs)->s_size)
+
+#else
+#error Sector size must be 512, 1024, 2048 or 4096.
+
+#endif
+
+
+
+/* Type of file name on FatFs API */
+
+#if _LFN_UNICODE && _USE_LFN
+typedef WCHAR XCHAR; /* Unicode */
+#else
+typedef char XCHAR; /* SBCS, DBCS */
+#endif
+
+
+
+/* File system object structure */
+
+typedef struct _FATFS_ {
+ BYTE fs_type; /* FAT sub type */
+ BYTE drive; /* Physical drive number */
+ BYTE csize; /* Number of sectors per cluster */
+ BYTE n_fats; /* Number of FAT copies */
+ BYTE wflag; /* win[] dirty flag (1:must be written back) */
+ BYTE fsi_flag; /* fsinfo dirty flag (1:must be written back) */
+ WORD id; /* File system mount ID */
+ WORD n_rootdir; /* Number of root directory entries (0 on FAT32) */
+#if _FS_REENTRANT
+ _SYNC_t sobj; /* Identifier of sync object */
+#endif
+#if _MAX_SS != 512
+ WORD s_size; /* Sector size */
+#endif
+#if !_FS_READONLY
+ DWORD last_clust; /* Last allocated cluster */
+ DWORD free_clust; /* Number of free clusters */
+ DWORD fsi_sector; /* fsinfo sector */
+#endif
+#if _FS_RPATH
+ DWORD cdir; /* Current directory (0:root)*/
+#endif
+ DWORD sects_fat; /* Sectors per fat */
+ DWORD max_clust; /* Maximum cluster# + 1. Number of clusters is max_clust - 2 */
+ DWORD fatbase; /* FAT start sector */
+ DWORD dirbase; /* Root directory start sector (Cluster# on FAT32) */
+ DWORD database; /* Data start sector */
+ DWORD winsect; /* Current sector appearing in the win[] */
+ BYTE win[_MAX_SS];/* Disk access window for Directory/FAT */
+} FATFS;
+
+
+
+/* Directory object structure */
+
+typedef struct _DIR_ {
+ FATFS* fs; /* Pointer to the owner file system object */
+ WORD id; /* Owner file system mount ID */
+ WORD index; /* Current read/write index number */
+ DWORD sclust; /* Table start cluster (0:Static table) */
+ DWORD clust; /* Current cluster */
+ DWORD sect; /* Current sector */
+ BYTE* dir; /* Pointer to the current SFN entry in the win[] */
+ BYTE* fn; /* Pointer to the SFN (in/out) {file[8],ext[3],status[1]} */
+#if _USE_LFN
+ WCHAR* lfn; /* Pointer to the LFN working buffer */
+ WORD lfn_idx; /* Last matched LFN index number (0xFFFF:No LFN) */
+#endif
+} DIR;
+
+
+
+/* File object structure */
+
+typedef struct _FIL_ {
+ FATFS* fs; /* Pointer to the owner file system object */
+ WORD id; /* Owner file system mount ID */
+ BYTE flag; /* File status flags */
+ BYTE csect; /* Sector address in the cluster */
+ DWORD fptr; /* File R/W pointer */
+ DWORD fsize; /* File size */
+ DWORD org_clust; /* File start cluster */
+ DWORD curr_clust; /* Current cluster */
+ DWORD dsect; /* Current data sector */
+#if !_FS_READONLY
+ DWORD dir_sect; /* Sector containing the directory entry */
+ BYTE* dir_ptr; /* Ponter to the directory entry in the window */
+#endif
+#if !_FS_TINY
+ BYTE buf[_MAX_SS];/* File R/W buffer */
+#endif
+} FIL;
+
+
+
+/* File status structure */
+
+typedef struct _FILINFO_ {
+ DWORD fsize; /* File size */
+ WORD fdate; /* Last modified date */
+ WORD ftime; /* Last modified time */
+ BYTE fattrib; /* Attribute */
+ char fname[13]; /* Short file name (8.3 format) */
+#if _USE_LFN
+ XCHAR* lfname; /* Pointer to the LFN buffer */
+ int lfsize; /* Size of LFN buffer [chrs] */
+#endif
+} FILINFO;
+
+
+
+/* File function return code (FRESULT) */
+
+typedef enum {
+ FR_OK = 0, /* 0 */
+ FR_DISK_ERR, /* 1 */
+ FR_INT_ERR, /* 2 */
+ FR_NOT_READY, /* 3 */
+ FR_NO_FILE, /* 4 */
+ FR_NO_PATH, /* 5 */
+ FR_INVALID_NAME, /* 6 */
+ FR_DENIED, /* 7 */
+ FR_EXIST, /* 8 */
+ FR_INVALID_OBJECT, /* 9 */
+ FR_WRITE_PROTECTED, /* 10 */
+ FR_INVALID_DRIVE, /* 11 */
+ FR_NOT_ENABLED, /* 12 */
+ FR_NO_FILESYSTEM, /* 13 */
+ FR_MKFS_ABORTED, /* 14 */
+ FR_TIMEOUT /* 15 */
+} FRESULT;
+
+
+
+/*--------------------------------------------------------------*/
+/* FatFs module application interface */
+
+FRESULT f_mount (BYTE, FATFS*); /* Mount/Unmount a logical drive */
+FRESULT f_open (FIL*, const XCHAR*, BYTE); /* Open or create a file */
+FRESULT f_read (FIL*, void*, UINT, UINT*); /* Read data from a file */
+FRESULT f_write (FIL*, const void*, UINT, UINT*); /* Write data to a file */
+FRESULT f_lseek (FIL*, DWORD); /* Move file pointer of a file object */
+FRESULT f_close (FIL*); /* Close an open file object */
+FRESULT f_opendir (DIR*, const XCHAR*); /* Open an existing directory */
+FRESULT f_readdir (DIR*, FILINFO*); /* Read a directory item */
+FRESULT f_stat (const XCHAR*, FILINFO*); /* Get file status */
+FRESULT f_getfree (const XCHAR*, DWORD*, FATFS**); /* Get number of free clusters on the drive */
+FRESULT f_truncate (FIL*); /* Truncate file */
+FRESULT f_sync (FIL*); /* Flush cached data of a writing file */
+FRESULT f_unlink (const XCHAR*); /* Delete an existing file or directory */
+FRESULT f_mkdir (const XCHAR*); /* Create a new directory */
+FRESULT f_chmod (const XCHAR*, BYTE, BYTE); /* Change attriburte of the file/dir */
+FRESULT f_utime (const XCHAR*, const FILINFO*); /* Change timestamp of the file/dir */
+FRESULT f_rename (const XCHAR*, const XCHAR*); /* Rename/Move a file or directory */
+FRESULT f_forward (FIL*, UINT(*)(const BYTE*,UINT), UINT, UINT*); /* Forward data to the stream */
+FRESULT f_mkfs (BYTE, BYTE, WORD); /* Create a file system on the drive */
+FRESULT f_chdir (const XCHAR*); /* Change current directory */
+FRESULT f_chdrive (BYTE); /* Change current drive */
+
+#if _USE_STRFUNC
+int f_putc (int, FIL*); /* Put a character to the file */
+int f_puts (const char*, FIL*); /* Put a string to the file */
+int f_printf (FIL*, const char*, ...); /* Put a formatted string to the file */
+char* f_gets (char*, int, FIL*); /* Get a string from the file */
+#define f_eof(fp) (((fp)->fptr == (fp)->fsize) ? 1 : 0)
+#define f_error(fp) (((fp)->flag & FA__ERROR) ? 1 : 0)
+#ifndef EOF
+#define EOF -1
+#endif
+#endif
+
+
+
+/*--------------------------------------------------------------*/
+/* User defined functions */
+
+/* Real time clock */
+#if !_FS_READONLY
+DWORD get_fattime (void); /* 31-25: Year(0-127 org.1980), 24-21: Month(1-12), 20-16: Day(1-31) */
+ /* 15-11: Hour(0-23), 10-5: Minute(0-59), 4-0: Second(0-29 *2) */
+#endif
+
+/* Unicode - OEM code conversion */
+#if _USE_LFN
+WCHAR ff_convert (WCHAR, UINT);
+WCHAR ff_wtoupper (WCHAR);
+#endif
+
+/* Sync functions */
+#if _FS_REENTRANT
+BOOL ff_cre_syncobj(BYTE, _SYNC_t*);
+BOOL ff_del_syncobj(_SYNC_t);
+BOOL ff_req_grant(_SYNC_t);
+void ff_rel_grant(_SYNC_t);
+#endif
+
+
+
+/*--------------------------------------------------------------*/
+/* Flags and offset address */
+
+
+/* File access control and file status flags (FIL.flag) */
+
+#define FA_READ 0x01
+#define FA_OPEN_EXISTING 0x00
+#if _FS_READONLY == 0
+#define FA_WRITE 0x02
+#define FA_CREATE_NEW 0x04
+#define FA_CREATE_ALWAYS 0x08
+#define FA_OPEN_ALWAYS 0x10
+#define FA__WRITTEN 0x20
+#define FA__DIRTY 0x40
+#endif
+#define FA__ERROR 0x80
+
+
+/* FAT sub type (FATFS.fs_type) */
+
+#define FS_FAT12 1
+#define FS_FAT16 2
+#define FS_FAT32 3
+
+
+/* File attribute bits for directory entry */
+
+#define AM_RDO 0x01 /* Read only */
+#define AM_HID 0x02 /* Hidden */
+#define AM_SYS 0x04 /* System */
+#define AM_VOL 0x08 /* Volume label */
+#define AM_LFN 0x0F /* LFN entry */
+#define AM_DIR 0x10 /* Directory */
+#define AM_ARC 0x20 /* Archive */
+#define AM_MASK 0x3F /* Mask of defined bits */
+
+
+/* FatFs refers the members in the FAT structures with byte offset instead
+/ of structure member because there are incompatibility of the packing option
+/ between various compilers. */
+
+#define BS_jmpBoot 0
+#define BS_OEMName 3
+#define BPB_BytsPerSec 11
+#define BPB_SecPerClus 13
+#define BPB_RsvdSecCnt 14
+#define BPB_NumFATs 16
+#define BPB_RootEntCnt 17
+#define BPB_TotSec16 19
+#define BPB_Media 21
+#define BPB_FATSz16 22
+#define BPB_SecPerTrk 24
+#define BPB_NumHeads 26
+#define BPB_HiddSec 28
+#define BPB_TotSec32 32
+#define BS_55AA 510
+
+#define BS_DrvNum 36
+#define BS_BootSig 38
+#define BS_VolID 39
+#define BS_VolLab 43
+#define BS_FilSysType 54
+
+#define BPB_FATSz32 36
+#define BPB_ExtFlags 40
+#define BPB_FSVer 42
+#define BPB_RootClus 44
+#define BPB_FSInfo 48
+#define BPB_BkBootSec 50
+#define BS_DrvNum32 64
+#define BS_BootSig32 66
+#define BS_VolID32 67
+#define BS_VolLab32 71
+#define BS_FilSysType32 82
+
+#define FSI_LeadSig 0
+#define FSI_StrucSig 484
+#define FSI_Free_Count 488
+#define FSI_Nxt_Free 492
+
+#define MBR_Table 446
+
+#define DIR_Name 0
+#define DIR_Attr 11
+#define DIR_NTres 12
+#define DIR_CrtTime 14
+#define DIR_CrtDate 16
+#define DIR_FstClusHI 20
+#define DIR_WrtTime 22
+#define DIR_WrtDate 24
+#define DIR_FstClusLO 26
+#define DIR_FileSize 28
+#define LDIR_Ord 0
+#define LDIR_Attr 11
+#define LDIR_Type 12
+#define LDIR_Chksum 13
+#define LDIR_FstClusLO 26
+
+
+
+/*--------------------------------*/
+/* Multi-byte word access macros */
+
+#if _WORD_ACCESS == 1 /* Enable word access to the FAT structure */
+#define LD_WORD(ptr) (WORD)(*(WORD*)(BYTE*)(ptr))
+#define LD_DWORD(ptr) (DWORD)(*(DWORD*)(BYTE*)(ptr))
+#define ST_WORD(ptr,val) *(WORD*)(BYTE*)(ptr)=(WORD)(val)
+#define ST_DWORD(ptr,val) *(DWORD*)(BYTE*)(ptr)=(DWORD)(val)
+#else /* Use byte-by-byte access to the FAT structure */
+#define LD_WORD(ptr) (WORD)(((WORD)*(BYTE*)((ptr)+1)<<8)|(WORD)*(BYTE*)(ptr))
+#define LD_DWORD(ptr) (DWORD)(((DWORD)*(BYTE*)((ptr)+3)<<24)|((DWORD)*(BYTE*)((ptr)+2)<<16)|((WORD)*(BYTE*)((ptr)+1)<<8)|*(BYTE*)(ptr))
+#define ST_WORD(ptr,val) *(BYTE*)(ptr)=(BYTE)(val); *(BYTE*)((ptr)+1)=(BYTE)((WORD)(val)>>8)
+#define ST_DWORD(ptr,val) *(BYTE*)(ptr)=(BYTE)(val); *(BYTE*)((ptr)+1)=(BYTE)((WORD)(val)>>8); *(BYTE*)((ptr)+2)=(BYTE)((DWORD)(val)>>16); *(BYTE*)((ptr)+3)=(BYTE)((DWORD)(val)>>24)
+#endif
+
+
+#endif /* _FATFS */
diff --git a/Projects/Webserver/Lib/FATFs/ff.lst b/Projects/Webserver/Lib/FATFs/ff.lst new file mode 100644 index 000000000..2a8f9fc4e --- /dev/null +++ b/Projects/Webserver/Lib/FATFs/ff.lst @@ -0,0 +1,3062 @@ + 1 .file "ff.c"
+ 2 __SREG__ = 0x3f
+ 3 __SP_H__ = 0x3e
+ 4 __SP_L__ = 0x3d
+ 5 __CCP__ = 0x34
+ 6 __tmp_reg__ = 0
+ 7 __zero_reg__ = 1
+ 15 .Ltext0:
+ 16 .section .text.clust2sect,"ax",@progbits
+ 17 .global clust2sect
+ 19 clust2sect:
+ 20 .LFB60:
+ 21 .LSM0:
+ 22 .LVL0:
+ 23 0000 EF92 push r14
+ 24 0002 FF92 push r15
+ 25 0004 0F93 push r16
+ 26 0006 1F93 push r17
+ 27 0008 CF93 push r28
+ 28 000a DF93 push r29
+ 29 /* prologue: function */
+ 30 /* frame size = 0 */
+ 31 000c EC01 movw r28,r24
+ 32 000e 7A01 movw r14,r20
+ 33 0010 8B01 movw r16,r22
+ 34 .LSM1:
+ 35 0012 8EEF ldi r24,lo8(-2)
+ 36 0014 9FEF ldi r25,hi8(-2)
+ 37 0016 AFEF ldi r26,hlo8(-2)
+ 38 0018 BFEF ldi r27,hhi8(-2)
+ 39 .LVL1:
+ 40 001a E80E add r14,r24
+ 41 001c F91E adc r15,r25
+ 42 001e 0A1F adc r16,r26
+ 43 0020 1B1F adc r17,r27
+ 44 .LVL2:
+ 45 .LSM2:
+ 46 0022 8E85 ldd r24,Y+14
+ 47 0024 9F85 ldd r25,Y+15
+ 48 0026 A889 ldd r26,Y+16
+ 49 0028 B989 ldd r27,Y+17
+ 50 002a 0297 sbiw r24,2
+ 51 002c A109 sbc r26,__zero_reg__
+ 52 002e B109 sbc r27,__zero_reg__
+ 53 0030 E816 cp r14,r24
+ 54 0032 F906 cpc r15,r25
+ 55 0034 0A07 cpc r16,r26
+ 56 0036 1B07 cpc r17,r27
+ 57 0038 00F0 brlo .L2
+ 58 003a 20E0 ldi r18,lo8(0)
+ 59 003c 30E0 ldi r19,hi8(0)
+ 60 003e 40E0 ldi r20,hlo8(0)
+ 61 0040 50E0 ldi r21,hhi8(0)
+ 62 0042 00C0 rjmp .L3
+ 63 .L2:
+ 64 .LSM3:
+ 65 0044 2A81 ldd r18,Y+2
+ 66 0046 30E0 ldi r19,lo8(0)
+ 67 0048 40E0 ldi r20,lo8(0)
+ 68 004a 50E0 ldi r21,hi8(0)
+ 69 004c C801 movw r24,r16
+ 70 004e B701 movw r22,r14
+ 71 0050 0E94 0000 call __mulsi3
+ 72 0054 9B01 movw r18,r22
+ 73 0056 AC01 movw r20,r24
+ 74 0058 8A8D ldd r24,Y+26
+ 75 005a 9B8D ldd r25,Y+27
+ 76 005c AC8D ldd r26,Y+28
+ 77 005e BD8D ldd r27,Y+29
+ 78 0060 280F add r18,r24
+ 79 0062 391F adc r19,r25
+ 80 0064 4A1F adc r20,r26
+ 81 0066 5B1F adc r21,r27
+ 82 .L3:
+ 83 .LSM4:
+ 84 0068 B901 movw r22,r18
+ 85 006a CA01 movw r24,r20
+ 86 /* epilogue start */
+ 87 006c DF91 pop r29
+ 88 006e CF91 pop r28
+ 89 .LVL3:
+ 90 0070 1F91 pop r17
+ 91 0072 0F91 pop r16
+ 92 0074 FF90 pop r15
+ 93 0076 EF90 pop r14
+ 94 .LVL4:
+ 95 0078 0895 ret
+ 96 .LFE60:
+ 98 .section .text.f_mount,"ax",@progbits
+ 99 .global f_mount
+ 101 f_mount:
+ 102 .LFB69:
+ 103 .LSM5:
+ 104 .LVL5:
+ 105 /* prologue: function */
+ 106 /* frame size = 0 */
+ 107 0000 DB01 movw r26,r22
+ 108 .LSM6:
+ 109 0002 8823 tst r24
+ 110 0004 01F0 breq .L6
+ 111 .LVL6:
+ 112 0006 8BE0 ldi r24,lo8(11)
+ 113 .LVL7:
+ 114 0008 0895 ret
+ 115 .LVL8:
+ 116 .L6:
+ 117 .LSM7:
+ 118 000a E091 0000 lds r30,FatFs
+ 119 000e F091 0000 lds r31,(FatFs)+1
+ 120 .LVL9:
+ 121 .LSM8:
+ 122 0012 3097 sbiw r30,0
+ 123 0014 01F0 breq .L8
+ 124 .LSM9:
+ 125 0016 1082 st Z,__zero_reg__
+ 126 .L8:
+ 127 .LSM10:
+ 128 0018 1097 sbiw r26,0
+ 129 001a 01F0 breq .L9
+ 130 .LSM11:
+ 131 001c 1C92 st X,__zero_reg__
+ 132 .L9:
+ 133 .LSM12:
+ 134 001e B093 0000 sts (FatFs)+1,r27
+ 135 0022 A093 0000 sts FatFs,r26
+ 136 0026 80E0 ldi r24,lo8(0)
+ 137 .LVL10:
+ 138 .LSM13:
+ 139 0028 0895 ret
+ 140 .LFE69:
+ 142 .section .text.validate,"ax",@progbits
+ 144 validate:
+ 145 .LFB68:
+ 146 .LSM14:
+ 147 .LVL11:
+ 148 /* prologue: function */
+ 149 /* frame size = 0 */
+ 150 0000 FC01 movw r30,r24
+ 151 .LSM15:
+ 152 0002 0097 sbiw r24,0
+ 153 0004 01F0 breq .L12
+ 154 0006 8081 ld r24,Z
+ 155 .LVL12:
+ 156 0008 8823 tst r24
+ 157 000a 01F0 breq .L12
+ 158 000c 8681 ldd r24,Z+6
+ 159 000e 9781 ldd r25,Z+7
+ 160 0010 8617 cp r24,r22
+ 161 0012 9707 cpc r25,r23
+ 162 0014 01F4 brne .L12
+ 163 .LSM16:
+ 164 0016 8181 ldd r24,Z+1
+ 165 0018 0E94 0000 call disk_status
+ 166 .LVL13:
+ 167 001c 80FD sbrc r24,0
+ 168 001e 00C0 rjmp .L13
+ 169 0020 80E0 ldi r24,lo8(0)
+ 170 0022 0895 ret
+ 171 .L13:
+ 172 0024 83E0 ldi r24,lo8(3)
+ 173 0026 0895 ret
+ 174 .LVL14:
+ 175 .L12:
+ 176 0028 89E0 ldi r24,lo8(9)
+ 177 .LSM17:
+ 178 002a 0895 ret
+ 179 .LFE68:
+ 181 .section .text.f_close,"ax",@progbits
+ 182 .global f_close
+ 184 f_close:
+ 185 .LFB72:
+ 186 .LSM18:
+ 187 .LVL15:
+ 188 0000 CF93 push r28
+ 189 0002 DF93 push r29
+ 190 /* prologue: function */
+ 191 /* frame size = 0 */
+ 192 0004 EC01 movw r28,r24
+ 193 .LSM19:
+ 194 0006 6A81 ldd r22,Y+2
+ 195 0008 7B81 ldd r23,Y+3
+ 196 000a 8881 ld r24,Y
+ 197 000c 9981 ldd r25,Y+1
+ 198 .LVL16:
+ 199 000e 0E94 0000 call validate
+ 200 .LSM20:
+ 201 0012 8823 tst r24
+ 202 .LVL17:
+ 203 0014 01F4 brne .L17
+ 204 0016 1982 std Y+1,__zero_reg__
+ 205 0018 1882 st Y,__zero_reg__
+ 206 .L17:
+ 207 .LVL18:
+ 208 /* epilogue start */
+ 209 .LSM21:
+ 210 001a DF91 pop r29
+ 211 001c CF91 pop r28
+ 212 .LVL19:
+ 213 001e 0895 ret
+ 214 .LFE72:
+ 216 .section .text.move_window,"ax",@progbits
+ 218 move_window:
+ 219 .LFB58:
+ 220 .LSM22:
+ 221 .LVL20:
+ 222 0000 CF92 push r12
+ 223 0002 DF92 push r13
+ 224 0004 EF92 push r14
+ 225 0006 FF92 push r15
+ 226 0008 0F93 push r16
+ 227 000a CF93 push r28
+ 228 000c DF93 push r29
+ 229 /* prologue: function */
+ 230 /* frame size = 0 */
+ 231 000e EC01 movw r28,r24
+ 232 0010 6A01 movw r12,r20
+ 233 0012 7B01 movw r14,r22
+ 234 .LSM23:
+ 235 0014 8E8D ldd r24,Y+30
+ 236 0016 9F8D ldd r25,Y+31
+ 237 0018 A8A1 ldd r26,Y+32
+ 238 001a B9A1 ldd r27,Y+33
+ 239 .LVL21:
+ 240 001c 8417 cp r24,r20
+ 241 001e 9507 cpc r25,r21
+ 242 0020 A607 cpc r26,r22
+ 243 0022 B707 cpc r27,r23
+ 244 0024 01F0 breq .L20
+ 245 .LSM24:
+ 246 0026 4115 cp r20,__zero_reg__
+ 247 0028 5105 cpc r21,__zero_reg__
+ 248 002a 6105 cpc r22,__zero_reg__
+ 249 002c 7105 cpc r23,__zero_reg__
+ 250 002e 01F0 breq .L20
+ 251 .LSM25:
+ 252 0030 BE01 movw r22,r28
+ 253 0032 6E5D subi r22,lo8(-(34))
+ 254 0034 7F4F sbci r23,hi8(-(34))
+ 255 0036 8981 ldd r24,Y+1
+ 256 0038 A701 movw r20,r14
+ 257 003a 9601 movw r18,r12
+ 258 003c 01E0 ldi r16,lo8(1)
+ 259 003e 0E94 0000 call disk_read
+ 260 .LVL22:
+ 261 0042 8823 tst r24
+ 262 0044 01F0 breq .L21
+ 263 0046 81E0 ldi r24,lo8(1)
+ 264 0048 00C0 rjmp .L22
+ 265 .L21:
+ 266 .LSM26:
+ 267 004a CE8E std Y+30,r12
+ 268 004c DF8E std Y+31,r13
+ 269 004e E8A2 std Y+32,r14
+ 270 0050 F9A2 std Y+33,r15
+ 271 .LVL23:
+ 272 .L20:
+ 273 0052 80E0 ldi r24,lo8(0)
+ 274 .L22:
+ 275 /* epilogue start */
+ 276 .LSM27:
+ 277 0054 DF91 pop r29
+ 278 0056 CF91 pop r28
+ 279 .LVL24:
+ 280 0058 0F91 pop r16
+ 281 005a FF90 pop r15
+ 282 005c EF90 pop r14
+ 283 005e DF90 pop r13
+ 284 0060 CF90 pop r12
+ 285 .LVL25:
+ 286 0062 0895 ret
+ 287 .LFE58:
+ 289 .section .text.get_fat,"ax",@progbits
+ 290 .global get_fat
+ 292 get_fat:
+ 293 .LFB59:
+ 294 .LSM28:
+ 295 .LVL26:
+ 296 0000 7F92 push r7
+ 297 0002 8F92 push r8
+ 298 0004 9F92 push r9
+ 299 0006 AF92 push r10
+ 300 0008 BF92 push r11
+ 301 000a CF92 push r12
+ 302 000c DF92 push r13
+ 303 000e EF92 push r14
+ 304 0010 FF92 push r15
+ 305 0012 0F93 push r16
+ 306 0014 1F93 push r17
+ 307 0016 CF93 push r28
+ 308 0018 DF93 push r29
+ 309 /* prologue: function */
+ 310 /* frame size = 0 */
+ 311 001a 4C01 movw r8,r24
+ 312 001c 7A01 movw r14,r20
+ 313 001e 8B01 movw r16,r22
+ 314 .LSM29:
+ 315 0020 4230 cpi r20,lo8(2)
+ 316 0022 5105 cpc r21,__zero_reg__
+ 317 0024 6105 cpc r22,__zero_reg__
+ 318 0026 7105 cpc r23,__zero_reg__
+ 319 .LVL27:
+ 320 0028 00F4 brsh .+2
+ 321 002a 00C0 rjmp .L25
+ 322 002c F401 movw r30,r8
+ 323 002e 8685 ldd r24,Z+14
+ 324 0030 9785 ldd r25,Z+15
+ 325 0032 A089 ldd r26,Z+16
+ 326 0034 B189 ldd r27,Z+17
+ 327 0036 4817 cp r20,r24
+ 328 0038 5907 cpc r21,r25
+ 329 003a 6A07 cpc r22,r26
+ 330 003c 7B07 cpc r23,r27
+ 331 003e 00F0 brlo .+2
+ 332 0040 00C0 rjmp .L25
+ 333 .LSM30:
+ 334 0042 A288 ldd r10,Z+18
+ 335 0044 B388 ldd r11,Z+19
+ 336 0046 C488 ldd r12,Z+20
+ 337 0048 D588 ldd r13,Z+21
+ 338 .LVL28:
+ 339 .LSM31:
+ 340 004a 8081 ld r24,Z
+ 341 004c 8230 cpi r24,lo8(2)
+ 342 004e 01F4 brne .+2
+ 343 0050 00C0 rjmp .L28
+ 344 0052 8330 cpi r24,lo8(3)
+ 345 0054 01F4 brne .+2
+ 346 0056 00C0 rjmp .L29
+ 347 0058 8130 cpi r24,lo8(1)
+ 348 005a 01F0 breq .+2
+ 349 005c 00C0 rjmp .L26
+ 350 .LSM32:
+ 351 005e EA01 movw r28,r20
+ 352 .LVL29:
+ 353 0060 D695 lsr r29
+ 354 0062 C795 ror r28
+ 355 .LVL30:
+ 356 0064 C40F add r28,r20
+ 357 0066 D51F adc r29,r21
+ 358 .LSM33:
+ 359 0068 AE01 movw r20,r28
+ 360 .LVL31:
+ 361 006a 452F mov r20,r21
+ 362 006c 5527 clr r21
+ 363 006e 4695 lsr r20
+ 364 0070 60E0 ldi r22,lo8(0)
+ 365 0072 70E0 ldi r23,hi8(0)
+ 366 0074 4A0D add r20,r10
+ 367 0076 5B1D adc r21,r11
+ 368 0078 6C1D adc r22,r12
+ 369 007a 7D1D adc r23,r13
+ 370 007c C401 movw r24,r8
+ 371 007e 0E94 0000 call move_window
+ 372 0082 8823 tst r24
+ 373 0084 01F0 breq .+2
+ 374 0086 00C0 rjmp .L26
+ 375 .LSM34:
+ 376 0088 FE01 movw r30,r28
+ 377 008a F170 andi r31,hi8(511)
+ 378 008c E80D add r30,r8
+ 379 008e F91D adc r31,r9
+ 380 0090 72A0 ldd r7,Z+34
+ 381 0092 2196 adiw r28,1
+ 382 .LVL32:
+ 383 .LSM35:
+ 384 0094 AE01 movw r20,r28
+ 385 0096 452F mov r20,r21
+ 386 0098 5527 clr r21
+ 387 009a 4695 lsr r20
+ 388 009c 60E0 ldi r22,lo8(0)
+ 389 009e 70E0 ldi r23,hi8(0)
+ 390 00a0 4A0D add r20,r10
+ 391 00a2 5B1D adc r21,r11
+ 392 00a4 6C1D adc r22,r12
+ 393 00a6 7D1D adc r23,r13
+ 394 00a8 C401 movw r24,r8
+ 395 00aa 0E94 0000 call move_window
+ 396 00ae 8823 tst r24
+ 397 00b0 01F0 breq .+2
+ 398 00b2 00C0 rjmp .L26
+ 399 .LSM36:
+ 400 00b4 672D mov r22,r7
+ 401 .LVL33:
+ 402 00b6 70E0 ldi r23,lo8(0)
+ 403 .LVL34:
+ 404 .LSM37:
+ 405 00b8 D170 andi r29,hi8(511)
+ 406 00ba C80D add r28,r8
+ 407 00bc D91D adc r29,r9
+ 408 00be 9AA1 ldd r25,Y+34
+ 409 00c0 80E0 ldi r24,lo8(0)
+ 410 00c2 682B or r22,r24
+ 411 00c4 792B or r23,r25
+ 412 .LVL35:
+ 413 .LSM38:
+ 414 00c6 C701 movw r24,r14
+ 415 .LVL36:
+ 416 00c8 8170 andi r24,lo8(1)
+ 417 00ca 9070 andi r25,hi8(1)
+ 418 00cc 892B or r24,r25
+ 419 00ce 01F0 breq .L30
+ 420 00d0 44E0 ldi r20,4
+ 421 00d2 7695 1: lsr r23
+ 422 00d4 6795 ror r22
+ 423 00d6 4A95 dec r20
+ 424 00d8 01F4 brne 1b
+ 425 00da 9B01 movw r18,r22
+ 426 00dc 00C0 rjmp .L33
+ 427 .L30:
+ 428 00de 9B01 movw r18,r22
+ 429 00e0 40E0 ldi r20,lo8(0)
+ 430 00e2 50E0 ldi r21,hi8(0)
+ 431 00e4 3F70 andi r19,hi8(4095)
+ 432 00e6 4070 andi r20,hlo8(4095)
+ 433 00e8 5070 andi r21,hhi8(4095)
+ 434 00ea 00C0 rjmp .L31
+ 435 .LVL37:
+ 436 .L28:
+ 437 .LSM39:
+ 438 00ec 452F mov r20,r21
+ 439 00ee 562F mov r21,r22
+ 440 00f0 672F mov r22,r23
+ 441 00f2 7727 clr r23
+ 442 .LVL38:
+ 443 00f4 4A0D add r20,r10
+ 444 00f6 5B1D adc r21,r11
+ 445 00f8 6C1D adc r22,r12
+ 446 00fa 7D1D adc r23,r13
+ 447 00fc C401 movw r24,r8
+ 448 00fe 0E94 0000 call move_window
+ 449 0102 8823 tst r24
+ 450 0104 01F4 brne .L26
+ 451 .LSM40:
+ 452 0106 F701 movw r30,r14
+ 453 .LVL39:
+ 454 0108 EE0F lsl r30
+ 455 010a FF1F rol r31
+ 456 010c F170 andi r31,hi8(511)
+ 457 010e E80D add r30,r8
+ 458 0110 F91D adc r31,r9
+ 459 0112 82A1 ldd r24,Z+34
+ 460 0114 93A1 ldd r25,Z+35
+ 461 0116 9C01 movw r18,r24
+ 462 .LVL40:
+ 463 .L33:
+ 464 0118 40E0 ldi r20,lo8(0)
+ 465 011a 50E0 ldi r21,hi8(0)
+ 466 011c 00C0 rjmp .L31
+ 467 .LVL41:
+ 468 .L29:
+ 469 .LSM41:
+ 470 011e 97E0 ldi r25,7
+ 471 0120 7695 1: lsr r23
+ 472 0122 6795 ror r22
+ 473 0124 5795 ror r21
+ 474 0126 4795 ror r20
+ 475 0128 9A95 dec r25
+ 476 012a 01F4 brne 1b
+ 477 .LVL42:
+ 478 012c 4A0D add r20,r10
+ 479 012e 5B1D adc r21,r11
+ 480 0130 6C1D adc r22,r12
+ 481 0132 7D1D adc r23,r13
+ 482 0134 C401 movw r24,r8
+ 483 0136 0E94 0000 call move_window
+ 484 013a 8823 tst r24
+ 485 013c 01F4 brne .L26
+ 486 .LSM42:
+ 487 013e F701 movw r30,r14
+ 488 .LVL43:
+ 489 0140 EE0F lsl r30
+ 490 0142 FF1F rol r31
+ 491 0144 EE0F lsl r30
+ 492 0146 FF1F rol r31
+ 493 0148 F170 andi r31,hi8(511)
+ 494 014a E80D add r30,r8
+ 495 014c F91D adc r31,r9
+ 496 014e 22A1 ldd r18,Z+34
+ 497 0150 33A1 ldd r19,Z+35
+ 498 0152 44A1 ldd r20,Z+36
+ 499 0154 55A1 ldd r21,Z+37
+ 500 0156 5F70 andi r21,hhi8(268435455)
+ 501 0158 00C0 rjmp .L31
+ 502 .LVL44:
+ 503 .L25:
+ 504 015a 21E0 ldi r18,lo8(1)
+ 505 015c 30E0 ldi r19,hi8(1)
+ 506 015e 40E0 ldi r20,hlo8(1)
+ 507 0160 50E0 ldi r21,hhi8(1)
+ 508 0162 00C0 rjmp .L31
+ 509 .LVL45:
+ 510 .L26:
+ 511 0164 2FEF ldi r18,lo8(-1)
+ 512 0166 3FEF ldi r19,hi8(-1)
+ 513 0168 4FEF ldi r20,hlo8(-1)
+ 514 016a 5FEF ldi r21,hhi8(-1)
+ 515 .LVL46:
+ 516 .L31:
+ 517 .LSM43:
+ 518 016c B901 movw r22,r18
+ 519 .LVL47:
+ 520 016e CA01 movw r24,r20
+ 521 /* epilogue start */
+ 522 0170 DF91 pop r29
+ 523 0172 CF91 pop r28
+ 524 .LVL48:
+ 525 0174 1F91 pop r17
+ 526 0176 0F91 pop r16
+ 527 0178 FF90 pop r15
+ 528 017a EF90 pop r14
+ 529 .LVL49:
+ 530 017c DF90 pop r13
+ 531 017e CF90 pop r12
+ 532 0180 BF90 pop r11
+ 533 0182 AF90 pop r10
+ 534 .LVL50:
+ 535 0184 9F90 pop r9
+ 536 0186 8F90 pop r8
+ 537 .LVL51:
+ 538 0188 7F90 pop r7
+ 539 018a 0895 ret
+ 540 .LFE59:
+ 542 .section .text.f_lseek,"ax",@progbits
+ 543 .global f_lseek
+ 545 f_lseek:
+ 546 .LFB73:
+ 547 .LSM44:
+ 548 .LVL52:
+ 549 0000 2F92 push r2
+ 550 0002 3F92 push r3
+ 551 0004 4F92 push r4
+ 552 0006 5F92 push r5
+ 553 0008 6F92 push r6
+ 554 000a 7F92 push r7
+ 555 000c 8F92 push r8
+ 556 000e 9F92 push r9
+ 557 0010 AF92 push r10
+ 558 0012 BF92 push r11
+ 559 0014 CF92 push r12
+ 560 0016 DF92 push r13
+ 561 0018 EF92 push r14
+ 562 001a FF92 push r15
+ 563 001c 0F93 push r16
+ 564 001e 1F93 push r17
+ 565 0020 DF93 push r29
+ 566 0022 CF93 push r28
+ 567 0024 00D0 rcall .
+ 568 0026 0F92 push __tmp_reg__
+ 569 0028 CDB7 in r28,__SP_L__
+ 570 002a DEB7 in r29,__SP_H__
+ 571 /* prologue: function */
+ 572 /* frame size = 3 */
+ 573 002c 9B83 std Y+3,r25
+ 574 002e 8A83 std Y+2,r24
+ 575 0030 E42E mov r14,r20
+ 576 0032 D52E mov r13,r21
+ 577 .LVL53:
+ 578 0034 C62E mov r12,r22
+ 579 .LVL54:
+ 580 0036 B72E mov r11,r23
+ 581 .LVL55:
+ 582 .LSM45:
+ 583 0038 DC01 movw r26,r24
+ 584 003a 1296 adiw r26,2
+ 585 003c 6D91 ld r22,X+
+ 586 003e 7C91 ld r23,X
+ 587 0040 1397 sbiw r26,2+1
+ 588 .LVL56:
+ 589 0042 8D91 ld r24,X+
+ 590 0044 9C91 ld r25,X
+ 591 .LVL57:
+ 592 0046 0E94 0000 call validate
+ 593 .LVL58:
+ 594 004a 8983 std Y+1,r24
+ 595 .LVL59:
+ 596 .LSM46:
+ 597 004c 8823 tst r24
+ 598 004e 01F0 breq .+2
+ 599 0050 00C0 rjmp .L35
+ 600 .LSM47:
+ 601 0052 EA81 ldd r30,Y+2
+ 602 0054 FB81 ldd r31,Y+3
+ 603 0056 8481 ldd r24,Z+4
+ 604 0058 87FD sbrc r24,7
+ 605 005a 00C0 rjmp .L51
+ 606 .L36:
+ 607 005c AA81 ldd r26,Y+2
+ 608 005e BB81 ldd r27,Y+3
+ 609 0060 1A96 adiw r26,10
+ 610 0062 6D90 ld r6,X+
+ 611 0064 7D90 ld r7,X+
+ 612 0066 8D90 ld r8,X+
+ 613 0068 9C90 ld r9,X
+ 614 006a 1D97 sbiw r26,10+3
+ 615 006c 2E2D mov r18,r14
+ 616 006e 3D2D mov r19,r13
+ 617 0070 4C2D mov r20,r12
+ 618 0072 5B2D mov r21,r11
+ 619 0074 C901 movw r24,r18
+ 620 0076 DA01 movw r26,r20
+ 621 0078 5C01 movw r10,r24
+ 622 007a 6D01 movw r12,r26
+ 623 007c 6A14 cp r6,r10
+ 624 007e 7B04 cpc r7,r11
+ 625 0080 8C04 cpc r8,r12
+ 626 0082 9D04 cpc r9,r13
+ 627 0084 00F4 brsh .L37
+ 628 .LVL60:
+ 629 0086 6401 movw r12,r8
+ 630 0088 5301 movw r10,r6
+ 631 .LVL61:
+ 632 .L37:
+ 633 .LSM48:
+ 634 008a EA81 ldd r30,Y+2
+ 635 008c FB81 ldd r31,Y+3
+ 636 008e 2681 ldd r18,Z+6
+ 637 0090 3781 ldd r19,Z+7
+ 638 0092 4085 ldd r20,Z+8
+ 639 0094 5185 ldd r21,Z+9
+ 640 .LVL62:
+ 641 .LSM49:
+ 642 0096 1682 std Z+6,__zero_reg__
+ 643 0098 1782 std Z+7,__zero_reg__
+ 644 009a 1086 std Z+8,__zero_reg__
+ 645 009c 1186 std Z+9,__zero_reg__
+ 646 009e 8FEF ldi r24,lo8(-1)
+ 647 00a0 8583 std Z+5,r24
+ 648 .LSM50:
+ 649 00a2 A114 cp r10,__zero_reg__
+ 650 00a4 B104 cpc r11,__zero_reg__
+ 651 00a6 C104 cpc r12,__zero_reg__
+ 652 00a8 D104 cpc r13,__zero_reg__
+ 653 00aa 01F4 brne .+2
+ 654 00ac 00C0 rjmp .L38
+ 655 .LSM51:
+ 656 00ae 0190 ld __tmp_reg__,Z+
+ 657 00b0 F081 ld r31,Z
+ 658 00b2 E02D mov r30,__tmp_reg__
+ 659 00b4 8281 ldd r24,Z+2
+ 660 00b6 682E mov r6,r24
+ 661 .LVL63:
+ 662 00b8 7724 clr r7
+ 663 .LVL64:
+ 664 00ba 8824 clr r8
+ 665 00bc 9924 clr r9
+ 666 .LVL65:
+ 667 00be 09E0 ldi r16,9
+ 668 00c0 660C 1: lsl r6
+ 669 00c2 771C rol r7
+ 670 00c4 881C rol r8
+ 671 00c6 991C rol r9
+ 672 00c8 0A95 dec r16
+ 673 00ca 01F4 brne 1b
+ 674 .LVL66:
+ 675 .LSM52:
+ 676 00cc 2115 cp r18,__zero_reg__
+ 677 00ce 3105 cpc r19,__zero_reg__
+ 678 00d0 4105 cpc r20,__zero_reg__
+ 679 00d2 5105 cpc r21,__zero_reg__
+ 680 00d4 01F0 breq .L39
+ 681 00d6 1901 movw r2,r18
+ 682 00d8 2A01 movw r4,r20
+ 683 00da 0894 sec
+ 684 00dc 2108 sbc r2,__zero_reg__
+ 685 00de 3108 sbc r3,__zero_reg__
+ 686 00e0 4108 sbc r4,__zero_reg__
+ 687 00e2 5108 sbc r5,__zero_reg__
+ 688 00e4 C601 movw r24,r12
+ 689 00e6 B501 movw r22,r10
+ 690 00e8 6150 subi r22,lo8(-(-1))
+ 691 00ea 7040 sbci r23,hi8(-(-1))
+ 692 00ec 8040 sbci r24,hlo8(-(-1))
+ 693 00ee 9040 sbci r25,hhi8(-(-1))
+ 694 00f0 A401 movw r20,r8
+ 695 00f2 9301 movw r18,r6
+ 696 .LVL67:
+ 697 00f4 0E94 0000 call __udivmodsi4
+ 698 00f8 7901 movw r14,r18
+ 699 00fa 8A01 movw r16,r20
+ 700 00fc C201 movw r24,r4
+ 701 00fe B101 movw r22,r2
+ 702 0100 A401 movw r20,r8
+ 703 0102 9301 movw r18,r6
+ 704 0104 0E94 0000 call __udivmodsi4
+ 705 0108 E216 cp r14,r18
+ 706 010a F306 cpc r15,r19
+ 707 010c 0407 cpc r16,r20
+ 708 010e 1507 cpc r17,r21
+ 709 0110 00F0 brlo .L39
+ 710 .LSM53:
+ 711 0112 8827 clr r24
+ 712 0114 9927 clr r25
+ 713 0116 DC01 movw r26,r24
+ 714 0118 8619 sub r24,r6
+ 715 011a 9709 sbc r25,r7
+ 716 011c A809 sbc r26,r8
+ 717 011e B909 sbc r27,r9
+ 718 0120 8221 and r24,r2
+ 719 0122 9321 and r25,r3
+ 720 0124 A421 and r26,r4
+ 721 0126 B521 and r27,r5
+ 722 0128 EA81 ldd r30,Y+2
+ 723 012a FB81 ldd r31,Y+3
+ 724 012c 8683 std Z+6,r24
+ 725 012e 9783 std Z+7,r25
+ 726 0130 A087 std Z+8,r26
+ 727 0132 B187 std Z+9,r27
+ 728 .LSM54:
+ 729 0134 A81A sub r10,r24
+ 730 0136 B90A sbc r11,r25
+ 731 0138 CA0A sbc r12,r26
+ 732 013a DB0A sbc r13,r27
+ 733 .LSM55:
+ 734 013c 4289 ldd r20,Z+18
+ 735 013e 5389 ldd r21,Z+19
+ 736 0140 6489 ldd r22,Z+20
+ 737 0142 7589 ldd r23,Z+21
+ 738 .LVL68:
+ 739 0144 00C0 rjmp .L40
+ 740 .LVL69:
+ 741 .L39:
+ 742 .LSM56:
+ 743 0146 AA81 ldd r26,Y+2
+ 744 0148 BB81 ldd r27,Y+3
+ 745 014a 1E96 adiw r26,14
+ 746 014c 4D91 ld r20,X+
+ 747 014e 5D91 ld r21,X+
+ 748 0150 6D91 ld r22,X+
+ 749 0152 7C91 ld r23,X
+ 750 0154 5197 sbiw r26,14+3
+ 751 .LVL70:
+ 752 .LSM57:
+ 753 0156 FD01 movw r30,r26
+ 754 0158 428B std Z+18,r20
+ 755 015a 538B std Z+19,r21
+ 756 015c 648B std Z+20,r22
+ 757 015e 758B std Z+21,r23
+ 758 .L40:
+ 759 .LSM58:
+ 760 0160 4115 cp r20,__zero_reg__
+ 761 0162 5105 cpc r21,__zero_reg__
+ 762 0164 6105 cpc r22,__zero_reg__
+ 763 0166 7105 cpc r23,__zero_reg__
+ 764 0168 01F0 breq .+2
+ 765 016a 00C0 rjmp .L49
+ 766 016c 00C0 rjmp .L38
+ 767 .L45:
+ 768 .LSM59:
+ 769 016e AA81 ldd r26,Y+2
+ 770 0170 BB81 ldd r27,Y+3
+ 771 0172 8D91 ld r24,X+
+ 772 0174 9C91 ld r25,X
+ 773 0176 0E94 0000 call get_fat
+ 774 .LVL71:
+ 775 017a AB01 movw r20,r22
+ 776 017c BC01 movw r22,r24
+ 777 .LVL72:
+ 778 .LSM60:
+ 779 017e 4F3F cpi r20,lo8(-1)
+ 780 0180 BFEF ldi r27,hi8(-1)
+ 781 0182 5B07 cpc r21,r27
+ 782 0184 BFEF ldi r27,hlo8(-1)
+ 783 0186 6B07 cpc r22,r27
+ 784 0188 BFEF ldi r27,hhi8(-1)
+ 785 018a 7B07 cpc r23,r27
+ 786 018c 01F4 brne .L42
+ 787 018e EA81 ldd r30,Y+2
+ 788 0190 FB81 ldd r31,Y+3
+ 789 0192 8481 ldd r24,Z+4
+ 790 0194 8068 ori r24,lo8(-128)
+ 791 0196 8483 std Z+4,r24
+ 792 0198 F1E0 ldi r31,lo8(1)
+ 793 .L50:
+ 794 019a F983 std Y+1,r31
+ 795 .LVL73:
+ 796 019c 00C0 rjmp .L35
+ 797 .L42:
+ 798 .LSM61:
+ 799 019e 4230 cpi r20,lo8(2)
+ 800 01a0 5105 cpc r21,__zero_reg__
+ 801 01a2 6105 cpc r22,__zero_reg__
+ 802 01a4 7105 cpc r23,__zero_reg__
+ 803 01a6 00F0 brlo .L43
+ 804 01a8 AA81 ldd r26,Y+2
+ 805 01aa BB81 ldd r27,Y+3
+ 806 01ac ED91 ld r30,X+
+ 807 01ae FC91 ld r31,X
+ 808 01b0 8685 ldd r24,Z+14
+ 809 01b2 9785 ldd r25,Z+15
+ 810 01b4 A089 ldd r26,Z+16
+ 811 01b6 B189 ldd r27,Z+17
+ 812 01b8 4817 cp r20,r24
+ 813 01ba 5907 cpc r21,r25
+ 814 01bc 6A07 cpc r22,r26
+ 815 01be 7B07 cpc r23,r27
+ 816 01c0 00F0 brlo .L44
+ 817 .L43:
+ 818 01c2 EA81 ldd r30,Y+2
+ 819 01c4 FB81 ldd r31,Y+3
+ 820 01c6 8481 ldd r24,Z+4
+ 821 01c8 8068 ori r24,lo8(-128)
+ 822 01ca 8483 std Z+4,r24
+ 823 .LVL74:
+ 824 .L51:
+ 825 01cc F2E0 ldi r31,lo8(2)
+ 826 01ce 00C0 rjmp .L50
+ 827 .LVL75:
+ 828 .L44:
+ 829 .LSM62:
+ 830 01d0 AA81 ldd r26,Y+2
+ 831 01d2 BB81 ldd r27,Y+3
+ 832 01d4 5296 adiw r26,18
+ 833 01d6 4D93 st X+,r20
+ 834 01d8 5D93 st X+,r21
+ 835 01da 6D93 st X+,r22
+ 836 01dc 7C93 st X,r23
+ 837 01de 5597 sbiw r26,18+3
+ 838 .LSM63:
+ 839 01e0 FD01 movw r30,r26
+ 840 01e2 8681 ldd r24,Z+6
+ 841 01e4 9781 ldd r25,Z+7
+ 842 01e6 A085 ldd r26,Z+8
+ 843 01e8 B185 ldd r27,Z+9
+ 844 01ea 860D add r24,r6
+ 845 01ec 971D adc r25,r7
+ 846 01ee A81D adc r26,r8
+ 847 01f0 B91D adc r27,r9
+ 848 01f2 8683 std Z+6,r24
+ 849 01f4 9783 std Z+7,r25
+ 850 01f6 A087 std Z+8,r26
+ 851 01f8 B187 std Z+9,r27
+ 852 .LSM64:
+ 853 01fa A618 sub r10,r6
+ 854 01fc B708 sbc r11,r7
+ 855 01fe C808 sbc r12,r8
+ 856 0200 D908 sbc r13,r9
+ 857 .LVL76:
+ 858 .L49:
+ 859 .LSM65:
+ 860 0202 6A14 cp r6,r10
+ 861 0204 7B04 cpc r7,r11
+ 862 0206 8C04 cpc r8,r12
+ 863 0208 9D04 cpc r9,r13
+ 864 020a 00F4 brsh .+2
+ 865 020c 00C0 rjmp .L45
+ 866 .LVL77:
+ 867 .LSM66:
+ 868 020e EA81 ldd r30,Y+2
+ 869 0210 FB81 ldd r31,Y+3
+ 870 0212 8681 ldd r24,Z+6
+ 871 0214 9781 ldd r25,Z+7
+ 872 0216 A085 ldd r26,Z+8
+ 873 0218 B185 ldd r27,Z+9
+ 874 021a 8A0D add r24,r10
+ 875 021c 9B1D adc r25,r11
+ 876 021e AC1D adc r26,r12
+ 877 0220 BD1D adc r27,r13
+ 878 0222 8683 std Z+6,r24
+ 879 0224 9783 std Z+7,r25
+ 880 0226 A087 std Z+8,r26
+ 881 0228 B187 std Z+9,r27
+ 882 .LSM67:
+ 883 022a D601 movw r26,r12
+ 884 022c C501 movw r24,r10
+ 885 022e 19E0 ldi r17,9
+ 886 0230 B695 1: lsr r27
+ 887 0232 A795 ror r26
+ 888 0234 9795 ror r25
+ 889 0236 8795 ror r24
+ 890 0238 1A95 dec r17
+ 891 023a 01F4 brne 1b
+ 892 023c E82E mov r14,r24
+ 893 023e 8583 std Z+5,r24
+ 894 .LSM68:
+ 895 0240 8FEF ldi r24,lo8(511)
+ 896 0242 91E0 ldi r25,hi8(511)
+ 897 0244 A0E0 ldi r26,hlo8(511)
+ 898 0246 B0E0 ldi r27,hhi8(511)
+ 899 0248 A822 and r10,r24
+ 900 024a B922 and r11,r25
+ 901 024c CA22 and r12,r26
+ 902 024e DB22 and r13,r27
+ 903 0250 A114 cp r10,__zero_reg__
+ 904 0252 B104 cpc r11,__zero_reg__
+ 905 0254 C104 cpc r12,__zero_reg__
+ 906 0256 D104 cpc r13,__zero_reg__
+ 907 0258 01F0 breq .L38
+ 908 .LSM69:
+ 909 025a 8081 ld r24,Z
+ 910 025c 9181 ldd r25,Z+1
+ 911 025e 0E94 0000 call clust2sect
+ 912 .LVL78:
+ 913 .LSM70:
+ 914 0262 6115 cp r22,__zero_reg__
+ 915 0264 7105 cpc r23,__zero_reg__
+ 916 0266 8105 cpc r24,__zero_reg__
+ 917 0268 9105 cpc r25,__zero_reg__
+ 918 .LVL79:
+ 919 026a 01F4 brne .L46
+ 920 026c AA81 ldd r26,Y+2
+ 921 026e BB81 ldd r27,Y+3
+ 922 0270 1496 adiw r26,4
+ 923 0272 8C91 ld r24,X
+ 924 0274 1497 sbiw r26,4
+ 925 0276 8068 ori r24,lo8(-128)
+ 926 0278 1496 adiw r26,4
+ 927 027a 8C93 st X,r24
+ 928 027c B2E0 ldi r27,lo8(2)
+ 929 027e B983 std Y+1,r27
+ 930 .LVL80:
+ 931 0280 00C0 rjmp .L35
+ 932 .L46:
+ 933 .LSM71:
+ 934 0282 9B01 movw r18,r22
+ 935 0284 AC01 movw r20,r24
+ 936 0286 2E0D add r18,r14
+ 937 0288 311D adc r19,__zero_reg__
+ 938 028a 411D adc r20,__zero_reg__
+ 939 028c 511D adc r21,__zero_reg__
+ 940 .LVL81:
+ 941 .LSM72:
+ 942 028e E394 inc r14
+ 943 0290 EA81 ldd r30,Y+2
+ 944 0292 FB81 ldd r31,Y+3
+ 945 0294 E582 std Z+5,r14
+ 946 0296 00C0 rjmp .L47
+ 947 .LVL82:
+ 948 .L38:
+ 949 0298 20E0 ldi r18,lo8(0)
+ 950 029a 30E0 ldi r19,hi8(0)
+ 951 029c 40E0 ldi r20,hlo8(0)
+ 952 029e 50E0 ldi r21,hhi8(0)
+ 953 .LVL83:
+ 954 .L47:
+ 955 .LSM73:
+ 956 02a0 EA81 ldd r30,Y+2
+ 957 02a2 FB81 ldd r31,Y+3
+ 958 02a4 8681 ldd r24,Z+6
+ 959 02a6 9781 ldd r25,Z+7
+ 960 02a8 A085 ldd r26,Z+8
+ 961 02aa B185 ldd r27,Z+9
+ 962 02ac 9170 andi r25,hi8(511)
+ 963 02ae A070 andi r26,hlo8(511)
+ 964 02b0 B070 andi r27,hhi8(511)
+ 965 02b2 0097 sbiw r24,0
+ 966 02b4 A105 cpc r26,__zero_reg__
+ 967 02b6 B105 cpc r27,__zero_reg__
+ 968 02b8 01F0 breq .L35
+ 969 02ba 8689 ldd r24,Z+22
+ 970 02bc 9789 ldd r25,Z+23
+ 971 02be A08D ldd r26,Z+24
+ 972 02c0 B18D ldd r27,Z+25
+ 973 02c2 2817 cp r18,r24
+ 974 02c4 3907 cpc r19,r25
+ 975 02c6 4A07 cpc r20,r26
+ 976 02c8 5B07 cpc r21,r27
+ 977 02ca 01F0 breq .L35
+ 978 .LSM74:
+ 979 02cc 268B std Z+22,r18
+ 980 02ce 378B std Z+23,r19
+ 981 02d0 408F std Z+24,r20
+ 982 02d2 518F std Z+25,r21
+ 983 .LVL84:
+ 984 .L35:
+ 985 .LSM75:
+ 986 02d4 8981 ldd r24,Y+1
+ 987 /* epilogue start */
+ 988 02d6 0F90 pop __tmp_reg__
+ 989 02d8 0F90 pop __tmp_reg__
+ 990 02da 0F90 pop __tmp_reg__
+ 991 02dc CF91 pop r28
+ 992 02de DF91 pop r29
+ 993 02e0 1F91 pop r17
+ 994 02e2 0F91 pop r16
+ 995 02e4 FF90 pop r15
+ 996 02e6 EF90 pop r14
+ 997 02e8 DF90 pop r13
+ 998 .LVL85:
+ 999 02ea CF90 pop r12
+ 1000 .LVL86:
+ 1001 02ec BF90 pop r11
+ 1002 .LVL87:
+ 1003 02ee AF90 pop r10
+ 1004 .LVL88:
+ 1005 02f0 9F90 pop r9
+ 1006 02f2 8F90 pop r8
+ 1007 .LVL89:
+ 1008 02f4 7F90 pop r7
+ 1009 .LVL90:
+ 1010 02f6 6F90 pop r6
+ 1011 .LVL91:
+ 1012 02f8 5F90 pop r5
+ 1013 02fa 4F90 pop r4
+ 1014 02fc 3F90 pop r3
+ 1015 02fe 2F90 pop r2
+ 1016 0300 0895 ret
+ 1017 .LFE73:
+ 1019 .section .text.dir_seek,"ax",@progbits
+ 1021 dir_seek:
+ 1022 .LFB61:
+ 1023 .LSM76:
+ 1024 .LVL92:
+ 1025 0000 EF92 push r14
+ 1026 0002 FF92 push r15
+ 1027 0004 0F93 push r16
+ 1028 0006 1F93 push r17
+ 1029 0008 CF93 push r28
+ 1030 000a DF93 push r29
+ 1031 /* prologue: function */
+ 1032 /* frame size = 0 */
+ 1033 000c 8C01 movw r16,r24
+ 1034 000e EB01 movw r28,r22
+ 1035 .LSM77:
+ 1036 0010 DC01 movw r26,r24
+ 1037 0012 1596 adiw r26,4+1
+ 1038 0014 7C93 st X,r23
+ 1039 0016 6E93 st -X,r22
+ 1040 0018 1497 sbiw r26,4
+ 1041 .LSM78:
+ 1042 001a 1696 adiw r26,6
+ 1043 001c 4D91 ld r20,X+
+ 1044 001e 5D91 ld r21,X+
+ 1045 0020 6D91 ld r22,X+
+ 1046 0022 7C91 ld r23,X
+ 1047 0024 1997 sbiw r26,6+3
+ 1048 .LVL93:
+ 1049 .LSM79:
+ 1050 0026 4130 cpi r20,lo8(1)
+ 1051 0028 5105 cpc r21,__zero_reg__
+ 1052 002a 6105 cpc r22,__zero_reg__
+ 1053 002c 7105 cpc r23,__zero_reg__
+ 1054 002e 01F4 brne .+2
+ 1055 0030 00C0 rjmp .L53
+ 1056 0032 ED91 ld r30,X+
+ 1057 0034 FC91 ld r31,X
+ 1058 0036 8685 ldd r24,Z+14
+ 1059 0038 9785 ldd r25,Z+15
+ 1060 003a A089 ldd r26,Z+16
+ 1061 003c B189 ldd r27,Z+17
+ 1062 .LVL94:
+ 1063 003e 4817 cp r20,r24
+ 1064 0040 5907 cpc r21,r25
+ 1065 0042 6A07 cpc r22,r26
+ 1066 0044 7B07 cpc r23,r27
+ 1067 0046 00F0 brlo .+2
+ 1068 0048 00C0 rjmp .L53
+ 1069 .LSM80:
+ 1070 004a 4115 cp r20,__zero_reg__
+ 1071 004c 5105 cpc r21,__zero_reg__
+ 1072 004e 6105 cpc r22,__zero_reg__
+ 1073 0050 7105 cpc r23,__zero_reg__
+ 1074 0052 01F4 brne .L54
+ 1075 0054 8081 ld r24,Z
+ 1076 0056 8330 cpi r24,lo8(3)
+ 1077 0058 01F4 brne .L55
+ 1078 .LSM81:
+ 1079 005a 4689 ldd r20,Z+22
+ 1080 005c 5789 ldd r21,Z+23
+ 1081 005e 608D ldd r22,Z+24
+ 1082 0060 718D ldd r23,Z+25
+ 1083 .LSM82:
+ 1084 0062 4115 cp r20,__zero_reg__
+ 1085 0064 5105 cpc r21,__zero_reg__
+ 1086 0066 6105 cpc r22,__zero_reg__
+ 1087 0068 7105 cpc r23,__zero_reg__
+ 1088 006a 01F4 brne .L54
+ 1089 .L55:
+ 1090 .LSM83:
+ 1091 006c F801 movw r30,r16
+ 1092 006e 1286 std Z+10,__zero_reg__
+ 1093 0070 1386 std Z+11,__zero_reg__
+ 1094 0072 1486 std Z+12,__zero_reg__
+ 1095 0074 1586 std Z+13,__zero_reg__
+ 1096 .LSM84:
+ 1097 0076 0190 ld __tmp_reg__,Z+
+ 1098 0078 F081 ld r31,Z
+ 1099 007a E02D mov r30,__tmp_reg__
+ 1100 007c 8085 ldd r24,Z+8
+ 1101 007e 9185 ldd r25,Z+9
+ 1102 0080 C817 cp r28,r24
+ 1103 0082 D907 cpc r29,r25
+ 1104 0084 00F0 brlo .+2
+ 1105 0086 00C0 rjmp .L53
+ 1106 .LVL95:
+ 1107 .LSM85:
+ 1108 0088 CE01 movw r24,r28
+ 1109 008a A4E0 ldi r26,4
+ 1110 008c 9695 1: lsr r25
+ 1111 008e 8795 ror r24
+ 1112 0090 AA95 dec r26
+ 1113 0092 01F4 brne 1b
+ 1114 0094 A0E0 ldi r26,lo8(0)
+ 1115 0096 B0E0 ldi r27,hi8(0)
+ 1116 0098 2689 ldd r18,Z+22
+ 1117 009a 3789 ldd r19,Z+23
+ 1118 009c 408D ldd r20,Z+24
+ 1119 009e 518D ldd r21,Z+25
+ 1120 00a0 820F add r24,r18
+ 1121 00a2 931F adc r25,r19
+ 1122 00a4 A41F adc r26,r20
+ 1123 00a6 B51F adc r27,r21
+ 1124 00a8 F801 movw r30,r16
+ 1125 00aa 8687 std Z+14,r24
+ 1126 00ac 9787 std Z+15,r25
+ 1127 00ae A08B std Z+16,r26
+ 1128 00b0 B18B std Z+17,r27
+ 1129 00b2 00C0 rjmp .L56
+ 1130 .LVL96:
+ 1131 .L54:
+ 1132 .LSM86:
+ 1133 00b4 8281 ldd r24,Z+2
+ 1134 00b6 E82E mov r14,r24
+ 1135 .LVL97:
+ 1136 00b8 FF24 clr r15
+ 1137 .LVL98:
+ 1138 00ba E4E0 ldi r30,4
+ 1139 00bc EE0C 1: lsl r14
+ 1140 00be FF1C rol r15
+ 1141 00c0 EA95 dec r30
+ 1142 00c2 01F4 brne 1b
+ 1143 .LVL99:
+ 1144 00c4 00C0 rjmp .L57
+ 1145 .LVL100:
+ 1146 .L60:
+ 1147 .LSM87:
+ 1148 00c6 0E94 0000 call get_fat
+ 1149 .LVL101:
+ 1150 00ca AB01 movw r20,r22
+ 1151 00cc BC01 movw r22,r24
+ 1152 .LVL102:
+ 1153 .LSM88:
+ 1154 00ce 4F3F cpi r20,lo8(-1)
+ 1155 00d0 FFEF ldi r31,hi8(-1)
+ 1156 00d2 5F07 cpc r21,r31
+ 1157 00d4 FFEF ldi r31,hlo8(-1)
+ 1158 00d6 6F07 cpc r22,r31
+ 1159 00d8 FFEF ldi r31,hhi8(-1)
+ 1160 00da 7F07 cpc r23,r31
+ 1161 00dc 01F4 brne .L58
+ 1162 00de 81E0 ldi r24,lo8(1)
+ 1163 00e0 00C0 rjmp .L59
+ 1164 .L58:
+ 1165 .LSM89:
+ 1166 00e2 4230 cpi r20,lo8(2)
+ 1167 00e4 5105 cpc r21,__zero_reg__
+ 1168 00e6 6105 cpc r22,__zero_reg__
+ 1169 00e8 7105 cpc r23,__zero_reg__
+ 1170 00ea 00F4 brsh .+2
+ 1171 00ec 00C0 rjmp .L53
+ 1172 00ee D801 movw r26,r16
+ 1173 00f0 ED91 ld r30,X+
+ 1174 00f2 FC91 ld r31,X
+ 1175 00f4 8685 ldd r24,Z+14
+ 1176 00f6 9785 ldd r25,Z+15
+ 1177 00f8 A089 ldd r26,Z+16
+ 1178 00fa B189 ldd r27,Z+17
+ 1179 00fc 4817 cp r20,r24
+ 1180 00fe 5907 cpc r21,r25
+ 1181 0100 6A07 cpc r22,r26
+ 1182 0102 7B07 cpc r23,r27
+ 1183 0104 00F4 brsh .L53
+ 1184 .LSM90:
+ 1185 0106 CE19 sub r28,r14
+ 1186 0108 DF09 sbc r29,r15
+ 1187 .LVL103:
+ 1188 .L57:
+ 1189 010a F801 movw r30,r16
+ 1190 010c 8081 ld r24,Z
+ 1191 010e 9181 ldd r25,Z+1
+ 1192 .LSM91:
+ 1193 0110 CE15 cp r28,r14
+ 1194 0112 DF05 cpc r29,r15
+ 1195 0114 00F4 brsh .L60
+ 1196 .LSM92:
+ 1197 0116 D801 movw r26,r16
+ 1198 0118 1A96 adiw r26,10
+ 1199 011a 4D93 st X+,r20
+ 1200 011c 5D93 st X+,r21
+ 1201 011e 6D93 st X+,r22
+ 1202 0120 7C93 st X,r23
+ 1203 0122 1D97 sbiw r26,10+3
+ 1204 .LSM93:
+ 1205 0124 0E94 0000 call clust2sect
+ 1206 .LVL104:
+ 1207 0128 9E01 movw r18,r28
+ 1208 012a 44E0 ldi r20,4
+ 1209 012c 3695 1: lsr r19
+ 1210 012e 2795 ror r18
+ 1211 0130 4A95 dec r20
+ 1212 0132 01F4 brne 1b
+ 1213 0134 40E0 ldi r20,lo8(0)
+ 1214 0136 50E0 ldi r21,hi8(0)
+ 1215 0138 260F add r18,r22
+ 1216 013a 371F adc r19,r23
+ 1217 013c 481F adc r20,r24
+ 1218 013e 591F adc r21,r25
+ 1219 0140 F801 movw r30,r16
+ 1220 0142 2687 std Z+14,r18
+ 1221 0144 3787 std Z+15,r19
+ 1222 0146 408B std Z+16,r20
+ 1223 0148 518B std Z+17,r21
+ 1224 .LVL105:
+ 1225 .L56:
+ 1226 .LSM94:
+ 1227 014a CF70 andi r28,lo8(15)
+ 1228 014c D070 andi r29,hi8(15)
+ 1229 014e 85E0 ldi r24,5
+ 1230 0150 CC0F 1: lsl r28
+ 1231 0152 DD1F rol r29
+ 1232 0154 8A95 dec r24
+ 1233 0156 01F4 brne 1b
+ 1234 0158 A296 adiw r28,34
+ 1235 015a D801 movw r26,r16
+ 1236 015c 8D91 ld r24,X+
+ 1237 015e 9C91 ld r25,X
+ 1238 0160 1197 sbiw r26,1
+ 1239 0162 8C0F add r24,r28
+ 1240 0164 9D1F adc r25,r29
+ 1241 0166 5396 adiw r26,18+1
+ 1242 0168 9C93 st X,r25
+ 1243 016a 8E93 st -X,r24
+ 1244 016c 5297 sbiw r26,18
+ 1245 016e 80E0 ldi r24,lo8(0)
+ 1246 0170 00C0 rjmp .L59
+ 1247 .LVL106:
+ 1248 .L53:
+ 1249 .LSM95:
+ 1250 0172 82E0 ldi r24,lo8(2)
+ 1251 .L59:
+ 1252 /* epilogue start */
+ 1253 .LSM96:
+ 1254 0174 DF91 pop r29
+ 1255 0176 CF91 pop r28
+ 1256 .LVL107:
+ 1257 0178 1F91 pop r17
+ 1258 017a 0F91 pop r16
+ 1259 .LVL108:
+ 1260 017c FF90 pop r15
+ 1261 .LVL109:
+ 1262 017e EF90 pop r14
+ 1263 .LVL110:
+ 1264 0180 0895 ret
+ 1265 .LFE61:
+ 1267 .section .text.f_read,"ax",@progbits
+ 1268 .global f_read
+ 1270 f_read:
+ 1271 .LFB71:
+ 1272 .LSM97:
+ 1273 .LVL111:
+ 1274 0000 2F92 push r2
+ 1275 0002 3F92 push r3
+ 1276 0004 4F92 push r4
+ 1277 0006 5F92 push r5
+ 1278 0008 7F92 push r7
+ 1279 000a 8F92 push r8
+ 1280 000c 9F92 push r9
+ 1281 000e AF92 push r10
+ 1282 0010 BF92 push r11
+ 1283 0012 CF92 push r12
+ 1284 0014 DF92 push r13
+ 1285 0016 EF92 push r14
+ 1286 0018 FF92 push r15
+ 1287 001a 0F93 push r16
+ 1288 001c 1F93 push r17
+ 1289 001e CF93 push r28
+ 1290 0020 DF93 push r29
+ 1291 /* prologue: function */
+ 1292 /* frame size = 0 */
+ 1293 0022 EC01 movw r28,r24
+ 1294 0024 162F mov r17,r22
+ 1295 0026 072F mov r16,r23
+ 1296 .LVL112:
+ 1297 0028 4A01 movw r8,r20
+ 1298 002a 1901 movw r2,r18
+ 1299 .LSM98:
+ 1300 002c D901 movw r26,r18
+ 1301 002e 1D92 st X+,__zero_reg__
+ 1302 0030 1C92 st X,__zero_reg__
+ 1303 .LSM99:
+ 1304 0032 6A81 ldd r22,Y+2
+ 1305 0034 7B81 ldd r23,Y+3
+ 1306 .LVL113:
+ 1307 0036 8881 ld r24,Y
+ 1308 0038 9981 ldd r25,Y+1
+ 1309 .LVL114:
+ 1310 003a 0E94 0000 call validate
+ 1311 .LVL115:
+ 1312 003e 782E mov r7,r24
+ 1313 .LVL116:
+ 1314 .LSM100:
+ 1315 0040 8823 tst r24
+ 1316 0042 01F0 breq .+2
+ 1317 0044 00C0 rjmp .L63
+ 1318 .LVL117:
+ 1319 .LSM101:
+ 1320 0046 8C81 ldd r24,Y+4
+ 1321 .LVL118:
+ 1322 0048 87FD sbrc r24,7
+ 1323 004a 00C0 rjmp .L85
+ 1324 .L64:
+ 1325 .LSM102:
+ 1326 004c 80FD sbrc r24,0
+ 1327 004e 00C0 rjmp .L65
+ 1328 0050 27E0 ldi r18,lo8(7)
+ 1329 0052 722E mov r7,r18
+ 1330 0054 00C0 rjmp .L63
+ 1331 .L65:
+ 1332 .LSM103:
+ 1333 0056 2A85 ldd r18,Y+10
+ 1334 0058 3B85 ldd r19,Y+11
+ 1335 005a 4C85 ldd r20,Y+12
+ 1336 005c 5D85 ldd r21,Y+13
+ 1337 .LVL119:
+ 1338 005e 8E81 ldd r24,Y+6
+ 1339 0060 9F81 ldd r25,Y+7
+ 1340 0062 A885 ldd r26,Y+8
+ 1341 0064 B985 ldd r27,Y+9
+ 1342 0066 281B sub r18,r24
+ 1343 0068 390B sbc r19,r25
+ 1344 006a 4A0B sbc r20,r26
+ 1345 006c 5B0B sbc r21,r27
+ 1346 .LSM104:
+ 1347 006e C401 movw r24,r8
+ 1348 0070 A0E0 ldi r26,lo8(0)
+ 1349 0072 B0E0 ldi r27,hi8(0)
+ 1350 .LVL120:
+ 1351 0074 2817 cp r18,r24
+ 1352 0076 3907 cpc r19,r25
+ 1353 0078 4A07 cpc r20,r26
+ 1354 007a 5B07 cpc r21,r27
+ 1355 007c 00F4 brsh .L66
+ 1356 .LVL121:
+ 1357 007e 4901 movw r8,r18
+ 1358 .LVL122:
+ 1359 .L66:
+ 1360 .LSM105:
+ 1361 0080 812F mov r24,r17
+ 1362 .LVL123:
+ 1363 0082 902F mov r25,r16
+ 1364 .LVL124:
+ 1365 0084 9C01 movw r18,r24
+ 1366 .LVL125:
+ 1367 0086 2901 movw r4,r18
+ 1368 .LVL126:
+ 1369 0088 00C0 rjmp .L67
+ 1370 .LVL127:
+ 1371 .L83:
+ 1372 .LSM106:
+ 1373 008a 2E81 ldd r18,Y+6
+ 1374 008c 3F81 ldd r19,Y+7
+ 1375 008e 4885 ldd r20,Y+8
+ 1376 0090 5985 ldd r21,Y+9
+ 1377 0092 DA01 movw r26,r20
+ 1378 0094 C901 movw r24,r18
+ 1379 0096 9170 andi r25,hi8(511)
+ 1380 0098 A070 andi r26,hlo8(511)
+ 1381 009a B070 andi r27,hhi8(511)
+ 1382 009c 0097 sbiw r24,0
+ 1383 009e A105 cpc r26,__zero_reg__
+ 1384 00a0 B105 cpc r27,__zero_reg__
+ 1385 00a2 01F0 breq .+2
+ 1386 00a4 00C0 rjmp .L68
+ 1387 .LSM107:
+ 1388 00a6 E881 ld r30,Y
+ 1389 00a8 F981 ldd r31,Y+1
+ 1390 .LVL128:
+ 1391 00aa 9D81 ldd r25,Y+5
+ 1392 .LVL129:
+ 1393 00ac 8281 ldd r24,Z+2
+ 1394 00ae 9817 cp r25,r24
+ 1395 00b0 00F0 brlo .L69
+ 1396 .LSM108:
+ 1397 00b2 2115 cp r18,__zero_reg__
+ 1398 00b4 3105 cpc r19,__zero_reg__
+ 1399 00b6 4105 cpc r20,__zero_reg__
+ 1400 00b8 5105 cpc r21,__zero_reg__
+ 1401 00ba 01F4 brne .L70
+ 1402 00bc 6E85 ldd r22,Y+14
+ 1403 00be 7F85 ldd r23,Y+15
+ 1404 00c0 8889 ldd r24,Y+16
+ 1405 00c2 9989 ldd r25,Y+17
+ 1406 .LVL130:
+ 1407 00c4 00C0 rjmp .L71
+ 1408 .LVL131:
+ 1409 .L70:
+ 1410 00c6 4A89 ldd r20,Y+18
+ 1411 00c8 5B89 ldd r21,Y+19
+ 1412 00ca 6C89 ldd r22,Y+20
+ 1413 00cc 7D89 ldd r23,Y+21
+ 1414 00ce CF01 movw r24,r30
+ 1415 00d0 0E94 0000 call get_fat
+ 1416 .LVL132:
+ 1417 .L71:
+ 1418 .LSM109:
+ 1419 00d4 6230 cpi r22,lo8(2)
+ 1420 00d6 7105 cpc r23,__zero_reg__
+ 1421 00d8 8105 cpc r24,__zero_reg__
+ 1422 00da 9105 cpc r25,__zero_reg__
+ 1423 00dc 00F4 brsh .L72
+ 1424 .LVL133:
+ 1425 .L87:
+ 1426 00de 8C81 ldd r24,Y+4
+ 1427 00e0 8068 ori r24,lo8(-128)
+ 1428 00e2 8C83 std Y+4,r24
+ 1429 .L85:
+ 1430 00e4 92E0 ldi r25,lo8(2)
+ 1431 00e6 792E mov r7,r25
+ 1432 00e8 00C0 rjmp .L63
+ 1433 .LVL134:
+ 1434 .L72:
+ 1435 .LSM110:
+ 1436 00ea 6F3F cpi r22,lo8(-1)
+ 1437 00ec BFEF ldi r27,hi8(-1)
+ 1438 00ee 7B07 cpc r23,r27
+ 1439 00f0 BFEF ldi r27,hlo8(-1)
+ 1440 00f2 8B07 cpc r24,r27
+ 1441 00f4 BFEF ldi r27,hhi8(-1)
+ 1442 00f6 9B07 cpc r25,r27
+ 1443 00f8 01F4 brne .+2
+ 1444 00fa 00C0 rjmp .L86
+ 1445 .L73:
+ 1446 .LSM111:
+ 1447 00fc 6A8B std Y+18,r22
+ 1448 00fe 7B8B std Y+19,r23
+ 1449 0100 8C8B std Y+20,r24
+ 1450 0102 9D8B std Y+21,r25
+ 1451 .LSM112:
+ 1452 0104 1D82 std Y+5,__zero_reg__
+ 1453 .LVL135:
+ 1454 .L69:
+ 1455 .LSM113:
+ 1456 0106 0881 ld r16,Y
+ 1457 0108 1981 ldd r17,Y+1
+ 1458 .LVL136:
+ 1459 010a 4A89 ldd r20,Y+18
+ 1460 010c 5B89 ldd r21,Y+19
+ 1461 010e 6C89 ldd r22,Y+20
+ 1462 0110 7D89 ldd r23,Y+21
+ 1463 0112 C801 movw r24,r16
+ 1464 0114 0E94 0000 call clust2sect
+ 1465 .LVL137:
+ 1466 .LSM114:
+ 1467 0118 6115 cp r22,__zero_reg__
+ 1468 011a 7105 cpc r23,__zero_reg__
+ 1469 011c 8105 cpc r24,__zero_reg__
+ 1470 011e 9105 cpc r25,__zero_reg__
+ 1471 0120 01F0 breq .L87
+ 1472 .LVL138:
+ 1473 .L74:
+ 1474 .LSM115:
+ 1475 0122 ED81 ldd r30,Y+5
+ 1476 0124 5B01 movw r10,r22
+ 1477 0126 6C01 movw r12,r24
+ 1478 0128 AE0E add r10,r30
+ 1479 012a B11C adc r11,__zero_reg__
+ 1480 012c C11C adc r12,__zero_reg__
+ 1481 012e D11C adc r13,__zero_reg__
+ 1482 .LVL139:
+ 1483 .LSM116:
+ 1484 0130 7401 movw r14,r8
+ 1485 0132 EF2C mov r14,r15
+ 1486 0134 FF24 clr r15
+ 1487 0136 E694 lsr r14
+ 1488 .LSM117:
+ 1489 0138 E114 cp r14,__zero_reg__
+ 1490 013a F104 cpc r15,__zero_reg__
+ 1491 013c 01F0 breq .L75
+ 1492 .LSM118:
+ 1493 013e D801 movw r26,r16
+ 1494 0140 1296 adiw r26,2
+ 1495 0142 2C91 ld r18,X
+ 1496 0144 F0E0 ldi r31,lo8(0)
+ 1497 0146 C701 movw r24,r14
+ 1498 0148 8E0F add r24,r30
+ 1499 014a 9F1F adc r25,r31
+ 1500 014c 622F mov r22,r18
+ 1501 014e 70E0 ldi r23,lo8(0)
+ 1502 0150 6817 cp r22,r24
+ 1503 0152 7907 cpc r23,r25
+ 1504 0154 00F4 brsh .L76
+ 1505 .LSM119:
+ 1506 0156 7B01 movw r14,r22
+ 1507 0158 EE1A sub r14,r30
+ 1508 015a FF0A sbc r15,r31
+ 1509 .L76:
+ 1510 .LSM120:
+ 1511 015c F801 movw r30,r16
+ 1512 015e 8181 ldd r24,Z+1
+ 1513 0160 B201 movw r22,r4
+ 1514 0162 A601 movw r20,r12
+ 1515 0164 9501 movw r18,r10
+ 1516 0166 0E2D mov r16,r14
+ 1517 0168 0E94 0000 call disk_read
+ 1518 016c 8823 tst r24
+ 1519 016e 01F4 brne .L86
+ 1520 .L77:
+ 1521 .LSM121:
+ 1522 0170 8D81 ldd r24,Y+5
+ 1523 0172 8E0D add r24,r14
+ 1524 0174 8D83 std Y+5,r24
+ 1525 .LSM122:
+ 1526 0176 B701 movw r22,r14
+ 1527 .LVL140:
+ 1528 0178 762F mov r23,r22
+ 1529 017a 6627 clr r22
+ 1530 017c 770F lsl r23
+ 1531 017e 00C0 rjmp .L78
+ 1532 .LVL141:
+ 1533 .L75:
+ 1534 .LSM123:
+ 1535 0180 AE8A std Y+22,r10
+ 1536 0182 BF8A std Y+23,r11
+ 1537 0184 C88E std Y+24,r12
+ 1538 0186 D98E std Y+25,r13
+ 1539 .LSM124:
+ 1540 0188 EF5F subi r30,lo8(-(1))
+ 1541 018a ED83 std Y+5,r30
+ 1542 .LVL142:
+ 1543 .L68:
+ 1544 .LSM125:
+ 1545 018c EE80 ldd r14,Y+6
+ 1546 018e FF80 ldd r15,Y+7
+ 1547 0190 0885 ldd r16,Y+8
+ 1548 0192 1985 ldd r17,Y+9
+ 1549 .LVL143:
+ 1550 .LSM126:
+ 1551 0194 4E89 ldd r20,Y+22
+ 1552 0196 5F89 ldd r21,Y+23
+ 1553 0198 688D ldd r22,Y+24
+ 1554 019a 798D ldd r23,Y+25
+ 1555 019c 8881 ld r24,Y
+ 1556 019e 9981 ldd r25,Y+1
+ 1557 01a0 0E94 0000 call move_window
+ 1558 .LVL144:
+ 1559 01a4 8823 tst r24
+ 1560 01a6 01F0 breq .L79
+ 1561 .LVL145:
+ 1562 .L86:
+ 1563 .LSM127:
+ 1564 01a8 8C81 ldd r24,Y+4
+ 1565 01aa 8068 ori r24,lo8(-128)
+ 1566 01ac 8C83 std Y+4,r24
+ 1567 01ae 7724 clr r7
+ 1568 01b0 7394 inc r7
+ 1569 01b2 00C0 rjmp .L63
+ 1570 .LVL146:
+ 1571 .L79:
+ 1572 .LSM128:
+ 1573 01b4 C701 movw r24,r14
+ 1574 01b6 9170 andi r25,hi8(511)
+ 1575 01b8 20E0 ldi r18,lo8(512)
+ 1576 01ba 32E0 ldi r19,hi8(512)
+ 1577 01bc 281B sub r18,r24
+ 1578 01be 390B sbc r19,r25
+ 1579 01c0 B401 movw r22,r8
+ 1580 .LVL147:
+ 1581 01c2 2815 cp r18,r8
+ 1582 01c4 3905 cpc r19,r9
+ 1583 01c6 00F4 brsh .L80
+ 1584 .LVL148:
+ 1585 01c8 B901 movw r22,r18
+ 1586 .L80:
+ 1587 .LSM129:
+ 1588 01ca 9B01 movw r18,r22
+ 1589 .LVL149:
+ 1590 .LBB4:
+ 1591 .LBB5:
+ 1592 .LSM130:
+ 1593 01cc 8E81 ldd r24,Y+6
+ 1594 01ce 9F81 ldd r25,Y+7
+ 1595 01d0 9170 andi r25,hi8(511)
+ 1596 01d2 8296 adiw r24,34
+ 1597 01d4 E881 ld r30,Y
+ 1598 01d6 F981 ldd r31,Y+1
+ 1599 .LVL150:
+ 1600 01d8 E80F add r30,r24
+ 1601 01da F91F adc r31,r25
+ 1602 01dc D201 movw r26,r4
+ 1603 01de 00C0 rjmp .L81
+ 1604 .LVL151:
+ 1605 .L82:
+ 1606 .LSM131:
+ 1607 01e0 8191 ld r24,Z+
+ 1608 01e2 8D93 st X+,r24
+ 1609 .L81:
+ 1610 01e4 2150 subi r18,lo8(-(-1))
+ 1611 01e6 3040 sbci r19,hi8(-(-1))
+ 1612 01e8 8FEF ldi r24,hi8(-1)
+ 1613 01ea 2F3F cpi r18,lo8(-1)
+ 1614 01ec 3807 cpc r19,r24
+ 1615 01ee 01F4 brne .L82
+ 1616 .LVL152:
+ 1617 .L78:
+ 1618 .LBE5:
+ 1619 .LBE4:
+ 1620 .LSM132:
+ 1621 01f0 460E add r4,r22
+ 1622 01f2 571E adc r5,r23
+ 1623 01f4 CB01 movw r24,r22
+ 1624 01f6 A0E0 ldi r26,lo8(0)
+ 1625 01f8 B0E0 ldi r27,hi8(0)
+ 1626 .LVL153:
+ 1627 01fa 2E81 ldd r18,Y+6
+ 1628 01fc 3F81 ldd r19,Y+7
+ 1629 01fe 4885 ldd r20,Y+8
+ 1630 0200 5985 ldd r21,Y+9
+ 1631 .LVL154:
+ 1632 0202 280F add r18,r24
+ 1633 0204 391F adc r19,r25
+ 1634 0206 4A1F adc r20,r26
+ 1635 0208 5B1F adc r21,r27
+ 1636 020a 2E83 std Y+6,r18
+ 1637 020c 3F83 std Y+7,r19
+ 1638 020e 4887 std Y+8,r20
+ 1639 0210 5987 std Y+9,r21
+ 1640 0212 D101 movw r26,r2
+ 1641 .LVL155:
+ 1642 0214 8D91 ld r24,X+
+ 1643 0216 9C91 ld r25,X
+ 1644 0218 1197 sbiw r26,1
+ 1645 021a 860F add r24,r22
+ 1646 021c 971F adc r25,r23
+ 1647 021e 8D93 st X+,r24
+ 1648 0220 9C93 st X,r25
+ 1649 0222 861A sub r8,r22
+ 1650 0224 970A sbc r9,r23
+ 1651 .LVL156:
+ 1652 .L67:
+ 1653 .LSM133:
+ 1654 0226 8114 cp r8,__zero_reg__
+ 1655 0228 9104 cpc r9,__zero_reg__
+ 1656 022a 01F0 breq .+2
+ 1657 022c 00C0 rjmp .L83
+ 1658 .LVL157:
+ 1659 .L63:
+ 1660 .LSM134:
+ 1661 022e 872D mov r24,r7
+ 1662 /* epilogue start */
+ 1663 0230 DF91 pop r29
+ 1664 0232 CF91 pop r28
+ 1665 .LVL158:
+ 1666 0234 1F91 pop r17
+ 1667 .LVL159:
+ 1668 0236 0F91 pop r16
+ 1669 .LVL160:
+ 1670 0238 FF90 pop r15
+ 1671 023a EF90 pop r14
+ 1672 .LVL161:
+ 1673 023c DF90 pop r13
+ 1674 023e CF90 pop r12
+ 1675 0240 BF90 pop r11
+ 1676 0242 AF90 pop r10
+ 1677 .LVL162:
+ 1678 0244 9F90 pop r9
+ 1679 0246 8F90 pop r8
+ 1680 .LVL163:
+ 1681 0248 7F90 pop r7
+ 1682 .LVL164:
+ 1683 024a 5F90 pop r5
+ 1684 024c 4F90 pop r4
+ 1685 .LVL165:
+ 1686 024e 3F90 pop r3
+ 1687 0250 2F90 pop r2
+ 1688 .LVL166:
+ 1689 0252 0895 ret
+ 1690 .LFE71:
+ 1692 .section .text.check_fs,"ax",@progbits
+ 1694 check_fs:
+ 1695 .LFB66:
+ 1696 .LSM135:
+ 1697 .LVL167:
+ 1698 0000 0F93 push r16
+ 1699 0002 CF93 push r28
+ 1700 0004 DF93 push r29
+ 1701 /* prologue: function */
+ 1702 /* frame size = 0 */
+ 1703 0006 EC01 movw r28,r24
+ 1704 0008 9A01 movw r18,r20
+ 1705 000a AB01 movw r20,r22
+ 1706 .LSM136:
+ 1707 000c BC01 movw r22,r24
+ 1708 000e 6E5D subi r22,lo8(-(34))
+ 1709 0010 7F4F sbci r23,hi8(-(34))
+ 1710 0012 8981 ldd r24,Y+1
+ 1711 .LVL168:
+ 1712 0014 01E0 ldi r16,lo8(1)
+ 1713 0016 0E94 0000 call disk_read
+ 1714 .LVL169:
+ 1715 001a 8823 tst r24
+ 1716 001c 01F0 breq .L89
+ 1717 001e 23E0 ldi r18,lo8(3)
+ 1718 0020 00C0 rjmp .L90
+ 1719 .L89:
+ 1720 .LSM137:
+ 1721 0022 C05E subi r28,lo8(-(544))
+ 1722 0024 DD4F sbci r29,hi8(-(544))
+ 1723 0026 8881 ld r24,Y
+ 1724 0028 9981 ldd r25,Y+1
+ 1725 002a C052 subi r28,lo8(-(-544))
+ 1726 002c D240 sbci r29,hi8(-(-544))
+ 1727 002e 8555 subi r24,lo8(-21931)
+ 1728 0030 9A4A sbci r25,hi8(-21931)
+ 1729 0032 01F0 breq .L91
+ 1730 0034 22E0 ldi r18,lo8(2)
+ 1731 0036 00C0 rjmp .L90
+ 1732 .L91:
+ 1733 .LSM138:
+ 1734 0038 C85A subi r28,lo8(-(88))
+ 1735 003a DF4F sbci r29,hi8(-(88))
+ 1736 003c 8881 ld r24,Y
+ 1737 003e 9981 ldd r25,Y+1
+ 1738 0040 AA81 ldd r26,Y+2
+ 1739 0042 BB81 ldd r27,Y+3
+ 1740 0044 C855 subi r28,lo8(-(-88))
+ 1741 0046 D040 sbci r29,hi8(-(-88))
+ 1742 0048 B070 andi r27,hhi8(16777215)
+ 1743 004a 8654 subi r24,lo8(5521734)
+ 1744 004c 9144 sbci r25,hi8(5521734)
+ 1745 004e A445 sbci r26,hlo8(5521734)
+ 1746 0050 B040 sbci r27,hhi8(5521734)
+ 1747 0052 01F4 brne .L92
+ 1748 0054 20E0 ldi r18,lo8(0)
+ 1749 0056 00C0 rjmp .L90
+ 1750 .L92:
+ 1751 0058 20E0 ldi r18,lo8(0)
+ 1752 005a CC58 subi r28,lo8(-(116))
+ 1753 005c DF4F sbci r29,hi8(-(116))
+ 1754 005e 8881 ld r24,Y
+ 1755 0060 9981 ldd r25,Y+1
+ 1756 0062 AA81 ldd r26,Y+2
+ 1757 0064 BB81 ldd r27,Y+3
+ 1758 0066 B070 andi r27,hhi8(16777215)
+ 1759 0068 8654 subi r24,lo8(5521734)
+ 1760 006a 9144 sbci r25,hi8(5521734)
+ 1761 006c A445 sbci r26,hlo8(5521734)
+ 1762 006e B040 sbci r27,hhi8(5521734)
+ 1763 0070 01F0 breq .L90
+ 1764 0072 21E0 ldi r18,lo8(1)
+ 1765 .L90:
+ 1766 .LSM139:
+ 1767 0074 822F mov r24,r18
+ 1768 /* epilogue start */
+ 1769 0076 DF91 pop r29
+ 1770 0078 CF91 pop r28
+ 1771 .LVL170:
+ 1772 007a 0F91 pop r16
+ 1773 007c 0895 ret
+ 1774 .LFE66:
+ 1776 .section .text.chk_mounted,"ax",@progbits
+ 1777 .global chk_mounted
+ 1779 chk_mounted:
+ 1780 .LFB67:
+ 1781 .LSM140:
+ 1782 .LVL171:
+ 1783 0000 AF92 push r10
+ 1784 0002 BF92 push r11
+ 1785 0004 CF92 push r12
+ 1786 0006 DF92 push r13
+ 1787 0008 EF92 push r14
+ 1788 000a FF92 push r15
+ 1789 000c 0F93 push r16
+ 1790 000e 1F93 push r17
+ 1791 0010 CF93 push r28
+ 1792 0012 DF93 push r29
+ 1793 /* prologue: function */
+ 1794 /* frame size = 0 */
+ 1795 0014 DC01 movw r26,r24
+ 1796 0016 AB01 movw r20,r22
+ 1797 .LVL172:
+ 1798 .LSM141:
+ 1799 0018 ED91 ld r30,X+
+ 1800 001a FC91 ld r31,X
+ 1801 001c 1197 sbiw r26,1
+ 1802 .LVL173:
+ 1803 .LSM142:
+ 1804 001e 8081 ld r24,Z
+ 1805 .LVL174:
+ 1806 0020 282F mov r18,r24
+ 1807 .LVL175:
+ 1808 0022 30E0 ldi r19,lo8(0)
+ 1809 .LVL176:
+ 1810 0024 2053 subi r18,lo8(-(-48))
+ 1811 0026 3040 sbci r19,hi8(-(-48))
+ 1812 .LVL177:
+ 1813 .LSM143:
+ 1814 0028 2A30 cpi r18,10
+ 1815 002a 3105 cpc r19,__zero_reg__
+ 1816 002c 00F4 brsh .L96
+ 1817 .LVL178:
+ 1818 002e 8181 ldd r24,Z+1
+ 1819 0030 8A33 cpi r24,lo8(58)
+ 1820 0032 01F4 brne .L96
+ 1821 .LSM144:
+ 1822 0034 3296 adiw r30,2
+ 1823 0036 ED93 st X+,r30
+ 1824 0038 FC93 st X,r31
+ 1825 .LSM145:
+ 1826 003a 232B or r18,r19
+ 1827 003c 01F0 breq .L96
+ 1828 003e 8BE0 ldi r24,lo8(11)
+ 1829 0040 00C0 rjmp .L97
+ 1830 .L96:
+ 1831 .LSM146:
+ 1832 0042 C091 0000 lds r28,FatFs
+ 1833 0046 D091 0000 lds r29,(FatFs)+1
+ 1834 .LVL179:
+ 1835 004a FA01 movw r30,r20
+ 1836 .LVL180:
+ 1837 004c D183 std Z+1,r29
+ 1838 004e C083 st Z,r28
+ 1839 .LSM147:
+ 1840 0050 2097 sbiw r28,0
+ 1841 0052 01F4 brne .L98
+ 1842 0054 8CE0 ldi r24,lo8(12)
+ 1843 0056 00C0 rjmp .L97
+ 1844 .L98:
+ 1845 .LSM148:
+ 1846 0058 8881 ld r24,Y
+ 1847 005a 8823 tst r24
+ 1848 005c 01F0 breq .L99
+ 1849 .LSM149:
+ 1850 005e 8981 ldd r24,Y+1
+ 1851 0060 0E94 0000 call disk_status
+ 1852 .LVL181:
+ 1853 .LSM150:
+ 1854 0064 80FF sbrs r24,0
+ 1855 0066 00C0 rjmp .L112
+ 1856 .LVL182:
+ 1857 .L99:
+ 1858 .LSM151:
+ 1859 0068 1882 st Y,__zero_reg__
+ 1860 .LSM152:
+ 1861 006a 1982 std Y+1,__zero_reg__
+ 1862 .LSM153:
+ 1863 006c 80E0 ldi r24,lo8(0)
+ 1864 006e 0E94 0000 call disk_initialize
+ 1865 .LVL183:
+ 1866 .LSM154:
+ 1867 0072 80FF sbrs r24,0
+ 1868 0074 00C0 rjmp .L100
+ 1869 0076 83E0 ldi r24,lo8(3)
+ 1870 0078 00C0 rjmp .L97
+ 1871 .L100:
+ 1872 .LSM155:
+ 1873 007a CE01 movw r24,r28
+ 1874 007c 40E0 ldi r20,lo8(0)
+ 1875 007e 50E0 ldi r21,hi8(0)
+ 1876 0080 60E0 ldi r22,hlo8(0)
+ 1877 0082 70E0 ldi r23,hhi8(0)
+ 1878 0084 0E94 0000 call check_fs
+ 1879 .LSM156:
+ 1880 0088 8130 cpi r24,lo8(1)
+ 1881 .LVL184:
+ 1882 008a 01F0 breq .L101
+ 1883 008c EE24 clr r14
+ 1884 008e FF24 clr r15
+ 1885 0090 8701 movw r16,r14
+ 1886 .LVL185:
+ 1887 0092 00C0 rjmp .L102
+ 1888 .LVL186:
+ 1889 .L101:
+ 1890 .LSM157:
+ 1891 0094 FE01 movw r30,r28
+ 1892 .LVL187:
+ 1893 0096 E052 subi r30,lo8(-(480))
+ 1894 0098 FE4F sbci r31,hi8(-(480))
+ 1895 .LSM158:
+ 1896 009a 8481 ldd r24,Z+4
+ 1897 .LVL188:
+ 1898 009c 8823 tst r24
+ 1899 009e 01F4 brne .+2
+ 1900 00a0 00C0 rjmp .L103
+ 1901 .LSM159:
+ 1902 00a2 E084 ldd r14,Z+8
+ 1903 00a4 F184 ldd r15,Z+9
+ 1904 00a6 0285 ldd r16,Z+10
+ 1905 00a8 1385 ldd r17,Z+11
+ 1906 .LVL189:
+ 1907 .LSM160:
+ 1908 00aa CE01 movw r24,r28
+ 1909 00ac B801 movw r22,r16
+ 1910 00ae A701 movw r20,r14
+ 1911 00b0 0E94 0000 call check_fs
+ 1912 .LVL190:
+ 1913 .L102:
+ 1914 .LSM161:
+ 1915 00b4 8330 cpi r24,lo8(3)
+ 1916 00b6 01F4 brne .L104
+ 1917 00b8 81E0 ldi r24,lo8(1)
+ 1918 .LVL191:
+ 1919 00ba 00C0 rjmp .L97
+ 1920 .LVL192:
+ 1921 .L104:
+ 1922 .LSM162:
+ 1923 00bc 8823 tst r24
+ 1924 00be 01F0 breq .+2
+ 1925 00c0 00C0 rjmp .L103
+ 1926 00c2 8DA5 ldd r24,Y+45
+ 1927 00c4 9EA5 ldd r25,Y+46
+ 1928 .LVL193:
+ 1929 00c6 8050 subi r24,lo8(512)
+ 1930 00c8 9240 sbci r25,hi8(512)
+ 1931 00ca 01F0 breq .+2
+ 1932 00cc 00C0 rjmp .L103
+ 1933 .LSM163:
+ 1934 00ce 88AD ldd r24,Y+56
+ 1935 00d0 99AD ldd r25,Y+57
+ 1936 00d2 BC01 movw r22,r24
+ 1937 .LVL194:
+ 1938 00d4 80E0 ldi r24,lo8(0)
+ 1939 00d6 90E0 ldi r25,hi8(0)
+ 1940 .LVL195:
+ 1941 .LSM164:
+ 1942 00d8 6115 cp r22,__zero_reg__
+ 1943 00da 7105 cpc r23,__zero_reg__
+ 1944 00dc 8105 cpc r24,__zero_reg__
+ 1945 00de 9105 cpc r25,__zero_reg__
+ 1946 00e0 01F4 brne .L105
+ 1947 00e2 CA5B subi r28,lo8(-(70))
+ 1948 00e4 DF4F sbci r29,hi8(-(70))
+ 1949 00e6 6881 ld r22,Y
+ 1950 00e8 7981 ldd r23,Y+1
+ 1951 00ea 8A81 ldd r24,Y+2
+ 1952 00ec 9B81 ldd r25,Y+3
+ 1953 .LVL196:
+ 1954 00ee C654 subi r28,lo8(-(-70))
+ 1955 00f0 D040 sbci r29,hi8(-(-70))
+ 1956 .L105:
+ 1957 .LSM165:
+ 1958 00f2 6A87 std Y+10,r22
+ 1959 00f4 7B87 std Y+11,r23
+ 1960 00f6 8C87 std Y+12,r24
+ 1961 00f8 9D87 std Y+13,r25
+ 1962 .LSM166:
+ 1963 00fa 2AA9 ldd r18,Y+50
+ 1964 00fc 2B83 std Y+3,r18
+ 1965 .LSM167:
+ 1966 00fe 30E0 ldi r19,lo8(0)
+ 1967 0100 40E0 ldi r20,lo8(0)
+ 1968 0102 50E0 ldi r21,hi8(0)
+ 1969 0104 0E94 0000 call __mulsi3
+ 1970 .LVL197:
+ 1971 0108 5B01 movw r10,r22
+ 1972 010a 6C01 movw r12,r24
+ 1973 .LVL198:
+ 1974 .LSM168:
+ 1975 010c 88A9 ldd r24,Y+48
+ 1976 010e 99A9 ldd r25,Y+49
+ 1977 .LVL199:
+ 1978 0110 A0E0 ldi r26,lo8(0)
+ 1979 0112 B0E0 ldi r27,hi8(0)
+ 1980 0114 E80E add r14,r24
+ 1981 0116 F91E adc r15,r25
+ 1982 0118 0A1F adc r16,r26
+ 1983 011a 1B1F adc r17,r27
+ 1984 011c EA8A std Y+18,r14
+ 1985 011e FB8A std Y+19,r15
+ 1986 0120 0C8B std Y+20,r16
+ 1987 0122 1D8B std Y+21,r17
+ 1988 .LSM169:
+ 1989 0124 8FA5 ldd r24,Y+47
+ 1990 0126 8A83 std Y+2,r24
+ 1991 .LSM170:
+ 1992 0128 2BA9 ldd r18,Y+51
+ 1993 012a 3CA9 ldd r19,Y+52
+ 1994 012c 3987 std Y+9,r19
+ 1995 012e 2887 std Y+8,r18
+ 1996 .LSM171:
+ 1997 0130 8DA9 ldd r24,Y+53
+ 1998 0132 9EA9 ldd r25,Y+54
+ 1999 0134 7C01 movw r14,r24
+ 2000 .LVL200:
+ 2001 0136 00E0 ldi r16,lo8(0)
+ 2002 0138 10E0 ldi r17,hi8(0)
+ 2003 .LVL201:
+ 2004 .LSM172:
+ 2005 013a E114 cp r14,__zero_reg__
+ 2006 013c F104 cpc r15,__zero_reg__
+ 2007 013e 0105 cpc r16,__zero_reg__
+ 2008 0140 1105 cpc r17,__zero_reg__
+ 2009 0142 01F4 brne .L106
+ 2010 0144 CE5B subi r28,lo8(-(66))
+ 2011 0146 DF4F sbci r29,hi8(-(66))
+ 2012 0148 E880 ld r14,Y
+ 2013 014a F980 ldd r15,Y+1
+ 2014 014c 0A81 ldd r16,Y+2
+ 2015 014e 1B81 ldd r17,Y+3
+ 2016 .LVL202:
+ 2017 0150 C254 subi r28,lo8(-(-66))
+ 2018 0152 D040 sbci r29,hi8(-(-66))
+ 2019 .L106:
+ 2020 .LSM173:
+ 2021 0154 88A9 ldd r24,Y+48
+ 2022 0156 99A9 ldd r25,Y+49
+ 2023 0158 A0E0 ldi r26,lo8(0)
+ 2024 015a B0E0 ldi r27,hi8(0)
+ 2025 015c E81A sub r14,r24
+ 2026 015e F90A sbc r15,r25
+ 2027 0160 0A0B sbc r16,r26
+ 2028 0162 1B0B sbc r17,r27
+ 2029 .LVL203:
+ 2030 0164 EA18 sub r14,r10
+ 2031 0166 FB08 sbc r15,r11
+ 2032 0168 0C09 sbc r16,r12
+ 2033 016a 1D09 sbc r17,r13
+ 2034 016c 44E0 ldi r20,4
+ 2035 016e 3695 1: lsr r19
+ 2036 0170 2795 ror r18
+ 2037 0172 4A95 dec r20
+ 2038 0174 01F4 brne 1b
+ 2039 0176 C901 movw r24,r18
+ 2040 0178 A0E0 ldi r26,lo8(0)
+ 2041 017a B0E0 ldi r27,hi8(0)
+ 2042 017c E81A sub r14,r24
+ 2043 017e F90A sbc r15,r25
+ 2044 0180 0A0B sbc r16,r26
+ 2045 0182 1B0B sbc r17,r27
+ 2046 0184 2A81 ldd r18,Y+2
+ 2047 0186 30E0 ldi r19,lo8(0)
+ 2048 0188 40E0 ldi r20,lo8(0)
+ 2049 018a 50E0 ldi r21,hi8(0)
+ 2050 018c C801 movw r24,r16
+ 2051 018e B701 movw r22,r14
+ 2052 0190 0E94 0000 call __udivmodsi4
+ 2053 0194 2E5F subi r18,lo8(-(2))
+ 2054 0196 3F4F sbci r19,hi8(-(2))
+ 2055 0198 4F4F sbci r20,hlo8(-(2))
+ 2056 019a 5F4F sbci r21,hhi8(-(2))
+ 2057 .LVL204:
+ 2058 019c 2E87 std Y+14,r18
+ 2059 019e 3F87 std Y+15,r19
+ 2060 01a0 488B std Y+16,r20
+ 2061 01a2 598B std Y+17,r21
+ 2062 .LSM174:
+ 2063 01a4 273F cpi r18,lo8(4087)
+ 2064 01a6 8FE0 ldi r24,hi8(4087)
+ 2065 01a8 3807 cpc r19,r24
+ 2066 01aa 80E0 ldi r24,hlo8(4087)
+ 2067 01ac 4807 cpc r20,r24
+ 2068 01ae 80E0 ldi r24,hhi8(4087)
+ 2069 01b0 5807 cpc r21,r24
+ 2070 01b2 00F4 brsh .L107
+ 2071 01b4 61E0 ldi r22,lo8(1)
+ 2072 .LVL205:
+ 2073 01b6 00C0 rjmp .L108
+ 2074 .LVL206:
+ 2075 .L107:
+ 2076 .LSM175:
+ 2077 01b8 275F subi r18,lo8(65527)
+ 2078 01ba 3F4F sbci r19,hi8(65527)
+ 2079 01bc 4040 sbci r20,hlo8(65527)
+ 2080 01be 5040 sbci r21,hhi8(65527)
+ 2081 01c0 00F0 brlo .+2
+ 2082 01c2 00C0 rjmp .L109
+ 2083 01c4 62E0 ldi r22,lo8(2)
+ 2084 .LVL207:
+ 2085 .L108:
+ 2086 .LSM176:
+ 2087 01c6 8A89 ldd r24,Y+18
+ 2088 01c8 9B89 ldd r25,Y+19
+ 2089 01ca AC89 ldd r26,Y+20
+ 2090 01cc BD89 ldd r27,Y+21
+ 2091 01ce 8A0D add r24,r10
+ 2092 01d0 9B1D adc r25,r11
+ 2093 01d2 AC1D adc r26,r12
+ 2094 01d4 BD1D adc r27,r13
+ 2095 01d6 8E8B std Y+22,r24
+ 2096 01d8 9F8B std Y+23,r25
+ 2097 01da A88F std Y+24,r26
+ 2098 01dc B98F std Y+25,r27
+ 2099 .L110:
+ 2100 .LSM177:
+ 2101 01de 8885 ldd r24,Y+8
+ 2102 01e0 9985 ldd r25,Y+9
+ 2103 01e2 34E0 ldi r19,4
+ 2104 01e4 9695 1: lsr r25
+ 2105 01e6 8795 ror r24
+ 2106 01e8 3A95 dec r19
+ 2107 01ea 01F4 brne 1b
+ 2108 01ec A0E0 ldi r26,lo8(0)
+ 2109 01ee B0E0 ldi r27,hi8(0)
+ 2110 01f0 2A89 ldd r18,Y+18
+ 2111 01f2 3B89 ldd r19,Y+19
+ 2112 01f4 4C89 ldd r20,Y+20
+ 2113 01f6 5D89 ldd r21,Y+21
+ 2114 .LVL208:
+ 2115 01f8 820F add r24,r18
+ 2116 01fa 931F adc r25,r19
+ 2117 01fc A41F adc r26,r20
+ 2118 01fe B51F adc r27,r21
+ 2119 0200 8A0D add r24,r10
+ 2120 0202 9B1D adc r25,r11
+ 2121 0204 AC1D adc r26,r12
+ 2122 0206 BD1D adc r27,r13
+ 2123 0208 8A8F std Y+26,r24
+ 2124 020a 9B8F std Y+27,r25
+ 2125 020c AC8F std Y+28,r26
+ 2126 020e BD8F std Y+29,r27
+ 2127 .LSM178:
+ 2128 0210 6883 st Y,r22
+ 2129 .LSM179:
+ 2130 0212 1E8E std Y+30,__zero_reg__
+ 2131 0214 1F8E std Y+31,__zero_reg__
+ 2132 0216 18A2 std Y+32,__zero_reg__
+ 2133 0218 19A2 std Y+33,__zero_reg__
+ 2134 .LSM180:
+ 2135 021a 8091 0000 lds r24,Fsid
+ 2136 021e 9091 0000 lds r25,(Fsid)+1
+ 2137 0222 0196 adiw r24,1
+ 2138 0224 9093 0000 sts (Fsid)+1,r25
+ 2139 0228 8093 0000 sts Fsid,r24
+ 2140 022c 9F83 std Y+7,r25
+ 2141 022e 8E83 std Y+6,r24
+ 2142 .L112:
+ 2143 0230 80E0 ldi r24,lo8(0)
+ 2144 0232 00C0 rjmp .L97
+ 2145 .LVL209:
+ 2146 .L103:
+ 2147 .LSM181:
+ 2148 0234 8DE0 ldi r24,lo8(13)
+ 2149 .LVL210:
+ 2150 .L97:
+ 2151 /* epilogue start */
+ 2152 .LSM182:
+ 2153 0236 DF91 pop r29
+ 2154 0238 CF91 pop r28
+ 2155 .LVL211:
+ 2156 023a 1F91 pop r17
+ 2157 023c 0F91 pop r16
+ 2158 .LVL212:
+ 2159 023e FF90 pop r15
+ 2160 0240 EF90 pop r14
+ 2161 .LVL213:
+ 2162 0242 DF90 pop r13
+ 2163 0244 CF90 pop r12
+ 2164 0246 BF90 pop r11
+ 2165 0248 AF90 pop r10
+ 2166 .LVL214:
+ 2167 024a 0895 ret
+ 2168 .LVL215:
+ 2169 .L109:
+ 2170 .LSM183:
+ 2171 024c C25B subi r28,lo8(-(78))
+ 2172 024e DF4F sbci r29,hi8(-(78))
+ 2173 0250 8881 ld r24,Y
+ 2174 0252 9981 ldd r25,Y+1
+ 2175 0254 AA81 ldd r26,Y+2
+ 2176 0256 BB81 ldd r27,Y+3
+ 2177 0258 CE54 subi r28,lo8(-(-78))
+ 2178 025a D040 sbci r29,hi8(-(-78))
+ 2179 025c 8E8B std Y+22,r24
+ 2180 025e 9F8B std Y+23,r25
+ 2181 0260 A88F std Y+24,r26
+ 2182 0262 B98F std Y+25,r27
+ 2183 0264 63E0 ldi r22,lo8(3)
+ 2184 .LVL216:
+ 2185 0266 00C0 rjmp .L110
+ 2186 .LFE67:
+ 2188 .data
+ 2189 .LC0:
+ 2190 0000 2022 2A2B .string " \"*+,[=]|\177"
+ 2190 2C5B 3D5D
+ 2190 7C7F 00
+ 2191 .section .text.f_open,"ax",@progbits
+ 2192 .global f_open
+ 2194 f_open:
+ 2195 .LFB70:
+ 2196 .LSM184:
+ 2197 .LVL217:
+ 2198 0000 3F92 push r3
+ 2199 0002 4F92 push r4
+ 2200 0004 5F92 push r5
+ 2201 0006 6F92 push r6
+ 2202 0008 7F92 push r7
+ 2203 000a 8F92 push r8
+ 2204 000c 9F92 push r9
+ 2205 000e AF92 push r10
+ 2206 0010 BF92 push r11
+ 2207 0012 CF92 push r12
+ 2208 0014 DF92 push r13
+ 2209 0016 EF92 push r14
+ 2210 0018 FF92 push r15
+ 2211 001a 0F93 push r16
+ 2212 001c 1F93 push r17
+ 2213 001e DF93 push r29
+ 2214 0020 CF93 push r28
+ 2215 0022 CDB7 in r28,__SP_L__
+ 2216 0024 DEB7 in r29,__SP_H__
+ 2217 0026 A497 sbiw r28,36
+ 2218 0028 0FB6 in __tmp_reg__,__SREG__
+ 2219 002a F894 cli
+ 2220 002c DEBF out __SP_H__,r29
+ 2221 002e 0FBE out __SREG__,__tmp_reg__
+ 2222 0030 CDBF out __SP_L__,r28
+ 2223 /* prologue: function */
+ 2224 /* frame size = 36 */
+ 2225 0032 4C01 movw r8,r24
+ 2226 0034 7CA3 std Y+36,r23
+ 2227 0036 6BA3 std Y+35,r22
+ 2228 0038 742E mov r7,r20
+ 2229 .LSM185:
+ 2230 003a DC01 movw r26,r24
+ 2231 003c 1D92 st X+,__zero_reg__
+ 2232 003e 1C92 st X,__zero_reg__
+ 2233 .LSM186:
+ 2234 0040 CE01 movw r24,r28
+ 2235 .LVL218:
+ 2236 0042 8396 adiw r24,35
+ 2237 0044 BE01 movw r22,r28
+ 2238 .LVL219:
+ 2239 0046 635F subi r22,lo8(-(13))
+ 2240 0048 7F4F sbci r23,hi8(-(13))
+ 2241 004a 40E0 ldi r20,lo8(0)
+ 2242 .LVL220:
+ 2243 004c 0E94 0000 call chk_mounted
+ 2244 .LSM187:
+ 2245 0050 8823 tst r24
+ 2246 .LVL221:
+ 2247 0052 01F0 breq .+2
+ 2248 0054 00C0 rjmp .L115
+ 2249 .LSM188:
+ 2250 0056 CE01 movw r24,r28
+ 2251 .LVL222:
+ 2252 0058 0196 adiw r24,1
+ 2253 005a 9AA3 std Y+34,r25
+ 2254 005c 89A3 std Y+33,r24
+ 2255 .LSM189:
+ 2256 005e CBA0 ldd r12,Y+35
+ 2257 0060 DCA0 ldd r13,Y+36
+ 2258 .LVL223:
+ 2259 0062 00C0 rjmp .L116
+ 2260 .L117:
+ 2261 .LBB20:
+ 2262 .LBB21:
+ 2263 .LSM190:
+ 2264 0064 0894 sec
+ 2265 0066 C11C adc r12,__zero_reg__
+ 2266 0068 D11C adc r13,__zero_reg__
+ 2267 .L116:
+ 2268 006a F601 movw r30,r12
+ 2269 006c 8081 ld r24,Z
+ 2270 006e 8032 cpi r24,lo8(32)
+ 2271 0070 01F0 breq .L117
+ 2272 .LSM191:
+ 2273 0072 8F32 cpi r24,lo8(47)
+ 2274 0074 01F0 breq .L118
+ 2275 0076 8C35 cpi r24,lo8(92)
+ 2276 0078 01F4 brne .L119
+ 2277 .L118:
+ 2278 .LSM192:
+ 2279 007a 0894 sec
+ 2280 007c C11C adc r12,__zero_reg__
+ 2281 007e D11C adc r13,__zero_reg__
+ 2282 .L119:
+ 2283 .LSM193:
+ 2284 0080 1B8A std Y+19,__zero_reg__
+ 2285 0082 1C8A std Y+20,__zero_reg__
+ 2286 0084 1D8A std Y+21,__zero_reg__
+ 2287 0086 1E8A std Y+22,__zero_reg__
+ 2288 .LSM194:
+ 2289 0088 D601 movw r26,r12
+ 2290 008a 8C91 ld r24,X
+ 2291 008c 8032 cpi r24,lo8(32)
+ 2292 008e 00F4 brsh .L120
+ 2293 .LBE21:
+ 2294 .LSM195:
+ 2295 0090 CE01 movw r24,r28
+ 2296 0092 0D96 adiw r24,13
+ 2297 0094 60E0 ldi r22,lo8(0)
+ 2298 0096 70E0 ldi r23,hi8(0)
+ 2299 0098 0E94 0000 call dir_seek
+ 2300 .LBE20:
+ 2301 .LSM196:
+ 2302 009c 8823 tst r24
+ 2303 .LVL224:
+ 2304 009e 01F4 brne .+2
+ 2305 00a0 00C0 rjmp .L160
+ 2306 00a2 00C0 rjmp .L115
+ 2307 .LVL225:
+ 2308 .L120:
+ 2309 .LBB45:
+ 2310 .LBB44:
+ 2311 .LBB22:
+ 2312 .LBB24:
+ 2313 .LBB28:
+ 2314 .LBB29:
+ 2315 .LSM197:
+ 2316 00a4 F0E2 ldi r31,lo8(32)
+ 2317 00a6 6F2E mov r6,r31
+ 2318 .LBE29:
+ 2319 .LBE28:
+ 2320 .LSM198:
+ 2321 00a8 E5E0 ldi r30,lo8(5)
+ 2322 00aa 3E2E mov r3,r30
+ 2323 .LBE24:
+ 2324 .LBE22:
+ 2325 .LBB32:
+ 2326 .LSM199:
+ 2327 00ac 7DE0 ldi r23,lo8(13)
+ 2328 00ae 472E mov r4,r23
+ 2329 00b0 512C mov r5,__zero_reg__
+ 2330 00b2 4C0E add r4,r28
+ 2331 00b4 5D1E adc r5,r29
+ 2332 .LVL226:
+ 2333 .L163:
+ 2334 .LBE32:
+ 2335 .LBB41:
+ 2336 .LBB23:
+ 2337 .LSM200:
+ 2338 00b6 A9A1 ldd r26,Y+33
+ 2339 00b8 BAA1 ldd r27,Y+34
+ 2340 .LVL227:
+ 2341 00ba FD01 movw r30,r26
+ 2342 .LVL228:
+ 2343 00bc 8BE0 ldi r24,lo8(11)
+ 2344 00be 90E0 ldi r25,hi8(11)
+ 2345 .LVL229:
+ 2346 00c0 00C0 rjmp .L122
+ 2347 .LVL230:
+ 2348 .L123:
+ 2349 .LBB27:
+ 2350 .LBB30:
+ 2351 .LSM201:
+ 2352 00c2 6192 st Z+,r6
+ 2353 .L122:
+ 2354 00c4 0197 sbiw r24,1
+ 2355 00c6 2FEF ldi r18,hi8(-1)
+ 2356 00c8 8F3F cpi r24,lo8(-1)
+ 2357 00ca 9207 cpc r25,r18
+ 2358 00cc 01F4 brne .L123
+ 2359 00ce 40E0 ldi r20,lo8(0)
+ 2360 00d0 50E0 ldi r21,hi8(0)
+ 2361 .LVL231:
+ 2362 00d2 AA24 clr r10
+ 2363 00d4 BB24 clr r11
+ 2364 00d6 68E0 ldi r22,lo8(8)
+ 2365 00d8 E62E mov r14,r22
+ 2366 00da F12C mov r15,__zero_reg__
+ 2367 00dc 10E0 ldi r17,lo8(0)
+ 2368 .LVL232:
+ 2369 .L161:
+ 2370 .LBE30:
+ 2371 .LBE27:
+ 2372 .LSM202:
+ 2373 00de F601 movw r30,r12
+ 2374 00e0 EA0D add r30,r10
+ 2375 00e2 FB1D adc r31,r11
+ 2376 00e4 2081 ld r18,Z
+ 2377 00e6 0894 sec
+ 2378 00e8 A11C adc r10,__zero_reg__
+ 2379 00ea B11C adc r11,__zero_reg__
+ 2380 .LSM203:
+ 2381 00ec 2132 cpi r18,lo8(33)
+ 2382 00ee 00F4 brsh .+2
+ 2383 00f0 00C0 rjmp .L124
+ 2384 00f2 2F32 cpi r18,lo8(47)
+ 2385 00f4 01F4 brne .+2
+ 2386 00f6 00C0 rjmp .L125
+ 2387 00f8 2C35 cpi r18,lo8(92)
+ 2388 00fa 01F4 brne .+2
+ 2389 00fc 00C0 rjmp .L125
+ 2390 .LSM204:
+ 2391 00fe 2E32 cpi r18,lo8(46)
+ 2392 0100 01F0 breq .L126
+ 2393 0102 4E15 cp r20,r14
+ 2394 0104 5F05 cpc r21,r15
+ 2395 0106 04F0 brlt .L127
+ 2396 .L126:
+ 2397 .LSM205:
+ 2398 0108 88E0 ldi r24,lo8(8)
+ 2399 010a E816 cp r14,r24
+ 2400 010c F104 cpc r15,__zero_reg__
+ 2401 .LVL233:
+ 2402 010e 01F0 breq .+2
+ 2403 0110 00C0 rjmp .L128
+ 2404 0112 2E32 cpi r18,lo8(46)
+ 2405 0114 01F0 breq .+2
+ 2406 0116 00C0 rjmp .L128
+ 2407 .LSM206:
+ 2408 0118 110F lsl r17
+ 2409 011a 110F lsl r17
+ 2410 011c 48E0 ldi r20,lo8(8)
+ 2411 011e 50E0 ldi r21,hi8(8)
+ 2412 0120 3BE0 ldi r19,lo8(11)
+ 2413 0122 E32E mov r14,r19
+ 2414 0124 F12C mov r15,__zero_reg__
+ 2415 .LVL234:
+ 2416 0126 00C0 rjmp .L161
+ 2417 .LVL235:
+ 2418 .L127:
+ 2419 .LSM207:
+ 2420 0128 27FD sbrc r18,7
+ 2421 .LSM208:
+ 2422 012a 1360 ori r17,lo8(3)
+ 2423 .L130:
+ 2424 .LSM209:
+ 2425 012c 822F mov r24,r18
+ 2426 .LVL236:
+ 2427 012e 8158 subi r24,lo8(-(127))
+ 2428 0130 8F31 cpi r24,lo8(31)
+ 2429 0132 00F0 brlo .L131
+ 2430 0134 8F55 subi r24,lo8(-(-95))
+ 2431 0136 8D31 cpi r24,lo8(29)
+ 2432 0138 00F4 brsh .L132
+ 2433 .L131:
+ 2434 .LSM210:
+ 2435 013a F601 movw r30,r12
+ 2436 013c EA0D add r30,r10
+ 2437 013e FB1D adc r31,r11
+ 2438 0140 3081 ld r19,Z
+ 2439 .LSM211:
+ 2440 0142 832F mov r24,r19
+ 2441 0144 8054 subi r24,lo8(-(-64))
+ 2442 0146 8F33 cpi r24,lo8(63)
+ 2443 0148 00F0 brlo .L133
+ 2444 014a 8054 subi r24,lo8(-(-64))
+ 2445 014c 8D37 cpi r24,lo8(125)
+ 2446 014e 00F0 brlo .+2
+ 2447 0150 00C0 rjmp .L128
+ 2448 .L133:
+ 2449 0152 C701 movw r24,r14
+ 2450 0154 0197 sbiw r24,1
+ 2451 0156 4817 cp r20,r24
+ 2452 0158 5907 cpc r21,r25
+ 2453 015a 04F0 brlt .+2
+ 2454 015c 00C0 rjmp .L128
+ 2455 .LSM212:
+ 2456 015e 0894 sec
+ 2457 0160 A11C adc r10,__zero_reg__
+ 2458 0162 B11C adc r11,__zero_reg__
+ 2459 .LSM213:
+ 2460 0164 FD01 movw r30,r26
+ 2461 0166 E40F add r30,r20
+ 2462 0168 F51F adc r31,r21
+ 2463 016a 2083 st Z,r18
+ 2464 016c CA01 movw r24,r20
+ 2465 016e 0196 adiw r24,1
+ 2466 .LVL237:
+ 2467 .LSM214:
+ 2468 0170 FD01 movw r30,r26
+ 2469 0172 E80F add r30,r24
+ 2470 0174 F91F adc r31,r25
+ 2471 0176 3083 st Z,r19
+ 2472 0178 AC01 movw r20,r24
+ 2473 017a 00C0 rjmp .L164
+ 2474 .LVL238:
+ 2475 .L132:
+ 2476 .LSM215:
+ 2477 017c 622F mov r22,r18
+ 2478 017e 70E0 ldi r23,lo8(0)
+ 2479 0180 E0E0 ldi r30,lo8(.LC0)
+ 2480 0182 F0E0 ldi r31,hi8(.LC0)
+ 2481 .LVL239:
+ 2482 0184 00C0 rjmp .L134
+ 2483 .LVL240:
+ 2484 .L136:
+ 2485 .LBB25:
+ 2486 .LBB26:
+ 2487 .LSM216:
+ 2488 0186 3196 adiw r30,1
+ 2489 .LVL241:
+ 2490 .L134:
+ 2491 0188 8081 ld r24,Z
+ 2492 018a 8823 tst r24
+ 2493 018c 01F0 breq .L135
+ 2494 018e 90E0 ldi r25,lo8(0)
+ 2495 .LVL242:
+ 2496 0190 8617 cp r24,r22
+ 2497 0192 9707 cpc r25,r23
+ 2498 0194 01F4 brne .L136
+ 2499 0196 00C0 rjmp .L128
+ 2500 .LVL243:
+ 2501 .L135:
+ 2502 .LBE26:
+ 2503 .LBE25:
+ 2504 .LSM217:
+ 2505 0198 822F mov r24,r18
+ 2506 019a 8154 subi r24,lo8(-(-65))
+ 2507 019c 8A31 cpi r24,lo8(26)
+ 2508 019e 00F4 brsh .L137
+ 2509 .LSM218:
+ 2510 01a0 1260 ori r17,lo8(2)
+ 2511 01a2 00C0 rjmp .L138
+ 2512 .L137:
+ 2513 .LSM219:
+ 2514 01a4 822F mov r24,r18
+ 2515 01a6 8156 subi r24,lo8(-(-97))
+ 2516 01a8 8A31 cpi r24,lo8(26)
+ 2517 01aa 00F4 brsh .L138
+ 2518 .LSM220:
+ 2519 01ac 1160 ori r17,lo8(1)
+ 2520 01ae 2052 subi r18,lo8(-(-32))
+ 2521 .L138:
+ 2522 .LSM221:
+ 2523 01b0 FD01 movw r30,r26
+ 2524 .LVL244:
+ 2525 01b2 E40F add r30,r20
+ 2526 01b4 F51F adc r31,r21
+ 2527 01b6 2083 st Z,r18
+ 2528 .LVL245:
+ 2529 .L164:
+ 2530 01b8 4F5F subi r20,lo8(-(1))
+ 2531 01ba 5F4F sbci r21,hi8(-(1))
+ 2532 01bc 00C0 rjmp .L161
+ 2533 .LVL246:
+ 2534 .L124:
+ 2535 01be 912F mov r25,r17
+ 2536 .LVL247:
+ 2537 01c0 64E0 ldi r22,lo8(4)
+ 2538 .LVL248:
+ 2539 .L158:
+ 2540 .LSM222:
+ 2541 01c2 452B or r20,r21
+ 2542 01c4 01F4 brne .+2
+ 2543 01c6 00C0 rjmp .L128
+ 2544 .LSM223:
+ 2545 01c8 8C91 ld r24,X
+ 2546 .LVL249:
+ 2547 01ca 853E cpi r24,lo8(-27)
+ 2548 01cc 01F4 brne .L139
+ 2549 01ce 3C92 st X,r3
+ 2550 .L139:
+ 2551 .LSM224:
+ 2552 01d0 E8E0 ldi r30,lo8(8)
+ 2553 01d2 EE16 cp r14,r30
+ 2554 01d4 F104 cpc r15,__zero_reg__
+ 2555 01d6 01F4 brne .L140
+ 2556 01d8 912F mov r25,r17
+ 2557 01da 990F lsl r25
+ 2558 01dc 990F lsl r25
+ 2559 .LVL250:
+ 2560 .L140:
+ 2561 .LSM225:
+ 2562 01de 292F mov r18,r25
+ 2563 01e0 30E0 ldi r19,lo8(0)
+ 2564 .LVL251:
+ 2565 01e2 C901 movw r24,r18
+ 2566 01e4 8370 andi r24,lo8(3)
+ 2567 01e6 9070 andi r25,hi8(3)
+ 2568 01e8 0197 sbiw r24,1
+ 2569 01ea 01F4 brne .L141
+ 2570 01ec 6061 ori r22,lo8(16)
+ 2571 .L141:
+ 2572 .LSM226:
+ 2573 01ee 2C70 andi r18,lo8(12)
+ 2574 01f0 3070 andi r19,hi8(12)
+ 2575 01f2 2430 cpi r18,4
+ 2576 01f4 3105 cpc r19,__zero_reg__
+ 2577 01f6 01F4 brne .L142
+ 2578 01f8 6860 ori r22,lo8(8)
+ 2579 .L142:
+ 2580 .LSM227:
+ 2581 01fa 1B96 adiw r26,11
+ 2582 01fc 6C93 st X,r22
+ 2583 .LBE23:
+ 2584 .LBE41:
+ 2585 .LBB42:
+ 2586 .LSM228:
+ 2587 01fe C201 movw r24,r4
+ 2588 0200 60E0 ldi r22,lo8(0)
+ 2589 0202 70E0 ldi r23,hi8(0)
+ 2590 .LVL252:
+ 2591 0204 0E94 0000 call dir_seek
+ 2592 .LVL253:
+ 2593 0208 482F mov r20,r24
+ 2594 .LVL254:
+ 2595 .LBB33:
+ 2596 .LSM229:
+ 2597 020a 8823 tst r24
+ 2598 020c 01F0 breq .+2
+ 2599 020e 00C0 rjmp .L143
+ 2600 .LVL255:
+ 2601 .L162:
+ 2602 .LBE33:
+ 2603 .LSM230:
+ 2604 0210 4B8D ldd r20,Y+27
+ 2605 0212 5C8D ldd r21,Y+28
+ 2606 0214 6D8D ldd r22,Y+29
+ 2607 0216 7E8D ldd r23,Y+30
+ 2608 .LVL256:
+ 2609 0218 8D85 ldd r24,Y+13
+ 2610 021a 9E85 ldd r25,Y+14
+ 2611 .LVL257:
+ 2612 021c 0E94 0000 call move_window
+ 2613 .LVL258:
+ 2614 0220 482F mov r20,r24
+ 2615 .LVL259:
+ 2616 .LBB40:
+ 2617 .LSM231:
+ 2618 0222 8823 tst r24
+ 2619 0224 01F0 breq .+2
+ 2620 0226 00C0 rjmp .L143
+ 2621 .LVL260:
+ 2622 .LSM232:
+ 2623 0228 EF8D ldd r30,Y+31
+ 2624 022a F8A1 ldd r31,Y+32
+ 2625 .LVL261:
+ 2626 .LSM233:
+ 2627 022c 8081 ld r24,Z
+ 2628 .LVL262:
+ 2629 022e 8823 tst r24
+ 2630 0230 01F4 brne .+2
+ 2631 0232 00C0 rjmp .L147
+ 2632 .L144:
+ 2633 .LSM234:
+ 2634 0234 8385 ldd r24,Z+11
+ 2635 0236 83FD sbrc r24,3
+ 2636 0238 00C0 rjmp .L145
+ 2637 023a 89A1 ldd r24,Y+33
+ 2638 .LVL263:
+ 2639 023c 9AA1 ldd r25,Y+34
+ 2640 .LVL264:
+ 2641 023e 9C01 movw r18,r24
+ 2642 .LVL265:
+ 2643 0240 D901 movw r26,r18
+ 2644 .LVL266:
+ 2645 0242 2BE0 ldi r18,lo8(11)
+ 2646 0244 30E0 ldi r19,hi8(11)
+ 2647 .LVL267:
+ 2648 .L146:
+ 2649 .LBB34:
+ 2650 .LBB35:
+ 2651 .LSM235:
+ 2652 0246 2150 subi r18,lo8(-(-1))
+ 2653 0248 3040 sbci r19,hi8(-(-1))
+ 2654 024a 8FEF ldi r24,hi8(-1)
+ 2655 024c 2F3F cpi r18,lo8(-1)
+ 2656 024e 3807 cpc r19,r24
+ 2657 0250 01F4 brne .+2
+ 2658 0252 00C0 rjmp .L143
+ 2659 0254 9081 ld r25,Z
+ 2660 .LVL268:
+ 2661 0256 8C91 ld r24,X
+ 2662 0258 9817 cp r25,r24
+ 2663 025a 01F4 brne .L145
+ 2664 025c 3196 adiw r30,1
+ 2665 .LVL269:
+ 2666 025e 1196 adiw r26,1
+ 2667 0260 00C0 rjmp .L146
+ 2668 .LVL270:
+ 2669 .L145:
+ 2670 .LBE35:
+ 2671 .LBE34:
+ 2672 .LBB36:
+ 2673 .LBB37:
+ 2674 .LSM236:
+ 2675 0262 0989 ldd r16,Y+17
+ 2676 0264 1A89 ldd r17,Y+18
+ 2677 0266 0F5F subi r16,lo8(-(1))
+ 2678 0268 1F4F sbci r17,hi8(-(1))
+ 2679 .LSM237:
+ 2680 026a 01F4 brne .+2
+ 2681 026c 00C0 rjmp .L147
+ 2682 026e 8B8D ldd r24,Y+27
+ 2683 0270 9C8D ldd r25,Y+28
+ 2684 0272 AD8D ldd r26,Y+29
+ 2685 0274 BE8D ldd r27,Y+30
+ 2686 0276 0097 sbiw r24,0
+ 2687 0278 A105 cpc r26,__zero_reg__
+ 2688 027a B105 cpc r27,__zero_reg__
+ 2689 027c 01F4 brne .+2
+ 2690 027e 00C0 rjmp .L147
+ 2691 .LSM238:
+ 2692 0280 2FE0 ldi r18,lo8(15)
+ 2693 0282 E22E mov r14,r18
+ 2694 0284 F12C mov r15,__zero_reg__
+ 2695 .LVL271:
+ 2696 0286 E022 and r14,r16
+ 2697 0288 F122 and r15,r17
+ 2698 028a E114 cp r14,__zero_reg__
+ 2699 028c F104 cpc r15,__zero_reg__
+ 2700 028e 01F0 breq .+2
+ 2701 0290 00C0 rjmp .L148
+ 2702 .LSM239:
+ 2703 0292 0196 adiw r24,1
+ 2704 0294 A11D adc r26,__zero_reg__
+ 2705 0296 B11D adc r27,__zero_reg__
+ 2706 0298 8B8F std Y+27,r24
+ 2707 029a 9C8F std Y+28,r25
+ 2708 029c AD8F std Y+29,r26
+ 2709 029e BE8F std Y+30,r27
+ 2710 .LSM240:
+ 2711 02a0 4F89 ldd r20,Y+23
+ 2712 02a2 588D ldd r21,Y+24
+ 2713 02a4 698D ldd r22,Y+25
+ 2714 02a6 7A8D ldd r23,Y+26
+ 2715 .LVL272:
+ 2716 02a8 ED85 ldd r30,Y+13
+ 2717 02aa FE85 ldd r31,Y+14
+ 2718 .LVL273:
+ 2719 02ac 4115 cp r20,__zero_reg__
+ 2720 02ae 5105 cpc r21,__zero_reg__
+ 2721 02b0 6105 cpc r22,__zero_reg__
+ 2722 02b2 7105 cpc r23,__zero_reg__
+ 2723 02b4 01F4 brne .L149
+ 2724 .LSM241:
+ 2725 02b6 8085 ldd r24,Z+8
+ 2726 02b8 9185 ldd r25,Z+9
+ 2727 02ba 0817 cp r16,r24
+ 2728 02bc 1907 cpc r17,r25
+ 2729 02be 00F0 brlo .L148
+ 2730 02c0 00C0 rjmp .L147
+ 2731 .L149:
+ 2732 .LSM242:
+ 2733 02c2 8281 ldd r24,Z+2
+ 2734 02c4 90E0 ldi r25,lo8(0)
+ 2735 02c6 0197 sbiw r24,1
+ 2736 02c8 9801 movw r18,r16
+ 2737 02ca A4E0 ldi r26,4
+ 2738 02cc 3695 1: lsr r19
+ 2739 02ce 2795 ror r18
+ 2740 02d0 AA95 dec r26
+ 2741 02d2 01F4 brne 1b
+ 2742 .LVL274:
+ 2743 02d4 8223 and r24,r18
+ 2744 02d6 9323 and r25,r19
+ 2745 02d8 892B or r24,r25
+ 2746 02da 01F4 brne .L148
+ 2747 .LBE37:
+ 2748 .LSM243:
+ 2749 02dc CF01 movw r24,r30
+ 2750 02de 0E94 0000 call get_fat
+ 2751 02e2 AB01 movw r20,r22
+ 2752 02e4 BC01 movw r22,r24
+ 2753 .LVL275:
+ 2754 .LBB38:
+ 2755 .LSM244:
+ 2756 02e6 4230 cpi r20,lo8(2)
+ 2757 02e8 5105 cpc r21,__zero_reg__
+ 2758 02ea 6105 cpc r22,__zero_reg__
+ 2759 02ec 7105 cpc r23,__zero_reg__
+ 2760 02ee 00F4 brsh .L150
+ 2761 02f0 42E0 ldi r20,lo8(2)
+ 2762 .LVL276:
+ 2763 02f2 00C0 rjmp .L143
+ 2764 .LVL277:
+ 2765 .L150:
+ 2766 .LSM245:
+ 2767 02f4 4F3F cpi r20,lo8(-1)
+ 2768 02f6 9FEF ldi r25,hi8(-1)
+ 2769 02f8 5907 cpc r21,r25
+ 2770 02fa 9FEF ldi r25,hlo8(-1)
+ 2771 02fc 6907 cpc r22,r25
+ 2772 02fe 9FEF ldi r25,hhi8(-1)
+ 2773 0300 7907 cpc r23,r25
+ 2774 0302 01F4 brne .L151
+ 2775 0304 41E0 ldi r20,lo8(1)
+ 2776 .LVL278:
+ 2777 0306 00C0 rjmp .L143
+ 2778 .LVL279:
+ 2779 .L151:
+ 2780 .LSM246:
+ 2781 0308 ED85 ldd r30,Y+13
+ 2782 030a FE85 ldd r31,Y+14
+ 2783 030c 8685 ldd r24,Z+14
+ 2784 030e 9785 ldd r25,Z+15
+ 2785 0310 A089 ldd r26,Z+16
+ 2786 0312 B189 ldd r27,Z+17
+ 2787 0314 4817 cp r20,r24
+ 2788 0316 5907 cpc r21,r25
+ 2789 0318 6A07 cpc r22,r26
+ 2790 031a 7B07 cpc r23,r27
+ 2791 031c 00F4 brsh .L147
+ 2792 .LSM247:
+ 2793 031e 4F8B std Y+23,r20
+ 2794 0320 588F std Y+24,r21
+ 2795 0322 698F std Y+25,r22
+ 2796 0324 7A8F std Y+26,r23
+ 2797 .LBE38:
+ 2798 .LSM248:
+ 2799 0326 CF01 movw r24,r30
+ 2800 0328 0E94 0000 call clust2sect
+ 2801 .LVL280:
+ 2802 .LBB39:
+ 2803 032c 6B8F std Y+27,r22
+ 2804 032e 7C8F std Y+28,r23
+ 2805 0330 8D8F std Y+29,r24
+ 2806 0332 9E8F std Y+30,r25
+ 2807 .LVL281:
+ 2808 .L148:
+ 2809 .LSM249:
+ 2810 0334 1A8B std Y+18,r17
+ 2811 0336 098B std Y+17,r16
+ 2812 .LSM250:
+ 2813 0338 75E0 ldi r23,5
+ 2814 033a EE0C 1: lsl r14
+ 2815 033c FF1C rol r15
+ 2816 033e 7A95 dec r23
+ 2817 0340 01F4 brne 1b
+ 2818 0342 A2E2 ldi r26,lo8(34)
+ 2819 0344 B0E0 ldi r27,hi8(34)
+ 2820 .LVL282:
+ 2821 0346 EA0E add r14,r26
+ 2822 0348 FB1E adc r15,r27
+ 2823 034a 8D85 ldd r24,Y+13
+ 2824 034c 9E85 ldd r25,Y+14
+ 2825 034e 8E0D add r24,r14
+ 2826 0350 9F1D adc r25,r15
+ 2827 0352 98A3 std Y+32,r25
+ 2828 0354 8F8F std Y+31,r24
+ 2829 0356 00C0 rjmp .L162
+ 2830 .LVL283:
+ 2831 .L147:
+ 2832 0358 44E0 ldi r20,lo8(4)
+ 2833 .LVL284:
+ 2834 .L143:
+ 2835 .LBE39:
+ 2836 .LBE36:
+ 2837 .LBE40:
+ 2838 .LBE42:
+ 2839 .LSM251:
+ 2840 035a E9A1 ldd r30,Y+33
+ 2841 035c FAA1 ldd r31,Y+34
+ 2842 .LVL285:
+ 2843 035e 9385 ldd r25,Z+11
+ 2844 .LVL286:
+ 2845 0360 9470 andi r25,lo8(4)
+ 2846 .LSM252:
+ 2847 0362 4423 tst r20
+ 2848 0364 01F0 breq .L153
+ 2849 0366 842F mov r24,r20
+ 2850 .LSM253:
+ 2851 0368 4430 cpi r20,lo8(4)
+ 2852 036a 01F0 breq .+2
+ 2853 036c 00C0 rjmp .L115
+ 2854 036e 9923 tst r25
+ 2855 0370 01F4 brne .+2
+ 2856 0372 00C0 rjmp .L155
+ 2857 0374 00C0 rjmp .L115
+ 2858 .L153:
+ 2859 .LSM254:
+ 2860 0376 9923 tst r25
+ 2861 0378 01F4 brne .L156
+ 2862 .LSM255:
+ 2863 037a EF8D ldd r30,Y+31
+ 2864 037c F8A1 ldd r31,Y+32
+ 2865 .LVL287:
+ 2866 .LSM256:
+ 2867 037e 8385 ldd r24,Z+11
+ 2868 0380 84FF sbrs r24,4
+ 2869 0382 00C0 rjmp .L155
+ 2870 .LBB43:
+ 2871 .LBB31:
+ 2872 .LSM257:
+ 2873 0384 CA0C add r12,r10
+ 2874 0386 DB1C adc r13,r11
+ 2875 .LBE31:
+ 2876 .LBE43:
+ 2877 .LSM258:
+ 2878 0388 8489 ldd r24,Z+20
+ 2879 038a 9589 ldd r25,Z+21
+ 2880 038c A0E0 ldi r26,lo8(0)
+ 2881 038e B0E0 ldi r27,hi8(0)
+ 2882 .LVL288:
+ 2883 0390 DC01 movw r26,r24
+ 2884 0392 9927 clr r25
+ 2885 0394 8827 clr r24
+ 2886 0396 228D ldd r18,Z+26
+ 2887 0398 338D ldd r19,Z+27
+ 2888 .LVL289:
+ 2889 039a 40E0 ldi r20,lo8(0)
+ 2890 039c 50E0 ldi r21,hi8(0)
+ 2891 .LVL290:
+ 2892 039e 822B or r24,r18
+ 2893 03a0 932B or r25,r19
+ 2894 03a2 A42B or r26,r20
+ 2895 03a4 B52B or r27,r21
+ 2896 03a6 8B8B std Y+19,r24
+ 2897 03a8 9C8B std Y+20,r25
+ 2898 03aa AD8B std Y+21,r26
+ 2899 03ac BE8B std Y+22,r27
+ 2900 03ae 00C0 rjmp .L163
+ 2901 .LVL291:
+ 2902 .L160:
+ 2903 .LSM259:
+ 2904 03b0 18A2 std Y+32,__zero_reg__
+ 2905 03b2 1F8E std Y+31,__zero_reg__
+ 2906 .LVL292:
+ 2907 .L156:
+ 2908 .LBE44:
+ 2909 .LBE45:
+ 2910 .LSM260:
+ 2911 03b4 EF8D ldd r30,Y+31
+ 2912 03b6 F8A1 ldd r31,Y+32
+ 2913 .LVL293:
+ 2914 .LSM261:
+ 2915 03b8 3097 sbiw r30,0
+ 2916 03ba 01F4 brne .+2
+ 2917 03bc 00C0 rjmp .L157
+ 2918 03be 8385 ldd r24,Z+11
+ 2919 .LVL294:
+ 2920 03c0 84FD sbrc r24,4
+ 2921 03c2 00C0 rjmp .L157
+ 2922 .LSM262:
+ 2923 03c4 B1E0 ldi r27,lo8(1)
+ 2924 03c6 7B22 and r7,r27
+ 2925 03c8 D401 movw r26,r8
+ 2926 .LVL295:
+ 2927 03ca 1496 adiw r26,4
+ 2928 03cc 7C92 st X,r7
+ 2929 .LSM263:
+ 2930 03ce 8489 ldd r24,Z+20
+ 2931 03d0 9589 ldd r25,Z+21
+ 2932 03d2 A0E0 ldi r26,lo8(0)
+ 2933 03d4 B0E0 ldi r27,hi8(0)
+ 2934 03d6 8C01 movw r16,r24
+ 2935 03d8 FF24 clr r15
+ 2936 03da EE24 clr r14
+ 2937 .LVL296:
+ 2938 03dc 228D ldd r18,Z+26
+ 2939 03de 338D ldd r19,Z+27
+ 2940 .LVL297:
+ 2941 03e0 40E0 ldi r20,lo8(0)
+ 2942 03e2 50E0 ldi r21,hi8(0)
+ 2943 .LVL298:
+ 2944 03e4 E22A or r14,r18
+ 2945 03e6 F32A or r15,r19
+ 2946 03e8 042B or r16,r20
+ 2947 03ea 152B or r17,r21
+ 2948 03ec D401 movw r26,r8
+ 2949 03ee 1E96 adiw r26,14
+ 2950 03f0 ED92 st X+,r14
+ 2951 03f2 FD92 st X+,r15
+ 2952 03f4 0D93 st X+,r16
+ 2953 03f6 1C93 st X,r17
+ 2954 03f8 5197 sbiw r26,14+3
+ 2955 .LSM264:
+ 2956 03fa 848D ldd r24,Z+28
+ 2957 03fc 958D ldd r25,Z+29
+ 2958 03fe A68D ldd r26,Z+30
+ 2959 0400 B78D ldd r27,Z+31
+ 2960 0402 F401 movw r30,r8
+ 2961 .LVL299:
+ 2962 0404 8287 std Z+10,r24
+ 2963 0406 9387 std Z+11,r25
+ 2964 0408 A487 std Z+12,r26
+ 2965 040a B587 std Z+13,r27
+ 2966 .LSM265:
+ 2967 040c D401 movw r26,r8
+ 2968 040e 1696 adiw r26,6
+ 2969 0410 1D92 st X+,__zero_reg__
+ 2970 0412 1D92 st X+,__zero_reg__
+ 2971 0414 1D92 st X+,__zero_reg__
+ 2972 0416 1C92 st X,__zero_reg__
+ 2973 0418 1997 sbiw r26,6+3
+ 2974 041a 8FEF ldi r24,lo8(-1)
+ 2975 041c 1596 adiw r26,5
+ 2976 041e 8C93 st X,r24
+ 2977 0420 1597 sbiw r26,5
+ 2978 .LSM266:
+ 2979 0422 168A std Z+22,__zero_reg__
+ 2980 0424 178A std Z+23,__zero_reg__
+ 2981 0426 108E std Z+24,__zero_reg__
+ 2982 0428 118E std Z+25,__zero_reg__
+ 2983 .LSM267:
+ 2984 042a ED85 ldd r30,Y+13
+ 2985 042c FE85 ldd r31,Y+14
+ 2986 042e 1196 adiw r26,1
+ 2987 0430 FC93 st X,r31
+ 2988 0432 EE93 st -X,r30
+ 2989 0434 8681 ldd r24,Z+6
+ 2990 0436 9781 ldd r25,Z+7
+ 2991 0438 1396 adiw r26,2+1
+ 2992 043a 9C93 st X,r25
+ 2993 043c 8E93 st -X,r24
+ 2994 043e 1297 sbiw r26,2
+ 2995 0440 80E0 ldi r24,lo8(0)
+ 2996 .LVL300:
+ 2997 0442 00C0 rjmp .L115
+ 2998 .LVL301:
+ 2999 .L157:
+ 3000 .LSM268:
+ 3001 0444 84E0 ldi r24,lo8(4)
+ 3002 .LVL302:
+ 3003 .L115:
+ 3004 .LVL303:
+ 3005 /* epilogue start */
+ 3006 .LSM269:
+ 3007 0446 A496 adiw r28,36
+ 3008 0448 0FB6 in __tmp_reg__,__SREG__
+ 3009 044a F894 cli
+ 3010 044c DEBF out __SP_H__,r29
+ 3011 044e 0FBE out __SREG__,__tmp_reg__
+ 3012 0450 CDBF out __SP_L__,r28
+ 3013 0452 CF91 pop r28
+ 3014 0454 DF91 pop r29
+ 3015 0456 1F91 pop r17
+ 3016 .LVL304:
+ 3017 0458 0F91 pop r16
+ 3018 .LVL305:
+ 3019 045a FF90 pop r15
+ 3020 045c EF90 pop r14
+ 3021 .LVL306:
+ 3022 045e DF90 pop r13
+ 3023 0460 CF90 pop r12
+ 3024 .LVL307:
+ 3025 0462 BF90 pop r11
+ 3026 0464 AF90 pop r10
+ 3027 .LVL308:
+ 3028 0466 9F90 pop r9
+ 3029 0468 8F90 pop r8
+ 3030 .LVL309:
+ 3031 046a 7F90 pop r7
+ 3032 .LVL310:
+ 3033 046c 6F90 pop r6
+ 3034 046e 5F90 pop r5
+ 3035 0470 4F90 pop r4
+ 3036 0472 3F90 pop r3
+ 3037 0474 0895 ret
+ 3038 .LVL311:
+ 3039 .L155:
+ 3040 .LSM270:
+ 3041 0476 85E0 ldi r24,lo8(5)
+ 3042 .LVL312:
+ 3043 0478 00C0 rjmp .L115
+ 3044 .LVL313:
+ 3045 .L128:
+ 3046 047a 86E0 ldi r24,lo8(6)
+ 3047 .LVL314:
+ 3048 047c 00C0 rjmp .L115
+ 3049 .LVL315:
+ 3050 .L125:
+ 3051 047e 912F mov r25,r17
+ 3052 .LVL316:
+ 3053 0480 60E0 ldi r22,lo8(0)
+ 3054 .LVL317:
+ 3055 0482 00C0 rjmp .L158
+ 3056 .LFE70:
+ 3058 .lcomm FatFs,2
+ 3059 .lcomm Fsid,2
+ 3172 .Letext0:
+DEFINED SYMBOLS
+ *ABS*:00000000 ff.c
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:2 *ABS*:0000003f __SREG__
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:3 *ABS*:0000003e __SP_H__
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:4 *ABS*:0000003d __SP_L__
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:5 *ABS*:00000034 __CCP__
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:6 *ABS*:00000000 __tmp_reg__
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:7 *ABS*:00000001 __zero_reg__
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:19 .text.clust2sect:00000000 clust2sect
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:101 .text.f_mount:00000000 f_mount
+ .bss:00000000 FatFs
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:144 .text.validate:00000000 validate
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:184 .text.f_close:00000000 f_close
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:218 .text.move_window:00000000 move_window
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:292 .text.get_fat:00000000 get_fat
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:545 .text.f_lseek:00000000 f_lseek
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:1021 .text.dir_seek:00000000 dir_seek
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:1270 .text.f_read:00000000 f_read
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:1694 .text.check_fs:00000000 check_fs
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:1779 .text.chk_mounted:00000000 chk_mounted
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:3058 .bss:00000002 Fsid
+C:\Users\Dean\AppData\Local\Temp/cchqutwM.s:2194 .text.f_open:00000000 f_open
+
+UNDEFINED SYMBOLS
+__mulsi3
+disk_status
+disk_read
+__udivmodsi4
+disk_initialize
+__do_copy_data
+__do_clear_bss
diff --git a/Projects/Webserver/Lib/FATFs/ffconf.h b/Projects/Webserver/Lib/FATFs/ffconf.h new file mode 100644 index 000000000..4b19f1326 --- /dev/null +++ b/Projects/Webserver/Lib/FATFs/ffconf.h @@ -0,0 +1,166 @@ +/*---------------------------------------------------------------------------/
+/ FatFs - FAT file system module configuration file R0.07e (C)ChaN, 2010
+/----------------------------------------------------------------------------/
+/
+/ CAUTION! Do not forget to make clean the project after any changes to
+/ the configuration options.
+/
+/----------------------------------------------------------------------------*/
+#ifndef _FFCONFIG
+#define _FFCONFIG 0x007E
+
+
+/*---------------------------------------------------------------------------/
+/ Function and Buffer Configurations
+/----------------------------------------------------------------------------*/
+
+#define _FS_TINY 1 /* 0 or 1 */
+/* When _FS_TINY is set to 1, FatFs uses the sector buffer in the file system
+/ object instead of the sector buffer in the individual file object for file
+/ data transfer. This reduces memory consumption 512 bytes each file object. */
+
+
+#define _FS_READONLY 1 /* 0 or 1 */
+/* Setting _FS_READONLY to 1 defines read only configuration. This removes
+/ writing functions, f_write, f_sync, f_unlink, f_mkdir, f_chmod, f_rename,
+/ f_truncate and useless f_getfree. */
+
+
+#define _FS_MINIMIZE 2 /* 0, 1, 2 or 3 */
+/* The _FS_MINIMIZE option defines minimization level to remove some functions.
+/
+/ 0: Full function.
+/ 1: f_stat, f_getfree, f_unlink, f_mkdir, f_chmod, f_truncate and f_rename
+/ are removed.
+/ 2: f_opendir and f_readdir are removed in addition to level 1.
+/ 3: f_lseek is removed in addition to level 2. */
+
+
+#define _USE_STRFUNC 0 /* 0, 1 or 2 */
+/* To enable string functions, set _USE_STRFUNC to 1 or 2. */
+
+
+#define _USE_MKFS 0 /* 0 or 1 */
+/* To enable f_mkfs function, set _USE_MKFS to 1 and set _FS_READONLY to 0 */
+
+
+#define _USE_FORWARD 0 /* 0 or 1 */
+/* To enable f_forward function, set _USE_FORWARD to 1 and set _FS_TINY to 1. */
+
+
+
+/*---------------------------------------------------------------------------/
+/ Locale and Namespace Configurations
+/----------------------------------------------------------------------------*/
+
+#define _CODE_PAGE 932
+/* The _CODE_PAGE specifies the OEM code page to be used on the target system.
+/ Incorrect setting of the code page can cause a file open failure.
+/
+/ 932 - Japanese Shift-JIS (DBCS, OEM, Windows)
+/ 936 - Simplified Chinese GBK (DBCS, OEM, Windows)
+/ 949 - Korean (DBCS, OEM, Windows)
+/ 950 - Traditional Chinese Big5 (DBCS, OEM, Windows)
+/ 1250 - Central Europe (Windows)
+/ 1251 - Cyrillic (Windows)
+/ 1252 - Latin 1 (Windows)
+/ 1253 - Greek (Windows)
+/ 1254 - Turkish (Windows)
+/ 1255 - Hebrew (Windows)
+/ 1256 - Arabic (Windows)
+/ 1257 - Baltic (Windows)
+/ 1258 - Vietnam (OEM, Windows)
+/ 437 - U.S. (OEM)
+/ 720 - Arabic (OEM)
+/ 737 - Greek (OEM)
+/ 775 - Baltic (OEM)
+/ 850 - Multilingual Latin 1 (OEM)
+/ 858 - Multilingual Latin 1 + Euro (OEM)
+/ 852 - Latin 2 (OEM)
+/ 855 - Cyrillic (OEM)
+/ 866 - Russian (OEM)
+/ 857 - Turkish (OEM)
+/ 862 - Hebrew (OEM)
+/ 874 - Thai (OEM, Windows)
+/ 1 - ASCII only (Valid for non LFN cfg.)
+*/
+
+
+#define _USE_LFN 0 /* 0, 1 or 2 */
+#define _MAX_LFN 255 /* Maximum LFN length to handle (12 to 255) */
+/* The _USE_LFN option switches the LFN support.
+/
+/ 0: Disable LFN. _MAX_LFN and _LFN_UNICODE have no effect.
+/ 1: Enable LFN with static working buffer on the bss. NOT REENTRANT.
+/ 2: Enable LFN with dynamic working buffer on the STACK.
+/
+/ The LFN working buffer occupies (_MAX_LFN + 1) * 2 bytes. When enable LFN,
+/ two Unicode handling functions ff_convert() and ff_wtoupper() must be added
+/ to the project. */
+
+
+#define _LFN_UNICODE 0 /* 0 or 1 */
+/* To switch the character code set on FatFs API to Unicode,
+/ enable LFN feature and set _LFN_UNICODE to 1.
+*/
+
+
+#define _FS_RPATH 0 /* 0 or 1 */
+/* When _FS_RPATH is set to 1, relative path feature is enabled and f_chdir,
+/ f_chdrive function are available.
+/ Note that output of the f_readdir fnction is affected by this option. */
+
+
+
+/*---------------------------------------------------------------------------/
+/ Physical Drive Configurations
+/----------------------------------------------------------------------------*/
+
+#define _DRIVES 1
+/* Number of volumes (logical drives) to be used. */
+
+
+#define _MAX_SS 512 /* 512, 1024, 2048 or 4096 */
+/* Maximum sector size to be handled.
+/ Always set 512 for memory card and hard disk but a larger value may be
+/ required for floppy disk (512/1024) and optical disk (512/2048).
+/ When _MAX_SS is larger than 512, GET_SECTOR_SIZE command must be implememted
+/ to the disk_ioctl function. */
+
+
+#define _MULTI_PARTITION 0 /* 0 or 1 */
+/* When _MULTI_PARTITION is set to 0, each volume is bound to the same physical
+/ drive number and can mount only first primaly partition. When it is set to 1,
+/ each volume is tied to the partitions listed in Drives[]. */
+
+
+
+/*---------------------------------------------------------------------------/
+/ System Configurations
+/----------------------------------------------------------------------------*/
+
+#define _WORD_ACCESS 1 /* 0 or 1 */
+/* The _WORD_ACCESS option defines which access method is used to the word
+/ data on the FAT volume.
+/
+/ 0: Byte-by-byte access. Always compatible with all platforms.
+/ 1: Word access. Do not choose this unless following condition is met.
+/
+/ When the byte order on the memory is big-endian or address miss-aligned
+/ word access results incorrect behavior, the _WORD_ACCESS must be set to 0.
+/ If it is not the case, the value can also be set to 1 to improve the
+/ performance and code size. */
+
+
+#define _FS_REENTRANT 0 /* 0 or 1 */
+#define _FS_TIMEOUT 1000 /* Timeout period in unit of time ticks */
+#define _SYNC_t HANDLE /* O/S dependent type of sync object. e.g. HANDLE, OS_EVENT*, ID and etc.. */
+/* The _FS_REENTRANT option switches the reentrancy of the FatFs module.
+/
+/ 0: Disable reentrancy. _SYNC_t and _FS_TIMEOUT have no effect.
+/ 1: Enable reentrancy. Also user provided synchronization handlers,
+/ ff_req_grant, ff_rel_grant, ff_del_syncobj and ff_cre_syncobj
+/ function must be added to the project. */
+
+
+#endif /* _FFCONFIG */
diff --git a/Projects/Webserver/Lib/FATFs/integer.h b/Projects/Webserver/Lib/FATFs/integer.h new file mode 100644 index 000000000..1d6bac368 --- /dev/null +++ b/Projects/Webserver/Lib/FATFs/integer.h @@ -0,0 +1,37 @@ +/*-------------------------------------------*/
+/* Integer type definitions for FatFs module */
+/*-------------------------------------------*/
+
+#ifndef _INTEGER
+
+#if 0
+#include <windows.h>
+#else
+
+/* These types must be 16-bit, 32-bit or larger integer */
+typedef int INT;
+typedef unsigned int UINT;
+
+/* These types must be 8-bit integer */
+typedef signed char CHAR;
+typedef unsigned char UCHAR;
+typedef unsigned char BYTE;
+
+/* These types must be 16-bit integer */
+typedef short SHORT;
+typedef unsigned short USHORT;
+typedef unsigned short WORD;
+typedef unsigned short WCHAR;
+
+/* These types must be 32-bit integer */
+typedef long LONG;
+typedef unsigned long ULONG;
+typedef unsigned long DWORD;
+
+/* Boolean type */
+typedef enum { FALSE = 0, TRUE } BOOL;
+
+#endif
+
+#define _INTEGER
+#endif
diff --git a/Projects/Webserver/Lib/HTTPServerApp.c b/Projects/Webserver/Lib/HTTPServerApp.c new file mode 100644 index 000000000..01aab76ea --- /dev/null +++ b/Projects/Webserver/Lib/HTTPServerApp.c @@ -0,0 +1,177 @@ +/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2010.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.fourwalledcubicle.com
+*/
+
+/*
+ Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that the copyright notice and this
+ permission notice and warranty disclaimer appear in supporting
+ documentation, and that the name of the author not be used in
+ advertising or publicity pertaining to distribution of the
+ software without specific, written prior permission.
+
+ The author disclaim all warranties with regard to this
+ software, including all implied warranties of merchantability
+ and fitness. In no event shall the author be liable for any
+ special, indirect or consequential damages or any damages
+ whatsoever resulting from loss of use, data or profits, whether
+ in an action of contract, negligence or other tortious action,
+ arising out of or in connection with the use or performance of
+ this software.
+*/
+
+/** \file
+ *
+ * Simple HTTP Webserver Application. When connected to the uIP stack,
+ * this will serve out files to HTTP clients.
+ */
+
+#include "HTTPServerApp.h"
+
+/** HTTP server response header, for transmission before the page contents. This indicates to the host that a page exists at the
+ * given location, and gives extra connection information.
+ */
+char PROGMEM HTTP200Header[] = "HTTP/1.1 200 OK\r\n"
+ "Server: LUFA RNDIS\r\n"
+ "Content-type: text/html\r\n"
+ "Connection: close\r\n\r\n";
+
+/** HTTP server response header, for transmission before a resource not found error. This indicates to the host that the given
+ * given URL is invalid, and gives extra error information.
+ */
+char PROGMEM HTTP404Header[] = "HTTP/1.1 404 Not Found\r\n"
+ "Server: LUFA RNDIS\r\n"
+ "Connection: close\r\n\r\n"
+ "The requested file was not found.";
+
+/** FAT Fs structure to hold the internal state of the FAT driver for the dataflash contents. */
+FATFS DiskFATState;
+
+/** Initialization function for the simple HTTP webserver. */
+void WebserverApp_Init(void)
+{
+ /* Listen on port 80 for HTTP connections from hosts */
+ uip_listen(HTONS(HTTP_SERVER_PORT));
+
+ /* Mount the dataflash disk via FatFS */
+ f_mount(0, &DiskFATState);
+}
+
+/** uIP stack application callback for the simple HTTP webserver. This function must be called each time the
+ * TCP/IP stack needs a TCP packet to be processed.
+ */
+void WebserverApp_Callback(void)
+{
+ uip_tcp_appstate_t* const AppState = &uip_conn->appstate;
+ char* AppData = (char*)uip_appdata;
+ uint16_t AppDataSize = 0;
+
+ if (uip_aborted() || uip_timedout())
+ {
+ /* Close the file before terminating, if it is open */
+ f_close(&AppState->FileToSend);
+
+ AppState->CurrentState = WEBSERVER_STATE_Closed;
+
+ return;
+ }
+ else if (uip_closed())
+ {
+ /* Completed connection, just return */
+ return;
+ }
+ else if (uip_connected())
+ {
+ /* New connection - initialize connection state and data pointer to the appropriate HTTP header */
+ AppState->CurrentState = WEBSERVER_STATE_OpenRequestedFile;
+ }
+
+ switch (AppState->CurrentState)
+ {
+ case WEBSERVER_STATE_OpenRequestedFile:
+ /* Wait for the packet containing the request header */
+ if (uip_datalen())
+ {
+ /* Must be a GET request, abort otherwise */
+ if (strncmp(AppData, "GET ", (sizeof("GET ") - 1)) != 0)
+ {
+ uip_abort();
+ break;
+ }
+
+ char FileName[13];
+
+ /* Copy over the requested filename from the GET request */
+ for (uint8_t i = 0; i < (sizeof(FileName) - 1); i++)
+ {
+ FileName[i] = AppData[sizeof("GET ") + i];
+
+ if (FileName[i] == ' ')
+ {
+ FileName[i] = 0x00;
+ break;
+ }
+ }
+
+ /* Ensure requested filename is null-terminated */
+ FileName[(sizeof(FileName) - 1)] = 0x00;
+
+ /* If no filename specified, assume the default of INDEX.HTM */
+ if (FileName[0] == 0x00)
+ strcpy(FileName, "INDEX.HTM");
+
+ /* Try to open the file from the Dataflash disk */
+ AppState->FileOpen = (f_open(&AppState->FileToSend, FileName, FA_OPEN_EXISTING | FA_READ) == FR_OK);
+
+ AppState->CurrentState = WEBSERVER_STATE_SendHeaders;
+ }
+
+ break;
+ case WEBSERVER_STATE_SendHeaders:
+ /* Determine what HTTP header should be sent to the client */
+ if (AppState->FileOpen)
+ {
+ AppDataSize = strlen_P(HTTP200Header);
+ strncpy_P(AppData, HTTP200Header, AppDataSize);
+ }
+ else
+ {
+ AppDataSize = strlen_P(HTTP404Header);
+ strncpy_P(AppData, HTTP404Header, AppDataSize);
+ }
+
+ uip_send(AppData, AppDataSize);
+
+ AppState->CurrentState = WEBSERVER_STATE_SendData;
+ break;
+ case WEBSERVER_STATE_SendData:
+ /* If end of file/file not open, progress to the close state */
+ if (!(AppState->FileOpen))
+ {
+ f_close(&AppState->FileToSend);
+ uip_close();
+ AppState->CurrentState = WEBSERVER_STATE_Closed;
+ break;
+ }
+
+ uint16_t MaxSegSize = uip_mss();
+
+ /* Read the next chunk of data from the open file */
+ f_read(&AppState->FileToSend, AppData, MaxSegSize, &AppDataSize);
+ AppState->FileOpen = (MaxSegSize == AppDataSize);
+
+ /* If data was read, send it to the client */
+ if (AppDataSize)
+ uip_send(AppData, AppDataSize);
+
+ break;
+ }
+}
diff --git a/Projects/Webserver/Lib/WebserverApp.h b/Projects/Webserver/Lib/HTTPServerApp.h index c788bdbeb..b96e2e303 100644 --- a/Projects/Webserver/Lib/WebserverApp.h +++ b/Projects/Webserver/Lib/HTTPServerApp.h @@ -30,24 +30,26 @@ /** \file
*
- * Header file for WebserverApp.c.
+ * Header file for HTTPServerApp.c.
*/
-#ifndef _WEBSERVER_APP_H_
-#define _WEBSERVER_APP_H_
+#ifndef _HTTPSERVER_APP_H_
+#define _HTTPSERVER_APP_H_
/* Includes: */
- #include <stdio.h>
#include <avr/pgmspace.h>
+ #include <string.h>
#include <LUFA/Version.h>
#include <uip.h>
+ #include <ff.h>
/* Enums: */
/** States for each HTTP connection to the webserver. */
enum Webserver_States_t
{
+ WEBSERVER_STATE_OpenRequestedFile, /** Currently opening requested file */
WEBSERVER_STATE_SendHeaders, /**< Currently sending HTTP headers to the client */
WEBSERVER_STATE_SendData, /**< Currently sending HTTP page data to the client */
WEBSERVER_STATE_Closed, /**< Connection closed after all data sent */
diff --git a/Projects/Webserver/Lib/SCSI.c b/Projects/Webserver/Lib/SCSI.c new file mode 100644 index 000000000..933253b46 --- /dev/null +++ b/Projects/Webserver/Lib/SCSI.c @@ -0,0 +1,281 @@ +/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2010.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.fourwalledcubicle.com
+*/
+
+/*
+ Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that the copyright notice and this
+ permission notice and warranty disclaimer appear in supporting
+ documentation, and that the name of the author not be used in
+ advertising or publicity pertaining to distribution of the
+ software without specific, written prior permission.
+
+ The author disclaim all warranties with regard to this
+ software, including all implied warranties of merchantability
+ and fitness. In no event shall the author be liable for any
+ special, indirect or consequential damages or any damages
+ whatsoever resulting from loss of use, data or profits, whether
+ in an action of contract, negligence or other tortious action,
+ arising out of or in connection with the use or performance of
+ this software.
+*/
+
+/** \file
+ *
+ * SCSI command processing routines, for SCSI commands issued by the host. Mass Storage
+ * devices use a thin "Bulk-Only Transport" protocol for issuing commands and status information,
+ * which wrap around standard SCSI device commands for controlling the actual storage medium.
+ */
+
+#define INCLUDE_FROM_SCSI_C
+#include "SCSI.h"
+
+/** Structure to hold the SCSI response data to a SCSI INQUIRY command. This gives information about the device's
+ * features and capabilities.
+ */
+SCSI_Inquiry_Response_t InquiryData =
+ {
+ .DeviceType = DEVICE_TYPE_BLOCK,
+ .PeripheralQualifier = 0,
+
+ .Removable = true,
+
+ .Version = 0,
+
+ .ResponseDataFormat = 2,
+ .NormACA = false,
+ .TrmTsk = false,
+ .AERC = false,
+
+ .AdditionalLength = 0x1F,
+
+ .SoftReset = false,
+ .CmdQue = false,
+ .Linked = false,
+ .Sync = false,
+ .WideBus16Bit = false,
+ .WideBus32Bit = false,
+ .RelAddr = false,
+
+ .VendorID = "LUFA",
+ .ProductID = "Dataflash Disk",
+ .RevisionID = {'0','.','0','0'},
+ };
+
+/** Structure to hold the sense data for the last issued SCSI command, which is returned to the host after a SCSI REQUEST SENSE
+ * command is issued. This gives information on exactly why the last command failed to complete.
+ */
+SCSI_Request_Sense_Response_t SenseData =
+ {
+ .ResponseCode = 0x70,
+ .AdditionalLength = 0x0A,
+ };
+
+
+/** Main routine to process the SCSI command located in the Command Block Wrapper read from the host. This dispatches
+ * to the appropriate SCSI command handling routine if the issued command is supported by the device, else it returns
+ * a command failure due to a ILLEGAL REQUEST.
+ *
+ * \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with
+ */
+bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
+{
+ /* Set initial sense data, before the requested command is processed */
+ SCSI_SET_SENSE(SCSI_SENSE_KEY_GOOD,
+ SCSI_ASENSE_NO_ADDITIONAL_INFORMATION,
+ SCSI_ASENSEQ_NO_QUALIFIER);
+
+ /* Run the appropriate SCSI command hander function based on the passed command */
+ switch (MSInterfaceInfo->State.CommandBlock.SCSICommandData[0])
+ {
+ case SCSI_CMD_INQUIRY:
+ SCSI_Command_Inquiry(MSInterfaceInfo);
+ break;
+ case SCSI_CMD_REQUEST_SENSE:
+ SCSI_Command_Request_Sense(MSInterfaceInfo);
+ break;
+ case SCSI_CMD_READ_CAPACITY_10:
+ SCSI_Command_Read_Capacity_10(MSInterfaceInfo);
+ break;
+ case SCSI_CMD_SEND_DIAGNOSTIC:
+ SCSI_Command_Send_Diagnostic(MSInterfaceInfo);
+ break;
+ case SCSI_CMD_WRITE_10:
+ SCSI_Command_ReadWrite_10(MSInterfaceInfo, DATA_WRITE);
+ break;
+ case SCSI_CMD_READ_10:
+ SCSI_Command_ReadWrite_10(MSInterfaceInfo, DATA_READ);
+ break;
+ case SCSI_CMD_TEST_UNIT_READY:
+ case SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
+ case SCSI_CMD_VERIFY_10:
+ /* These commands should just succeed, no handling required */
+ MSInterfaceInfo->State.CommandBlock.DataTransferLength = 0;
+ break;
+ default:
+ /* Update the SENSE key to reflect the invalid command */
+ SCSI_SET_SENSE(SCSI_SENSE_KEY_ILLEGAL_REQUEST,
+ SCSI_ASENSE_INVALID_COMMAND,
+ SCSI_ASENSEQ_NO_QUALIFIER);
+ break;
+ }
+
+ return (SenseData.SenseKey == SCSI_SENSE_KEY_GOOD);
+}
+
+/** Command processing for an issued SCSI INQUIRY command. This command returns information about the device's features
+ * and capabilities to the host.
+ *
+ * \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with
+ */
+static void SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
+{
+ uint16_t AllocationLength = (((uint16_t)MSInterfaceInfo->State.CommandBlock.SCSICommandData[3] << 8) |
+ MSInterfaceInfo->State.CommandBlock.SCSICommandData[4]);
+ uint16_t BytesTransferred = (AllocationLength < sizeof(InquiryData))? AllocationLength :
+ sizeof(InquiryData);
+
+ /* Only the standard INQUIRY data is supported, check if any optional INQUIRY bits set */
+ if ((MSInterfaceInfo->State.CommandBlock.SCSICommandData[1] & ((1 << 0) | (1 << 1))) ||
+ MSInterfaceInfo->State.CommandBlock.SCSICommandData[2])
+ {
+ /* Optional but unsupported bits set - update the SENSE key and fail the request */
+ SCSI_SET_SENSE(SCSI_SENSE_KEY_ILLEGAL_REQUEST,
+ SCSI_ASENSE_INVALID_FIELD_IN_CDB,
+ SCSI_ASENSEQ_NO_QUALIFIER);
+
+ return;
+ }
+
+ Endpoint_Write_Stream_LE(&InquiryData, BytesTransferred, NO_STREAM_CALLBACK);
+
+ uint8_t PadBytes[AllocationLength - BytesTransferred];
+
+ /* Pad out remaining bytes with 0x00 */
+ Endpoint_Write_Stream_LE(&PadBytes, (AllocationLength - BytesTransferred), NO_STREAM_CALLBACK);
+
+ /* Finalize the stream transfer to send the last packet */
+ Endpoint_ClearIN();
+
+ /* Succeed the command and update the bytes transferred counter */
+ MSInterfaceInfo->State.CommandBlock.DataTransferLength -= BytesTransferred;
+}
+
+/** Command processing for an issued SCSI REQUEST SENSE command. This command returns information about the last issued command,
+ * including the error code and additional error information so that the host can determine why a command failed to complete.
+ *
+ * \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with
+ */
+static void SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
+{
+ uint8_t AllocationLength = MSInterfaceInfo->State.CommandBlock.SCSICommandData[4];
+ uint8_t BytesTransferred = (AllocationLength < sizeof(SenseData))? AllocationLength : sizeof(SenseData);
+
+ uint8_t PadBytes[AllocationLength - BytesTransferred];
+
+ Endpoint_Write_Stream_LE(&SenseData, BytesTransferred, NO_STREAM_CALLBACK);
+ Endpoint_Write_Stream_LE(&PadBytes, (AllocationLength - BytesTransferred), NO_STREAM_CALLBACK);
+ Endpoint_ClearIN();
+
+ /* Succeed the command and update the bytes transferred counter */
+ MSInterfaceInfo->State.CommandBlock.DataTransferLength -= BytesTransferred;
+}
+
+/** Command processing for an issued SCSI READ CAPACITY (10) command. This command returns information about the device's capacity
+ * on the selected Logical Unit (drive), as a number of OS-sized blocks.
+ *
+ * \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with
+ */
+static void SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
+{
+ uint32_t LastBlockAddressInLUN = (VIRTUAL_MEMORY_BLOCKS - 1);
+ uint32_t MediaBlockSize = VIRTUAL_MEMORY_BLOCK_SIZE;
+
+ Endpoint_Write_Stream_BE(&LastBlockAddressInLUN, sizeof(LastBlockAddressInLUN), NO_STREAM_CALLBACK);
+ Endpoint_Write_Stream_BE(&MediaBlockSize, sizeof(MediaBlockSize), NO_STREAM_CALLBACK);
+ Endpoint_ClearIN();
+
+ /* Succeed the command and update the bytes transferred counter */
+ MSInterfaceInfo->State.CommandBlock.DataTransferLength -= 8;
+}
+
+/** Command processing for an issued SCSI SEND DIAGNOSTIC command. This command performs a quick check of the Dataflash ICs on the
+ * board, and indicates if they are present and functioning correctly. Only the Self-Test portion of the diagnostic command is
+ * supported.
+ *
+ * \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with
+ */
+static void SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
+{
+ /* Check to see if the SELF TEST bit is not set */
+ if (!(MSInterfaceInfo->State.CommandBlock.SCSICommandData[1] & (1 << 2)))
+ {
+ /* Only self-test supported - update SENSE key and fail the command */
+ SCSI_SET_SENSE(SCSI_SENSE_KEY_ILLEGAL_REQUEST,
+ SCSI_ASENSE_INVALID_FIELD_IN_CDB,
+ SCSI_ASENSEQ_NO_QUALIFIER);
+
+ return;
+ }
+
+ /* Check to see if all attached Dataflash ICs are functional */
+ if (!(DataflashManager_CheckDataflashOperation()))
+ {
+ /* Update SENSE key with a hardware error condition and return command fail */
+ SCSI_SET_SENSE(SCSI_SENSE_KEY_HARDWARE_ERROR,
+ SCSI_ASENSE_NO_ADDITIONAL_INFORMATION,
+ SCSI_ASENSEQ_NO_QUALIFIER);
+
+ return;
+ }
+
+ /* Succeed the command and update the bytes transferred counter */
+ MSInterfaceInfo->State.CommandBlock.DataTransferLength = 0;
+}
+
+/** Command processing for an issued SCSI READ (10) or WRITE (10) command. This command reads in the block start address
+ * and total number of blocks to process, then calls the appropriate low-level dataflash routine to handle the actual
+ * reading and writing of the data.
+ *
+ * \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with
+ * \param[in] IsDataRead Indicates if the command is a READ (10) command or WRITE (10) command (DATA_READ or DATA_WRITE)
+ */
+static void SCSI_Command_ReadWrite_10(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const bool IsDataRead)
+{
+ uint32_t BlockAddress;
+ uint16_t TotalBlocks;
+
+ /* Load in the 32-bit block address (SCSI uses big-endian, so have to reverse the byte order) */
+ BlockAddress = SwapEndian_32(*(uint32_t*)&MSInterfaceInfo->State.CommandBlock.SCSICommandData[2]);
+
+ /* Load in the 16-bit total blocks (SCSI uses big-endian, so have to reverse the byte order) */
+ TotalBlocks = SwapEndian_16(*(uint32_t*)&MSInterfaceInfo->State.CommandBlock.SCSICommandData[7]);
+
+ /* Check if the block address is outside the maximum allowable value for the LUN */
+ if (BlockAddress >= VIRTUAL_MEMORY_BLOCKS)
+ {
+ /* Block address is invalid, update SENSE key and return command fail */
+ SCSI_SET_SENSE(SCSI_SENSE_KEY_ILLEGAL_REQUEST,
+ SCSI_ASENSE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE,
+ SCSI_ASENSEQ_NO_QUALIFIER);
+
+ return;
+ }
+
+ /* Determine if the packet is a READ (10) or WRITE (10) command, call appropriate function */
+ if (IsDataRead == DATA_READ)
+ DataflashManager_ReadBlocks(MSInterfaceInfo, BlockAddress, TotalBlocks);
+ else
+ DataflashManager_WriteBlocks(MSInterfaceInfo, BlockAddress, TotalBlocks);
+
+ /* Update the bytes transferred counter and succeed the command */
+ MSInterfaceInfo->State.CommandBlock.DataTransferLength -= ((uint32_t)TotalBlocks * VIRTUAL_MEMORY_BLOCK_SIZE);
+}
diff --git a/Projects/Webserver/Lib/SCSI.h b/Projects/Webserver/Lib/SCSI.h new file mode 100644 index 000000000..aa7d9327c --- /dev/null +++ b/Projects/Webserver/Lib/SCSI.h @@ -0,0 +1,85 @@ +/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2010.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.fourwalledcubicle.com
+*/
+
+/*
+ Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that the copyright notice and this
+ permission notice and warranty disclaimer appear in supporting
+ documentation, and that the name of the author not be used in
+ advertising or publicity pertaining to distribution of the
+ software without specific, written prior permission.
+
+ The author disclaim all warranties with regard to this
+ software, including all implied warranties of merchantability
+ and fitness. In no event shall the author be liable for any
+ special, indirect or consequential damages or any damages
+ whatsoever resulting from loss of use, data or profits, whether
+ in an action of contract, negligence or other tortious action,
+ arising out of or in connection with the use or performance of
+ this software.
+*/
+
+/** \file
+ *
+ * Header file for SCSI.c.
+ */
+
+#ifndef _SCSI_H_
+#define _SCSI_H_
+
+ /* Includes: */
+ #include <avr/io.h>
+ #include <avr/pgmspace.h>
+
+ #include <LUFA/Drivers/USB/USB.h>
+ #include <LUFA/Drivers/USB/Class/MassStorage.h>
+ + #include "../Descriptors.h"
+ #include "DataflashManager.h"
+
+ /* Macros: */
+ /** Macro to set the current SCSI sense data to the given key, additional sense code and additional sense qualifier. This
+ * is for convenience, as it allows for all three sense values (returned upon request to the host to give information about
+ * the last command failure) in a quick and easy manner.
+ *
+ * \param[in] key New SCSI sense key to set the sense code to
+ * \param[in] acode New SCSI additional sense key to set the additional sense code to
+ * \param[in] aqual New SCSI additional sense key qualifier to set the additional sense qualifier code to
+ */
+ #define SCSI_SET_SENSE(key, acode, aqual) MACROS{ SenseData.SenseKey = (key); \
+ SenseData.AdditionalSenseCode = (acode); \
+ SenseData.AdditionalSenseQualifier = (aqual); }MACROE
+
+ /** Macro for the SCSI_Command_ReadWrite_10() function, to indicate that data is to be read from the storage medium. */
+ #define DATA_READ true
+
+ /** Macro for the SCSI_Command_ReadWrite_10() function, to indicate that data is to be written to the storage medium. */
+ #define DATA_WRITE false
+
+ /** Value for the DeviceType entry in the SCSI_Inquiry_Response_t enum, indicating a Block Media device. */
+ #define DEVICE_TYPE_BLOCK 0x00
+
+ /** Value for the DeviceType entry in the SCSI_Inquiry_Response_t enum, indicating a CD-ROM device. */
+ #define DEVICE_TYPE_CDROM 0x05
+
+ /* Function Prototypes: */
+ bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
+
+ #if defined(INCLUDE_FROM_SCSI_C)
+ static void SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
+ static void SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
+ static void SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
+ static void SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
+ static void SCSI_Command_ReadWrite_10(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const bool IsDataRead);
+ #endif
+
+#endif
diff --git a/Projects/Webserver/Lib/WebserverApp.c b/Projects/Webserver/Lib/WebserverApp.c deleted file mode 100644 index 02f38be87..000000000 --- a/Projects/Webserver/Lib/WebserverApp.c +++ /dev/null @@ -1,142 +0,0 @@ -/*
- LUFA Library
- Copyright (C) Dean Camera, 2010.
-
- dean [at] fourwalledcubicle [dot] com
- www.fourwalledcubicle.com
-*/
-
-/*
- Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
-
- Permission to use, copy, modify, distribute, and sell this
- software and its documentation for any purpose is hereby granted
- without fee, provided that the above copyright notice appear in
- all copies and that both that the copyright notice and this
- permission notice and warranty disclaimer appear in supporting
- documentation, and that the name of the author not be used in
- advertising or publicity pertaining to distribution of the
- software without specific, written prior permission.
-
- The author disclaim all warranties with regard to this
- software, including all implied warranties of merchantability
- and fitness. In no event shall the author be liable for any
- special, indirect or consequential damages or any damages
- whatsoever resulting from loss of use, data or profits, whether
- in an action of contract, negligence or other tortious action,
- arising out of or in connection with the use or performance of
- this software.
-*/
-
-/** \file
- *
- * Simple HTTP Webserver Application. When connected to the uIP stack,
- * this will serve out files to HTTP clients.
- */
-
-#include "WebserverApp.h"
-
-/** HTTP server response header, for transmission before the page contents. This indicates to the host that a page exists at the
- * given location, and gives extra connection information.
- */
-char PROGMEM HTTP200Header[] = "HTTP/1.1 200 OK\r\n"
- "Server: LUFA RNDIS\r\n"
- "Content-type: text/html\r\n"
- "Connection: close\r\n\r\n";
-
-/** HTTP server response header, for transmission before a resource not found error. This indicates to the host that the given
- * given URL is invalid, and gives extra error information.
- */
-char PROGMEM HTTP404Header[] = "HTTP/1.1 404 Not Found\r\n"
- "Server: LUFA RNDIS\r\n"
- "Connection: close\r\n\r\n";
-
-/** Static HTTP page to serve to the host when a HTTP request is made from a host. */
-char PROGMEM HTTPPage[] =
- "<html>"
- " <head>"
- " <title>"
- " LUFA Webserver Demo"
- " </title>"
- " </head>"
- " <body>"
- " <h1>Hello from your USB AVR!</h1>"
- " <p>"
- " Hello! Welcome to the LUFA RNDIS Demo Webserver test page, running on your USB AVR via the LUFA library and uIP TCP/IP network stack. This"
- " demonstrates a simple HTTP webserver serving out pages to HTTP clients."
- " <br /><br />"
- " <small>Project Information: <a href=\"http://www.fourwalledcubicle.com/LUFA.php\">http://www.fourwalledcubicle.com/LUFA.php</a>.</small>"
- " <hr />"
- " <i>LUFA Version: </i>" LUFA_VERSION_STRING
- " </p>"
- " </body>"
- "</html>";
-
-/** Initialization function for the simple HTTP webserver. */
-void WebserverApp_Init(void)
-{
- /* Listen on port 80 for HTTP connections from hosts */
- uip_listen(HTONS(HTTP_SERVER_PORT));
-}
-
-/** uIP stack application callback for the simple HTTP webserver. This function must be called each time the
- * TCP/IP stack needs a TCP packet to be processed.
- */
-void WebserverApp_Callback(void)
-{
- uip_tcp_appstate_t* const AppState = &uip_conn->appstate;
- char* AppData = (char*)uip_appdata;
- uint16_t AppDataSize = 0;
-
- if (uip_closed() || uip_aborted() || uip_timedout())
- {
- /* Terminated or completed connection - don't send any new data */
- return;
- }
- else if (uip_connected())
- {
- /* New connection - initialize connection state and data pointer to the appropriate HTTP header */
- AppState->SendPos = HTTP200Header;
- AppState->CurrentState = WEBSERVER_STATE_SendHeaders;
- }
-
- /* Calculate the maximum segment size and remaining data size */
- uint16_t BytesRemaining = strlen_P(AppState->SendPos);
- uint16_t MaxSegSize = uip_mss();
-
- /* No more bytes remaining in the current data being sent - progress to next data chunk or
- * terminate the connection once all chunks are sent */
- if (!(BytesRemaining))
- {
- /* Check which data chunk we are currently sending (header or data) */
- if (AppState->CurrentState == WEBSERVER_STATE_SendHeaders)
- {
- AppState->SendPos = HTTPPage;
- AppState->CurrentState = WEBSERVER_STATE_SendData;
- }
- else if (AppState->CurrentState == WEBSERVER_STATE_SendData)
- {
- uip_close();
- AppState->CurrentState = WEBSERVER_STATE_Closed;
- }
-
- return;
- }
- else if (BytesRemaining > MaxSegSize)
- {
- /* More bytes remaining to send than the maximum segment size, send next chunk */
- AppDataSize = MaxSegSize;
- }
- else
- {
- /* Less bytes than the segment size remaining, send all remaining bytes in the one packet */
- AppDataSize = BytesRemaining;
- }
-
- /* Copy over the next data segment to the application buffer, advance send position pointer */
- strncpy_P(AppData, AppState->SendPos, AppDataSize);
- AppState->SendPos += AppDataSize;
-
- /* Send the data to the requesting host */
- uip_send(AppData, AppDataSize);
-}
diff --git a/Projects/Webserver/Lib/uIPManagement.c b/Projects/Webserver/Lib/uIPManagement.c new file mode 100644 index 000000000..dd9f15f42 --- /dev/null +++ b/Projects/Webserver/Lib/uIPManagement.c @@ -0,0 +1,189 @@ +/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2010.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.fourwalledcubicle.com
+*/
+
+/*
+ Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that the copyright notice and this
+ permission notice and warranty disclaimer appear in supporting
+ documentation, and that the name of the author not be used in
+ advertising or publicity pertaining to distribution of the
+ software without specific, written prior permission.
+
+ The author disclaim all warranties with regard to this
+ software, including all implied warranties of merchantability
+ and fitness. In no event shall the author be liable for any
+ special, indirect or consequential damages or any damages
+ whatsoever resulting from loss of use, data or profits, whether
+ in an action of contract, negligence or other tortious action,
+ arising out of or in connection with the use or performance of
+ this software.
+*/
+
+/** \file
+ *
+ * uIP Managament functions. This file contains the functions and globals needed to maintain the uIP
+ * stack once an RNDIS device has been attached to the system.
+ */
+
+#define INCLUDE_FROM_UIPMANAGEMENT_C
+#include "uIPManagement.h"
+
+/** Connection timer, to retain the time elapsed since the last time the uIP connections were managed. */
+struct timer ConnectionTimer;
+
+/** ARP timer, to retain the time elapsed since the ARP cache was last updated. */
+struct timer ARPTimer;
+
+/** MAC address of the RNDIS device, when enumerated */
+struct uip_eth_addr MACAddress;
+
+
+/** Configures the uIP stack ready for network traffic. */
+void uIPManagement_Init(void)
+{
+ /* uIP Timing Initialization */
+ clock_init();
+ timer_set(&ConnectionTimer, CLOCK_SECOND / 2);
+ timer_set(&ARPTimer, CLOCK_SECOND * 10);
+
+ /* uIP Stack Initialization */
+ uip_init();
+
+ /* DHCP/Server IP Settings Initialization */
+ #if defined(ENABLE_DHCP)
+ DHCPApp_Init();
+ #else
+ uip_ipaddr_t IPAddress, Netmask, GatewayIPAddress;
+ uip_ipaddr(&IPAddress, DEVICE_IP_ADDRESS[0], DEVICE_IP_ADDRESS[1], DEVICE_IP_ADDRESS[2], DEVICE_IP_ADDRESS[3]);
+ uip_ipaddr(&Netmask, DEVICE_NETMASK[0], DEVICE_NETMASK[1], DEVICE_NETMASK[2], DEVICE_NETMASK[3]);
+ uip_ipaddr(&GatewayIPAddress, DEVICE_GATEWAY[0], DEVICE_GATEWAY[1], DEVICE_GATEWAY[2], DEVICE_GATEWAY[3]);
+ uip_sethostaddr(&IPAddress);
+ uip_setnetmask(&Netmask);
+ uip_setdraddr(&GatewayIPAddress);
+ #endif
+
+ uip_setethaddr(MACAddress);
+
+ /* HTTP Webserver Initialization */
+ WebserverApp_Init();
+}
+
+/** uIP Management function. This function manages the uIP stack when called while an RNDIS device has been
+ * attached to the system.
+ */
+void uIPManagement_ManageNetwork(void)
+{
+ if ((USB_CurrentMode == USB_MODE_HOST) && (USB_HostState == HOST_STATE_Configured))
+ {
+ uIPManagement_ProcessIncommingPacket();
+ uIPManagement_ManageConnections();
+ }
+}
+
+/** Processes incomming packets to the server from the connected RNDIS device, creating responses as needed. */
+static void uIPManagement_ProcessIncommingPacket(void)
+{
+ if (RNDIS_Host_IsPacketReceived(&Ethernet_RNDIS_Interface))
+ {
+ LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
+
+ /* Read the incomming packet straight into the UIP packet buffer */
+ RNDIS_Host_ReadPacket(&Ethernet_RNDIS_Interface, &uip_buf[0], &uip_len);
+
+ if (uip_len > 0)
+ {
+ bool PacketHandled = true;
+
+ struct uip_eth_hdr* EthernetHeader = (struct uip_eth_hdr*)&uip_buf[0];
+ if (EthernetHeader->type == HTONS(UIP_ETHTYPE_IP))
+ {
+ /* Filter packet by MAC destination */
+ uip_arp_ipin();
+
+ /* Process incomming packet */
+ uip_input();
+
+ /* Add destination MAC to outgoing packet */
+ if (uip_len > 0)
+ uip_arp_out();
+ }
+ else if (EthernetHeader->type == HTONS(UIP_ETHTYPE_ARP))
+ {
+ /* Process ARP packet */
+ uip_arp_arpin();
+ }
+ else
+ {
+ PacketHandled = false;
+ }
+
+ /* If a response was generated, send it */
+ if ((uip_len > 0) && PacketHandled)
+ RNDIS_Host_SendPacket(&Ethernet_RNDIS_Interface, &uip_buf[0], uip_len);
+ }
+
+ LEDs_SetAllLEDs(LEDMASK_USB_READY);
+ }
+}
+
+/** Manages the currently open network connections, including TCP and (if enabled) UDP. */
+static void uIPManagement_ManageConnections(void)
+{
+ /* Manage open connections */
+ if (timer_expired(&ConnectionTimer))
+ {
+ timer_reset(&ConnectionTimer);
+
+ LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
+
+ for (uint8_t i = 0; i < UIP_CONNS; i++)
+ {
+ /* Run periodic connection management for each TCP connection */
+ uip_periodic(i);
+
+ /* If a response was generated, send it */
+ if (uip_len > 0)
+ {
+ /* Add destination MAC to outgoing packet */
+ uip_arp_out();
+
+ RNDIS_Host_SendPacket(&Ethernet_RNDIS_Interface, &uip_buf[0], uip_len);
+ }
+ }
+
+ #if defined(ENABLE_DHCP)
+ for (uint8_t i = 0; i < UIP_UDP_CONNS; i++)
+ {
+ /* Run periodic connection management for each UDP connection */
+ uip_udp_periodic(i);
+
+ /* If a response was generated, send it */
+ if (uip_len > 0)
+ {
+ /* Add destination MAC to outgoing packet */
+ uip_arp_out();
+
+ RNDIS_Host_SendPacket(&Ethernet_RNDIS_Interface, &uip_buf[0], uip_len);
+ }
+ }
+ #endif
+
+ LEDs_SetAllLEDs(LEDMASK_USB_READY);
+ }
+
+ /* Manage ARP cache refreshing */
+ if (timer_expired(&ARPTimer))
+ {
+ timer_reset(&ARPTimer);
+ uip_arp_timer();
+ }
+}
diff --git a/Projects/Webserver/Lib/uIPManagement.h b/Projects/Webserver/Lib/uIPManagement.h new file mode 100644 index 000000000..24881556b --- /dev/null +++ b/Projects/Webserver/Lib/uIPManagement.h @@ -0,0 +1,73 @@ +/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2010.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.fourwalledcubicle.com
+*/
+
+/*
+ Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that the copyright notice and this
+ permission notice and warranty disclaimer appear in supporting
+ documentation, and that the name of the author not be used in
+ advertising or publicity pertaining to distribution of the
+ software without specific, written prior permission.
+
+ The author disclaim all warranties with regard to this
+ software, including all implied warranties of merchantability
+ and fitness. In no event shall the author be liable for any
+ special, indirect or consequential damages or any damages
+ whatsoever resulting from loss of use, data or profits, whether
+ in an action of contract, negligence or other tortious action,
+ arising out of or in connection with the use or performance of
+ this software.
+*/
+
+/** \file
+ *
+ * Header file for uIPManagement.c.
+ */
+
+#ifndef _UIPMANAGEMENT_H_
+#define _UIPMANAGEMENT_H_
+
+ /* Includes: */
+ #include <LUFA/Drivers/USB/Class/RNDIS.h>
+
+ #include <uip.h>
+ #include <uip_arp.h>
+ #include <timer.h>
+
+ #include "Lib/DHCPApp.h"
+ #include "Lib/HTTPServerApp.h"
+
+ /* Macros: */
+ /** IP address that the webserver should use once connected to a RNDIS device (when DHCP is disabled). */
+ #define DEVICE_IP_ADDRESS (uint8_t[]){192, 168, 1, 10}
+
+ /** Netmask that the webserver should once connected to a RNDIS device (when DHCP is disabled). */
+ #define DEVICE_NETMASK (uint8_t[]){255, 255, 255, 0}
+
+ /** IP address of the default gateway the webserver should use when routing outside the local subnet
+ * (when DHCP is disabled).
+ */
+ #define DEVICE_GATEWAY (uint8_t[]){192, 168, 1, 1}
+
+ /* External Variables: */
+ extern struct uip_eth_addr MACAddress;
+
+ /* Function Prototypes: */
+ void uIPManagement_Init(void);
+ void uIPManagement_ManageNetwork(void);
+
+ #if defined(INCLUDE_FROM_UIPMANAGEMENT_C)
+ static void uIPManagement_ProcessIncommingPacket(void);
+ static void uIPManagement_ManageConnections(void);
+ #endif
+
+#endif
diff --git a/Projects/Webserver/Lib/uip/conf/apps-conf.h b/Projects/Webserver/Lib/uip/conf/apps-conf.h index fc9727dcd..76cd93719 100644 --- a/Projects/Webserver/Lib/uip/conf/apps-conf.h +++ b/Projects/Webserver/Lib/uip/conf/apps-conf.h @@ -1,10 +1,13 @@ #ifndef __APPS_CONF_H__
#define __APPS_CONF_H__
+ #include <ff.h>
+
typedef struct
{
uint8_t CurrentState;
- char* SendPos;
+ FIL FileToSend;
+ bool FileOpen;
} uip_tcp_appstate_t;
typedef struct
diff --git a/Projects/Webserver/USBDeviceMode.c b/Projects/Webserver/USBDeviceMode.c new file mode 100644 index 000000000..c93ba4632 --- /dev/null +++ b/Projects/Webserver/USBDeviceMode.c @@ -0,0 +1,113 @@ +/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2010.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.fourwalledcubicle.com
+*/
+
+/*
+ Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that the copyright notice and this
+ permission notice and warranty disclaimer appear in supporting
+ documentation, and that the name of the author not be used in
+ advertising or publicity pertaining to distribution of the
+ software without specific, written prior permission.
+
+ The author disclaim all warranties with regard to this
+ software, including all implied warranties of merchantability
+ and fitness. In no event shall the author be liable for any
+ special, indirect or consequential damages or any damages
+ whatsoever resulting from loss of use, data or profits, whether
+ in an action of contract, negligence or other tortious action,
+ arising out of or in connection with the use or performance of
+ this software.
+*/
+
+/** \file
+ *
+ * USB Device Mode management functions and variables. This file contains the LUFA code required to
+ * manage the USB Mass Storage device mode.
+ */
+
+#include "USBDeviceMode.h"
+
+/** LUFA Mass Storage Class driver interface configuration and state information. This structure is
+ * passed to all Mass Storage Class driver functions, so that multiple instances of the same class
+ * within a device can be differentiated from one another.
+ */
+USB_ClassInfo_MS_Device_t Disk_MS_Interface =
+ {
+ .Config =
+ {
+ .InterfaceNumber = 0,
+
+ .DataINEndpointNumber = MASS_STORAGE_IN_EPNUM,
+ .DataINEndpointSize = MASS_STORAGE_IO_EPSIZE,
+ .DataINEndpointDoubleBank = false,
+
+ .DataOUTEndpointNumber = MASS_STORAGE_OUT_EPNUM,
+ .DataOUTEndpointSize = MASS_STORAGE_IO_EPSIZE,
+ .DataOUTEndpointDoubleBank = false,
+
+ .TotalLUNs = 1,
+ },
+ };
+
+
+/** USB device mode management task. This function manages the Mass Storage Device class driver when the device is
+ * initialized in USB device mode.
+ */
+void USBDeviceMode_USBTask(void)
+{
+ if (USB_CurrentMode != USB_MODE_DEVICE)
+ return;
+
+ MS_Device_USBTask(&Disk_MS_Interface);
+}
+
+/** Event handler for the library USB Connection event. */
+void EVENT_USB_Device_Connect(void)
+{
+ LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
+}
+
+/** Event handler for the library USB Disconnection event. */
+void EVENT_USB_Device_Disconnect(void)
+{
+ LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
+}
+
+/** Event handler for the library USB Configuration Changed event. */
+void EVENT_USB_Device_ConfigurationChanged(void)
+{
+ LEDs_SetAllLEDs(LEDMASK_USB_READY);
+
+ if (!(MS_Device_ConfigureEndpoints(&Disk_MS_Interface)))
+ LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+}
+
+/** Event handler for the library USB Unhandled Control Request event. */
+void EVENT_USB_Device_UnhandledControlRequest(void)
+{
+ MS_Device_ProcessControlRequest(&Disk_MS_Interface);
+}
+
+/** Mass Storage class driver callback function the reception of SCSI commands from the host, which must be processed.
+ *
+ * \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface configuration structure being referenced
+ */
+bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
+{
+ bool CommandSuccess;
+
+ LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
+ CommandSuccess = SCSI_DecodeSCSICommand(MSInterfaceInfo);
+ LEDs_SetAllLEDs(LEDMASK_USB_READY);
+
+ return CommandSuccess;
+}
diff --git a/Projects/Webserver/USBDeviceMode.h b/Projects/Webserver/USBDeviceMode.h new file mode 100644 index 000000000..d76c66778 --- /dev/null +++ b/Projects/Webserver/USBDeviceMode.h @@ -0,0 +1,56 @@ +/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2010.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.fourwalledcubicle.com
+*/
+
+/*
+ Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that the copyright notice and this
+ permission notice and warranty disclaimer appear in supporting
+ documentation, and that the name of the author not be used in
+ advertising or publicity pertaining to distribution of the
+ software without specific, written prior permission.
+
+ The author disclaim all warranties with regard to this
+ software, including all implied warranties of merchantability
+ and fitness. In no event shall the author be liable for any
+ special, indirect or consequential damages or any damages
+ whatsoever resulting from loss of use, data or profits, whether
+ in an action of contract, negligence or other tortious action,
+ arising out of or in connection with the use or performance of
+ this software.
+*/
+
+/** \file
+ *
+ * Header file for USBDeviceMode.c.
+ */
+
+#ifndef _USBDEVICEMODE_H_
+#define _USBDEVICEMODE_H_
+
+ /* Includes: */
+ #include <LUFA/Drivers/USB/Class/MassStorage.h>
+
+ #include "Webserver.h"
+ #include "Descriptors.h"
+ #include "Lib/SCSI.h"
+
+ /* Function Prototypes: */
+ void USBDeviceMode_USBTask(void);
+
+ void EVENT_USB_Device_Connect(void);
+ void EVENT_USB_Device_Disconnect(void);
+ void EVENT_USB_Device_ConfigurationChanged(void);
+ void EVENT_USB_Device_UnhandledControlRequest(void);
+
+ bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
+
+#endif
diff --git a/Projects/Webserver/USBHostMode.c b/Projects/Webserver/USBHostMode.c new file mode 100644 index 000000000..14f33e07c --- /dev/null +++ b/Projects/Webserver/USBHostMode.c @@ -0,0 +1,178 @@ +/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2010.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.fourwalledcubicle.com
+*/
+
+/*
+ Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that the copyright notice and this
+ permission notice and warranty disclaimer appear in supporting
+ documentation, and that the name of the author not be used in
+ advertising or publicity pertaining to distribution of the
+ software without specific, written prior permission.
+
+ The author disclaim all warranties with regard to this
+ software, including all implied warranties of merchantability
+ and fitness. In no event shall the author be liable for any
+ special, indirect or consequential damages or any damages
+ whatsoever resulting from loss of use, data or profits, whether
+ in an action of contract, negligence or other tortious action,
+ arising out of or in connection with the use or performance of
+ this software.
+*/
+
+/** \file
+ *
+ * USB Host Mode management functions and variables. This file contains the LUFA code required to
+ * manage the USB RNDIS host mode.
+ */
+
+#include "USBHostMode.h"
+
+/** LUFA RNDIS Class driver interface configuration and state information. This structure is
+ * passed to all RNDIS Class driver functions, so that multiple instances of the same class
+ * within a device can be differentiated from one another.
+ */
+USB_ClassInfo_RNDIS_Host_t Ethernet_RNDIS_Interface =
+ {
+ .Config =
+ {
+ .DataINPipeNumber = 1,
+ .DataINPipeDoubleBank = false,
+
+ .DataOUTPipeNumber = 2,
+ .DataOUTPipeDoubleBank = false,
+
+ .NotificationPipeNumber = 3,
+ .NotificationPipeDoubleBank = false,
+
+ .HostMaxPacketSize = UIP_CONF_BUFFER_SIZE,
+ },
+ };
+
+
+/** USB host mode management task. This function manages the RNDIS Host class driver and uIP stack when the device is
+ * initialized in USB host mode.
+ */
+void USBHostMode_USBTask(void)
+{
+ if (USB_CurrentMode != USB_MODE_HOST)
+ return;
+
+ switch (USB_HostState)
+ {
+ case HOST_STATE_Addressed:
+ LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
+
+ uint16_t ConfigDescriptorSize;
+ uint8_t ConfigDescriptorData[512];
+
+ if (USB_Host_GetDeviceConfigDescriptor(1, &ConfigDescriptorSize, ConfigDescriptorData,
+ sizeof(ConfigDescriptorData)) != HOST_GETCONFIG_Successful)
+ {
+ LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+ USB_HostState = HOST_STATE_WaitForDeviceRemoval;
+ break;
+ }
+
+ if (RNDIS_Host_ConfigurePipes(&Ethernet_RNDIS_Interface,
+ ConfigDescriptorSize, ConfigDescriptorData) != RNDIS_ENUMERROR_NoError)
+ {
+ LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+ USB_HostState = HOST_STATE_WaitForDeviceRemoval;
+ break;
+ }
+
+ if (USB_Host_SetDeviceConfiguration(1) != HOST_SENDCONTROL_Successful)
+ {
+ LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+ USB_HostState = HOST_STATE_WaitForDeviceRemoval;
+ break;
+ }
+
+ if (RNDIS_Host_InitializeDevice(&Ethernet_RNDIS_Interface) != HOST_SENDCONTROL_Successful)
+ {
+ LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+ USB_HostState = HOST_STATE_WaitForDeviceRemoval;
+ break;
+ }
+
+ uint32_t PacketFilter = (REMOTE_NDIS_PACKET_DIRECTED | REMOTE_NDIS_PACKET_BROADCAST);
+ if (RNDIS_Host_SetRNDISProperty(&Ethernet_RNDIS_Interface, OID_GEN_CURRENT_PACKET_FILTER,
+ &PacketFilter, sizeof(PacketFilter)) != HOST_SENDCONTROL_Successful)
+ {
+ LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+ USB_HostState = HOST_STATE_WaitForDeviceRemoval;
+ break;
+ }
+
+ if (RNDIS_Host_QueryRNDISProperty(&Ethernet_RNDIS_Interface, OID_802_3_CURRENT_ADDRESS,
+ &MACAddress, sizeof(MACAddress)) != HOST_SENDCONTROL_Successful)
+ {
+ LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+ USB_HostState = HOST_STATE_WaitForDeviceRemoval;
+ break;
+ }
+
+ /* Initialize uIP stack */
+ uIPManagement_Init();
+
+ LEDs_SetAllLEDs(LEDMASK_USB_READY);
+ USB_HostState = HOST_STATE_Configured;
+ break;
+ case HOST_STATE_Configured:
+ uIPManagement_ManageNetwork();
+
+ break;
+ }
+
+ RNDIS_Host_USBTask(&Ethernet_RNDIS_Interface);
+}
+
+/** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
+ * starts the library USB task to begin the enumeration and USB management process.
+ */
+void EVENT_USB_Host_DeviceAttached(void)
+{
+ LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
+}
+
+/** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
+ * stops the library USB task management process.
+ */
+void EVENT_USB_Host_DeviceUnattached(void)
+{
+ LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
+}
+
+/** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
+ * enumerated by the host and is now ready to be used by the application.
+ */
+void EVENT_USB_Host_DeviceEnumerationComplete(void)
+{
+ LEDs_SetAllLEDs(LEDMASK_USB_READY);
+}
+
+/** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
+void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
+{
+ USB_ShutDown();
+
+ LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+ for(;;);
+}
+
+/** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
+ * enumerating an attached USB device.
+ */
+void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode)
+{
+ LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+}
diff --git a/Projects/Webserver/USBHostMode.h b/Projects/Webserver/USBHostMode.h new file mode 100644 index 000000000..03387edd2 --- /dev/null +++ b/Projects/Webserver/USBHostMode.h @@ -0,0 +1,57 @@ +/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2010.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.fourwalledcubicle.com
+*/
+
+/*
+ Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that the copyright notice and this
+ permission notice and warranty disclaimer appear in supporting
+ documentation, and that the name of the author not be used in
+ advertising or publicity pertaining to distribution of the
+ software without specific, written prior permission.
+
+ The author disclaim all warranties with regard to this
+ software, including all implied warranties of merchantability
+ and fitness. In no event shall the author be liable for any
+ special, indirect or consequential damages or any damages
+ whatsoever resulting from loss of use, data or profits, whether
+ in an action of contract, negligence or other tortious action,
+ arising out of or in connection with the use or performance of
+ this software.
+*/
+
+/** \file
+ *
+ * Header file for USBHostMode.c.
+ */
+
+#ifndef _USBHOSTMODE_H_
+#define _USBHOSTMODE_H_
+
+ /* Includes: */
+ #include <LUFA/Drivers/USB/Class/RNDIS.h>
+
+ #include "Webserver.h"
+ #include "Lib/uIPManagement.h"
+
+ /* External Variables: */
+ extern USB_ClassInfo_RNDIS_Host_t Ethernet_RNDIS_Interface;
+
+ /* Function Prototypes: */
+ void USBHostMode_USBTask(void);
+
+ void EVENT_USB_Host_HostError(const uint8_t ErrorCode);
+ void EVENT_USB_Host_DeviceAttached(void);
+ void EVENT_USB_Host_DeviceUnattached(void);
+ void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode);
+ void EVENT_USB_Host_DeviceEnumerationComplete(void);
+
+#endif
diff --git a/Projects/Webserver/Webserver.c b/Projects/Webserver/Webserver.c index ec1dabffb..47fd9c7e5 100644 --- a/Projects/Webserver/Webserver.c +++ b/Projects/Webserver/Webserver.c @@ -36,36 +36,6 @@ #include "Webserver.h"
-/** LUFA RNDIS Class driver interface configuration and state information. This structure is
- * passed to all RNDIS Class driver functions, so that multiple instances of the same class
- * within a device can be differentiated from one another.
- */
-USB_ClassInfo_RNDIS_Host_t Ethernet_RNDIS_Interface =
- {
- .Config =
- {
- .DataINPipeNumber = 1,
- .DataINPipeDoubleBank = false,
-
- .DataOUTPipeNumber = 2,
- .DataOUTPipeDoubleBank = false,
-
- .NotificationPipeNumber = 3,
- .NotificationPipeDoubleBank = false,
-
- .HostMaxPacketSize = UIP_CONF_BUFFER_SIZE,
- },
- };
-
-/** Connection timer, to retain the time elapsed since the last time the uIP connections were managed. */
-struct timer ConnectionTimer;
-
-/** ARP timer, to retain the time elapsed since the ARP cache was last updated. */
-struct timer ARPTimer;
-
-/** MAC address of the RNDIS device, when enumerated */
-struct uip_eth_addr MACAddress;
-
/** Main program entry point. This routine configures the hardware required by the application, then
* enters a loop to run the application tasks in sequence.
*/
@@ -77,177 +47,13 @@ int main(void) for (;;)
{
- switch (USB_HostState)
- {
- case HOST_STATE_Addressed:
- LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
-
- uint16_t ConfigDescriptorSize;
- uint8_t ConfigDescriptorData[512];
+ USBDeviceMode_USBTask();
+ USBHostMode_USBTask();
- if (USB_Host_GetDeviceConfigDescriptor(1, &ConfigDescriptorSize, ConfigDescriptorData,
- sizeof(ConfigDescriptorData)) != HOST_GETCONFIG_Successful)
- {
- LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
- USB_HostState = HOST_STATE_WaitForDeviceRemoval;
- break;
- }
-
- if (RNDIS_Host_ConfigurePipes(&Ethernet_RNDIS_Interface,
- ConfigDescriptorSize, ConfigDescriptorData) != RNDIS_ENUMERROR_NoError)
- {
- LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
- USB_HostState = HOST_STATE_WaitForDeviceRemoval;
- break;
- }
-
- if (USB_Host_SetDeviceConfiguration(1) != HOST_SENDCONTROL_Successful)
- {
- LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
- USB_HostState = HOST_STATE_WaitForDeviceRemoval;
- break;
- }
-
- if (RNDIS_Host_InitializeDevice(&Ethernet_RNDIS_Interface) != HOST_SENDCONTROL_Successful)
- {
- LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
- USB_HostState = HOST_STATE_WaitForDeviceRemoval;
- break;
- }
-
- uint32_t PacketFilter = (REMOTE_NDIS_PACKET_DIRECTED | REMOTE_NDIS_PACKET_BROADCAST);
- if (RNDIS_Host_SetRNDISProperty(&Ethernet_RNDIS_Interface, OID_GEN_CURRENT_PACKET_FILTER,
- &PacketFilter, sizeof(PacketFilter)) != HOST_SENDCONTROL_Successful)
- {
- LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
- USB_HostState = HOST_STATE_WaitForDeviceRemoval;
- break;
- }
-
- if (RNDIS_Host_QueryRNDISProperty(&Ethernet_RNDIS_Interface, OID_802_3_CURRENT_ADDRESS,
- &MACAddress, sizeof(MACAddress)) != HOST_SENDCONTROL_Successful)
- {
- LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
- USB_HostState = HOST_STATE_WaitForDeviceRemoval;
- break;
- }
-
- uip_setethaddr(MACAddress);
-
- LEDs_SetAllLEDs(LEDMASK_USB_READY);
- USB_HostState = HOST_STATE_Configured;
- break;
- case HOST_STATE_Configured:
- ProcessIncommingPacket();
- ManageConnections();
-
- break;
- }
-
- RNDIS_Host_USBTask(&Ethernet_RNDIS_Interface);
USB_USBTask();
}
}
-/** Processes incomming packets to the server from the connected RNDIS device, creating responses as needed. */
-void ProcessIncommingPacket(void)
-{
- if (RNDIS_Host_IsPacketReceived(&Ethernet_RNDIS_Interface))
- {
- LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
-
- /* Read the incomming packet straight into the UIP packet buffer */
- RNDIS_Host_ReadPacket(&Ethernet_RNDIS_Interface, &uip_buf[0], &uip_len);
-
- if (uip_len > 0)
- {
- bool PacketHandled = true;
-
- struct uip_eth_hdr* EthernetHeader = (struct uip_eth_hdr*)&uip_buf[0];
- if (EthernetHeader->type == HTONS(UIP_ETHTYPE_IP))
- {
- /* Filter packet by MAC destination */
- uip_arp_ipin();
-
- /* Process incomming packet */
- uip_input();
-
- /* Add destination MAC to outgoing packet */
- if (uip_len > 0)
- uip_arp_out();
- }
- else if (EthernetHeader->type == HTONS(UIP_ETHTYPE_ARP))
- {
- /* Process ARP packet */
- uip_arp_arpin();
- }
- else
- {
- PacketHandled = false;
- }
-
- /* If a response was generated, send it */
- if ((uip_len > 0) && PacketHandled)
- RNDIS_Host_SendPacket(&Ethernet_RNDIS_Interface, &uip_buf[0], uip_len);
- }
-
- LEDs_SetAllLEDs(LEDMASK_USB_READY);
- }
-}
-
-/** Manages the currently open network connections, including TCP and (if enabled) UDP. */
-void ManageConnections(void)
-{
- /* Manage open connections */
- if (timer_expired(&ConnectionTimer))
- {
- timer_reset(&ConnectionTimer);
-
- LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
-
- for (uint8_t i = 0; i < UIP_CONNS; i++)
- {
- /* Run periodic connection management for each TCP connection */
- uip_periodic(i);
-
- /* If a response was generated, send it */
- if (uip_len > 0)
- {
- /* Add destination MAC to outgoing packet */
- uip_arp_out();
-
- RNDIS_Host_SendPacket(&Ethernet_RNDIS_Interface, &uip_buf[0], uip_len);
- }
- }
-
- #if defined(ENABLE_DHCP)
- for (uint8_t i = 0; i < UIP_UDP_CONNS; i++)
- {
- /* Run periodic connection management for each UDP connection */
- uip_udp_periodic(i);
-
- /* If a response was generated, send it */
- if (uip_len > 0)
- {
- /* Add destination MAC to outgoing packet */
- uip_arp_out();
-
- RNDIS_Host_SendPacket(&Ethernet_RNDIS_Interface, &uip_buf[0], uip_len);
- }
- }
- #endif
-
- LEDs_SetAllLEDs(LEDMASK_USB_READY);
- }
-
- /* Manage ARP cache refreshing */
- if (timer_expired(&ARPTimer))
- {
- timer_reset(&ARPTimer);
- uip_arp_timer();
- }
-}
-
/** Configures the board hardware and chip peripherals for the demo's functionality. */
void SetupHardware(void)
{
@@ -259,71 +65,8 @@ void SetupHardware(void) clock_prescale_set(clock_div_1);
/* Hardware Initialization */
+ SPI_Init(SPI_SPEED_FCPU_DIV_2 | SPI_SCK_LEAD_FALLING | SPI_SAMPLE_TRAILING | SPI_MODE_MASTER);
+ Dataflash_Init();
LEDs_Init();
- USB_Init();
-
- /* uIP Timing Initialization */
- clock_init();
- timer_set(&ConnectionTimer, CLOCK_SECOND / 2);
- timer_set(&ARPTimer, CLOCK_SECOND * 10);
-
- /* uIP Stack Initialization */
- uip_init();
-
- /* DHCP/Server IP Settings Initialization */
- #if defined(ENABLE_DHCP)
- DHCPApp_Init();
- #else
- uip_ipaddr_t IPAddress, Netmask, GatewayIPAddress;
- uip_ipaddr(&IPAddress, DEVICE_IP_ADDRESS[0], DEVICE_IP_ADDRESS[1], DEVICE_IP_ADDRESS[2], DEVICE_IP_ADDRESS[3]);
- uip_ipaddr(&Netmask, DEVICE_NETMASK[0], DEVICE_NETMASK[1], DEVICE_NETMASK[2], DEVICE_NETMASK[3]);
- uip_ipaddr(&GatewayIPAddress, DEVICE_GATEWAY[0], DEVICE_GATEWAY[1], DEVICE_GATEWAY[2], DEVICE_GATEWAY[3]);
- uip_sethostaddr(&IPAddress);
- uip_setnetmask(&Netmask);
- uip_setdraddr(&GatewayIPAddress);
- #endif
-
- /* HTTP Webserver Initialization */
- WebserverApp_Init();
-}
-
-/** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
- * starts the library USB task to begin the enumeration and USB management process.
- */
-void EVENT_USB_Host_DeviceAttached(void)
-{
- LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
-}
-
-/** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
- * stops the library USB task management process.
- */
-void EVENT_USB_Host_DeviceUnattached(void)
-{
- LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
-}
-
-/** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
- * enumerated by the host and is now ready to be used by the application.
- */
-void EVENT_USB_Host_DeviceEnumerationComplete(void)
-{
- LEDs_SetAllLEDs(LEDMASK_USB_READY);
-}
-
-/** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
-void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
-{
- USB_ShutDown();
-
- LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
- for(;;);
-}
-
-/** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
- * enumerating an attached USB device.
- */
-void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode)
-{
- LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+ USB_Init(USB_MODE_UID);
}
diff --git a/Projects/Webserver/Webserver.h b/Projects/Webserver/Webserver.h index 13462a2a2..a9621e32f 100644 --- a/Projects/Webserver/Webserver.h +++ b/Projects/Webserver/Webserver.h @@ -44,28 +44,14 @@ #include <LUFA/Version.h>
#include <LUFA/Drivers/Board/LEDs.h>
+ #include <LUFA/Drivers/Board/Dataflash.h>
+ #include <LUFA/Drivers/Peripheral/SPI.h>
#include <LUFA/Drivers/USB/USB.h>
- #include <LUFA/Drivers/USB/Class/RNDIS.h>
- #include <uip.h>
- #include <uip_arp.h>
- #include <timer.h>
-
- #include "Lib/WebserverApp.h"
- #include "Lib/DHCPApp.h"
+ #include "USBDeviceMode.h"
+ #include "USBHostMode.h"
/* Macros: */
- /** IP address that the webserver should use once connected to a RNDIS device (when DHCP is disabled). */
- #define DEVICE_IP_ADDRESS (uint8_t[]){192, 168, 1, 10}
-
- /** Netmask that the webserver should once connected to a RNDIS device (when DHCP is disabled). */
- #define DEVICE_NETMASK (uint8_t[]){255, 255, 255, 0}
-
- /** IP address of the default gateway the webserver should use when routing outside the local subnet
- * (when DHCP is disabled).
- */
- #define DEVICE_GATEWAY (uint8_t[]){192, 168, 1, 1}
-
/** LED mask for the library LED driver, to indicate that the USB interface is not ready. */
#define LEDMASK_USB_NOTREADY LEDS_LED1
@@ -80,19 +66,8 @@ /** LED mask for the library LED driver, to indicate that the USB interface is busy. */
#define LEDMASK_USB_BUSY LEDS_LED2
-
- /* External Variables: */
- extern struct uip_eth_addr MACAddress;
-
+
/* Function Prototypes: */
void SetupHardware(void);
- void ProcessIncommingPacket(void);
- void ManageConnections(void);
-
- void EVENT_USB_Host_HostError(const uint8_t ErrorCode);
- void EVENT_USB_Host_DeviceAttached(void);
- void EVENT_USB_Host_DeviceUnattached(void);
- void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode);
- void EVENT_USB_Host_DeviceEnumerationComplete(void);
#endif
diff --git a/Projects/Webserver/Webserver.txt b/Projects/Webserver/Webserver.txt index e1d298596..e78cf5eff 100644 --- a/Projects/Webserver/Webserver.txt +++ b/Projects/Webserver/Webserver.txt @@ -41,16 +41,22 @@ *
* \section SSec_Description Project Description:
*
- * Simple HTTP webserver project. This project combines the LUFA library with the uIP TCP/IP full network stack, to create a
- * RNDIS host capable of serving out HTTP webpages to up to 10 hosts simultaneously. This project demonstrates how the two
- * libraries can be combined into a robust network enabled application, with the addition of a RNDIS network device.
+ * Simple HTTP webserver project. This project combines the LUFA library with the uIP TCP/IP full network stack and FatFS
+ * library to create a RNDIS host capable of serving out HTTP webpages to multiple hosts simultaneously. This project
+ * demonstrates how the libraries can be combined into a robust network enabled application, with the addition of a RNDIS
+ * network device.
*
- * To use this project, plug the USB AVR into a RNDIS class device, such as a USB (desktop) modem. If compatible, the project
- * will enumerate the device, set the appropriate parameters needed for connectivity and begin listening for new HTTP connections
- * on port 80. The device IP, netmask and default gateway IP must be set to values appropriate for the RNDIS device being used
- * for this project to work.
+ * To use this project, plug the USB AVR into a computer, so that it enumerates as a standard Mass Storage device. Load
+ * HTML files onto the disk, so that they can be served out to clients -- the default file to serve should be called
+ * <i>index.htm<i>. Filenames must be in 8.3 format for them to be retrieved correctly by the webserver.
+
+ * When attached to a RNDIS class device, such as a USB (desktop) modem. If compatible, the system will enumerate the
+ * device, set the appropriate parameters needed for connectivity and begin listening for new HTTP connections on port 80.
+ * The device IP, netmask and default gateway IP must be set to values appropriate for the RNDIS device being used for this
+ * project to work, if the DHCP client is disabled (see \ref SSec_Options).
*
- * When properly configured, the webserver can be accessed from any HTTP webrowser by typing in the device's IP address.
+ * When properly configured, the webserver can be accessed from any HTTP webrowser by typing in the device's static or
+ * dynamically allocated IP address.
*
* \section SSec_Options Project Options
*
@@ -69,17 +75,17 @@ * </tr>
* <tr>
* <td>DEVICE_IP_ADDRESS</td>
- * <td>Webserver.h</td>
+ * <td>Lib/uIPManagement.h</td>
* <td>IP address that the webserver should use when connected to a RNDIS device (when ENABLE_DHCP is not defined).</td>
* </tr>
* <tr>
* <td>DEVICE_NETMASK</td>
- * <td>Webserver.h</td>
+ * <td>Lib/uIPManagement.h</td>
* <td>Netmask that the webserver should use when connected to a RNDIS device (when ENABLE_DHCP is not defined).</td>
* </tr>
* <tr>
* <td>DEVICE_GATEWAY</td>
- * <td>Webserver.h</td>
+ * <td>Lib/uIPManagement.h</td>
* <td>Default routing gateway that the webserver should use when connected to a RNDIS device (when ENABLE_DHCP
* is not defined).</td>
* </tr>
diff --git a/Projects/Webserver/makefile b/Projects/Webserver/makefile index 4a1b85bdd..3c72ad875 100644 --- a/Projects/Webserver/makefile +++ b/Projects/Webserver/makefile @@ -116,14 +116,31 @@ LUFA_PATH = ../../ # LUFA library compile-time options
-LUFA_OPTS += -D USB_HOST_ONLY
-LUFA_OPTS += -D USE_STATIC_OPTIONS="(USB_OPT_REG_ENABLED | USB_OPT_AUTO_PLL)"
+LUFA_OPTS = -D FIXED_CONTROL_ENDPOINT_SIZE=8
+LUFA_OPTS += -D FIXED_NUM_CONFIGURATIONS=1
+LUFA_OPTS += -D USE_FLASH_DESCRIPTORS
+LUFA_OPTS += -D USE_STATIC_OPTIONS="(USB_DEVICE_OPT_FULLSPEED | USB_OPT_REG_ENABLED | USB_OPT_AUTO_PLL)"
# List C source files here. (C dependencies are automatically generated.)
SRC = $(TARGET).c \
+ Descriptors.c \
+ USBDeviceMode.c \
+ USBHostMode.c \
+ Lib/SCSI.c \
+ Lib/uIPManagement.c \
Lib/DHCPApp.c \
- Lib/WebserverApp.c \
+ Lib/HTTPServerApp.c \
+ Lib/DataflashManager.c \
+ Lib/uip/uip.c \
+ Lib/uip/uip_arp.c \
+ Lib/uip/uiplib.c \
+ Lib/uip/psock.c \
+ Lib/uip/timer.c \
+ Lib/uip/uip-neighbor.c \
+ Lib/uip/conf/clock-arch.c \
+ Lib/FatFS/diskio.c \
+ Lib/FatFS/ff.c \
$(LUFA_PATH)/LUFA/Drivers/USB/LowLevel/DevChapter9.c \
$(LUFA_PATH)/LUFA/Drivers/USB/LowLevel/Endpoint.c \
$(LUFA_PATH)/LUFA/Drivers/USB/LowLevel/Host.c \
@@ -134,17 +151,11 @@ SRC = $(TARGET).c \ $(LUFA_PATH)/LUFA/Drivers/USB/HighLevel/USBInterrupt.c \
$(LUFA_PATH)/LUFA/Drivers/USB/HighLevel/USBTask.c \
$(LUFA_PATH)/LUFA/Drivers/USB/HighLevel/ConfigDescriptor.c \
+ $(LUFA_PATH)/LUFA/Drivers/USB/Class/Device/MassStorage.c \
+ $(LUFA_PATH)/LUFA/Drivers/USB/Class/Host/MassStorage.c \
$(LUFA_PATH)/LUFA/Drivers/USB/Class/Device/RNDIS.c \
$(LUFA_PATH)/LUFA/Drivers/USB/Class/Host/RNDIS.c \
- Lib/uip/uip.c \
- Lib/uip/uip_arp.c \
- Lib/uip/uiplib.c \
- Lib/uip/psock.c \
- Lib/uip/timer.c \
- Lib/uip/uip-neighbor.c \
- Lib/uip/conf/clock-arch.c \
-
-
+
# List C++ source files here. (C dependencies are automatically generated.)
CPPSRC =
@@ -176,7 +187,7 @@ DEBUG = dwarf-2 # Each directory must be seperated by a space.
# Use forward slashes for directory separators.
# For a directory that has spaces, enclose it in quotes.
-EXTRAINCDIRS = $(LUFA_PATH)/ Lib/uip/ Lib/uip/conf/
+EXTRAINCDIRS = $(LUFA_PATH)/ Lib/uip/ Lib/uip/conf/ Lib/FatFS/
# Compiler flag to set the C Standard level.
|