Spell check all source files once again to find any typos.

3 files changed, 63 insertions, 63 deletions

diff --git a/Demos/Device/ClassDriver/MassStorageKeyboard/Lib/DataflashManager.c b/Demos/Device/ClassDriver/MassStorageKeyboard/Lib/DataflashManager.c
index 00016b0a2..445082f24 100644
--- a/Demos/Device/ClassDriver/MassStorageKeyboard/Lib/DataflashManager.c
+++ b/Demos/Device/ClassDriver/MassStorageKeyboard/Lib/DataflashManager.c
@@ -30,7 +30,7 @@
 
 /** \file
  *
- *  Functions to manage the physical dataflash media, including reading and writing of
+ *  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.
@@ -39,9 +39,9 @@
 #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
+/** 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.
+ *  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
@@ -60,13 +60,13 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	/* 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 */
+	/* Send the Dataflash buffer write command */
 	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 	Dataflash_SendAddressBytes(0, CurrDFPageByte);
 
@@ -78,7 +78,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
 			/* Check if the endpoint is currently empty */
@@ -92,30 +92,30 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 				  return;
 			}
 
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Write the dataflash buffer contents back to the dataflash page */
+				/* 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 */
+				/* 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 */
+				/* 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 */
+				/* 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 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 */
+					/* 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);
@@ -123,12 +123,12 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 				}
 #endif
 
-				/* Send the dataflash buffer write command */
+				/* 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 */
+			/* 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());
@@ -146,7 +146,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 
 			/* Increment the block 16 byte block counter */
@@ -161,7 +161,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 		TotalBlocks--;
 	}
 
-	/* Write the dataflash buffer contents back to the dataflash page */
+	/* 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);
@@ -171,11 +171,11 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	if (!(Endpoint_IsReadWriteAllowed()))
 	  Endpoint_ClearOUT();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+/** 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.
  *
@@ -194,7 +194,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	/* Select the correct starting Dataflash IC for the block requested */
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
-	/* Send the dataflash main memory page read command */
+	/* Send the Dataflash main memory page read command */
 	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
 	Dataflash_SendByte(0x00);
@@ -210,7 +210,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
 			/* Check if the endpoint is currently full */
@@ -224,17 +224,17 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 				  return;
 			}
 			
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 				
-				/* Send the dataflash main memory page read command */
+				/* Send the Dataflash main memory page read command */
 				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 				Dataflash_SendByte(0x00);
@@ -243,7 +243,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 				Dataflash_SendByte(0x00);
 			}	
 
-			/* Read one 16-byte chunk of data from the dataflash */
+			/* 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());
@@ -261,7 +261,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 			
 			/* Increment the block 16 byte block counter */
@@ -280,14 +280,14 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	if (!(Endpoint_IsReadWriteAllowed()))
 	  Endpoint_ClearIN();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+/** 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.
+ *  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
@@ -306,13 +306,13 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	/* 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 */
+	/* Send the Dataflash buffer write command */
 	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 	Dataflash_SendAddressBytes(0, CurrDFPageByte);
 	
@@ -320,33 +320,33 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Write the dataflash buffer contents back to the dataflash page */
+				/* 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 */
+				/* 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 */
+				/* 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 */
+				/* 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 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 */
+					/* 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);
@@ -354,17 +354,17 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 				}
 #endif
 
-				/* Send the dataflash buffer write command */
+				/* 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 */
+			/* 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 */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 
 			/* Increment the block 16 byte block counter */
@@ -375,20 +375,20 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 		TotalBlocks--;
 	}
 
-	/* Write the dataflash buffer contents back to the dataflash page */
+	/* 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 */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+/** 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.
+ *  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
@@ -405,7 +405,7 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 	/* Select the correct starting Dataflash IC for the block requested */
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
-	/* Send the dataflash main memory page read command */
+	/* Send the Dataflash main memory page read command */
 	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
 	Dataflash_SendByte(0x00);
@@ -417,20 +417,20 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 				
-				/* Send the dataflash main memory page read command */
+				/* Send the Dataflash main memory page read command */
 				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 				Dataflash_SendByte(0x00);
@@ -439,11 +439,11 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 				Dataflash_SendByte(0x00);
 			}	
 
-			/* Read one 16-byte chunk of data from the dataflash */
+			/* 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 */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 			
 			/* Increment the block 16 byte block counter */
@@ -454,14 +454,14 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 		TotalBlocks--;
 	}
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Disables the dataflash memory write protection bits on the board Dataflash ICs, if enabled. */
+/** 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 */
+	/* Select first Dataflash chip, send the read status register command */
 	Dataflash_SelectChip(DATAFLASH_CHIP1);
 	Dataflash_SendByte(DF_CMD_GETSTATUS);
 	
@@ -477,7 +477,7 @@ void DataflashManager_ResetDataflashProtections(void)
 		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[3]);
 	}
 	
-	/* Select second dataflash chip (if present on selected board), send read status register command */
+	/* 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);
@@ -495,6 +495,6 @@ void DataflashManager_ResetDataflashProtections(void)
 	}
 	#endif
 	
-	/* Deselect current dataflash chip */
+	/* Deselect current Dataflash chip */
 	Dataflash_DeselectChip();
 }
diff --git a/Demos/Device/ClassDriver/MassStorageKeyboard/Lib/DataflashManager.h b/Demos/Device/ClassDriver/MassStorageKeyboard/Lib/DataflashManager.h
index f1f0ec734..694867f0e 100644
--- a/Demos/Device/ClassDriver/MassStorageKeyboard/Lib/DataflashManager.h
+++ b/Demos/Device/ClassDriver/MassStorageKeyboard/Lib/DataflashManager.h
@@ -52,7 +52,7 @@
 		#endif
 
 	/* Defines: */
-		/** Total number of bytes of the storage medium, comprised of one or more dataflash ICs. */
+		/** 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
diff --git a/Demos/Device/ClassDriver/MassStorageKeyboard/Lib/SCSI.c b/Demos/Device/ClassDriver/MassStorageKeyboard/Lib/SCSI.c
index c55af622d..0dac65090 100644
--- a/Demos/Device/ClassDriver/MassStorageKeyboard/Lib/SCSI.c
+++ b/Demos/Device/ClassDriver/MassStorageKeyboard/Lib/SCSI.c
@@ -292,7 +292,7 @@ static bool SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* const MSInte
 }
 
 /** 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
+ *  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