Example #1
0
        /// <summary>
        /// Main entry point of application
        /// </summary>
        /// <param name="args">Array of command-line arguments</param>
        /// <returns>Return code: 0 for correct exit, -1 for unexpected exit</returns>
        static Int32 Main(String[] args)
        {
            // Assumes that in AssemblyInfo.cs, the version is specified as 1.0.* or the like,
            // with only 2 numbers specified;  the next two are generated from the date.
            System.Version v = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;

            // v.Build is days since Jan. 1, 2000, v.Revision*2 is seconds since local midnight
            Int32 buildYear = new DateTime(v.Build * TimeSpan.TicksPerDay + v.Revision * TimeSpan.TicksPerSecond * 2).AddYears(1999).Year;

            // Begin main code
            //Console.Clear();
            Console.WriteLine("-----------------------------------------------------");
            Console.WriteLine("   TI EMIF2.x Hamming ECC Parity Generator for " + devString);
            Console.WriteLine("   (C) " + buildYear + ", Texas Instruments, Inc.");
            Console.WriteLine("   Ver. " + v.Major + "." + v.Minor.ToString("D2"));
            Console.WriteLine("-----------------------------------------------------");
            Console.Write("\n\n");

            // Parse the input command line parameters
            ProgramCmdParams cmdParams = ParseCmdLine(args);

            if (!cmdParams.valid)
            {
                DispHelp();
                return(-1);
            }

            // Create ECC object
            HammingECC h = new HammingECC(512);

            // Create binary writer for saving ECC data to output file
            BinaryWriter bw = new BinaryWriter(new FileStream(cmdParams.outputFileName, FileMode.Create, FileAccess.Write));

            // Read input data from file
            Byte[] fileData = FileIO.GetFileData(cmdParams.inputfileName);

            Byte[] subArray = new Byte[512];


            for (int i = 0; i < fileData.Length; i += 512)
            {
                for (int j = 0; j < 512; j++)
                {
                    subArray[j] = (Byte)(((i + j) >= fileData.Length) ? (0xFF) : fileData[i + j]);
                }

                // Calculate parity of the message data
                Int32 parity = h.GenerateParity(subArray);

                // Prep the parity data and output it to file
                if (cmdParams.verbose)
                {
                    Console.WriteLine("NAND operation #{0}", (i / 512) + 1);
                    Console.WriteLine("\tNANDFxECC = 0x{0:X8}", parity);
                }
                bw.Write(parity);
            }

            return(0);
        }
Example #2
0
        /// <summary>
        /// Main program.
        /// </summary>
        /// <param name="args">Input commandline arguments</param>
        /// <returns>Return code</returns>
        static Int32 Main(String[] args)
        {
            // Assumes that in AssemblyInfo.cs, the version is specified as 1.0.* or the like,
            // with only 2 numbers specified;  the next two are generated from the date.
            System.Version v = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;

            // v.Build is days since Jan. 1, 2000, v.Revision*2 is seconds since local midnight
            Int32 buildYear = new DateTime(v.Build * TimeSpan.TicksPerDay + v.Revision * TimeSpan.TicksPerSecond * 2).AddYears(1999).Year;

            // Begin main code
            Console.Clear();
            Console.WriteLine("-----------------------------------------------------");
            Console.WriteLine("   TI NOR AIS File Generator for " + devString);
            Console.WriteLine("   (C) " + buildYear + ", Texas Instruments, Inc.");
            Console.WriteLine("   Ver. " + v.Major + "." + v.Minor.ToString("D2"));
            Console.WriteLine("-----------------------------------------------------");
            Console.Write("\n\n");


            // Parse the input command line parameters
            ProgramCmdParams cmdParams = ParseCmdLine(args);

            if (!cmdParams.valid)
            {
                DispHelp();
                return(-1);
            }

            // Now proceed with main program
            FileStream tempAIS_fs = null;

            Byte[] AISData;

            // Create a new C642x AIS generator object
            AISGen_C642x generator = new AISGen_C642x();

            generator.CRCType = CRCCheckType.SECTION_CRC;

            // Do the AIS generation
            try
            {
                AISData    = AISGen.GenAIS(cmdParams.inputfileName, "emifa", generator);
                tempAIS_fs = new FileStream(cmdParams.outFileName, FileMode.Create, FileAccess.Write);
                tempAIS_fs.Write(AISData, 0, (int)AISData.Length);
                tempAIS_fs.Close();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.StackTrace);
                Console.WriteLine("Unhandled Exception!!! Application will now exit.");
                return(-1);
            }

            Console.WriteLine("AIS generation is complete.");
            return(0);
        }
