IMX6ull固件升级程序开发问题讨论

zgq2298673

SDP命令如上所示
关于SDP命令的使用，尤其是使用顺序，NXP的手册上并没有太多介绍，而且有个问题很棘手搞了两天了没搞定，hid report 2的读写问题，report 1,3,4使用时没有异常，只有在需要report2的场景，比如下载文件到指定地址和下载dcd表到指定地址时总是出现问题，我已经将这个问题汇报给微软，希望能得到一些帮助，毕竟这是一个hid系统库调用的问题，我不知道其他人是怎么解决这个问题，或者说没有遇到这个问题的。
当我使用串口而不是hid方式连接时，他就没有这个问题，dcd写入没有问题，文件写入时，写入imx文件会失去响应，写入bin文件时没问题。所以我觉得还是hid系统库的问题。
下面是我自己做的一个ui程序，主要将sdp命令的可视化：

在测试的时候发现很多问题，
读取寄存器命令可以读取内部的00920000这部分内存，这部分内存实际上是内部的可以自由使用的ram，但是，他不能读取020E0000这些地址，根据如下的内存映射表：

根据以上，020E0000地址应该是IOMUXC控制寄存器地址区，应该是可以访问的，但是我试图使用sdp指令读取这些地址时imx6ull就会失去响应，同样的，0209C000等这些地址，比如这个GPIO寄存器地址，读取就不会有问题。
还有一个就是，我成功的把dcd表写入到00920000，但是好像并没有运行啊？？？为啥？？当我使用跳转指令跳转到00920000地址运行时明显设备重启了，说明dcd表不能跳转运行，但是也没用一个指令是运行dcd表的指令啊，dcd表应该会配置ddr，我发送成功dcd表后依然无法访问87800000地址，也无法把程序复制到这个地址运行，往这个地址下载bin文件时imx6直接失去响应，啥情况？
各位，有开发过固件烧录工具的吗？讨论一下？多谢各位
如果要代码的话发一部分代码如下：

1. /// <summary>
   
2.         /// 读取一系列寄存器的值
   
3.         /// </summary>
   
4.         /// <param name="addr"></param>
   
5.         /// <param name="len"></param>
   
6.         /// <param name="format"></param>
   
7.         /// <returns></returns>
   
8.         public byte[] ReadReg(uint addr, int len, SDPCommend.AccessFormat format)
   
9.         {
   
10.             if (!IsOpened) throw new Exception("设备未打开，不能操作");
    
11.             var cmd = SDPCommend.CreateReadReg(addr, format, (uint)len);
    
12.             if (ComPort is not null)
    
13.             {//串口连接情况下
    
14.                 ComPort.ReadExisting();
    
15.                 ComPort.BaseStream.Flush();
    
16.                 ComPort.Write(cmd.SourceData, 1, cmd.SourceData.Length - 1);
    
17.                 var hab = new HABSecurity(4);
    
18.                 ReadDataOnCom(hab.SourceData, 1, 4);
    
19.                 using var ms = new MemoryStream();
    
20.                 for (int i = 0; i < len;)
    
21.                 {
    
22.                     var dt = new SDPResponseData(64);
    
23.                     var l = ComPort.Read(dt.SourceData, 1, len > 64 ? Math.Min(64, len - 64) : len);
    
24.                     ms.Write(dt.SourceData, 1, l);
    
25.                     i += l;
    
26.                 }
    
27.                 ms.Seek(0, SeekOrigin.Begin);
    
28.                 return ms.ToArray();
    
29.             }
    
30.             if (HidStream is not null)
    
31.             {
    
32.                 HidStream.Flush();
    
33.                 HidStream.Write(cmd.SourceData);
    
34.                 var hab = new HABSecurity(InputReportSize - 1);
    
35.                 HidStream.Read(hab.SourceData);
    
36.                 using var ms = new MemoryStream();
    
37.                 for (int i = 0; i < len;)
    
38.                 {
    
39.                     var dt = new SDPResponseData(InputReportSize - 1);
    
40.                     var l = HidStream.Read(dt.SourceData) - 1;
    
41.                     ms.Write(dt.SourceData, 1, l);
    
42.                     i += l;
    
43.                 }
    
44.                 ms.Seek(0, SeekOrigin.Begin);
    
45.                 return ms.ToArray();
    
46.             }
    
47.             //if (HidHandle is not null)
    
48.             //{
    
49.             //    var hidp = HidHandle.DangerousGetHandle();
    
50.             //    HID.HidD_FlushQueue(hidp);
    
51.             //    var pbuf = Marshal.AllocHGlobal(OutputReportLength);
    
52.             //    try
    
53.             //    {
    
54.             //        Marshal.Copy(cmd.SourceData, 0, pbuf, cmd.SourceData.Length);
    
55.             //        if (!HID.HidD_SetOutputReport(hidp, pbuf, OutputReportLength)) throw new IOException($"无法写入数据到HID:{Kernel32.GetLastError()}");
    
56.             //        var hab = new HABSecurity(InputReportLength - 1);
    
57.             //        Marshal.WriteByte(pbuf, hab.SourceData[0]);
    
58.             //        if (!HID.HidD_GetInputReport(hidp, pbuf, InputReportLength)) throw new IOException($"无法从HID读取数据:{Kernel32.GetLastError()}");
    
59.             //        hab.SourceData = Marshal.PtrToStructure<byte[]>(pbuf) ?? hab.SourceData;
    
60.             //        using var ms = new MemoryStream();
    
61.             //        for (int i = 0; i < len;)
    
62.             //        {
    
63.             //            var dt = new SDPResponseData(InputReportLength - 1);
    
64.             //            Marshal.WriteByte(pbuf, dt.SourceData[0]);
    
65.             //            if (!HID.HidD_GetInputReport(hidp, pbuf, InputReportLength)) throw new IOException($"无法从HID读取数据:{Kernel32.GetLastError()}");
    
66.             //            dt.SourceData = Marshal.PtrToStructure<byte[]>(pbuf) ?? hab.SourceData;
    
67.             //            ms.Write(dt.SourceData, 1, InputReportLength - 1);
    
68.             //            i += InputReportLength - 1;
    
69.             //        }
    
70.             //        ms.Seek(0, SeekOrigin.Begin);
    
71.             //        return ms.ToArray();
    
72.             //    }
    
73.             //    finally
    
74.             //    {
    
75.             //        Marshal.FreeHGlobal(pbuf);
    
76.             //    }
    
77.             //}
    
78.             return Array.Empty<byte>();
    
79.         }
    
