Exemple #1
0
        static void DOCSHELL_ExPrint(string msg)
        {
            Log.L.Out(msg);

            if (msg == "\n\n")
            {
                _currentAddrRd = 0;
                _currentAddrWr = 0;
                _currentDataRd = 0;
                _currentDataWr = 0;
                //_currenDataRd.Clear();
                //_currenDataWr.Clear();

                Log.L.Out("Отправляем в программатор команду на снятие питания с микросхемы.");
                var cmd = new CMD_PROG()
                {
                    Cmd = 1, ProgProcNum = 15
                };
                bool bRes = FrmMain._main.USB_Write(2, cmd);
                if (!bRes)
                {
                    return;
                }

                bRes = FrmMain._main.USB_ReadPipe(3);                   // _ev_USB_ReadPipe3.WaitOne( 5000 );
                if (!bRes)
                {
                    Log.L.OutError("Программатор не ответил на запрос.\n");
                }
                else
                {
                    Log.L.Out("--------------- END ---------------");
                }
            }
        }
Exemple #2
0
        bool SendProgStruc(ref Dictionary <int, PIN> pinsIC)
        {
            bool bRes = false;

            var progStruc = new PROG_STRUC();

            progStruc.NumOfPins = 140;

            for (int i = 0; i < 140; i++)
            {
                if (pinsIC.ContainsKey(i))
                {
                    progStruc.Pins[i] = pinsIC[i].PinType;
                }
            }

            var cmd = new CMD_PROG()
            {
                Cmd  = 11,
                Size = progStruc.StrucSize
            };

            Log.L.Out("Отправляем в программатор команду на прием от нас структуры PROG_STRUC.");
            bRes = USB_Write(2, cmd);
            if (!bRes)
            {
                return(bRes);
            }

            Log.L.Out("Отправляем в программатор структуру PROG_STRUC.");
            bRes = USB_Write(0, progStruc.Buf, progStruc.StrucSize);
            if (!bRes)
            {
                return(bRes);
            }

            bRes = USB_ReadPipe(3);               // _ev_USB_ReadPipe3.WaitOne( 5000 );
            if (!bRes)
            {
                Log.L.OutError("Программатор не ответил на запрос.\n");
                return(bRes);
            }

            if (!(_buf_USB_ReadPipe[0] == 3 && _buf_USB_ReadPipe[1] == 0))
            {
                Log.L.OutError("Программатор сообщил об ошибке \"" + _buf_USB_ReadPipe[0] + "\" при приеме структуры PROG_STRUC.\n");
                return(false);
            }

            if (bRes)
            {
                Log.L.In("Программатор подтвердил получение структуры PROG_STRUC.\n");
            }

            return(bRes);
        }
Exemple #3
0
        bool SendAlgoFile(string algoFile)
        {
            bool bRes = false;

            var cmd     = new CMD_PROG();
            var buf     = new byte[64];
            var algoBuf = new byte[0xFE00];

            // SRAM_T_1

            var algo    = File.ReadAllBytes(algoFile);
            int lenAlgo = algo.Length;

            cmd.Cmd         = 13;
            cmd.ProgProcNum = 0;
            cmd.BaseAddr    = 0x20000000;
            cmd.Size        = 0x2FA00;

            bRes = USB_Write(2, cmd);

            for (int i = 0; i < 3; i++)
            {
                if (lenAlgo > 0)
                {
                    int len = ((lenAlgo >= algoBuf.Length) ? (algoBuf.Length) : (lenAlgo));
                    Array.Copy(algo, i * 0xFE00, algoBuf, 0, len);
                    lenAlgo -= len;
                }

                bRes = USB_Write(0, algoBuf, 0xFE00);
                if (!bRes)
                {
                    return(false);
                }
            }

            if (bRes)
            {
                bRes = USB_Read(3, buf);
            }

            if (bRes && buf[0] != 3)
            {
                bRes = false;
            }

            return(bRes);
        }