Example #3
0
        /// <summary>
        /// Function to parse the command line
        /// </summary>
        /// <param name="args">Array of command-line arguments</param>
        /// <returns>Struct of the filled in program arguments</returns>
        static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams = new ProgramCmdParams();

            Boolean[] argsHandled = new Boolean[args.Length];

            UInt32 numUnhandledArgs, numHandledArgs = 0;
            String s;

            // Check for no argumnents
            if (args.Length == 0)
            {
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            // Set Defaults
            myCmdParams.valid         = true;
            myCmdParams.outFileName   = null;
            myCmdParams.iniFileName   = null;
            myCmdParams.inputfileName = null;
            myCmdParams.convType      = ConvType.COFF2Hex;

            // Initialize array of handled argument booleans to false
            for (int i = 0; i < argsHandled.Length; i++)
            {
                argsHandled[i] = false;
            }

            // For loop to check for all dash options
            for (int i = 0; i < args.Length; i++)
            {
                s = args[i];
                if (s.StartsWith("-"))
                {
                    switch (s.Substring(1).ToLower())
                    {
                    case "coff2hex":
                        myCmdParams.convType = ConvType.COFF2Hex;
                        break;

                    case "ais2hex":
                        myCmdParams.convType = ConvType.AIS2Hex;
                        break;

                    case "ini":
                        myCmdParams.iniFileName = args[i + 1];
                        argsHandled[i + 1]      = true;
                        numHandledArgs++;
                        break;

                    case "o":
                        myCmdParams.outFileName = args[i + 1];
                        argsHandled[i + 1]      = true;
                        numHandledArgs++;
                        break;

                    default:
                        myCmdParams.valid = false;
                        break;
                    }
                    argsHandled[i] = true;
                    numHandledArgs++;
                }
            }
            numUnhandledArgs = (UInt32)(args.Length - numHandledArgs);

            // Check to make sure we are still valid
            if ((!myCmdParams.valid) || (numUnhandledArgs != 1) || (argsHandled[args.Length - 1]))
            {
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            // Get input file
            FileInfo fi = new FileInfo(args[args.Length - 1]);

            if (fi.Exists)
            {
                //myCmdParams.inputfileName = fi.Name;
                myCmdParams.inputfileName = args[args.Length - 1];
                String extension = Path.GetExtension(fi.Name);
                if (myCmdParams.outFileName == null)
                {
                    myCmdParams.outFileName = Path.GetFileNameWithoutExtension(fi.Name) + ".hex";
                }
                if ((myCmdParams.convType == ConvType.COFF2Hex) &&
                    (!extension.Equals(".out", StringComparison.OrdinalIgnoreCase)))
                {
                    Console.WriteLine("Warning: Input filename does not have .out extension!");
                    Console.WriteLine("\tIt may not be a valid COFF file.");
                }

                if ((myCmdParams.convType == ConvType.AIS2Hex) &&
                    (!extension.Equals(".ais", StringComparison.OrdinalIgnoreCase)))
                {
                    Console.WriteLine("Warning: Input filename does not have .ais extension!");
                    Console.WriteLine("\tIt may not be a valid binary AIS file.");
                }
            }
            else
            {
                Console.WriteLine("File not found.");
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            return(myCmdParams);
        }
Example #4
0
        /// <summary>
        /// Function to parse the command line
        /// </summary>
        /// <param name="args">Array of command-line arguments</param>
        /// <returns>Struct of the filled in program arguments</returns>
        static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams = new ProgramCmdParams();

            Boolean[] argsHandled = new Boolean[args.Length];

            UInt32 numUnhandledArgs, numHandledArgs = 0;
            String s, defaultExtension;

            // Check for no argumnents
            if (args.Length == 0)
            {
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            // Set Defaults
            myCmdParams.valid         = true;
            myCmdParams.outFileName   = null;
            myCmdParams.iniFileName   = null;
            myCmdParams.inputfileName = null;
            myCmdParams.convType      = ConvType.Exec2Bin;
            defaultExtension          = ".bin";

            // Initialize array of handled argument booleans to false
            for (int i = 0; i < argsHandled.Length; i++)
            {
                argsHandled[i] = false;
            }

            // For loop to check for all dash options
            for (int i = 0; i < args.Length; i++)
            {
                s = args[i];
                if (s.StartsWith("-"))
                {
                    switch (s.Substring(1).ToLower())
                    {
                    case "otype":
                        String temp = args[i + 1];
                        if (temp.ToLower().Equals("binary"))
                        {
                            myCmdParams.convType = ConvType.Exec2Bin;
                            defaultExtension     = ".bin";
                        }
                        else if (temp.ToLower().Equals("carray"))
                        {
                            myCmdParams.convType = ConvType.Exec2CArray;
                            defaultExtension     = ".c";
                        }
                        else if (temp.ToLower().Equals("srecord"))
                        {
                            myCmdParams.convType = ConvType.Exec2Srec;
                            defaultExtension     = ".srec";
                        }
                        else if (temp.ToLower().Equals("text"))
                        {
                            myCmdParams.convType = ConvType.Exec2Text;
                            defaultExtension     = ".txt";
                        }
                        else
                        {
                            myCmdParams.valid = false;
                        }
                        argsHandled[i + 1] = true;
                        numHandledArgs++;
                        break;

                    case "ini":
                        myCmdParams.iniFileName = args[i + 1];
                        argsHandled[i + 1]      = true;
                        numHandledArgs++;
                        break;

                    case "o":
                        myCmdParams.outFileName = args[i + 1];
                        argsHandled[i + 1]      = true;
                        numHandledArgs++;
                        break;

                    default:
                        myCmdParams.valid = false;
                        break;
                    }
                    argsHandled[i] = true;
                    numHandledArgs++;
                }
            }
            numUnhandledArgs = (UInt32)(args.Length - numHandledArgs);

            // Check to make sure we are still valid
            if ((!myCmdParams.valid))
            {
                return(myCmdParams);
            }

            // Check to see if one last arg is still left - if so it is input object filename
            if ((numUnhandledArgs == 1) && (!argsHandled[args.Length - 1]))
            {
                // Get input file
                FileInfo fi = new FileInfo(args[args.Length - 1]);
                if (fi.Exists)
                {
                    myCmdParams.inputfileName = args[args.Length - 1];
                    String extension = Path.GetExtension(fi.Name);
                    if (myCmdParams.outFileName == null)
                    {
                        myCmdParams.outFileName = Path.GetFileNameWithoutExtension(fi.Name) + defaultExtension;
                    }
                }
            }

            if (myCmdParams.outFileName == null)
            {
                myCmdParams.outFileName = devString + "_boot_image.ais";
            }

            return(myCmdParams);
        }
Example #5
0
File: sfh.cs Project: sv99/DVSDK
        /// <summary>
        /// Parse the command line into the appropriate internal command structure
        /// </summary>
        /// <param name="args">The array of strings passed to the command line.</param>
        public static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams =  new ProgramCmdParams();
              Boolean[] argsHandled = new Boolean[args.Length];
              Int32 numFiles = -1;
              UInt32 numUnhandledArgs,numHandledArgs=0;
              String s;

              if (args.Length == 0)
              {
              myCmdParams.valid = false;
              return myCmdParams;
              }

              // Initialize array of handled argument booleans to false
              for (int i = 0; i < argsHandled.Length; i++ )
            argsHandled[i] = false;

              // Set Defualts for application
              myCmdParams.UBLFlashType = FlashType.NONE;

              myCmdParams.CMDMagicFlag = MagicFlags.MAGIC_NUMBER_INVALID;
              myCmdParams.valid = true;
              myCmdParams.verbose = false;
              myCmdParams.SerialPortName = null;
              myCmdParams.SerialPortBaudRate = 115200;

              myCmdParams.APPMagicFlag = MagicFlags.UBL_MAGIC_SAFE;
              myCmdParams.APPFileName = null;
              myCmdParams.APPLoadAddr = 0xFFFFFFFF;
              myCmdParams.APPStartAddr = 0xFFFFFFFF;

            #if   DM35X_STANDARD
              myCmdParams.UBLMagicFlag = MagicFlags.UBL_MAGIC_SAFE_DM35x_REVC;
            #else
              myCmdParams.UBLMagicFlag = MagicFlags.UBL_MAGIC_SAFE;
            #endif
              myCmdParams.UBLFileName = null;
              myCmdParams.UBLStartAddr = 0xFFFFFFFF;

              // For loop for required command type
              for(int i = 0; i<args.Length; i++)
              {
            s = args[i];
            if (s.StartsWith("-"))
            {
              switch (s.Substring(1).ToLower())
              {
            case "norflash":
              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_NOR_FLASH;
              else
                myCmdParams.valid = false;
              numFiles = 2;
              myCmdParams.UBLFlashType = FlashType.NOR;
              cmdString = "Flashing NOR with ";
              break;
            case "norflash_noubl":
              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_NOR_FLASH_NO_UBL;
              else
                myCmdParams.valid = false;
              numFiles = 1;
              myCmdParams.UBLFlashType = FlashType.NOR;
              cmdString = "Flashing NOR with ";
              break;
            case "sdflash":
              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_SDMMC_FLASH;
              else
                myCmdParams.valid = false;
              numFiles = 2;
              myCmdParams.UBLFlashType = FlashType.SD_MMC;
              cmdString = "Flashing SD/MMC with ";
              break;
            case "nandflash":
              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_NAND_FLASH;
              else
                myCmdParams.valid = false;
              numFiles = 2;
              myCmdParams.UBLFlashType = FlashType.NAND;
              cmdString = "Flashing NAND with ";
              break;
            case "norerase":
              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_NOR_ERASE;
              else
                myCmdParams.valid = false;
              numFiles = 0;
              myCmdParams.UBLFlashType = FlashType.NOR;
              cmdString = "Globally erasing NOR flash.";
              break;
            case "nanderase":
              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_NAND_ERASE;
              else
                myCmdParams.valid = false;
              numFiles = 0;
              myCmdParams.UBLFlashType = FlashType.NAND;
              cmdString = "Globally erasing NAND flash.";
              break;
            default:
              continue;
              }
              argsHandled[i] = true;
              numHandledArgs++;

              if (!myCmdParams.valid)
            return myCmdParams;
            }
              } // end of for loop for handling dash params

              // Check to make sure a command was selected
              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
              {
            myCmdParams.valid = false;
            return myCmdParams;
              }

              // For loop for all other dash options
              try
              {
            for(int i = 0; i<args.Length; i++)
            {
              s = args[i];
              if ((s.StartsWith("-")) && (argsHandled[i] != true))
              {
            switch (s.Substring(1).ToLower())
            {
              case "appstartaddr":
                if (args[i + 1].StartsWith("0x"))
                  args[i + 1] = args[i + 1].Substring(2);
                myCmdParams.APPStartAddr = System.UInt32.Parse(args[i + 1],System.Globalization.NumberStyles.AllowHexSpecifier);
                argsHandled[i + 1] = true;
                numHandledArgs++;
                break;
              case "apploadaddr":
                if (args[i + 1].StartsWith("0x"))
                  args[i + 1] = args[i + 1].Substring(2);
                myCmdParams.APPLoadAddr = System.UInt32.Parse(args[i + 1],System.Globalization.NumberStyles.AllowHexSpecifier);
                argsHandled[i + 1] = true;
                numHandledArgs++;
                break;
              case "ublstartaddr":
                if (args[i + 1].StartsWith("0x"))
                  args[i + 1] = args[i + 1].Substring(2);
                myCmdParams.UBLStartAddr = System.UInt32.Parse(args[i + 1],System.Globalization.NumberStyles.AllowHexSpecifier);
                argsHandled[i + 1] = true;
                numHandledArgs++;
                break;
              case "p":
                myCmdParams.SerialPortName = args[i + 1];
                argsHandled[i + 1] = true;
                numHandledArgs++;
                break;
              case "baud":
                myCmdParams.SerialPortBaudRate = System.Int32.Parse(args[i + 1]);
                argsHandled[i + 1] = true;
                numHandledArgs++;
                break;
              case "v":
                myCmdParams.verbose = true;
                break;
              default:
                myCmdParams.valid = false;
                break;
            }
            argsHandled[i] = true;
            numHandledArgs++;
            if (!myCmdParams.valid)
              return myCmdParams;
              }
            } // end of for loop for handling dash params
              }
              catch(Exception e)
              {
            Console.WriteLine(e.Message);
            myCmdParams.valid = false;
            return myCmdParams;
              }

              // Verify that the number of unhandled arguments is equal to numFiles
              // If not, then there is a problem.
              numUnhandledArgs = (UInt32) (args.Length - numHandledArgs);
              if (numUnhandledArgs != numFiles)
              {
            myCmdParams.valid = false;
            return myCmdParams;
              }

              // This for loop handles all othe params (namely filenames)
              for (int i = 0; i < args.Length; i++)
              {
            if (!argsHandled[i])
            {
              switch (numFiles)
              {
            case 1:
              if (myCmdParams.APPFileName == null)
              {
                myCmdParams.APPFileName = args[i];
                cmdString += myCmdParams.APPFileName + ".";
              }
              else
                myCmdParams.valid = false;
              break;
            case 2:
              if (myCmdParams.UBLFileName == null)
              {
                myCmdParams.UBLFileName = args[i];
                cmdString += myCmdParams.UBLFileName + " and ";
              }
              else if (myCmdParams.APPFileName == null)
              {
                myCmdParams.APPFileName = args[i];
                cmdString += myCmdParams.APPFileName + ".";
              }
              else
                myCmdParams.valid = false;
              break;
            default:
              myCmdParams.valid = false;
              break;
              }
            }
            argsHandled[i] = true;
            if (!myCmdParams.valid)
              return myCmdParams;
              } // end of for loop for handling dash params

              // Set default binary execution address on target device
              if (myCmdParams.APPLoadAddr == 0xFFFFFFFF)
            myCmdParams.APPLoadAddr = 0x81080000;

              if (myCmdParams.APPStartAddr == 0xFFFFFFFF)
            myCmdParams.APPStartAddr = 0x81080000;

              if (myCmdParams.UBLStartAddr == 0xFFFFFFFF)
            myCmdParams.UBLStartAddr = 0x00000100;

              //Setup default serial port name
              if (myCmdParams.SerialPortName == null)
              {
            int p = (int)Environment.OSVersion.Platform;
            if ((p == 4) || (p == 128)) //Check for unix/linux
            {
              Console.WriteLine("Platform is Unix/Linux.");
              myCmdParams.SerialPortName = "/dev/ttyS0";
            }
            else
            {
              Console.WriteLine("Platform is Windows.");
              myCmdParams.SerialPortName = "COM1";
            }
              }
            return myCmdParams;
        }
Example #6
0
        /// <summary>
        /// Parse the command line into the appropriate internal command structure
        /// </summary>
        /// <param name="args">The array of strings passed to the command line.</param>
        public static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams = new ProgramCmdParams();

            Boolean[] argsHandled = new Boolean[args.Length];
            Int32     numFiles = -1;
            UInt32    numUnhandledArgs, numHandledArgs = 0;
            String    s;

            if (args.Length == 0)
            {
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            // Initialize array of handled argument booleans to false
            for (int i = 0; i < argsHandled.Length; i++)
            {
                argsHandled[i] = false;
            }

            // Set Defualts for application
            myCmdParams.CMDMagicFlag   = MagicFlags.MAGIC_NUMBER_INVALID;
            myCmdParams.valid          = true;
            myCmdParams.verbose        = false;
            myCmdParams.SerialPortName = null;

            myCmdParams.APPFileName  = null;
            myCmdParams.APPLoadAddr  = 0xFFFFFFFF;
            myCmdParams.APPStartAddr = 0xFFFFFFFF;

            // For loop for required load type
            for (int i = 0; i < args.Length; i++)
            {
                s = args[i];
                if (s.StartsWith("-"))
                {
                    switch (s.Substring(1).ToLower())
                    {
                    case "load2iram":
                        if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                        {
                            myCmdParams.CMDMagicFlag = MagicFlags.SLT_MAGIC_LOADIMAGE_IRAM;
                        }
                        else
                        {
                            myCmdParams.valid = false;
                        }
                        myCmdParams.APPLoadAddr  = 0x0020;
                        myCmdParams.APPStartAddr = 0x0100;
                        numFiles  = 1;
                        cmdString = "Loading image to ARM IRAM ";
                        break;

                    case "load2ddr":
                        if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                        {
                            myCmdParams.CMDMagicFlag = MagicFlags.SLT_MAGIC_LOADIMAGE_DDR;
                        }
                        else
                        {
                            myCmdParams.valid = false;
                        }
                        myCmdParams.APPLoadAddr  = 0x80000000;
                        myCmdParams.APPStartAddr = 0x80000000;
                        numFiles  = 1;
                        cmdString = "Loading image to DDR";
                        break;

                    default:
                        continue;
                    }
                    argsHandled[i] = true;
                    numHandledArgs++;

                    if (!myCmdParams.valid)
                    {
                        return(myCmdParams);
                    }
                }
            }

            if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
            {
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            // For loop for all other dash options
            for (int i = 0; i < args.Length; i++)
            {
                s = args[i];
                if ((s.StartsWith("-")) && (argsHandled[i] != true))
                {
                    switch (s.Substring(1).ToLower())
                    {
                    case "startaddr":
                        if (args[i + 1].StartsWith("0x"))
                        {
                            args[i + 1] = args[i + 1].Substring(2);
                        }
                        myCmdParams.APPStartAddr = System.UInt32.Parse(args[i + 1], System.Globalization.NumberStyles.AllowHexSpecifier);
                        argsHandled[i + 1]       = true;
                        numHandledArgs++;
                        break;

                    case "loadaddr":
                        if (args[i + 1].StartsWith("0x"))
                        {
                            args[i + 1] = args[i + 1].Substring(2);
                        }
                        myCmdParams.APPLoadAddr = System.UInt32.Parse(args[i + 1], System.Globalization.NumberStyles.AllowHexSpecifier);
                        argsHandled[i + 1]      = true;
                        numHandledArgs++;
                        break;

                    case "p":
                        myCmdParams.SerialPortName = args[i + 1];
                        argsHandled[i + 1]         = true;
                        numHandledArgs++;
                        break;

                    case "v":
                        myCmdParams.verbose = true;
                        break;

                    default:
                        myCmdParams.valid = false;
                        break;
                    }
                    argsHandled[i] = true;
                    numHandledArgs++;
                    if (!myCmdParams.valid)
                    {
                        return(myCmdParams);
                    }
                }
            } // end of for loop for handling dash params

            // Verify that the number of unhandled arguments is equal to numFiles
            // If not, then there is a problem.
            numUnhandledArgs = (UInt32)(args.Length - numHandledArgs);
            if (numUnhandledArgs != numFiles)
            {
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            // This for loop handles all othe params (namely filenames)
            for (int i = 0; i < args.Length; i++)
            {
                if (!argsHandled[i])
                {
                    switch (numFiles)
                    {
                    case 1:
                        if (myCmdParams.APPFileName == null)
                        {
                            myCmdParams.APPFileName = args[i];
                        }
                        else
                        {
                            myCmdParams.valid = false;
                        }
                        break;

                    default:
                        myCmdParams.valid = false;
                        break;
                    }
                }
                argsHandled[i] = true;
                numHandledArgs++;
                if (!myCmdParams.valid)
                {
                    return(myCmdParams);
                }
            } // end of for loop handling file name inputs

            //Setup default serial port name
            if (myCmdParams.SerialPortName == null)
            {
                int p = (int)Environment.OSVersion.Platform;
                if ((p == 4) || (p == 128)) //Check for unix/linux
                {
                    Console.WriteLine("Platform is Unix/Linux.");
                    myCmdParams.SerialPortName = "/dev/ttyS0";
                }
                else
                {
                    Console.WriteLine("Platform is Windows.");
                    myCmdParams.SerialPortName = "COM1";
                }
            }
            return(myCmdParams);
        }
Example #7
0
File: HexAIS.cs Project: sv99/DVSDK
        /// <summary>
        /// Function to parse the command line
        /// </summary>
        /// <param name="args">Array of command-line arguments</param>
        /// <returns>Struct of the filled in program arguments</returns>
        static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams = new ProgramCmdParams();
              Boolean[] argsHandled = new Boolean[args.Length];

              UInt32 numUnhandledArgs, numHandledArgs = 0;
              String s;

              // Check for no argumnents
              if (args.Length == 0)
              {
              myCmdParams.valid = false;
              return myCmdParams;
              }

              // Set Defaults
              myCmdParams.valid = true;
              myCmdParams.outFileName = null;
              myCmdParams.iniFileName = null;
              myCmdParams.inputfileName = null;
              myCmdParams.convType = ConvType.COFF2Hex;

              // Initialize array of handled argument booleans to false
              for (int i = 0; i < argsHandled.Length; i++)
              argsHandled[i] = false;

              // For loop to check for all dash options
              for (int i = 0; i < args.Length; i++)
              {
              s = args[i];
              if (s.StartsWith("-"))
              {
                  switch (s.Substring(1).ToLower())
                  {
                      case "coff2hex":
                          myCmdParams.convType = ConvType.COFF2Hex;
                          break;
                      case "ais2hex":
                          myCmdParams.convType = ConvType.AIS2Hex;
                          break;
                      case "ini":
                          myCmdParams.iniFileName = args[i + 1];
                          argsHandled[i + 1] = true;
                          numHandledArgs++;
                          break;
                      case "o":
                          myCmdParams.outFileName = args[i + 1];
                          argsHandled[i + 1] = true;
                          numHandledArgs++;
                          break;
                      default:
                          myCmdParams.valid = false;
                          break;
                  }
                  argsHandled[i] = true;
                  numHandledArgs++;
              }
              }
              numUnhandledArgs = (UInt32)(args.Length - numHandledArgs);

              // Check to make sure we are still valid
              if ( (!myCmdParams.valid) || (numUnhandledArgs != 1) || (argsHandled[args.Length-1]))
              {
              myCmdParams.valid = false;
              return myCmdParams;
              }

              // Get input file
              FileInfo fi = new FileInfo(args[args.Length-1]);
              if (fi.Exists)
              {
              //myCmdParams.inputfileName = fi.Name;
              myCmdParams.inputfileName = args[args.Length - 1];
              String extension = Path.GetExtension(fi.Name);
              if (myCmdParams.outFileName == null)
              {
                  myCmdParams.outFileName = Path.GetFileNameWithoutExtension(fi.Name) + ".hex";
              }
              if ( (myCmdParams.convType == ConvType.COFF2Hex) &&
                   (!extension.Equals(".out",StringComparison.OrdinalIgnoreCase)) )
              {
                  Console.WriteLine("Warning: Input filename does not have .out extension!");
                  Console.WriteLine("\tIt may not be a valid COFF file.");
              }

              if ( (myCmdParams.convType == ConvType.AIS2Hex) &&
                   (!extension.Equals(".ais",StringComparison.OrdinalIgnoreCase)) )
              {
                  Console.WriteLine("Warning: Input filename does not have .ais extension!");
                  Console.WriteLine("\tIt may not be a valid binary AIS file.");
              }
              }
              else
              {
              Console.WriteLine("File not found.");
              myCmdParams.valid = false;
              return myCmdParams;
              }

              return myCmdParams;
        }
Example #8
0
        /// <summary>
        /// Parse the command line into the appropriate internal command structure
        /// </summary>
        /// <param name="args">The array of strings passed to the command line.</param>
        public static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams =  new ProgramCmdParams();
              Boolean[] argsHandled = new Boolean[args.Length];
              Int32 numFiles = -1;
              UInt32 numUnhandledArgs,numHandledArgs=0;
              String s;

              if (args.Length == 0)
              {
              myCmdParams.valid = false;
              return myCmdParams;
              }

              // Initialize array of handled argument booleans to false
              for (int i = 0; i < argsHandled.Length; i++ )
            argsHandled[i] = false;

              // Set Defualts for application
              myCmdParams.CMDMagicFlag = MagicFlags.MAGIC_NUMBER_INVALID;
              myCmdParams.valid = true;
              myCmdParams.verbose = false;
              myCmdParams.SerialPortName = null;

              myCmdParams.APPFileName = null;

              // For loop for required load type
              myCmdParams.CMDMagicFlag = MagicFlags.SLT_MAGIC_LOADIMAGE;
              numFiles = 1;

              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
              {
            myCmdParams.valid = false;
            return myCmdParams;
              }

              // For loop for all other dash options
              for(int i = 0; i<args.Length; i++)
              {
            s = args[i];
            if ((s.StartsWith("-")) && (argsHandled[i] != true))
            {
              switch (s.Substring(1).ToLower())
              {
            case "p":
              myCmdParams.SerialPortName = args[i + 1];
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            case "v":
              myCmdParams.verbose = true;
              break;
            case "waitfordevice":
              myCmdParams.waitForBOOTME = true;
              break;
            default:
              myCmdParams.valid = false;
              break;
              }
              argsHandled[i] = true;
              numHandledArgs++;
              if (!myCmdParams.valid)
            return myCmdParams;
            }
              } // end of for loop for handling dash params

              // Verify that the number of unhandled arguments is equal to numFiles
              // If not, then there is a problem.
              numUnhandledArgs = (UInt32) (args.Length - numHandledArgs);
              if (numUnhandledArgs != numFiles)
              {
            myCmdParams.valid = false;
            return myCmdParams;
              }

              // This for loop handles all other params (namely filenames)
              for (int i = 0; i < args.Length; i++)
              {
            if (!argsHandled[i])
            {
              switch (numFiles)
              {
            case 1:
              if (myCmdParams.APPFileName == null)
              {
                myCmdParams.APPFileName = args[i];
              }
              else
                myCmdParams.valid = false;
              break;
            default:
              myCmdParams.valid = false;
              break;
              }
            }
            argsHandled[i] = true;
            numHandledArgs++;
            if (!myCmdParams.valid) return myCmdParams;
              } // end of for loop handling file name inputs

              //Setup default serial port name
              if (myCmdParams.SerialPortName == null)
              {
            int p = (int)Environment.OSVersion.Platform;
            if ((p == 4) || (p == 128)) //Check for unix/linux
            {
              Console.WriteLine("Platform is Unix/Linux.");
              myCmdParams.SerialPortName = "/dev/ttyS0";
            }
            else
            {
              Console.WriteLine("Platform is Windows.");
              myCmdParams.SerialPortName = "COM1";
            }
              }
              return myCmdParams;
        }
Example #9
0
        /// <summary>
        /// Main program.
        /// </summary>
        /// <param name="args">Input commandline arguments</param>
        /// <returns>Return code</returns>
        static Int32 Main(String[] args)
        {
            IniFile myIniFile;

            // From Common/AIS/HexAIS_version.cs
            System.Version v = GetVersion();

            // From Common/AIS/HexAIS_version.cs
            Int32 buildYear = GetBuildYear();

            // Begin main code
            Console.WriteLine("-----------------------------------------------------");
            Console.WriteLine("   TI AIS Hex File Generator for " + devString);
            Console.WriteLine("   (C) " + buildYear + ", Texas Instruments, Inc.");
            Console.WriteLine("   Ver. " + v.Major + "." + v.Minor.ToString("D2"));
            Console.WriteLine("-----------------------------------------------------");
            Console.Write("\n\n");


            // Parse the input command line parameters
            ProgramCmdParams cmdParams = ParseCmdLine(args);

            if (!cmdParams.valid)
            {
                DispHelp();
                return(-1);
            }

            // Now proceed with main program
            FileStream tempAIS_fs = null;

            Byte[] AISData, convertedData;

            AISGen_OMAP_L137 generator = new AISGen_OMAP_L137();

            // Update the default INI file name to the one supplied on the command line
            if (cmdParams.iniFileName == null)
            {
                Console.WriteLine("No ini file provided. Using default, {0}", generator.DeviceNameShort + ".ini");
                cmdParams.iniFileName = generator.DeviceNameShort + ".ini";
            }

            // Read the INI data from file
            if (File.Exists(cmdParams.iniFileName))
            {
                myIniFile = new IniFile(new FileStream(cmdParams.iniFileName, FileMode.Open, FileAccess.Read), cmdParams.iniFileName);
            }
            else
            {
                Console.WriteLine("File {0} not found.", cmdParams.iniFileName);
                return(-1);
            }

            // Put entryPoint in General Ini section (may be overridden by INI InputFile sections)
            myIniFile.InsertValue("General", "EntryPoint", "0x" + cmdParams.entryPoint.ToString("X8"));

            // Force section-by-section CRC checks (may be overridden in INI file)
            generator.AISCRCType = AisCRCCheckType.SECTION_CRC;

            // Do the AIS generation
            try
            {
                AISData = AISGen.GenAIS(generator, cmdParams.inputFileName, myIniFile);
            }
            catch (Exception e)
            {
                System.Diagnostics.StackTrace trace = new System.Diagnostics.StackTrace(e, true);

                Console.WriteLine(e.StackTrace);
                Console.WriteLine(e.Message);
                Console.WriteLine("Unhandled Exception!!! Application will now exit.");
                return(-1);
            }

            // Check if SecureAISGen completed successfully
            if (AISData == null)
            {
                Console.WriteLine("AIS generation failed.");
                return(-1);
            }

            using (tempAIS_fs = new FileStream(cmdParams.outFileName, FileMode.Create, FileAccess.Write))
            {
                // Convert the AIS data to the correct output format
                switch (cmdParams.convType)
                {
                case ConvType.Exec2Bin:
                    tempAIS_fs.Write(AISData, 0, (int)AISData.Length);
                    Console.WriteLine("Wrote {0} bytes to file {1}.", AISData.Length, cmdParams.outFileName);
                    break;

                case ConvType.Exec2CArray:
                    convertedData = CArray.bin2CArray(cmdParams.cArrayName, AISData, 4);
                    tempAIS_fs.Write(convertedData, 0, (int)convertedData.Length);
                    Console.WriteLine("Wrote {0} bytes to file {1}.", convertedData.Length, cmdParams.outFileName);
                    break;

                case ConvType.Exec2Srec:
                    convertedData = SRecord.bin2srec(AISData, (UInt32)cmdParams.srecAddr, 32);
                    tempAIS_fs.Write(convertedData, 0, (int)convertedData.Length);
                    Console.WriteLine("Wrote {0} bytes to file {1}.", convertedData.Length, cmdParams.outFileName);
                    break;

                case ConvType.Exec2Text:
                    Console.WriteLine("Mode Not supported.");
                    break;
                }
            }

            Console.WriteLine("Conversion is complete.");
            return(0);
        }
Example #10
0
        /// <summary>
        /// Main program.
        /// </summary>
        /// <param name="args">Input commandline arguments</param>
        /// <returns>Return code</returns>
        static Int32 Main(String[] args)
        {
            // Assumes that in AssemblyInfo.cs, the version is specified as 1.0.* or the like,
            // with only 2 numbers specified;  the next two are generated from the date.
            System.Version v = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;

            // v.Build is days since Jan. 1, 2000, v.Revision*2 is seconds since local midnight
            Int32 buildYear = new DateTime(v.Build * TimeSpan.TicksPerDay + v.Revision * TimeSpan.TicksPerSecond * 2).AddYears(1999).Year;

            // Begin main code
            Console.Clear();
            Console.WriteLine("-----------------------------------------------------");
            Console.WriteLine("   TI AIS Hex File Generator for " + devString);
            Console.WriteLine("   (C) " + buildYear + ", Texas Instruments, Inc.");
            Console.WriteLine("   Ver. " + v.Major + "." + v.Minor.ToString("D2"));
            Console.WriteLine("-----------------------------------------------------");
            Console.Write("\n\n");


            // Parse the input command line parameters
            ProgramCmdParams cmdParams = ParseCmdLine(args);

            if (!cmdParams.valid)
            {
                DispHelp();
                return(-1);
            }

            // Now proceed with main program
            FileStream tempAIS_fs = null;

            Byte[] AISData, convertedData;

            AISGen_OMAP_L138 generator = new AISGen_OMAP_L138();

            // Update the default INI file name to the one supplied on the command line
            if (cmdParams.iniFileName == null)
            {
                cmdParams.iniFileName = generator.DeviceNameShort + ".ini";
            }

            // Read the INI data from file
            INISection[] iniSecs = INI.Parse(new FileStream(cmdParams.iniFileName, FileMode.Open, FileAccess.Read));

            // Force section-by-section CRC checks (may be overridden in INI file)
            generator.CRCType = CRCCheckType.SECTION_CRC;

            // Do the AIS generation
            try
            {
                AISData = AISGen.GenAIS(cmdParams.inputfileName, generator, iniSecs);
            }
            catch (Exception e)
            {
                System.Diagnostics.StackTrace trace = new System.Diagnostics.StackTrace(e, true);

                Console.WriteLine(e.StackTrace);
                Console.WriteLine("Unhandled Exception!!! Application will now exit.");
                return(-1);
            }

            tempAIS_fs = new FileStream(cmdParams.outFileName, FileMode.Create, FileAccess.Write);

            switch (cmdParams.convType)
            {
            case ConvType.Exec2Bin:
                tempAIS_fs.Write(AISData, 0, (int)AISData.Length);
                break;

            case ConvType.Exec2CArray:
                convertedData = CArray.bin2CArray(AISData, 4);
                tempAIS_fs.Write(convertedData, 0, (int)convertedData.Length);
                break;

            case ConvType.Exec2Srec:
                convertedData = SRecord.bin2srec(AISData, 0x60000000, 32);
                tempAIS_fs.Write(convertedData, 0, (int)convertedData.Length);
                break;

            case ConvType.Exec2Text:
                Console.WriteLine("Mode Not supported.");
                //Byte[] val = SRecord.bin2srec(aisData, 0x60000000, 32);
                break;
            }

            tempAIS_fs.Close();

            Console.WriteLine("Conversion is complete.");
            return(0);
        }
Example #11
0
        /// <summary>
        /// Function to parse the command line
        /// </summary>
        /// <param name="args">Array of command-line arguments</param>
        /// <returns>Struct of the filled in program arguments</returns>
        static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams = new ProgramCmdParams();

            Boolean[] argsHandled = new Boolean[args.Length];

            Int32  numUnhandledArgs, numHandledArgs = 0;
            String defaultExtension;

            // Set Defaults
            myCmdParams.valid         = true;
            myCmdParams.outFileName   = null;
            myCmdParams.iniFileName   = null;
            myCmdParams.inputFileName = null;
            myCmdParams.srecAddr      = 0xFFFFFFFF;
            myCmdParams.entryPoint    = 0xFFFFFFFF;
            myCmdParams.convType      = ConvType.Exec2Bin;
            defaultExtension          = ".bin";

            // Initialize array of handled argument booleans to false
            for (int i = 0; i < argsHandled.Length; i++)
            {
                argsHandled[i] = false;
            }

            // For loop to check for all dash options
            for (int i = 0; i < args.Length; i++)
            {
                if (args[i].StartsWith("-"))
                {
                    switch (args[i].Substring(1).ToLower())
                    {
                    case "entrypoint":
                    {
                        UInt32 temp;
                        if (args[i + 1].StartsWith("0x") || args[i + 1].StartsWith("0X"))
                        {
                            if (!UInt32.TryParse(args[i + 1].Replace("0x", ""), NumberStyles.HexNumber, null, out temp))
                            {
                                Console.WriteLine("WARNING: Invalid entrypoint address, {0}. Ignoring...", args[i + 1]);
                            }
                            else
                            {
                                myCmdParams.entryPoint = temp;
                            }
                        }
                        else if (UInt32.TryParse(args[i + 1], out temp))
                        {
                            myCmdParams.entryPoint = temp;
                        }
                        else
                        {
                            Console.WriteLine("WARNING: Invalid entrypoint address, {0}. Ignoring...", args[i + 1]);
                        }

                        argsHandled[i + 1] = true;
                        numHandledArgs++;
                        break;
                    }

                    case "otype":
                    {
                        // Handle possible srecord@addr, carray:name case
                        String[] otype = args[i + 1].Split(new Char [] { '@', ':' });

                        if (otype[0].ToLower().Equals("binary"))
                        {
                            myCmdParams.convType = ConvType.Exec2Bin;
                            defaultExtension     = ".bin";
                        }
                        else if (otype[0].ToLower().Equals("carray"))
                        {
                            myCmdParams.convType = ConvType.Exec2CArray;
                            defaultExtension     = ".c";
                            if (otype.Length == 1)
                            {
                                myCmdParams.cArrayName = "data_array";
                            }
                            else if (otype.Length == 2)
                            {
                                myCmdParams.cArrayName = otype[1];
                            }
                            else
                            {
                                myCmdParams.valid = false;
                            }
                        }
                        else if (otype[0].ToLower().Equals("text"))
                        {
                            myCmdParams.convType = ConvType.Exec2Text;
                            defaultExtension     = ".txt";
                        }
                        else if (otype[0].ToLower().Equals("srecord"))
                        {
                            if (otype.Length == 2)
                            {
                                UInt32 temp;
                                otype[1] = otype[1].ToLower();
                                if (otype[1].StartsWith("0x"))
                                {
                                    if (!UInt32.TryParse(otype[1].Replace("0x", ""), NumberStyles.HexNumber, null, out temp))
                                    {
                                        Console.WriteLine("ERROR: Invalid S-record address, {0}. Aborting...", otype[1]);
                                        myCmdParams.valid = false;
                                    }
                                    else
                                    {
                                        myCmdParams.srecAddr = temp;
                                    }
                                }
                                else if (UInt32.TryParse(otype[1], out temp))
                                {
                                    myCmdParams.srecAddr = temp;
                                }
                                else
                                {
                                    Console.WriteLine("ERROR: Invalid S-record address, {0}. Aborting...", otype[1]);
                                    myCmdParams.valid = false;
                                }
                                myCmdParams.convType = ConvType.Exec2Srec;
                                defaultExtension     = ".srec";
                            }
                            else
                            {
                                myCmdParams.valid = false;
                            }
                        }
                        else
                        {
                            myCmdParams.valid = false;
                        }
                        argsHandled[i + 1] = true;
                        numHandledArgs++;
                        break;
                    }

                    case "ini":
                    {
                        myCmdParams.iniFileName = args[i + 1];
                        argsHandled[i + 1]      = true;
                        numHandledArgs++;
                        break;
                    }

                    case "o":
                    {
                        myCmdParams.outFileName = args[i + 1];
                        argsHandled[i + 1]      = true;
                        numHandledArgs++;
                        break;
                    }

                    default:
                    {
                        myCmdParams.valid = false;
                        break;
                    }
                    }
                    argsHandled[i] = true;
                    numHandledArgs++;

                    // If we've seen any error, bug out
                    if (!myCmdParams.valid)
                    {
                        break;
                    }
                }
            }
            numUnhandledArgs = args.Length - numHandledArgs;

            // Check to make sure we are still valid
            if (!myCmdParams.valid)
            {
                return(myCmdParams);
            }

            // Get optional input files in order (all unhandled args, if any, are input files)
            if (numUnhandledArgs != 0)
            {
                myCmdParams.inputFileName = new List <String>(numUnhandledArgs);
            }
            for (int i = numUnhandledArgs; i > 0; i--)
            {
                String[] file = args[args.Length - i].Split('@');
                myCmdParams.inputFileName.Add(args[args.Length - i]);
            }

            // Set output filename to match input filename, if needed
            if (myCmdParams.outFileName == null)
            {
                if (myCmdParams.inputFileName != null)
                {
                    String lastFileName = ((String)myCmdParams.inputFileName[myCmdParams.inputFileName.Count - 1]).Split('@')[0];
                    myCmdParams.outFileName = Path.GetFileNameWithoutExtension(lastFileName) + defaultExtension;
                }
                else
                {
                    myCmdParams.outFileName = "ais_output" + defaultExtension;
                }
            }

            return(myCmdParams);
        }