80.         /// <summary>
    
81.         /// 写入一系列寄存器的值
    
82.         /// </summary>
    
83.         /// <param name="addr"></param>
    
84.         /// <param name="len"></param>
    
85.         /// <param name="format">写入寄存器数据的格式</param>
    
86.         /// <param name="data">所有寄存器只能写入同一个值</param>
    
87.         /// <returns></returns>
    
88.         public bool WriteReg(uint addr, int len, uint data, SDPCommend.AccessFormat format)
    
89.         {
    
90.             if (!IsOpened) throw new Exception("设备未打开，不能操作");
    
91.             var cmd = SDPCommend.CreateWriteReg(addr, format, (uint)len, data);
    
92.             if (ComPort is not null)
    
93.             {//串口连接情况下
    
94.                 ComPort.ReadExisting();
    
95.                 ComPort.BaseStream.Flush();
    
96.                 ComPort.Write(cmd.SourceData, 1, cmd.SourceData.Length - 1);
    
97.                 var hab = new HABSecurity(4);
    
98.                 ReadDataOnCom(hab.SourceData, 1, 4);
    
99.                 var dt = new SDPResponseData(4);
    
100.                 ReadDataOnCom(dt.SourceData, 1, 4);
     
101.                 return dt.IsWriteRegComplete;
     
102.             }
     
103.             if (HidStream is not null)
     
104.             {
     
105.                 HidStream.Flush();
     
106.                 HidStream.Write(cmd.SourceData);
     
107.                 var hab = new HABSecurity(InputReportSize - 1);
     
108.                 HidStream.Read(hab.SourceData);
     
109.                 var dt = new SDPResponseData(InputReportSize - 1);
     
110.                 HidStream.Read(dt.SourceData);
     
111.                 return dt.IsWriteRegComplete;
     
112.             }
     
113.             return false;
     
114.         }
     
115.         /// <summary>
     
116.         /// 写入镜像文件
     
117.         /// </summary>
     
118.         /// <param name="addr"></param>
     
119.         /// <param name="fp">本地文件地址</param>
     
120.         /// <param name="prog">进度条显示,0-100f</param>
     
121.         /// <returns></returns>
     
122.         public bool WriteFile(uint addr, string fp, Action<float>? prog = null)
     