Exemple #4
0
        static uint DOCSHELL_FLREAD_IO_WORD(uint addr)
        {
            bool bRes = false;

            var cmd = new CMD_PROG()
            {
                Cmd         = 1,
                ProgProcNum = 2,
                BaseAddr    = addr
            };

            //Log.L.Out( "Отправляем в программатор команду на чтение одного слова." );
            bRes = FrmMain._main.USB_Write(2, cmd);
            if (!bRes)
            {
                return(0);
            }

            bRes = FrmMain._main.USB_ReadPipe(3);               // _ev_USB_ReadPipe3.WaitOne( 5000 );
            if (!bRes)
            {
                Log.L.OutError("Программатор не ответил на запрос.\n");
                return(0);
            }

            uint wrd = (uint)(FrmMain._main._buf_USB_ReadPipe[2] + ((ushort)FrmMain._main._buf_USB_ReadPipe[3] << 8));

            if (_isDebug)
            {
                if ((_currentAddrRd != addr) || (_currentDataRd != (ushort)wrd))
                {
                    Log.L.In("[" + addr.ToString("X04") + "] -> " + wrd.ToString("X04"));
                }

                _currentAddrRd = addr;
                _currentDataRd = (ushort)wrd;

                _currentAddrWr = 0;
            }

            return(wrd);
        }
Exemple #5
0
        bool SendLoaderFile()
        {
            bool bRes = false;

            var cmd       = new CMD_PROG();
            var buf       = new byte[64];
            var loaderBuf = new byte[0xF800];

            // Сначала загружаем в программатор файл "\bin\loader.bin"
            //
            cmd.Cmd         = 13;
            cmd.ProgProcNum = 0;
            cmd.BaseAddr    = 0x20200000;
            cmd.Size        = 0xF800;

            bRes = USB_Write(2, cmd);
            if (!bRes)
            {
                return(bRes);
            }

            var loader = File.ReadAllBytes(@"c:\Program Files (x86)\SP6100\bin\loader.bin");

            Array.Copy(loader, loaderBuf, loader.Length);

            bRes = USB_Write(0, loaderBuf, 0xF800);
            if (bRes)
            {
                bRes = USB_Read(3, buf);
            }

            if (bRes && buf[0] != 3)
            {
                bRes = false;
            }

            return(bRes);
        }
Exemple #6
0
        bool IC_Read()
        {
            bool bRes = false;

            progBarOne.Value = 0;
            progBarOne.Step  = 1;

            progBarAll.Value = 0;
            progBarAll.Step  = 1;

            var cmd = new CMD_PROG()
            {
                Cmd         = 1,
                ProgProcNum = 0
            };

            Log.L.Out("Отправляем в программатор команду на чтение.");
            bRes = USB_Write(2, cmd);
            if (!bRes)
            {
                return(false);
            }

            int    bufPtr    = 0;
            uint   blockSize = 0;
            ushort blocks    = 0;
            ushort blockNum  = 0;

            do
            {
                progBarOne.Value = 0;

                bRes = USB_ReadPipe(3);                   // _ev_USB_ReadPipe3.WaitOne( 5000 );
                if (!bRes)
                {
                    Log.L.OutError("Программатор не ответил на запрос.\n");
                    return(false);
                }

                if (!(_buf_USB_ReadPipe[0] == 5 && _buf_USB_ReadPipe[1] == 0))
                {
                    Log.L.InError("Программатор прислал неизвестный запрос \"" + _buf_USB_ReadPipe[0] + "\".\n");
                    return(false);
                }

                blockNum  = (ushort)(_buf_USB_ReadPipe[2] + ((ushort)_buf_USB_ReadPipe[3] << 8));
                blocks    = (ushort)(_buf_USB_ReadPipe[4] + ((ushort)_buf_USB_ReadPipe[5] << 8));
                blockSize = (uint)(_buf_USB_ReadPipe[8] + ((uint)_buf_USB_ReadPipe[9] << 8) + ((uint)_buf_USB_ReadPipe[10] << 16) + ((uint)_buf_USB_ReadPipe[11] << 24));
                bufPtr    = 0;

                progBarAll.Maximum = blocks;
                progBarOne.Maximum = (int)blockSize;

                using (BinaryWriter bw = new BinaryWriter(File.Open(@"d:\9\SDED5_" + blockNum + ".bin", FileMode.Create, FileAccess.ReadWrite, FileShare.Read)))
                {
                    do
                    {
                        bRes = USB_ReadPipe(1);
                        if (!bRes)
                        {
                            Log.L.OutError("Программатор не прислал очередной блок данных.\n");
                            return(false);
                        }

                        progBarOne.PerformStep();

                        Application.DoEvents();

                        bw.Write(_buf_USB_ReadPipe);
                        bw.Flush();

                        bufPtr++;
                    }while(bufPtr < blockSize);
                }

                progBarAll.PerformStep();
            }while((blockNum + 1) < blocks);

            bRes = USB_ReadPipe(3);
            if (!bRes)
            {
                Log.L.OutError("Программатор не подтвердил передачу всего буфера чтения.\n");
                return(false);
            }

            Log.L.Out("Микросхема успешно прочитана.\n");

            return(bRes);
        }