Example #12
0
        /// <summary>
        /// Main program.
        /// </summary>
        /// <param name="args">Input commandline arguments</param>
        /// <returns>Return code: 0 for correct exit, -1 for unexpected exit</returns>
        static Int32 Main(String[] args)
        {
            // Assumes that in AssemblyInfo.cs, the version is specified as 1.0.* or the like,
            // with only 2 numbers specified;  the next two are generated from the date.
            System.Version v = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;

            // v.Build is days since Jan. 1, 2000, v.Revision*2 is seconds since local midnight
            Int32 buildYear = new DateTime(v.Build * TimeSpan.TicksPerDay + v.Revision * TimeSpan.TicksPerSecond * 2).AddYears(1999).Year;

            // Begin main code
            //Console.Clear();
            Console.WriteLine("-----------------------------------------------------");
            Console.WriteLine("   TI EMIF2.5 ECC Parity Generator for " + devString);
            Console.WriteLine("   (C) " + buildYear + ", Texas Instruments, Inc.");
            Console.WriteLine("   Ver. " + v.Major + "." + v.Minor.ToString("D2"));
            Console.WriteLine("-----------------------------------------------------");
            Console.Write("\n\n");

            // Parse the input command line parameters
            ProgramCmdParams cmdParams = ParseCmdLine(args);

            if (!cmdParams.valid)
            {
                DispHelp();
                return(-1);
            }

            // Create Reed Solomon ECC Object
            // Usage: ReedSolomonECC(Int32 msgSymbolCnt, Int32 maxCorrectibleErrorCnt, Byte symbolBitWidth)
            ReedSolomonECC rs = new ReedSolomonECC(512, 4, 10);

            // Create binary writer for saving ECC data to output file
            BinaryWriter bw = new BinaryWriter(new FileStream(cmdParams.outputFileName, FileMode.Create, FileAccess.Write));

            // Read input data from file
            Byte[] fileData = FileIO.GetFileData(cmdParams.inputfileName);

            Int32[] subArray = new Int32[512];
            Int32[] parityArray;

            for (int i = 0; i < fileData.Length; i += 512)
            {
                for (int j = 0; j < 512; j++)
                {
                    // Swap order of message data since this is apparently what the hardware does
                    // for its RS calculations
                    subArray[511 - j] = ((i + j) >= fileData.Length) ? (0xFF) : ((Int32)fileData[i + j]);
                }

                // Calculate parity of the message data
                parityArray = rs.GenerateParity(subArray);

                // Prep the parity data and output it to file
                if (cmdParams.verbose)
                {
                    Console.WriteLine("NAND operation #{0}", (i / 512) + 1);
                }
                for (int j = 0; j < 8; j += 2)
                {
                    if (cmdParams.verbose)
                    {
                        Console.WriteLine("\tNAND4BITECC{0} = {1:X8}", (j / 2 + 1), ((parityArray[j + 1] & 0x3FF) << 16) | (parityArray[j] & 0x3FF));
                    }
                    bw.Write(((parityArray[j + 1] & 0x3FF) << 16) | (parityArray[j] & 0x3FF));
                }
            }

            return(0);
        }
