Initial commit - WPinternals 2.6

Models/QualcommDownload.cs

@@ -0,0 +1,151 @@
+// Copyright (c) 2018, Rene Lergner - wpinternals.net - @Heathcliff74xda
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.IO;
+using System.Linq;
+
+namespace WPinternals
+{
+    internal class QualcommDownload
+    {
+        private QualcommSerial Serial;
+
+        public QualcommDownload(QualcommSerial Serial)
+        {
+            this.Serial = Serial;
+        }
+
+        public bool IsAlive()
+        {
+            try
+            {
+                Serial.SendCommand(new byte[] { 0x06 }, new byte[] { 0x02 });
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        public void SendToPhoneMemory(UInt32 Address, Stream Data, UInt32 Length = UInt32.MaxValue)
+        {
+            long Remaining;
+            if (Length > (Data.Length - Data.Position))
+                Remaining = Data.Length - Data.Position;
+            else
+                Remaining = Length;
+            UInt32 CurrentLength;
+            byte[] Buffer = new byte[0x107];
+            Buffer[0] = 0x0F;
+            System.Buffer.BlockCopy(BitConverter.GetBytes((UInt16)0x100).Reverse().ToArray(), 0, Buffer, 5, 2); // Length is in Big Endian
+            UInt32 CurrentAddress = Address;
+            while (Remaining > 0)
+            {
+                System.Buffer.BlockCopy(BitConverter.GetBytes(CurrentAddress).Reverse().ToArray(), 0, Buffer, 1, 4); // Address is in Big Endian
+
+                if (Remaining >= 0x100)
+                    CurrentLength = 0x100;
+                else
+                    CurrentLength = (UInt32)Remaining;
+                CurrentLength = (UInt32)(Data.Read(Buffer, 7, (int)CurrentLength));
+                Serial.SendCommand(Buffer, new byte[] { 0x02 });
+
+                CurrentAddress += CurrentLength;
+                Remaining -= CurrentLength;
+            }
+        }
+
+        public void SendToPhoneMemory(UInt32 Address, byte[] Data, UInt32 Offset = 0, UInt32 Length = UInt32.MaxValue)
+        {
+            long Remaining;
+            if (Offset > (Data.Length - 1))
+                throw new ArgumentException("Wrong offset");
+            if (Length > (Data.Length - Offset))
+                Remaining = Data.Length - Offset;
+            else
+                Remaining = Length;
+            UInt32 CurrentLength;
+            UInt32 CurrentOffset = Offset;
+            byte[] Buffer = new byte[0x107];
+            UInt32 CurrentAddress = Address;
+            byte[] CurrentBytes;
+            while (Remaining > 0)
+            {
+
+                if (Remaining >= 0x100)
+                {
+                    CurrentLength = 0x100;
+                    CurrentBytes = Buffer;
+                }
+                else
+                {
+                    CurrentLength = (UInt32)Remaining;
+                    CurrentBytes = new byte[CurrentLength + 7];
+                }
+                CurrentBytes[0] = 0x0F;
+                System.Buffer.BlockCopy(BitConverter.GetBytes(CurrentAddress).Reverse().ToArray(), 0, CurrentBytes, 1, 4); // Address is in Big Endian
+                System.Buffer.BlockCopy(BitConverter.GetBytes((UInt16)CurrentLength).Reverse().ToArray(), 0, CurrentBytes, 5, 2); // Length is in Big Endian
+                System.Buffer.BlockCopy(Data, (int)CurrentOffset, CurrentBytes, 7, (int)CurrentLength);
+
+                Serial.SendCommand(CurrentBytes, new byte[] { 0x02 });
+
+                CurrentAddress += CurrentLength;
+                CurrentOffset += CurrentLength;
+                Remaining -= CurrentLength;
+            }
+        }
+
+        public void StartBootloader(UInt32 Address)
+        {
+            byte[] Buffer = new byte[5];
+            Buffer[0] = 0x05;
+            System.Buffer.BlockCopy(BitConverter.GetBytes(Address).Reverse().ToArray(), 0, Buffer, 1, 4); // Address is in Big Endian
+            Serial.SendCommand(Buffer, new byte[] { 0x02 });
+        }
+
+        // Reset interface. Interface becomes unresponsive.
+        public void Reset()
+        {
+            Serial.SendCommand(new byte[] { 0x0A }, new byte[] { 0x02 });
+        }
+
+        // This also resets interface. This does not actually reboot the phone. The interface becomes unresponsive.
+        public void Shutdown()
+        {
+            Serial.SendCommand(new byte[] { 0x0E }, new byte[] { 0x02 });
+        }
+
+        // This command only works on 9008 interface.
+        public byte[] GetRKH()
+        {
+            byte[] Response = Serial.SendCommand(new byte[] { 0x18 }, new byte[] { 0x18, 0x01, 0x00 });
+            byte[] Result = new byte[0x20];
+            Buffer.BlockCopy(Response, 3, Result, 0, 0x20);
+            return Result;
+        }
+
+        public void CloseSerial()
+        {
+            Serial.Close();
+        }
+    }
+}