Exemple #7
0
        private void txtBox2_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            int line    = txtBox2.GetLineFromCharIndex(txtBox2.SelectionStart);
            var cmdLine = txtBox2.Lines[line];

            bool bRes = false;

            do
            {
                // Проверяем тип адаптера
                //
                if (!CheckAdaptor("DX1011"))
                {
                    break;
                }

                // В зависимости от выбранной микросхемы, загружаем соответствующий алгоритм и прошивку для XILINX.
                //
                //if( !SendAlgo( @"c:\Program Files (x86)\SP6100\algo1\Sram_t_1_dec.usb" ) )
                //{
                //}

                // В зависимости от выбранной микросхемы, загружаем заполненную структуру.
                //
                if (!SendProgStruc(ref _pinsSDED5))
                {
                    break;
                }
                //Task.Factory.StartNew( () =>
                //{
                //	while( true )
                //	{
                //		Thread.Sleep( 200 );
                //		CheckInsertIC();
                //	}
                //} );

                if (!CheckInsertIC(ref _pinsSDED5))
                {
                    break;
                }

                Log.L.Out("Отправляем в программатор команду на подачу питания на микросхему.");
                var cmd = new CMD_PROG()
                {
                    Cmd = 1, ProgProcNum = 14
                };
                if (!FrmMain._main.USB_Write(2, cmd))
                {
                    break;
                }

                if (!FrmMain._main.USB_ReadPipe(3))
                {
                    Log.L.OutError("Программатор не ответил на запрос.\n");
                    break;
                }

                var start = txtBox.TextLength;
                txtBox.Select(start, 0);
                txtBox.Focus();

                DOCSHELL.Cmd(cmdLine);

                bRes = true;
            }while(false);

            if (!bRes)
            {
                var start = txtBox.TextLength;
                txtBox.Select(start, 0);
                txtBox.Focus();

                Log.L.Out("Отправляем в программатор команду на снятие питания с микросхемы.");
                var cmd = new CMD_PROG()
                {
                    Cmd = 1, ProgProcNum = 15
                };
                bRes = FrmMain._main.USB_Write(2, cmd);

                if (!FrmMain._main.USB_ReadPipe(3))
                {
                    Log.L.OutError("Программатор не ответил на запрос.\n");
                }
            }
        }