Example #13
0
        /// <summary>
        /// Function to parse the command line
        /// </summary>
        /// <param name="args">Array of command-line arguments</param>
        /// <returns>Struct of the filled in program arguments</returns>
        static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams = new ProgramCmdParams();
              Boolean[] argsHandled = new Boolean[args.Length];

              Int32 numUnhandledArgs, numHandledArgs = 0;
              String defaultExtension;

              // Set Defaults
              myCmdParams.valid = true;
              myCmdParams.outFileName = null;
              myCmdParams.iniFileName = null;
              myCmdParams.inputFileName = null;
              myCmdParams.srecAddr = 0xFFFFFFFF;
              myCmdParams.entryPoint = 0xFFFFFFFF;
              myCmdParams.convType = ConvType.Exec2Bin;
              defaultExtension = ".bin";

              // Initialize array of handled argument booleans to false
              for (int i = 0; i < argsHandled.Length; i++)
              {
            argsHandled[i] = false;
              }

              // For loop to check for all dash options
              for (int i = 0; i < args.Length; i++)
              {
            if (args[i].StartsWith("-"))
            {
              switch (args[i].Substring(1).ToLower())
              {
            case "entrypoint":
            {
              UInt32 temp;
              if (args[i + 1].StartsWith("0x") || args[i + 1].StartsWith("0X"))
              {
                if (!UInt32.TryParse(args[i + 1].Replace("0x", ""), NumberStyles.HexNumber, null, out temp))
                {
                  Console.WriteLine("WARNING: Invalid entrypoint address, {0}. Ignoring...", args[i + 1]);
                }
                else
                {
                  myCmdParams.entryPoint = temp;
                }
              }
              else if (UInt32.TryParse(args[i + 1], out temp))
              {
                myCmdParams.entryPoint = temp;
              }
              else
              {
                Console.WriteLine("WARNING: Invalid entrypoint address, {0}. Ignoring...", args[i + 1]);
              }

              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            }
            case "otype":
            {
              // Handle possible srecord@addr, carray:name case
              String[] otype = args[i + 1].Split(new Char [] {'@',':'});

              if (otype[0].ToLower().Equals("binary"))
              {
                myCmdParams.convType = ConvType.Exec2Bin;
                defaultExtension = ".bin";
              }
              else if (otype[0].ToLower().Equals("carray"))
              {
                myCmdParams.convType = ConvType.Exec2CArray;
                defaultExtension = ".c";
                if (otype.Length == 1)
                {
                  myCmdParams.cArrayName = "data_array";
                }
                else if (otype.Length == 2)
                {
                  myCmdParams.cArrayName = otype[1];
                }
                else
                {
                  myCmdParams.valid = false;
                }
              }
              else if (otype[0].ToLower().Equals("text"))
              {
                myCmdParams.convType = ConvType.Exec2Text;
                defaultExtension = ".txt";
              }
              else if (otype[0].ToLower().Equals("srecord"))
              {
                if (otype.Length == 2)
                {
                  UInt32 temp;
                  otype[1] = otype[1].ToLower();
                  if (otype[1].StartsWith("0x"))
                  {
                    if (!UInt32.TryParse(otype[1].Replace("0x", ""), NumberStyles.HexNumber, null, out temp))
                    {
                      Console.WriteLine("ERROR: Invalid S-record address, {0}. Aborting...", otype[1]);
                      myCmdParams.valid = false;
                    }
                    else
                    {
                      myCmdParams.srecAddr = temp;
                    }
                  }
                  else if (UInt32.TryParse(otype[1], out temp))
                  {
                    myCmdParams.srecAddr = temp;
                  }
                  else
                  {
                    Console.WriteLine("ERROR: Invalid S-record address, {0}. Aborting...", otype[1]);
                    myCmdParams.valid = false;
                  }
                  myCmdParams.convType = ConvType.Exec2Srec;
                  defaultExtension = ".srec";
                }
                else
                {
                  myCmdParams.valid = false;
                }
              }
              else
              {
                myCmdParams.valid = false;
              }
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            }
            case "ini":
            {
              myCmdParams.iniFileName = args[i + 1];
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            }
            case "o":
            {
              myCmdParams.outFileName = args[i + 1];
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            }
            default:
            {
              myCmdParams.valid = false;
              break;
            }
              }
              argsHandled[i] = true;
              numHandledArgs++;

              // If we've seen any error, bug out
              if (!myCmdParams.valid)
              {
            break;
              }
            }
              }
              numUnhandledArgs = args.Length - numHandledArgs;

              // Check to make sure we are still valid
              if (!myCmdParams.valid)
              {
            return myCmdParams;
              }

              // Get optional input files in order (all unhandled args, if any, are input files)
              if (numUnhandledArgs != 0)
              {
            myCmdParams.inputFileName = new List<String>(numUnhandledArgs);
              }
              for (int i=numUnhandledArgs; i>0; i--)
              {
            String[] file = args[args.Length-i].Split('@');
            myCmdParams.inputFileName.Add(args[args.Length-i]);
              }

              // Set output filename to match input filename, if needed
              if (myCmdParams.outFileName == null)
              {
            if  (myCmdParams.inputFileName != null)
            {
              String lastFileName = ((String) myCmdParams.inputFileName[myCmdParams.inputFileName.Count - 1]).Split('@')[0];
              myCmdParams.outFileName = Path.GetFileNameWithoutExtension(lastFileName) + defaultExtension;
            }
            else
            {
              myCmdParams.outFileName = "ais_output" + defaultExtension;
            }
              }

              return myCmdParams;
        }