123.         {
     
124.             if (!IsOpened) throw new Exception("设备未打开，不能操作");
     
125.             if (!System.IO.File.Exists(fp)) throw new Exception("文件不存在");
     
126.             if (ComPort is not null)
     
127.             {//串口连接情况下
     
128.                 using var fst = System.IO.File.OpenRead(fp);
     
129.                 var cmd = SDPCommend.CreateWriteFile(addr, (uint)fst.Length);
     
130.                 ComPort.ReadExisting();
     
131.                 ComPort.BaseStream.Flush();
     
132.                 ComPort.Write(cmd.SourceData, 1, cmd.SourceData.Length - 1);
     
133.                 var cmddt = new SDPCommendData(1024);
     
134.                 prog?.Invoke(0);
     
135.                 for (int i = 0; i < fst.Length;)
     
136.                 {
     
137.                     var l = fst.Read(cmddt.SourceData, 1, cmddt.SourceData.Length - 1);
     
138.                     ComPort.Write(cmddt.SourceData, 1, l);
     
139.                     i += l;
     
140.                     prog?.Invoke(i * 100f / fst.Length);
     
141.                 }
     
142.                 var hab = new HABSecurity(4);
     
143.                 ReadDataOnCom(hab.SourceData, 1, 4);
     
144.                 var dt = new SDPResponseData(4);
     
145.                 ReadDataOnCom(dt.SourceData, 1, 4);
     
146.                 return dt.IsWriteFileComplete;
     
147.             }
     
148.             if (HidStream is not null)
     
149.             {
     
150.                 HidStream.Flush();
     
151.                 using var fst = System.IO.File.OpenRead(fp);
     
152.                 var cmd = SDPCommend.CreateWriteFile(addr, (uint)fst.Length);
     
153.                 HidStream.Write(cmd.SourceData);
     
154.                 var cmddt = new SDPCommendData(OutputReportSize - 1);
     
155.                 prog?.Invoke(0);
     
156.                 for (int i = 0; i < fst.Length;)
     
157.                 {
     
158.                     var l = fst.Read(cmddt.SourceData, 1, OutputReportSize - 1);
     
159.                     HidStream.Write(cmddt.SourceData);
     
160.                     i += l;
     
161.                     prog?.Invoke(i * 100f / fst.Length);
     
162.                 }
     
163.                 var hab = new HABSecurity(InputReportSize - 1);
     
164.                 HidStream.Read(hab.SourceData);
     
165.                 var dt = new SDPResponseData(InputReportSize - 1);
     
166.                 HidStream.Read(dt.SourceData);
     
167.                 return dt.IsWriteFileComplete;
     
168.             }
     
169.             return false;
     
170.         }
     
171.         /// <summary>
     
172.         /// 获取设备的错误码
     
173.         /// </summary>
     
174.         /// <returns></returns>
     
175.         public int GetErrStatue()
     
176.         {
     
177.             if (!IsOpened) throw new Exception("设备未打开，不能操作");
     
178.             var cmd = SDPCommend.CreateErrorStatue();
     
179.             if (ComPort is not null)
     
180.             {//串口连接情况下
     
181.                 ComPort.ReadExisting();
     
182.                 ComPort.BaseStream.Flush();
     
183.                 ComPort.Write(cmd.SourceData, 1, cmd.SourceData.Length - 1);
     
184.                 var hab = new HABSecurity(4);
     
185.                 ReadDataOnCom(hab.SourceData, 1, 4);
     
186.                 var dt = new SDPResponseData(4);
     
187.                 ReadDataOnCom(dt.SourceData, 1, 4);
     
188.                 return dt.ResponseStatue;
     
189.             }
     
190.             if (HidStream is not null)
     
191.             {
     
192.                 HidStream.Flush();
     
193.                 HidStream.Write(cmd.SourceData);
     
194.                 var hab = new HABSecurity(InputReportSize - 1);
     
195.                 HidStream.Read(hab.SourceData);
     
196.                 var dt = new SDPResponseData(InputReportSize - 1);
     
197.                 HidStream.Read(dt.SourceData);
     
198.                 return dt.ResponseStatue;
     
199.             }
     
200.             return 0;
     
201.         }
     
202.         /// <summary>
     
203.         /// 写入Dcd数据
     
204.         /// </summary>
     
205.         /// <param name="addr"></param>
     
206.         /// <param name="dcdarray">本地文件地址</param>
     
207.         /// <returns></returns>
     
208.         public bool WriteDCD(uint addr, byte[] dcdarray)
     