Exemple #8
0
        private void dINFOToolStripMenuItem_Click(object sender, EventArgs e)
        {
            bool bRes = false;

            do
            {
                // Проверяем тип адаптера
                //
                if (!CheckAdaptor("DX1011"))
                {
                    break;
                }

                // В зависимости от выбранной микросхемы, загружаем соответствующий алгоритм и прошивку для XILINX.
                //
                //if( !SendAlgo( @"c:\Program Files (x86)\SP6100\algo1\Sram_t_1_dec.usb" ) )
                //{
                //}

                // В зависимости от выбранной микросхемы, загружаем заполненную структуру.
                //
                if (!SendProgStruc(ref _pinsSDED5))
                {
                    break;
                }
                //Task.Factory.StartNew( () =>
                //{
                //	while( true )
                //	{
                //		Thread.Sleep( 200 );
                //		CheckInsertIC();
                //	}
                //} );

                if (!CheckInsertIC(ref _pinsSDED5))
                {
                    break;
                }

                Log.L.Out("Отправляем в программатор команду на подачу питания на микросхему.");
                var cmd = new CMD_PROG()
                {
                    Cmd = 1, ProgProcNum = 14
                };
                if (!FrmMain._main.USB_Write(2, cmd))
                {
                    break;
                }

                if (!FrmMain._main.USB_ReadPipe(3))
                {
                    Log.L.OutError("Программатор не ответил на запрос.\n");
                    break;
                }

                var start = txtBox.TextLength;
                txtBox.Select(start, 0);
                txtBox.Focus();

                //DOCSHELL.Cmd( "DIMAGE /WINSRC:00000 /FILETRG:sded5.img" );
                DOCSHELL.Cmd("DIMAGE /FILESRC:sded5_0_.img /WINTRG:0");
                //DOCSHELL.Cmd( "DFORMAT /WIN:00000 /BDKL0:512K /BDTLL0:1M /BDTLL1:1M /BDTLL2:1M /BDTLL3:1M" );
                //DOCSHELL.Cmd( "DFORMAT /WIN:00000 /UNFORMAT" );
                //DOCSHELL.Cmd( "DINFO /WIN:00000 /IPL" );
                //DOCSHELL.Cmd( "DINFO /WIN:00000 /BDTL" );
                //mainEntry( "" );

                bRes = true;
            }while(false);

            if (!bRes)
            {
                var start = txtBox.TextLength;
                txtBox.Select(start, 0);
                txtBox.Focus();

                Log.L.Out("Отправляем в программатор команду на снятие питания с микросхемы.");
                var cmd = new CMD_PROG()
                {
                    Cmd = 1, ProgProcNum = 15
                };
                bRes = FrmMain._main.USB_Write(2, cmd);

                if (!FrmMain._main.USB_ReadPipe(3))
                {
                    Log.L.OutError("Программатор не ответил на запрос.\n");
                }
            }
        }
Exemple #9
0
        static uint DOCSHELL_hal_blk_write_nor(uint addr, uint a2, uint a3, IntPtr pBuf, uint blocks, uint a6, uint a7)
        {
            bool bRes;

            _currentAddrRd = 0;
            _currentAddrWr = 0;

            byte[] buf      = new byte[512];
            byte[] bufWrite = new byte[512 * blocks];

            fixed(byte *pBufWrite = bufWrite)
            {
                System.Buffer.MemoryCopy(pBuf.ToPointer(), pBufWrite, 512 * blocks, 512 * blocks);
            }

            if (addr != 0x0800 || a2 != 0 || a3 != 0x1000 || a6 != 1 || a7 != 7)
            {
                addr = 0x0800;
            }

            if (_isDebug)
            {
                Log.L.Out("DOCSHELL_hal_blk_write_nor( " +
                          addr.ToString("X8") + ", " +
                          a2.ToString("X8") + ", " +
                          a3.ToString("X8") + ", " +
                          pBuf.ToInt32().ToString("X8") + ", " +
                          blocks.ToString("X8") + ", " +
                          a6.ToString("X8") + ", " +
                          a7.ToString("X8") +
                          " )");

                Log.L.Out(GetHex(bufWrite));
            }

            var cmd = new CMD_PROG()
            {
                Cmd         = 1,
                ProgProcNum = 3,
                BaseAddr    = addr,
                Size        = (int)blocks
            };

            bRes = FrmMain._main.USB_Write(2, cmd);
            if (!bRes)
            {
                return(0);
            }

            for (uint i = 0; i < blocks; i++)
            {
                Array.Copy(bufWrite, 512 * i, buf, 0, 512);

                bRes = FrmMain._main.USB_Write(0, buf, 512);
                if (!bRes)
                {
                    Log.L.OutError("Не удалось отправить в программатор очередной сектор.\n");
                    return(0);
                }
            }

            bRes = FrmMain._main.USB_ReadPipe(3);               // _ev_USB_ReadPipe3.WaitOne( 5000 );
            if (!bRes)
            {
                Log.L.OutError("Программатор не подтвердил прием сектора.\n");
                return(0);
            }

            return(0);
        }
