Add DFU verification (#35)

***NO_CI***

Author: josesimoes

source/nanoFirmwareFlasher/Exceptions/DfuVerificationFailedException.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace nanoFramework.Tools.FirmwareFlasher
+{
+    /// <summary>
+    /// Verification of DFU write failed.
+    /// </summary>
+    [Serializable]
+    internal class DfuVerificationFailedException : Exception
+    {
+        public DfuVerificationFailedException()
+        {
+        }
+
+        public DfuVerificationFailedException(string message) : base(message)
+        {
+        }
+
+        public DfuVerificationFailedException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+
+        protected DfuVerificationFailedException(SerializationInfo info, StreamingContext context) : base(info, context)
+        {
+        }
+    }
+}

source/nanoFirmwareFlasher/StDfu.cs

@@ -345,6 +345,14 @@ internal static extern uint STDFU_Open(
             [MarshalAs(UnmanagedType.LPStr)]string szDevicePath,
             out IntPtr hDevice);
 
+        [DllImport(@"stdfu\STDFU.dll", EntryPoint = "STDFU_Upload", CharSet = CharSet.Ansi)]
+        internal static extern uint STDFU_Upload(
+            ref IntPtr hDevice,
+            [MarshalAs(UnmanagedType.LPArray)]byte[] pBuffer,
+            uint nBytes,
+            ushort nBlocks);
+
+
 
         #endregion
 
@@ -947,6 +955,36 @@ internal static void WriteBlock(
             }
         }
 
+        internal static void ReadBlock(
+            IntPtr hDevice,
+            uint address,
+            byte[] data,
+            uint blockNumber)
+        {
+            DfuStatus dfuStatus = new DfuStatus();
+
+            if (0 == blockNumber)
+            {
+                SetAddressPointer(hDevice, address);
+            }
+
+            STDFU_GetStatus(ref hDevice, ref dfuStatus);
+            while (dfuStatus.bState != STATE_DFU_IDLE)
+            {
+                STDFU_ClrStatus(ref hDevice);
+                STDFU_GetStatus(ref hDevice, ref dfuStatus);
+            }
+
+            STDFU_Upload(ref hDevice, data, (uint)data.Length, (ushort)(blockNumber + 2));
+
+            STDFU_GetStatus(ref hDevice, ref dfuStatus);
+            while (dfuStatus.bState != STATE_DFU_UPLOAD_IDLE)
+            {
+                STDFU_ClrStatus(ref hDevice);
+                STDFU_GetStatus(ref hDevice, ref dfuStatus);
+            }
+        }
+
         private static void SetAddressPointer(
             IntPtr hDevice,
             uint address)

source/nanoFirmwareFlasher/StmDfuDevice.cs

@@ -237,6 +237,7 @@ public void FlashDfuFile(string filePath)
                 Console.Write("Flashing device...");
             }
 
+            // write flash
             for (int elementIndex = 0; elementIndex < dfuTarget.DfuElements.Length; ++elementIndex)
             {
                 StDfu.DfuElement dfuElement = dfuTarget.DfuElements[elementIndex];
@@ -256,6 +257,44 @@ public void FlashDfuFile(string filePath)
                 Console.WriteLine(" OK");
             }
 
+            if (Verbosity >= VerbosityLevel.Normal)
+            {
+                Console.Write("Verifying flash...");
+            }
+
+            // read back for confirmation
+            for (int elementIndex = 0; elementIndex < dfuTarget.DfuElements.Length; ++elementIndex)
+            {
+                StDfu.DfuElement dfuElement = dfuTarget.DfuElements[elementIndex];
+
+                // read the data in MaxWriteBlockSize blocks
+                for (uint blockNumber = 0; blockNumber <= (uint)dfuElement.Data.Length / _maxWriteBlockSize; blockNumber++)
+                {
+                    byte[] readBuffer = new byte[_maxWriteBlockSize];
+                    StDfu.ReadBlock(_hDevice, dfuElement.Address, readBuffer, blockNumber);
+
+                    // get data for the current block
+                    byte[] buffer = dfuElement.Data.Skip((int)(_maxWriteBlockSize * blockNumber)).Take(_maxWriteBlockSize).ToArray();
+
+                    // exit condition has to be tied with the buffer length because the data for the last block 
+                    // can be shorter than the block max size
+                    for(int index = 0; index < buffer.Length; index++)
+                    {
+                        if(readBuffer[index] != buffer[index])
+                        {
+                            Console.WriteLine("");
+                            Console.WriteLine($"Error verifying flash write. Check failed for block address 0x{dfuElement.Address + blockNumber * _maxWriteBlockSize:X8}.");
+                            throw new DfuVerificationFailedException();
+                        }
+                    }
+                }
+            }
+
+            if (Verbosity >= VerbosityLevel.Normal)
+            {
+                Console.WriteLine(" OK");
+            }
+
             if (Verbosity >= VerbosityLevel.Normal)
             {
                 Console.Write("Launching nanoBooter...");