209.         {
     
210.             if (!IsOpened) throw new Exception("设备未打开，不能操作");
     
211.             if (dcdarray.Length < 4 || dcdarray.Length > 1768) throw new Exception("dcd表过大或过小");
     
212.             if (ComPort is not null)
     
213.             {//串口连接情况下
     
214.                 ComPort.ReadExisting();
     
215.                 ComPort.BaseStream.Flush();
     
216.                 var cmd = SDPCommend.CreateDCDWrite(addr, (uint)dcdarray.Length);
     
217.                 ComPort.Write(cmd.SourceData, 1, cmd.SourceData.Length - 1);
     
218.                 var cmddt = new SDPCommendData(1024);
     
219.                 using var fst = new MemoryStream(dcdarray);
     
220.                 for (int i = 0; i < dcdarray.Length;)
     
221.                 {
     
222.                     var l = fst.Read(cmddt.SourceData, 1, cmddt.SourceData.Length - 1);
     
223.                     ComPort.Write(cmddt.SourceData, 1, l);
     
224.                     i += l;
     
225.                 }
     
226.                 var hab = new HABSecurity(4);
     
227.                 ReadDataOnCom(hab.SourceData, 1, 4);
     
228.                 var dt = new SDPResponseData(4);
     
229.                 ReadDataOnCom(dt.SourceData, 1, 4);
     
230.                 return dt.IsWriteDCDComplete || dt.IsWriteRegComplete;
     
231.             }
     
232.             if (HidStream is not null)
     
233.             {
     
234.                 HidStream.Flush();
     
235.                 var cmd = SDPCommend.CreateDCDWrite(addr, (uint)dcdarray.Length);
     
236.                 HidStream.Write(cmd.SourceData);
     
237.                 var cmddt = new SDPCommendData(OutputReportSize - 1);
     
238.                 using var fst = new MemoryStream(dcdarray);
     
239.                 for (int i = 0; i < dcdarray.Length;)
     
240.                 {
     
241.                     var l = fst.Read(cmddt.SourceData, 1, OutputReportSize - 1);
     
242.                     HidStream.Write(cmddt.SourceData);
     
243.                     i += l;
     
244.                 }
     
245.                 var hab = new HABSecurity(InputReportSize - 1);
     
246.                 HidStream.Read(hab.SourceData);
     
247.                 var dt = new SDPResponseData(InputReportSize - 1);
     
248.                 HidStream.Read(dt.SourceData);
     
249.                 return dt.IsWriteDCDComplete;
     
250.             }
     
251.             return false;
     
252.         }
     
253.         /// <summary>
     
254.         /// 跳过dcd命令
     
255.         /// </summary>
     
256.         /// <returns></returns>
     
257.         public bool SkipDCD()
     
258.         {
     
259.             if (!IsOpened) throw new Exception("设备未打开，不能操作");
     
260.             var cmd = SDPCommend.CreateSkipDCD();
     
261.             if (ComPort is not null)
     
262.             {//串口连接情况下
     
263.                 ComPort.ReadExisting();
     
264.                 ComPort.BaseStream.Flush();
     
265.                 ComPort.Write(cmd.SourceData, 1, cmd.SourceData.Length - 1);
     
266.                 var hab = new HABSecurity(4);
     
267.                 ReadDataOnCom(hab.SourceData, 1, 4);
     
268.                 var dt = new SDPResponseData(4);
     
269.                 ReadDataOnCom(dt.SourceData, 1, 4);
     
270.                 return dt.IsSkipDCDComplete;
     
271.             }
     
272.             if (HidStream is not null)
     
273.             {
     
274.                 HidStream.Flush();
     
275.                 HidStream.Write(cmd.SourceData);
     
276.                 var hab = new HABSecurity(InputReportSize - 1);
     
277.                 HidStream.Read(hab.SourceData);
     
278.                 var dt = new SDPResponseData(InputReportSize - 1);
     
279.                 HidStream.Read(dt.SourceData);
     
280.                 return dt.IsSkipDCDComplete;
     
281.             }
     
282.             return false;
     
283.         }
     
284.         /// <summary>
     
285.         /// 跳到指定的地址执行代码或者验证镜像文件
     
286.         /// </summary>
     
287.         /// <returns>返回错误码</returns>
     
288.         public int JumpTo(uint addr)
     
289.         {
     
290.             if (!IsOpened) throw new Exception("设备未打开，不能操作");
     
291.             var cmd = SDPCommend.CreateJumpAddress(addr);
     
292.             if (ComPort is not null)
     
293.             {//串口连接情况下
     
294.                 ComPort.ReadExisting();
     
295.                 ComPort.BaseStream.Flush();
     
296.                 ComPort.Write(cmd.SourceData, 1, cmd.SourceData.Length - 1);
     
297.                 var hab = new HABSecurity(4);
     
298.                 ReadDataOnCom(hab.SourceData, 1, 4);
     
299.                 var dt = new SDPResponseData(4);
     
300.                 ReadDataOnCom(dt.SourceData, 1, 4);
     
301.                 return dt.ResponseStatue;
     
302.             }
     
303.             if (HidStream is not null)
     
304.             {
     
305.                 HidStream.Flush();
     
306.                 HidStream.Write(cmd.SourceData);
     
307.                 var hab = new HABSecurity(InputReportSize - 1);
     
308.                 HidStream.Read(hab.SourceData);
     
309.                 var dt = new SDPResponseData(InputReportSize  - 1);
     
310.                 HidStream.Read(dt.SourceData);
     
311.                 return dt.ResponseStatue;
     
312.             }
     
313.             return 0;
     
314.         }

复制代码