Exemple #10
0
        static uint DOCSHELL_hal_blk_read_nor(uint addr, uint a2, uint a3, IntPtr pBuf, uint blocks, uint a6, uint a7)
        {
            bool bRes;

            _currentAddrRd = 0;
            _currentAddrWr = 0;

            byte[] bufRead = new byte[512 * blocks];

            if (addr != 0x0800 || a2 != 0 || a3 != 0x1000 || a6 != 1 || a7 != 7)
            {
                addr = 0x0800;
            }

            if (_isDebug)
            {
                Log.L.In("DOCSHELL_hal_blk_read_nor( " +
                         addr.ToString("X8") + ", " +
                         a2.ToString("X8") + ", " +
                         a3.ToString("X8") + ", " +
                         pBuf.ToInt32().ToString("X8") + ", " +
                         blocks.ToString("X8") + ", " +
                         a6.ToString("X8") + ", " +
                         a7.ToString("X8") +
                         " )");
            }

            var cmd = new CMD_PROG()
            {
                Cmd         = 1,
                ProgProcNum = 4,
                BaseAddr    = addr,
                Size        = (int)blocks
            };

            bRes = FrmMain._main.USB_Write(2, cmd);
            if (!bRes)
            {
                return(0);
            }

            for (uint i = 0; i < blocks; i++)
            {
                bRes = FrmMain._main.USB_ReadPipe(1);
                if (!bRes)
                {
                    Log.L.OutError("Программатор не прислал очередной блок данных.\n");
                    return(0);
                }

                Array.Copy(FrmMain._main._buf_USB_ReadPipe, 0, bufRead, 512 * i, 512);
            }

            bRes = FrmMain._main.USB_ReadPipe(3);               // _ev_USB_ReadPipe3.WaitOne( 5000 );
            if (!bRes)
            {
                Log.L.OutError("Программатор не подтвердил передачу сектора.\n");
                return(0);
            }

            fixed(byte *buf = bufRead)
            {
                IntPtr ptr = (IntPtr)buf;

                System.Buffer.MemoryCopy(ptr.ToPointer(), pBuf.ToPointer(), 512 * blocks, 512 * blocks);
            }

            if (_isDebug)
            {
                Log.L.In(GetHex(bufRead));
            }

            return(0);
        }