Example #14
0
        /// <summary>
        /// Parse the command line into the appropriate internal command structure
        /// </summary>
        /// <param name="args">The array of strings passed to the command line.</param>
        public static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams =  new ProgramCmdParams();
              Boolean[] argsHandled = new Boolean[args.Length];
              Int32 numFiles = -1;
              UInt32 numUnhandledArgs,numHandledArgs=0;
              String s;

              if (args.Length == 0)
              {
              myCmdParams.valid = false;
              return myCmdParams;
              }

              // Initialize array of handled argument booleans to false
              for (int i = 0; i < argsHandled.Length; i++ )
            argsHandled[i] = false;

              // Set Defualts for parsing
              myCmdParams.CMDMagicFlag  = MagicFlags.MAGIC_NUMBER_INVALID;
              myCmdParams.valid         = true;
              myCmdParams.inFileName    = null;
              myCmdParams.outFileName   = null;
              myCmdParams.loadAddr      = 0xFFFFFFFF;
              myCmdParams.startAddr     = 0xFFFFFFFF;

              // For loop for required options
              for(int i = 0; i<args.Length; i++)
              {
            s = args[i];
            if (s.StartsWith("-"))
            {
              switch (s.Substring(1).ToLower())
              {
            case "pagesize":
              if (args[i + 1].StartsWith("0x"))
              {
                args[i + 1] = args[i + 1].Substring(2);
                myCmdParams.pageSize = System.UInt32.Parse(args[i + 1],System.Globalization.NumberStyles.AllowHexSpecifier);
              }
              else
              {
                myCmdParams.pageSize = System.UInt32.Parse(args[i + 1],System.Globalization.NumberStyles.Number);
              }
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            case "blocknum":
              if (args[i + 1].StartsWith("0x"))
              {
                args[i + 1] = args[i + 1].Substring(2);
                myCmdParams.blockNum = System.UInt32.Parse(args[i + 1],System.Globalization.NumberStyles.AllowHexSpecifier);
              }
              else
              {
                myCmdParams.blockNum = System.UInt32.Parse(args[i + 1],System.Globalization.NumberStyles.Number);
              }
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            default:
              continue;
              }
              argsHandled[i] = true;
              numHandledArgs++;

              if (!myCmdParams.valid)
            return myCmdParams;
            }
              }

              // Must have received pageSize, blockNum, and their values
              if (numHandledArgs != 4)
              {
            myCmdParams.valid = false;
            return myCmdParams;
              }

              // For loop for all other dash options
              for(int i = 0; i<args.Length; i++)
              {
            s = args[i];
            if ((s.StartsWith("-")) && (argsHandled[i] != true))
            {
              switch (s.Substring(1).ToLower())
              {
            case "uboot":
              myCmdParams.CMDMagicFlag = MagicFlags.MAGIC_NUMBER_UBOOT;
              myCmdParams.valid = true;
              break;
            case "startaddr":
              if (args[i + 1].StartsWith("0x"))
                args[i + 1] = args[i + 1].Substring(2);
              myCmdParams.startAddr = System.UInt32.Parse(args[i + 1],System.Globalization.NumberStyles.AllowHexSpecifier);
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            case "loadaddr":
              if (args[i + 1].StartsWith("0x"))
                args[i + 1] = args[i + 1].Substring(2);
              myCmdParams.loadAddr = System.UInt32.Parse(args[i + 1],System.Globalization.NumberStyles.AllowHexSpecifier);
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            case "o":
              myCmdParams.outFileName = args[i + 1];
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            default:
              myCmdParams.valid = false;
              break;
              }
              argsHandled[i] = true;
              numHandledArgs++;
              if (!myCmdParams.valid)
            return myCmdParams;
            }
              } // end of for loop for handling dash params

              // We should always expect 1 binary file for input
              numFiles = 1;

              // Verify that the number of unhandled arguments is equal to numFiles
              // If not, then there is a problem.
              numUnhandledArgs = (UInt32) (args.Length - numHandledArgs);
              if (numUnhandledArgs != numFiles)
              {
            myCmdParams.valid = false;
            return myCmdParams;
              }

              // This for loop handles all othe params (namely filenames)
              for (int i = 0; i < args.Length; i++)
              {
            if (!argsHandled[i])
            {
              switch (numFiles)
              {
            case 1:
              if (myCmdParams.inFileName == null)
              {
                myCmdParams.inFileName = args[i];
              }
              else
              {
                myCmdParams.valid = false;
              }
              break;
            default:
              myCmdParams.valid = false;
              break;
              }
            }
            argsHandled[i] = true;
            numHandledArgs++;
            if (!myCmdParams.valid) return myCmdParams;
              } // end of for loop handling file name inputs

              // default to UBL usage
              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
              myCmdParams.CMDMagicFlag = MagicFlags.MAGIC_NUMBER_UBL;

              // Set output file name to default
              if (myCmdParams.outFileName == null)
              {
            myCmdParams.outFileName =
              Path.GetFileNameWithoutExtension(myCmdParams.inFileName) + "_withNANDHeader" + Path.GetExtension(myCmdParams.inFileName);
              }

              // Set start and load addresses to default if not provided
              if (myCmdParams.startAddr == 0xFFFFFFFF)
              {
            if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_UBL)
              myCmdParams.startAddr = 0x00000100;
            else
              myCmdParams.startAddr = 0x81080000;
              }

              if (myCmdParams.loadAddr == 0xFFFFFFFF)
              {
            if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_UBL)
              myCmdParams.loadAddr = 0x00000020;  // Not used for UBL, but this is the value the RBL uses
            else
              myCmdParams.loadAddr = 0x81080000;
              }

              return myCmdParams;
        }
Example #15
0
        /// <summary>
        /// Parse the command line into the appropriate internal command structure
        /// </summary>
        /// <param name="args">The array of strings passed to the command line.</param>
        public static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams =  new ProgramCmdParams();
              Boolean[] argsHandled = new Boolean[args.Length];
              Int32 numFiles = -1;
              UInt32 numUnhandledArgs,numHandledArgs=0;
              String s;

              if (args.Length == 0)
              {
              myCmdParams.valid = false;
              return myCmdParams;
              }

              // Initialize array of handled argument booleans to false
              for (int i = 0; i < argsHandled.Length; i++ )
            argsHandled[i] = false;

              // Set Defualts for application
              myCmdParams.UBLFlashType = FlashType.NONE;

              myCmdParams.CMDMagicFlag = MagicFlags.MAGIC_NUMBER_INVALID;
              myCmdParams.valid = true;
              myCmdParams.verbose = false;
              myCmdParams.SerialPortName = null;
              myCmdParams.SerialPortBaudRate = 115200;

              myCmdParams.deviceType = null;
              myCmdParams.flashType = null;

              myCmdParams.APPMagicFlag = MagicFlags.UBL_MAGIC_BINARY_BOOT;
              myCmdParams.APPMagicFlagLeg = MagicFlags.UBL_MAGIC_BINARY_BOOT_LEG;
              myCmdParams.APPFileName = null;
              myCmdParams.APPLoadAddr = 0xFFFFFFFF;
              myCmdParams.APPStartAddr = 0xFFFFFFFF;
              myCmdParams.APPFlashAddr = 0xFFFFFFFF;
              myCmdParams.APPFlashBlock = 0xFFFFFFFF;

              myCmdParams.UBLMagicFlag = MagicFlags.UBL_MAGIC_BINARY_BOOT;
              myCmdParams.DSPUBLMagicFlag = MagicFlags.UBL_MAGIC_BINARY_BOOT;
              myCmdParams.ARMUBLMagicFlag = MagicFlags.UBL_MAGIC_BINARY_BOOT;

              myCmdParams.UBLFileName = null;
              myCmdParams.DSPUBLFileName = null;
              myCmdParams.ARMUBLFileName = null;

              myCmdParams.UBLStartAddr = 0xFFFFFFFF;

              // For loop for required command-line params
              for(int i = 0; i<args.Length; i++)
              {
            s = args[i];
            if (s.StartsWith("-"))
            {
              switch (s.Substring(1).ToLower())
              {
            case "flash":
              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
              {
                myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_FLASH;
              }
              else
              {
                myCmdParams.valid = false;
              }
              numFiles = 2;
              cmdString += "      [TYPE] UBL and application image\n";
              break;
            case "flash_noubl":
              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
              {
                myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_FLASH_NO_UBL;
              }
              else
              {
                myCmdParams.valid = false;
              }
              numFiles = 1;
              cmdString += "      [TYPE] Single boot image\n";
              break;
            case "flash_dsp":
              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
              {
                myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_FLASH_DSP;
              }
              else
              {
                myCmdParams.valid = false;
              }
              numFiles = 3;
              cmdString += "      [TYPE] DSP UBL, ARM UBL, and application image\n";
              break;
            case "erase":
              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
              {
                myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_ERASE;
              }
              else
              {
                myCmdParams.valid = false;
              }
              cmdString += "      [TYPE] Global erase\n";
              numFiles = 0;
              break;
            default:
              continue;
              }
              argsHandled[i] = true;
              numHandledArgs++;

              if (!myCmdParams.valid)
            return myCmdParams;
            }
              } // end of for loop for handling dash params

              // Check to make sure a command was selected
              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
              {
            myCmdParams.valid = false;
            return myCmdParams;
              }

              // For loop for optional command-line params
              try
              {
            for(int i = 0; i<args.Length; i++)
            {
              Int32 index;
              s = args[i];
              if ((s.StartsWith("-")) && (argsHandled[i] != true))
              {
            switch (s.Substring(1).ToLower())
            {
              case "targettype":
                index = Array.IndexOf<String>(deviceTypes,args[i + 1]);
                myCmdParams.deviceType = (index < 0)?deviceTypes[0]:deviceTypes[index];
                if (index < 0)
                {
                  Console.WriteLine("Target type not recongnized");
                  myCmdParams.valid = false;
                }
                argsHandled[i + 1] = true;
                numHandledArgs++;

                break;
              case "flashtype":
                index = Array.IndexOf<String>(flashTypes,args[i + 1]);
                myCmdParams.flashType = (index < 0)?flashTypes[0]:flashTypes[index];
                if (index < 0)
                {
                  Console.WriteLine("Flash type not recongnized, using default ({0}).",myCmdParams.flashType);
                }
                argsHandled[i + 1] = true;
                numHandledArgs++;
                break;
              case "appstartaddr":
                if (args[i + 1].StartsWith("0x"))
                  args[i + 1] = args[i + 1].Substring(2);
                myCmdParams.APPStartAddr = System.UInt32.Parse(args[i + 1],System.Globalization.NumberStyles.AllowHexSpecifier);
                argsHandled[i + 1] = true;
                numHandledArgs++;
                break;
              case "apploadaddr":
                if (args[i + 1].StartsWith("0x"))
                  args[i + 1] = args[i + 1].Substring(2);
                myCmdParams.APPLoadAddr = System.UInt32.Parse(args[i + 1],System.Globalization.NumberStyles.AllowHexSpecifier);
                argsHandled[i + 1] = true;
                numHandledArgs++;
                break;
              case "appflashblock":
                if (args[i + 1].StartsWith("0x"))
                  args[i + 1] = args[i + 1].Substring(2);
                myCmdParams.APPFlashBlock = System.UInt32.Parse(args[i + 1]);
                argsHandled[i + 1] = true;
                numHandledArgs++;
                break;
              case "ublstartaddr":
                if (args[i + 1].StartsWith("0x"))
                  args[i + 1] = args[i + 1].Substring(2);
                myCmdParams.UBLStartAddr = System.UInt32.Parse(args[i + 1],System.Globalization.NumberStyles.AllowHexSpecifier);
                argsHandled[i + 1] = true;
                numHandledArgs++;
                break;
              case "p":
                myCmdParams.SerialPortName = args[i + 1];
                argsHandled[i + 1] = true;
                numHandledArgs++;
                break;
              case "baud":
                myCmdParams.SerialPortBaudRate = System.Int32.Parse(args[i + 1]);
                argsHandled[i + 1] = true;
                numHandledArgs++;
                break;
              case "v":
                myCmdParams.verbose = true;
                break;
              default:
                myCmdParams.valid = false;
                break;
            }
            argsHandled[i] = true;
            numHandledArgs++;
            if (!myCmdParams.valid)
              return myCmdParams;
              }
            } // end of for loop for handling dash params
              }
              catch(Exception e)
              {
            Console.WriteLine(e.Message);
            myCmdParams.valid = false;
            return myCmdParams;
              }

              // Verify that the number of unhandled arguments is equal to numFiles
              // If not, then there is a problem.
              numUnhandledArgs = (UInt32) (args.Length - numHandledArgs);
              if (numUnhandledArgs != numFiles)
              {
            myCmdParams.valid = false;
            return myCmdParams;
              }

              // This for loop handles all othe params (namely filenames)
              for (int i = 0; i < args.Length; i++)
              {
            if (!argsHandled[i])
            {
              switch (numFiles)
              {
            case 1:
              if (myCmdParams.APPFileName == null)
              {
                myCmdParams.APPFileName = args[i];
                cmdString += "[BOOT IMAGE] " + myCmdParams.APPFileName + "\n" ;
              }
              else
                myCmdParams.valid = false;
              break;
            case 2:
              if (myCmdParams.UBLFileName == null)
              {
                myCmdParams.UBLFileName = args[i];
                cmdString += "       [UBL] "+ myCmdParams.UBLFileName + "\n";
              }
              else if (myCmdParams.APPFileName == null)
              {
                myCmdParams.APPFileName = args[i];
                cmdString += " [APP IMAGE] " + myCmdParams.APPFileName + "\n";
              }
              else
                myCmdParams.valid = false;
              break;
            case 3:
              if (myCmdParams.DSPUBLFileName == null)
              {
                myCmdParams.DSPUBLFileName = args[i];
                cmdString += "   [DSP UBL] "+ myCmdParams.DSPUBLFileName + "\n";
              }
              else if (myCmdParams.ARMUBLFileName == null)
              {
                myCmdParams.ARMUBLFileName = args[i];
                cmdString += "   [ARM UBL] "+ myCmdParams.ARMUBLFileName + "\n";
              }
              else if (myCmdParams.APPFileName == null)
              {
                myCmdParams.APPFileName = args[i];
                cmdString += " [APP IMAGE] " + myCmdParams.APPFileName + "\n";
              }
              else
                myCmdParams.valid = false;
              break;

            default:
              myCmdParams.valid = false;
              break;
              }
            }
            argsHandled[i] = true;
            if (!myCmdParams.valid)
              return myCmdParams;
              } // end of for loop for handling dash params

              // Set default binary execution address on target device
              if (myCmdParams.APPLoadAddr == 0xFFFFFFFF)
              {
            myCmdParams.APPLoadAddr = externalRAMStart + 0x01080000;
              }

              if (myCmdParams.APPStartAddr == 0xFFFFFFFF)
              {
            myCmdParams.APPStartAddr = externalRAMStart + 0x01080000;
              }

              if (myCmdParams.UBLStartAddr == 0xFFFFFFFF)
            myCmdParams.UBLStartAddr = 0x00000100;

              myCmdParams.ARMUBLStartAddr = 0x80000000;

              if (myCmdParams.deviceType == null)
              {
            myCmdParams.deviceType = deviceTypes[0];
              }

              if (myCmdParams.flashType == null)
              {
            myCmdParams.flashType = flashTypes[0];
              }

              if (myCmdParams.APPFlashBlock == 0xFFFFFFFF)
              {
            if(myCmdParams.flashType == "NAND")
            {
              myCmdParams.APPFlashBlock = 1;
            }
            else {
              myCmdParams.APPFlashBlock = 0;
            }
              }

              //Setup default serial port name
              if (myCmdParams.SerialPortName == null)
              {
            int p = (int)Environment.OSVersion.Platform;
            if ((p == 4) || (p == 128)) //Check for unix/linux
            {
              Console.WriteLine("Platform is Unix/Linux.");
              myCmdParams.SerialPortName = "/dev/ttyS0";
            }
            else
            {
              Console.WriteLine("Platform is Windows.");
              myCmdParams.SerialPortName = "COM1";
            }
              }

              // Prep command string
              cmdString += "    [TARGET] " + myCmdParams.deviceType + "\n";
              cmdString = cmdString + "    [DEVICE] " + myCmdParams.flashType+ "\n";

              if(myCmdParams.flashType == "SPI_MEM") {
            cmdString = cmdString + " [SPI Block] " + myCmdParams.APPFlashBlock + "\n";
              }
              else if(myCmdParams.flashType =="NAND") {
            cmdString = cmdString + "    [NAND Block] " + myCmdParams.APPFlashBlock;
              }
              else if(myCmdParams.flashType =="NOR") {
            cmdString = cmdString + "    [NOR Block] " + myCmdParams.APPFlashBlock;
              }
              else
            cmdString = cmdString + "    [UNKNOWN Flash Address] " + myCmdParams.APPFlashBlock;

              return myCmdParams;
        }