Exemple #11
0
        static void DOCSHELL_FLWRITE_IO_WORD(ushort wrd, uint addr)
        {
            bool bRes;

            if (addr == 0x080C && wrd == 0x00C0)
            {
            }

            string sAddr = addr.ToString("X04");
            string sWrd  = wrd.ToString("X04");

            // [080C] <- 0000
            // [080E] -> 0050
            //
            // [0804] <- 0000
            // [0806] <- 0000
            // [0808] <- 0000
            // [080A] <- 0000
            // [0802] <- DOCH_ADD_PARTITION
            // [080E] <- DOCH_VSCMD_PARTITION_MANAGEMENT

            if (addr == 0x80C)
            {
                Log.L.Out("");
            }

            if (_isDebug)
            {
                switch (addr)
                {
                case 0x802:
                case 0x804:
                case 0x806:
                case 0x808:
                case 0x80A:
                {
                    _lstAtaCmd.Add((ushort)addr, (byte)wrd);
                    _isNeedToPrint = false;
                }
                break;

                case 0x80E:
                {
                    _lstAtaCmd.Add((ushort)addr, (byte)wrd);
                    _isNeedToPrint = true;
                }
                break;

                default:
                {
                    if (_lstAtaCmd.Count > 0)
                    {
                        _isNeedToPrint = true;
                    }
                }
                break;
                }

                if (_lstAtaCmd.Count == 0)
                {
                    if ((_currentAddrWr != addr) || (_currentDataWr != (ushort)wrd))
                    {
                        Log.L.Out("[" + sAddr + "] <- " + sWrd);
                    }
                }
                else if (_isNeedToPrint)
                {
                    var sb = new StringBuilder();

                    foreach (var pair in _lstAtaCmd)
                    {
                        sb.Append("[" + pair.Key.ToString("X04") + "] <- ");

                        if (pair.Key == 0x802)
                        {
                            sWrd = pair.Value.ToString("X02");

                            switch (_lstAtaCmd[0x80E])
                            {
                            // I/O

                            // DOCH_VSCMD_READ_PARTITION = 0x82,
                            case 0x82:
                            {
                            }
                            break;

                            // DOCH_VSCMD_WRITE_PARTITION = 0x83,
                            case 0x83:
                            {
                            }
                            break;

                            // DOCH_VSCMD_WRITE_FLEXI = 0x84,
                            case 0x84:
                            {
                            }
                            break;

                            // Sectors Operations

                            // DOCH_VSCMD_OPTIMIZE_PARTITION_SECTORS = 0x86,
                            case 0x86:
                            {
                            }
                            break;

                            // DOCH_VSCMD_ERASE_PARTITION_SECTORS = 0x88,
                            case 0x88:
                            {
                            }
                            break;

                            // Hash

                            // DOCH_VSCMD_READ_CALCULATED_HASH = 0x8A,
                            case 0x8A:
                            {
                            }
                            break;

                            // DOCH_VSCMD_WRITE_CALCULATED_HASH = 0x8B,
                            case 0x8B:
                            {
                            }
                            break;

                            // DOCH_VSCMD_READ_ORIGINAL_HASH = 0x8C,
                            case 0x8C:
                            {
                            }
                            break;

                            // DOCH_VSCMD_WRITE_GIVEN_HASH = 0x8D,
                            case 0x8D:
                            {
                            }
                            break;

                            // Sub-commanded commands

                            // DOCH_VSCMD_PARTITION_MANAGEMENT = 0xFA,
                            case 0xFA:
                            {
                                sWrd = Enum.GetName(typeof(DOCH_PartitionManageOp), pair.Value);
                            }
                            break;

                            // DOCH_VSCMD_ACCESS_CONTROL = 0xFB,
                            case 0xFB:
                            {
                                sWrd = Enum.GetName(typeof(DOCH_AccessCtrlOp), pair.Value);
                            }
                            break;

                            // DOCH_VSCMD_EXT_DEVICE_CTRL = 0xFC,
                            case 0xFC:
                            {
                                sWrd = Enum.GetName(typeof(DOCH_DeviceCtrlOp), pair.Value);
                            }
                            break;

                            // DOCH_VSCMD_EXT_SECURITY_CTRL = 0xFD,
                            case 0xFD:
                            {
                            }
                            break;

                            // Supported standard ATA commands

                            //DOCH_CMD_IDENTIFY_DEV = 0xEC,
                            case 0xEC:
                            {
                            }
                            break;

                            //DOCH_DOWNLOAD_MICROCODE = 0x92
                            case 0x92:
                            {
                            }
                            break;
                            }

                            sb.Append(sWrd + "\n");
                        }
                        else if (pair.Key == 0x80E)
                        {
                            sb.Append(Enum.GetName(typeof(DOCH_Command), pair.Value));
                        }
                        else
                        {
                            sb.Append(pair.Value.ToString("X02") + "\n");
                        }
                    }

                    _lstAtaCmd.Clear();

                    Log.L.Out(sb.ToString());

                    _isNeedToPrint = false;
                }

                _currentAddrWr = addr;
                _currentDataWr = (ushort)wrd;

                _currentAddrRd = 0;
            }

            var cmd = new CMD_PROG()
            {
                Cmd         = 1,
                ProgProcNum = 1,
                BaseAddr    = addr,
                Size        = wrd
            };

            //Log.L.Out( "Отправляем в программатор команду на запись одного слова." );
            bRes = FrmMain._main.USB_Write(2, cmd);
            if (!bRes)
            {
                return;
            }

            bRes = FrmMain._main.USB_ReadPipe(3);               // _ev_USB_ReadPipe3.WaitOne( 5000 );
            if (!bRes)
            {
                Log.L.OutError("Программатор не ответил на запрос.\n");
            }
        }
Exemple #12
0
 internal bool USB_Write(int pipeNum, CMD_PROG cmd)
 {
     return(USB_Write(pipeNum, cmd.Buf, cmd.StrucSize));
 }