Example #16
0
        /// <summary>
        /// Main entry point of application
        /// </summary>
        /// <param name="args">Array of command-line arguments</param>
        /// <returns>Return code: 0 for correct exit, -1 for unexpected exit</returns>
        static Int32 Main(String[] args)
        {
            // Assumes that in AssemblyInfo.cs, the version is specified as 1.0.* or the like,
              // with only 2 numbers specified;  the next two are generated from the date.
              System.Version v = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;

              // v.Build is days since Jan. 1, 2000, v.Revision*2 is seconds since local midnight
              Int32 buildYear = new DateTime( v.Build * TimeSpan.TicksPerDay + v.Revision * TimeSpan.TicksPerSecond * 2 ).AddYears(1999).Year;

              // Begin main code
              Console.Clear();
              Console.WriteLine("-----------------------------------------------------");
              Console.WriteLine("   TI Binary Creator for " + devString                );
              Console.WriteLine("   (C) "+buildYear+", Texas Instruments, Inc."        );
              Console.WriteLine("   Ver. "+v.Major+"."+v.Minor.ToString("D2")          );
              Console.WriteLine("-----------------------------------------------------");
              Console.Write("\n\n");

              // Parse command line
              cmdParams = ParseCmdLine(args);
              if (!cmdParams.valid)
              {
            DispHelp();
            return -1;
              }

              Console.WriteLine("Preparing binary image with header prepended...\n");
              Console.WriteLine("  Intended NAND device has {0} byte pages.",cmdParams.pageSize);
              Console.WriteLine("  Image intended for block {0}.",cmdParams.blockNum);
              Console.WriteLine("  Image entry point is 0x{0:X8}.",cmdParams.startAddr);
              Console.WriteLine("  Image load address is 0x{0:X8}.",cmdParams.loadAddr);

              // Setup the thread that will actually do all the work of interfacing to
              // the Device boot ROM.  Start that thread.
              workerThread = new Thread(new ThreadStart(Program.WorkerThreadStart));
              workerThread.Start();

              // Wait for a key to terminate the program
              while ((workerThread.IsAlive) && (!Console.KeyAvailable))
              {
            Thread.Sleep(1000);
              }

              // If a key is pressed then abort the worker thread and close the serial port
              try
              {
            if (Console.KeyAvailable)
            {
              Console.ReadKey();
              Console.WriteLine("Aborting program...");
              workerThread.Abort();
            }
            else if (workerThread.IsAlive)
            {
              Console.WriteLine("Aborting program...");
              workerThread.Abort();
            }

            while ((workerThread.ThreadState & ThreadState.Stopped) != ThreadState.Stopped){}
              }
              catch (Exception e)
              {
            Console.WriteLine("Abort thread error...");
            Console.WriteLine(e.GetType());
            Console.WriteLine(e.Message);
              }

              if (workerThreadSucceeded)
              {
            Console.WriteLine("\nOperation completed successfully.");
            return 0;
              }
              else
              {
            Console.WriteLine("\nOperation did NOT complete successfully.");
            return -1;
              }
        }
        /// <summary>
        /// Function to parse the command line
        /// </summary>
        /// <param name="args">Array of command-line arguments</param>
        /// <returns>Struct of the filled in program arguments</returns>
        private static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams = new ProgramCmdParams();
              Boolean[] argsHandled = new Boolean[args.Length];

              UInt32 numUnhandledArgs, numHandledArgs = 0;
              String s,defaultExtension;

              // Check for no argumnents
              if (args.Length == 0)
              {
            myCmdParams.valid = false;
            return myCmdParams;
              }

              // Set Defaults
              myCmdParams.valid = true;
              myCmdParams.verbose = false;
              myCmdParams.outputFileName = null;
              myCmdParams.inputfileName = null;
              defaultExtension = "_eccdata.bin";

              // Initialize array of handled argument booleans to false
              for (int i = 0; i < argsHandled.Length; i++)
            argsHandled[i] = false;

              // For loop to check for all dash options
              for (int i = 0; i < args.Length; i++)
              {
            s = args[i];
            if (s.StartsWith("-"))
            {
              switch (s.Substring(1).ToLower())
              {
            case "o":
              myCmdParams.outputFileName = args[i + 1];
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            case "v":
              myCmdParams.verbose = true;
              break;
            default:
              myCmdParams.valid = false;
              break;
              }
              argsHandled[i] = true;
              numHandledArgs++;
            }
              }
              numUnhandledArgs = (UInt32)(args.Length - numHandledArgs);

              // Check to make sure we are still valid
              if ( (!myCmdParams.valid) || (numUnhandledArgs != 1) || (argsHandled[args.Length-1]))
              {
              myCmdParams.valid = false;
              return myCmdParams;
              }

              // Get input file
              FileInfo fi = new FileInfo(args[args.Length-1]);
              if (fi.Exists)
              {
            myCmdParams.inputfileName = args[args.Length - 1];
            String extension = Path.GetExtension(fi.Name);
            if (myCmdParams.outputFileName == null)
            {
              myCmdParams.outputFileName = Path.GetFileNameWithoutExtension(fi.Name) + defaultExtension;
            }
              }
              else
              {
            Console.WriteLine("File not found.");
            myCmdParams.valid = false;
            return myCmdParams;
              }

              return myCmdParams;
        }
Example #18
0
        /// <summary>
        /// Function to parse the command line
        /// </summary>
        /// <param name="args">Array of command-line arguments</param>
        /// <returns>Struct of the filled in program arguments</returns>
        private static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams = new ProgramCmdParams();

            Boolean[] argsHandled = new Boolean[args.Length];

            UInt32 numUnhandledArgs, numHandledArgs = 0;
            String s, defaultExtension;

            // Check for no argumnents
            if (args.Length == 0)
            {
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            // Set Defaults
            myCmdParams.valid          = true;
            myCmdParams.verbose        = false;
            myCmdParams.outputFileName = null;
            myCmdParams.inputfileName  = null;
            defaultExtension           = "_eccdata.bin";

            // Initialize array of handled argument booleans to false
            for (int i = 0; i < argsHandled.Length; i++)
            {
                argsHandled[i] = false;
            }

            // For loop to check for all dash options
            for (int i = 0; i < args.Length; i++)
            {
                s = args[i];
                if (s.StartsWith("-"))
                {
                    switch (s.Substring(1).ToLower())
                    {
                    case "o":
                        myCmdParams.outputFileName = args[i + 1];
                        argsHandled[i + 1]         = true;
                        numHandledArgs++;
                        break;

                    case "v":
                        myCmdParams.verbose = true;
                        break;

                    default:
                        myCmdParams.valid = false;
                        break;
                    }
                    argsHandled[i] = true;
                    numHandledArgs++;
                }
            }
            numUnhandledArgs = (UInt32)(args.Length - numHandledArgs);

            // Check to make sure we are still valid
            if ((!myCmdParams.valid) || (numUnhandledArgs != 1) || (argsHandled[args.Length - 1]))
            {
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            // Get input file
            FileInfo fi = new FileInfo(args[args.Length - 1]);

            if (fi.Exists)
            {
                myCmdParams.inputfileName = args[args.Length - 1];
                String extension = Path.GetExtension(fi.Name);
                if (myCmdParams.outputFileName == null)
                {
                    myCmdParams.outputFileName = Path.GetFileNameWithoutExtension(fi.Name) + defaultExtension;
                }
            }
            else
            {
                Console.WriteLine("File not found.");
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            return(myCmdParams);
        }
Example #19
0
        /// <summary>
        /// Function to parse the command line
        /// </summary>
        /// <param name="args">Array of command-line arguments</param>
        /// <returns>Struct of the filled in program arguments</returns>
        static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams = new ProgramCmdParams();
              Boolean[] argsHandled = new Boolean[args.Length];

              UInt32 numUnhandledArgs, numHandledArgs = 0;
              String s,defaultExtension;

              // Check for no argumnents
              if (args.Length == 0)
              {
            myCmdParams.valid = false;
            return myCmdParams;
              }

              // Set Defaults
              myCmdParams.valid = true;
              myCmdParams.outFileName = null;
              myCmdParams.iniFileName = null;
              myCmdParams.inputfileName = null;
              myCmdParams.convType = ConvType.Exec2Bin;
              defaultExtension = ".bin";

              // Initialize array of handled argument booleans to false
              for (int i = 0; i < argsHandled.Length; i++)
            argsHandled[i] = false;

              // For loop to check for all dash options
              for (int i = 0; i < args.Length; i++)
              {
            s = args[i];
            if (s.StartsWith("-"))
            {
              switch (s.Substring(1).ToLower())
              {
            case "otype":
              String temp = args[i + 1];
              if (temp.ToLower().Equals("binary"))
              {
                myCmdParams.convType = ConvType.Exec2Bin;
                defaultExtension = ".bin";
              }
              else if (temp.ToLower().Equals("carray"))
              {
                myCmdParams.convType = ConvType.Exec2CArray;
                defaultExtension = ".c";
              }
              else if (temp.ToLower().Equals("srecord"))
              {
                myCmdParams.convType = ConvType.Exec2Srec;
                defaultExtension = ".srec";
              }
              else if (temp.ToLower().Equals("text"))
              {
                myCmdParams.convType = ConvType.Exec2Text;
                defaultExtension = ".txt";
              }
              else
              {
                myCmdParams.valid = false;
              }
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            case "ini":
              myCmdParams.iniFileName = args[i + 1];
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            case "o":
              myCmdParams.outFileName = args[i + 1];
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            default:
              myCmdParams.valid = false;
              break;
              }
              argsHandled[i] = true;
              numHandledArgs++;
            }
              }
              numUnhandledArgs = (UInt32)(args.Length - numHandledArgs);

              // Check to make sure we are still valid
              if ( (!myCmdParams.valid))
              {
              return myCmdParams;
              }

              // Check to see if one last arg is still left - if so it is input object filename
              if ((numUnhandledArgs == 1) && (!argsHandled[args.Length-1]))
              {
            // Get input file
            FileInfo fi = new FileInfo(args[args.Length-1]);
            if (fi.Exists)
            {
              myCmdParams.inputfileName = args[args.Length - 1];
              String extension = Path.GetExtension(fi.Name);
              if (myCmdParams.outFileName == null)
              {
            myCmdParams.outFileName = Path.GetFileNameWithoutExtension(fi.Name) + defaultExtension;
              }
            }
              }

              if (myCmdParams.outFileName == null)
              {
            myCmdParams.outFileName = devString + "_boot_image.ais";
              }

              return myCmdParams;
        }
Example #20
0
File: sfh.cs Project: gxk/dm6467
        /// <summary>
        /// Parse the command line into the appropriate internal command structure
        /// </summary>
        /// <param name="args">The array of strings passed to the command line.</param>
        public static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams = new ProgramCmdParams();

            Boolean[] argsHandled = new Boolean[args.Length];
            Int32     numFiles = -1;
            UInt32    numUnhandledArgs, numHandledArgs = 0;
            String    s;

            if (args.Length == 0)
            {
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            // Initialize array of handled argument booleans to false
            for (int i = 0; i < argsHandled.Length; i++)
            {
                argsHandled[i] = false;
            }

            // Set Defualts for application
            myCmdParams.UBLFlashType = FlashType.NONE;

            myCmdParams.CMDMagicFlag       = MagicFlags.MAGIC_NUMBER_INVALID;
            myCmdParams.valid              = true;
            myCmdParams.verbose            = false;
            myCmdParams.SerialPortName     = null;
            myCmdParams.SerialPortBaudRate = 115200;

            myCmdParams.APPMagicFlag = MagicFlags.UBL_MAGIC_SAFE;
            myCmdParams.APPFileName  = null;
            myCmdParams.APPLoadAddr  = 0xFFFFFFFF;
            myCmdParams.APPStartAddr = 0xFFFFFFFF;

#if   DM35x_REVC
            myCmdParams.UBLMagicFlag = MagicFlags.UBL_MAGIC_SAFE_DM35x_REVC;
#else
            myCmdParams.UBLMagicFlag = MagicFlags.UBL_MAGIC_SAFE;
#endif
            myCmdParams.UBLFileName  = null;
            myCmdParams.UBLStartAddr = 0xFFFFFFFF;

            // For loop for required command type
            for (int i = 0; i < args.Length; i++)
            {
                s = args[i];
                if (s.StartsWith("-"))
                {
                    switch (s.Substring(1).ToLower())
                    {
                    case "norflash":
                        if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                        {
                            myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_NOR_FLASH;
                        }
                        else
                        {
                            myCmdParams.valid = false;
                        }
                        numFiles = 2;
                        myCmdParams.UBLFlashType = FlashType.NOR;
                        cmdString = "Flashing NOR with ";
                        break;

                    case "norflash_noubl":
                        if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                        {
                            myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_NOR_FLASH_NO_UBL;
                        }
                        else
                        {
                            myCmdParams.valid = false;
                        }
                        numFiles = 1;
                        myCmdParams.UBLFlashType = FlashType.NOR;
                        cmdString = "Flashing NOR with ";
                        break;

                    case "sdflash":
                        if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                        {
                            myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_SDMMC_FLASH;
                        }
                        else
                        {
                            myCmdParams.valid = false;
                        }
                        numFiles = 2;
                        myCmdParams.UBLFlashType = FlashType.SD_MMC;
                        cmdString = "Flashing SD/MMC with ";
                        break;

                    case "nandflash":
                        if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                        {
                            myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_NAND_FLASH;
                        }
                        else
                        {
                            myCmdParams.valid = false;
                        }
                        numFiles = 2;
                        myCmdParams.UBLFlashType = FlashType.NAND;
                        cmdString = "Flashing NAND with ";
                        break;

                    case "norerase":
                        if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                        {
                            myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_NOR_ERASE;
                        }
                        else
                        {
                            myCmdParams.valid = false;
                        }
                        numFiles = 0;
                        myCmdParams.UBLFlashType = FlashType.NOR;
                        cmdString = "Globally erasing NOR flash.";
                        break;

                    case "nanderase":
                        if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                        {
                            myCmdParams.CMDMagicFlag = MagicFlags.UBL_MAGIC_NAND_ERASE;
                        }
                        else
                        {
                            myCmdParams.valid = false;
                        }
                        numFiles = 0;
                        myCmdParams.UBLFlashType = FlashType.NAND;
                        cmdString = "Globally erasing NAND flash.";
                        break;

                    default:
                        continue;
                    }
                    argsHandled[i] = true;
                    numHandledArgs++;

                    if (!myCmdParams.valid)
                    {
                        return(myCmdParams);
                    }
                }
            } // end of for loop for handling dash params

            // Check to make sure a command was selected
            if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
            {
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            // For loop for all other dash options
            try
            {
                for (int i = 0; i < args.Length; i++)
                {
                    s = args[i];
                    if ((s.StartsWith("-")) && (argsHandled[i] != true))
                    {
                        switch (s.Substring(1).ToLower())
                        {
                        case "appstartaddr":
                            if (args[i + 1].StartsWith("0x"))
                            {
                                args[i + 1] = args[i + 1].Substring(2);
                            }
                            myCmdParams.APPStartAddr = System.UInt32.Parse(args[i + 1], System.Globalization.NumberStyles.AllowHexSpecifier);
                            argsHandled[i + 1]       = true;
                            numHandledArgs++;
                            break;

                        case "apploadaddr":
                            if (args[i + 1].StartsWith("0x"))
                            {
                                args[i + 1] = args[i + 1].Substring(2);
                            }
                            myCmdParams.APPLoadAddr = System.UInt32.Parse(args[i + 1], System.Globalization.NumberStyles.AllowHexSpecifier);
                            argsHandled[i + 1]      = true;
                            numHandledArgs++;
                            break;

                        case "ublstartaddr":
                            if (args[i + 1].StartsWith("0x"))
                            {
                                args[i + 1] = args[i + 1].Substring(2);
                            }
                            myCmdParams.UBLStartAddr = System.UInt32.Parse(args[i + 1], System.Globalization.NumberStyles.AllowHexSpecifier);
                            argsHandled[i + 1]       = true;
                            numHandledArgs++;
                            break;

                        case "p":
                            myCmdParams.SerialPortName = args[i + 1];
                            argsHandled[i + 1]         = true;
                            numHandledArgs++;
                            break;

                        case "baud":
                            myCmdParams.SerialPortBaudRate = System.Int32.Parse(args[i + 1]);
                            argsHandled[i + 1]             = true;
                            numHandledArgs++;
                            break;

                        case "v":
                            myCmdParams.verbose = true;
                            break;

                        default:
                            myCmdParams.valid = false;
                            break;
                        }
                        argsHandled[i] = true;
                        numHandledArgs++;
                        if (!myCmdParams.valid)
                        {
                            return(myCmdParams);
                        }
                    }
                } // end of for loop for handling dash params
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            // Verify that the number of unhandled arguments is equal to numFiles
            // If not, then there is a problem.
            numUnhandledArgs = (UInt32)(args.Length - numHandledArgs);
            if (numUnhandledArgs != numFiles)
            {
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            // This for loop handles all othe params (namely filenames)
            for (int i = 0; i < args.Length; i++)
            {
                if (!argsHandled[i])
                {
                    switch (numFiles)
                    {
                    case 1:
                        if (myCmdParams.APPFileName == null)
                        {
                            myCmdParams.APPFileName = args[i];
                            cmdString += myCmdParams.APPFileName + ".";
                        }
                        else
                        {
                            myCmdParams.valid = false;
                        }
                        break;

                    case 2:
                        if (myCmdParams.UBLFileName == null)
                        {
                            myCmdParams.UBLFileName = args[i];
                            cmdString += myCmdParams.UBLFileName + " and ";
                        }
                        else if (myCmdParams.APPFileName == null)
                        {
                            myCmdParams.APPFileName = args[i];
                            cmdString += myCmdParams.APPFileName + ".";
                        }
                        else
                        {
                            myCmdParams.valid = false;
                        }
                        break;

                    default:
                        myCmdParams.valid = false;
                        break;
                    }
                }
                argsHandled[i] = true;
                if (!myCmdParams.valid)
                {
                    return(myCmdParams);
                }
            } // end of for loop for handling dash params

            // Set default binary execution address on target device
            if (myCmdParams.APPLoadAddr == 0xFFFFFFFF)
            {
                myCmdParams.APPLoadAddr = 0x81080000;
            }

            if (myCmdParams.APPStartAddr == 0xFFFFFFFF)
            {
                myCmdParams.APPStartAddr = 0x81080000;
            }

            if (myCmdParams.UBLStartAddr == 0xFFFFFFFF)
            {
                myCmdParams.UBLStartAddr = 0x00000100;
            }

            //Setup default serial port name
            if (myCmdParams.SerialPortName == null)
            {
                int p = (int)Environment.OSVersion.Platform;
                if ((p == 4) || (p == 128)) //Check for unix/linux
                {
                    Console.WriteLine("Platform is Unix/Linux.");
                    myCmdParams.SerialPortName = "/dev/ttyS0";
                }
                else
                {
                    Console.WriteLine("Platform is Windows.");
                    myCmdParams.SerialPortName = "COM1";
                }
            }
            return(myCmdParams);
        }
Example #21
0
        /// <summary>
        /// Parse the command line into the appropriate internal command structure
        /// </summary>
        /// <param name="args">The array of strings passed to the command line.</param>
        public static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams = new ProgramCmdParams();

            Boolean[] argsHandled = new Boolean[args.Length];
            Int32     numFiles = -1;
            UInt32    numUnhandledArgs, numHandledArgs = 0;
            String    s;

            if (args.Length == 0)
            {
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            // Initialize array of handled argument booleans to false
            for (int i = 0; i < argsHandled.Length; i++)
            {
                argsHandled[i] = false;
            }

            // Set Defualts for parsing
            myCmdParams.CMDMagicFlag = MagicFlags.MAGIC_NUMBER_INVALID;
            myCmdParams.valid        = true;
            myCmdParams.inFileName   = null;
            myCmdParams.outFileName  = null;
            myCmdParams.loadAddr     = 0xFFFFFFFF;
            myCmdParams.startAddr    = 0xFFFFFFFF;

            // For loop for required options
            for (int i = 0; i < args.Length; i++)
            {
                s = args[i];
                if (s.StartsWith("-"))
                {
                    switch (s.Substring(1).ToLower())
                    {
                    case "pagesize":
                        if (args[i + 1].StartsWith("0x"))
                        {
                            args[i + 1]          = args[i + 1].Substring(2);
                            myCmdParams.pageSize = System.UInt32.Parse(args[i + 1], System.Globalization.NumberStyles.AllowHexSpecifier);
                        }
                        else
                        {
                            myCmdParams.pageSize = System.UInt32.Parse(args[i + 1], System.Globalization.NumberStyles.Number);
                        }
                        argsHandled[i + 1] = true;
                        numHandledArgs++;
                        break;

                    case "blocknum":
                        if (args[i + 1].StartsWith("0x"))
                        {
                            args[i + 1]          = args[i + 1].Substring(2);
                            myCmdParams.blockNum = System.UInt32.Parse(args[i + 1], System.Globalization.NumberStyles.AllowHexSpecifier);
                        }
                        else
                        {
                            myCmdParams.blockNum = System.UInt32.Parse(args[i + 1], System.Globalization.NumberStyles.Number);
                        }
                        argsHandled[i + 1] = true;
                        numHandledArgs++;
                        break;

                    default:
                        continue;
                    }
                    argsHandled[i] = true;
                    numHandledArgs++;

                    if (!myCmdParams.valid)
                    {
                        return(myCmdParams);
                    }
                }
            }

            // Must have received pageSize, blockNum, and their values
            if (numHandledArgs != 4)
            {
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            // For loop for all other dash options
            for (int i = 0; i < args.Length; i++)
            {
                s = args[i];
                if ((s.StartsWith("-")) && (argsHandled[i] != true))
                {
                    switch (s.Substring(1).ToLower())
                    {
                    case "uboot":
                        myCmdParams.CMDMagicFlag = MagicFlags.MAGIC_NUMBER_UBOOT;
                        myCmdParams.valid        = true;
                        break;

                    case "startaddr":
                        if (args[i + 1].StartsWith("0x"))
                        {
                            args[i + 1] = args[i + 1].Substring(2);
                        }
                        myCmdParams.startAddr = System.UInt32.Parse(args[i + 1], System.Globalization.NumberStyles.AllowHexSpecifier);
                        argsHandled[i + 1]    = true;
                        numHandledArgs++;
                        break;

                    case "loadaddr":
                        if (args[i + 1].StartsWith("0x"))
                        {
                            args[i + 1] = args[i + 1].Substring(2);
                        }
                        myCmdParams.loadAddr = System.UInt32.Parse(args[i + 1], System.Globalization.NumberStyles.AllowHexSpecifier);
                        argsHandled[i + 1]   = true;
                        numHandledArgs++;
                        break;

                    case "o":
                        myCmdParams.outFileName = args[i + 1];
                        argsHandled[i + 1]      = true;
                        numHandledArgs++;
                        break;

                    default:
                        myCmdParams.valid = false;
                        break;
                    }
                    argsHandled[i] = true;
                    numHandledArgs++;
                    if (!myCmdParams.valid)
                    {
                        return(myCmdParams);
                    }
                }
            } // end of for loop for handling dash params

            // We should always expect 1 binary file for input
            numFiles = 1;

            // Verify that the number of unhandled arguments is equal to numFiles
            // If not, then there is a problem.
            numUnhandledArgs = (UInt32)(args.Length - numHandledArgs);
            if (numUnhandledArgs != numFiles)
            {
                myCmdParams.valid = false;
                return(myCmdParams);
            }

            // This for loop handles all othe params (namely filenames)
            for (int i = 0; i < args.Length; i++)
            {
                if (!argsHandled[i])
                {
                    switch (numFiles)
                    {
                    case 1:
                        if (myCmdParams.inFileName == null)
                        {
                            myCmdParams.inFileName = args[i];
                        }
                        else
                        {
                            myCmdParams.valid = false;
                        }
                        break;

                    default:
                        myCmdParams.valid = false;
                        break;
                    }
                }
                argsHandled[i] = true;
                numHandledArgs++;
                if (!myCmdParams.valid)
                {
                    return(myCmdParams);
                }
            } // end of for loop handling file name inputs

            // default to UBL usage
            if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
            {
                myCmdParams.CMDMagicFlag = MagicFlags.MAGIC_NUMBER_UBL;
            }

            // Set output file name to default
            if (myCmdParams.outFileName == null)
            {
                myCmdParams.outFileName =
                    Path.GetFileNameWithoutExtension(myCmdParams.inFileName) + "_withNANDHeader" + Path.GetExtension(myCmdParams.inFileName);
            }

            // Set start and load addresses to default if not provided
            if (myCmdParams.startAddr == 0xFFFFFFFF)
            {
                if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_UBL)
                {
                    myCmdParams.startAddr = 0x00000100;
                }
                else
                {
                    myCmdParams.startAddr = 0x81080000;
                }
            }

            if (myCmdParams.loadAddr == 0xFFFFFFFF)
            {
                if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_UBL)
                {
                    myCmdParams.loadAddr = 0x00000020; // Not used for UBL, but this is the value the RBL uses
                }
                else
                {
                    myCmdParams.loadAddr = 0x81080000;
                }
            }

            return(myCmdParams);
        }
Example #22
0
        /// <summary>
        /// Main entry point of application
        /// </summary>
        /// <param name="args">Array of command-line arguments</param>
        /// <returns>Return code: 0 for correct exit, -1 for unexpected exit</returns>
        static Int32 Main(String[] args)
        {
            // Assumes that in AssemblyInfo.cs, the version is specified as 1.0.* or the like,
            // with only 2 numbers specified;  the next two are generated from the date.
            System.Version v = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;

            // v.Build is days since Jan. 1, 2000, v.Revision*2 is seconds since local midnight
            Int32 buildYear = new DateTime(v.Build * TimeSpan.TicksPerDay + v.Revision * TimeSpan.TicksPerSecond * 2).AddYears(1999).Year;

            // Begin main code
            Console.Clear();
            Console.WriteLine("-----------------------------------------------------");
            Console.WriteLine("   TI Serial Loader Host Program for " + devString);
            Console.WriteLine("   (C) " + buildYear + ", Texas Instruments, Inc.");
            Console.WriteLine("   Ver. " + v.Major + "." + v.Minor.ToString("D2"));
            Console.WriteLine("-----------------------------------------------------");
            Console.Write("\n\n");

            // Parse command line
            cmdParams = ParseCmdLine(args);
            if (!cmdParams.valid)
            {
                DispHelp();
                return(-1);
            }
            else
            {
                Console.Write(cmdString + "\n\n\n");
            }

            try
            {
                Console.WriteLine("Attempting to connect to device " + cmdParams.SerialPortName + "...");
                MySP          = new SerialPort(cmdParams.SerialPortName, 115200, Parity.None, 8, StopBits.One);
                MySP.Encoding = Encoding.ASCII;
                MySP.Open();
            }
            catch (Exception e)
            {
                if (e is UnauthorizedAccessException)
                {
                    Console.WriteLine(e.Message);
                    Console.WriteLine("This application failed to open the COM port.");
                    Console.WriteLine("Most likely it is in use by some other application.");
                    return(-1);
                }
                Console.WriteLine(e.Message);
                return(-1);
            }

            Console.WriteLine("Press any key to end this program at any time.\n");

            // Setup the thread that will actually do all the work of interfacing to
            // the Device boot ROM.  Start that thread.
            workerThread = new Thread(new ThreadStart(Program.WorkerThreadStart));
            workerThread.Start();

            // Wait for a key to terminate the program
            while ((workerThread.IsAlive) && (!Console.KeyAvailable))
            {
                Thread.Sleep(1000);
            }

            // If a key is pressed then abort the worker thread and close the serial port
            try
            {
                if (Console.KeyAvailable)
                {
                    Console.ReadKey();
                    Console.WriteLine("Aborting program...");
                    workerThread.Abort();
                }
                else if (workerThread.IsAlive)
                {
                    Console.WriteLine("Aborting program...");
                    workerThread.Abort();
                }

                while ((workerThread.ThreadState & ThreadState.Stopped) != ThreadState.Stopped)
                {
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Abort thread error...");
                Console.WriteLine(e.GetType());
                Console.WriteLine(e.Message);
            }

            if (workerThreadSucceeded)
            {
                Console.WriteLine("\nOperation completed successfully.");
                return(0);
            }
            else
            {
                Console.WriteLine("\n\nInterfacing to the " + devString + " via UART failed." +
                                  "\nPlease reset or power-cycle the board and try again...");
                return(-1);
            }
        }
Example #23
0
        /// <summary>
        /// Main entry point of application
        /// </summary>
        /// <param name="args">Array of command-line arguments</param>
        /// <returns>Return code: 0 for correct exit, -1 for unexpected exit</returns>
        static Int32 Main(String[] args)
        {
            // Assumes that in AssemblyInfo.cs, the version is specified as 1.0.* or the like,
            // with only 2 numbers specified;  the next two are generated from the date.
            System.Version v = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;

            // v.Build is days since Jan. 1, 2000, v.Revision*2 is seconds since local midnight
            Int32 buildYear = new DateTime(v.Build * TimeSpan.TicksPerDay + v.Revision * TimeSpan.TicksPerSecond * 2).AddYears(1999).Year;

            // Begin main code
            Console.Clear();
            Console.WriteLine("-----------------------------------------------------");
            Console.WriteLine("   TI Binary Creator for " + devString);
            Console.WriteLine("   (C) " + buildYear + ", Texas Instruments, Inc.");
            Console.WriteLine("   Ver. " + v.Major + "." + v.Minor.ToString("D2"));
            Console.WriteLine("-----------------------------------------------------");
            Console.Write("\n\n");

            // Parse command line
            cmdParams = ParseCmdLine(args);
            if (!cmdParams.valid)
            {
                DispHelp();
                return(-1);
            }

            Console.WriteLine("Preparing binary image with header prepended...\n");
            Console.WriteLine("  Intended NAND device has {0} byte pages.", cmdParams.pageSize);
            Console.WriteLine("  Image intended for block {0}.", cmdParams.blockNum);
            Console.WriteLine("  Image entry point is 0x{0:X8}.", cmdParams.startAddr);
            Console.WriteLine("  Image load address is 0x{0:X8}.", cmdParams.loadAddr);


            // Setup the thread that will actually do all the work of interfacing to
            // the Device boot ROM.  Start that thread.
            workerThread = new Thread(new ThreadStart(Program.WorkerThreadStart));
            workerThread.Start();

            // Wait for a key to terminate the program
            while ((workerThread.IsAlive) && (!Console.KeyAvailable))
            {
                Thread.Sleep(1000);
            }

            // If a key is pressed then abort the worker thread and close the serial port
            try
            {
                if (Console.KeyAvailable)
                {
                    Console.ReadKey();
                    Console.WriteLine("Aborting program...");
                    workerThread.Abort();
                }
                else if (workerThread.IsAlive)
                {
                    Console.WriteLine("Aborting program...");
                    workerThread.Abort();
                }

                while ((workerThread.ThreadState & ThreadState.Stopped) != ThreadState.Stopped)
                {
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Abort thread error...");
                Console.WriteLine(e.GetType());
                Console.WriteLine(e.Message);
            }

            if (workerThreadSucceeded)
            {
                Console.WriteLine("\nOperation completed successfully.");
                return(0);
            }
            else
            {
                Console.WriteLine("\nOperation did NOT complete successfully.");
                return(-1);
            }
        }
Example #24
0
File: sfh.cs Project: sv99/DVSDK
        /// <summary>
        /// Main entry point of application
        /// </summary>
        /// <param name="args">Array of command-line arguments</param>
        /// <returns>Return code: 0 for correct exit, -1 for unexpected exit</returns>
        static Int32 Main(String[] args)
        {
            // Assumes that in AssemblyInfo.cs, the version is specified as 1.0.* or the like,
              // with only 2 numbers specified;  the next two are generated from the date.
              System.Version v = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;

              // v.Build is days since Jan. 1, 2000, v.Revision*2 is seconds since local midnight
              Int32 buildYear = new DateTime( v.Build * TimeSpan.TicksPerDay + v.Revision * TimeSpan.TicksPerSecond * 2 ).AddYears(1999).Year;

              // Begin main code
              Console.Clear();
              Console.WriteLine("-----------------------------------------------------");
              Console.WriteLine("   TI Serial Flasher Host Program for " + devString   );
              Console.WriteLine("   (C) "+buildYear+", Texas Instruments, Inc."        );
              Console.WriteLine("   Ver. "+v.Major+"."+v.Minor.ToString("D2")          );
              Console.WriteLine("-----------------------------------------------------");
              Console.Write("\n\n");

              // Parse command line
              cmdParams = ParseCmdLine(args);
              if (!cmdParams.valid)
              {
            DispHelp();
            return -1;
              }
              else
              {
            Console.Write(cmdString + "\n\n\n");
              }

              try
              {
            Console.WriteLine("Attempting to connect to device " + cmdParams.SerialPortName + "...");
            MySP = new SerialPort(cmdParams.SerialPortName, cmdParams.SerialPortBaudRate, Parity.None, 8, StopBits.One);
            MySP.Encoding = Encoding.ASCII;
            MySP.Open();
              }
              catch(Exception e)
              {
            if (e is UnauthorizedAccessException)
            {
              Console.WriteLine(e.Message);
              Console.WriteLine("This application failed to open the COM port.");
              Console.WriteLine("Most likely it is in use by some other application.");
              return -1;
            }
            Console.WriteLine(e.Message);
            return -1;
              }

              Console.WriteLine("Press any key to end this program at any time.\n");

              // Setup the thread that will actually do all the work of interfacing to
              // the Device boot ROM.  Start that thread.
              workerThread = new Thread(new ThreadStart(Program.WorkerThreadStart));
              workerThread.Start();

              // Wait for a key to terminate the program
              while ((workerThread.IsAlive) && (!Console.KeyAvailable))
              {
            Thread.Sleep(1000);
              }

              // If a key is pressed then abort the worker thread and close the serial port
              try
              {
            if (Console.KeyAvailable)
            {
              Console.ReadKey();
              Console.WriteLine("Aborting program...");
              workerThread.Abort();
            }
            else if (workerThread.IsAlive)
            {
              Console.WriteLine("Aborting program...");
              workerThread.Abort();
            }

            while ((workerThread.ThreadState & ThreadState.Stopped) != ThreadState.Stopped){}
              }
              catch (Exception e)
              {
            Console.WriteLine("Abort thread error...");
            Console.WriteLine(e.GetType());
            Console.WriteLine(e.Message);
              }

              if (workerThreadSucceeded)
              {
            Console.WriteLine("\nOperation completed successfully.");
            return 0;
              }
              else
              {
            Console.WriteLine("\n\nInterfacing to the "+devString+" via UART failed." +
            "\nPlease reset or power-cycle the board and try again...");
            return -1;
              }
        }
Example #25
0
File: slh.cs Project: sv99/DVSDK
        /// <summary>
        /// Parse the command line into the appropriate internal command structure
        /// </summary>
        /// <param name="args">The array of strings passed to the command line.</param>
        public static ProgramCmdParams ParseCmdLine(String[] args)
        {
            ProgramCmdParams myCmdParams =  new ProgramCmdParams();
              Boolean[] argsHandled = new Boolean[args.Length];
              Int32 numFiles = -1;
              UInt32 numUnhandledArgs,numHandledArgs=0;
              String s;

              if (args.Length == 0)
              {
              myCmdParams.valid = false;
              return myCmdParams;
              }

              // Initialize array of handled argument booleans to false
              for (int i = 0; i < argsHandled.Length; i++ )
            argsHandled[i] = false;

              // Set Defualts for application
              myCmdParams.CMDMagicFlag = MagicFlags.MAGIC_NUMBER_INVALID;
              myCmdParams.valid = true;
              myCmdParams.verbose = false;
              myCmdParams.SerialPortName = null;

              myCmdParams.APPFileName = null;
              myCmdParams.APPLoadAddr = 0xFFFFFFFF;
              myCmdParams.APPStartAddr = 0xFFFFFFFF;

              // For loop for required load type
              for(int i = 0; i<args.Length; i++)
              {
            s = args[i];
            if (s.StartsWith("-"))
            {
              switch (s.Substring(1).ToLower())
              {
            case "load2iram":
              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                myCmdParams.CMDMagicFlag = MagicFlags.SLT_MAGIC_LOADIMAGE_IRAM;
              else
                myCmdParams.valid = false;
              myCmdParams.APPLoadAddr = 0x0020;
              myCmdParams.APPStartAddr = 0x0100;
              numFiles = 1;
              cmdString = "Loading image to ARM IRAM ";
              break;
            case "load2ddr":
              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
                myCmdParams.CMDMagicFlag = MagicFlags.SLT_MAGIC_LOADIMAGE_DDR;
              else
                myCmdParams.valid = false;
              myCmdParams.APPLoadAddr = 0x80000000;
              myCmdParams.APPStartAddr = 0x80000000;
              numFiles = 1;
              cmdString = "Loading image to DDR";
              break;
            default:
              continue;
              }
              argsHandled[i] = true;
              numHandledArgs++;

              if (!myCmdParams.valid)
            return myCmdParams;
            }
              }

              if (myCmdParams.CMDMagicFlag == MagicFlags.MAGIC_NUMBER_INVALID)
              {
            myCmdParams.valid = false;
            return myCmdParams;
              }

              // For loop for all other dash options
              for(int i = 0; i<args.Length; i++)
              {
            s = args[i];
            if ((s.StartsWith("-")) && (argsHandled[i] != true))
            {
              switch (s.Substring(1).ToLower())
              {
            case "startaddr":
              if (args[i + 1].StartsWith("0x"))
                args[i + 1] = args[i + 1].Substring(2);
              myCmdParams.APPStartAddr = System.UInt32.Parse(args[i + 1],System.Globalization.NumberStyles.AllowHexSpecifier);
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            case "loadaddr":
              if (args[i + 1].StartsWith("0x"))
                args[i + 1] = args[i + 1].Substring(2);
              myCmdParams.APPLoadAddr = System.UInt32.Parse(args[i + 1],System.Globalization.NumberStyles.AllowHexSpecifier);
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            case "p":
              myCmdParams.SerialPortName = args[i + 1];
              argsHandled[i + 1] = true;
              numHandledArgs++;
              break;
            case "v":
              myCmdParams.verbose = true;
              break;
            default:
              myCmdParams.valid = false;
              break;
              }
              argsHandled[i] = true;
              numHandledArgs++;
              if (!myCmdParams.valid)
            return myCmdParams;
            }
              } // end of for loop for handling dash params

              // Verify that the number of unhandled arguments is equal to numFiles
              // If not, then there is a problem.
              numUnhandledArgs = (UInt32) (args.Length - numHandledArgs);
              if (numUnhandledArgs != numFiles)
              {
            myCmdParams.valid = false;
            return myCmdParams;
              }

              // This for loop handles all othe params (namely filenames)
              for (int i = 0; i < args.Length; i++)
              {
            if (!argsHandled[i])
            {
              switch (numFiles)
              {
            case 1:
              if (myCmdParams.APPFileName == null)
              {
                myCmdParams.APPFileName = args[i];
              }
              else
                myCmdParams.valid = false;
              break;
            default:
              myCmdParams.valid = false;
              break;
              }
            }
            argsHandled[i] = true;
            numHandledArgs++;
            if (!myCmdParams.valid) return myCmdParams;
              } // end of for loop handling file name inputs

              //Setup default serial port name
              if (myCmdParams.SerialPortName == null)
              {
            int p = (int)Environment.OSVersion.Platform;
            if ((p == 4) || (p == 128)) //Check for unix/linux
            {
              Console.WriteLine("Platform is Unix/Linux.");
              myCmdParams.SerialPortName = "/dev/ttyS0";
            }
            else
            {
              Console.WriteLine("Platform is Windows.");
              myCmdParams.SerialPortName = "COM1";
            }
              }
              return myCmdParams;
        }