开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
main.c
资源名称：SMDK2440.rar　[点击查看]
上传用户：qiulin1960
上传日期：2013-10-16
资源大小：2844k
文件大小：43k
源码类别：

Windows CE

开发平台：

Windows_Unix

main.c：源码内容
  1. //
  2. // Copyright (c) Microsoft Corporation.  All rights reserved.
  3. //
  4. //
  5. // Use of this source code is subject to the terms of the Microsoft end-user
  6. // license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
  7. // If you did not accept the terms of the EULA, you are not authorized to use
  8. // this source code. For a copy of the EULA, please see the LICENSE.RTF on your
  9. // install media.
  10. //
  11. /*++
  12. THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  13. ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  14. THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  15. PARTICULAR PURPOSE.
  17. Module Name:
  18.     main.c
  20. Abstract:
  21.     Ethernet boot loader main module. This file contains the C main
  22.     for the boot loader.    NOTE: The firmware "entry" point (the real
  23.     entry point is _EntryPoint in init assembler file.
  25.     The Windows CE boot loader is the code that is executed on a Windows CE
  26.     development system at power-on reset and loads the Windows CE
  27.     operating system. The boot loader also provides code that monitors
  28.     the behavior of a Windows CE platform between the time the boot loader
  29.     starts running and the time the full operating system debugger is
  30.     available. Windows CE OEMs are supplied with sample boot loader code
  31.     that runs on a particular development platform and CPU.
  33. Functions:
  36. Notes:
  38. --*/
  40. #include <windows.h>
  41. #include <pcireg.h>
  42. #include <ethdbg.h>
  43. #include <drv_glob.h>
  44. #include <nkintr.h>
  45. #include <pehdr.h>
  46. #include <romldr.h>
  47. #include <blcommon.h>
  48. #include <bootpart.h>
  49. #include <kitlprot.h>
  51. #include "s2440.h"
  52. #include "loader.h"
  53. #include "fmd.h"
  54. #include "cfnand.h"
  55. #include "warning.h"
  57. PDRIVER_GLOBALS pDriverGlobals = ((PDRIVER_GLOBALS) DRIVER_GLOBALS_PHYSICAL_MEMORY_START);
  58. extern BOOL UbootReadData (DWORD cbData, LPBYTE pbData);
  59. extern BOOL InitUSB ();
  60. extern void Isr_Init();
  62. //  Some global definitions
  64. #ifdef SIMULATOR
  65. void CleanExit(DWORD dwExitCode);
  66. #define SPIN_FOREVER    CleanExit(41);
  67. #else
  68. #define SPIN_FOREVER    {while(TRUE);}
  69. #endif
  71. //
  72. //  Global variables
  73. //
  74. static BOOLEAN  g_bDownloadImage  = TRUE;
  75. BOOLEAN         g_bWaitForConnect;
  76. DWORD           g_dwImageStartBlock;
  77. DWORD           g_ImageType;
  78. DWORD           g_dwMinImageStart;
  79. MultiBINInfo    g_BINRegionInfo;
  80. BOOL            g_bBootMediaExist = FALSE;
  81. BOOLEAN g_bUSBDownload = FALSE;
  83. #pragma pack(1)
  84. // N.B: only uses 1 sector for now.
  85. UCHAR g_TOC[SECTOR_SIZE];
  86. #pragma pack()
  88. const PTOC g_pTOC = (PTOC)&g_TOC;
  89. PBOOT_CFG  g_pBootCfg;
  90. DWORD      g_dwTocEntry;
  92. #ifdef DEBUG
  93. DWORD   EdbgDebugZone = 0;//ZONE_WARNING|ZONE_INIT; //ZONE_DHCP;
  94. #endif
  96. //  External functions
  97. extern void  InitClock();
  98. extern DWORD OEMAddressTable[];
  99. void Launch();
  100. void BootloaderMain (void);
  101. BOOL InitEthDevice(PBOOT_CFG  pBootCfg);
  102. static void SetDelay();
  103. static void SetCS8900MACAddress();
  105. //  Function prototypes
  106. static BOOL GetUserIPAddr (EDBG_ADDR *pMyAddr, LPDWORD pdwSubnetMask);
  108. #define LAST_LAUNCH_ADDR_VALID 0xBADBEEF6
  110. //  Local util function
  111. //
  112. DWORD
  113. ToPhysicalAddr(DWORD add)
  114. {
  115.     DWORD   padd = add;
  116.     DWORD * pt = OEMAddressTable;
  117.     DWORD   vir_start;
  118.     DWORD   vir_end;
  119.     DWORD   phy_start;
  120.     DWORD   sz;
  122. EdbgOutputDebugString("+ToPhysicalAddr:0x%xrn", add);
  124.     do
  125.     {
  126.         vir_start = *pt++;
  127.         phy_start = *pt++;
  128.         sz        = *pt++;
  130.         if (vir_start == 0 && phy_start == 0 && sz == 0) break;
  132.         vir_end = vir_start + sz * (1024 * 1024);
  134.         if (add >= vir_start && add < vir_end)
  135.         {
  136.             padd = add - vir_start + phy_start;
  137.             break;
  138.         }
  139.     } while (1);
  141. EdbgOutputDebugString("-ToPhysicalAddr:0x%xrn", padd);
  143.     return padd;
  144. }
  147. //  util function that should really be in blcommon
  148. //
  149. static void
  150. itoa10(
  151.     int n,
  152.     char s[]
  153.     )
  154. {
  155.     int i = 0;
  157.     // Get absolute value of number
  158.     unsigned int val = (unsigned int)((n < 0) ? -n : n);
  160.     // Extract digits in reverse order
  161.     do {
  162.         s[i++] = (val % 10) + '0';
  163.     } while (val /= 10);
  165.     // Add sign if number negative
  166.     if (n < 0) s[i++] = '-';
  168.     s[i--] = '';
  170.     // Reverse string
  171.     for (n = 0; n < i; n++, i--) {
  172.         char swap = s[n];
  173.         s[n] = s[i];
  174.         s[i] = swap;
  175.     }
  176. }
  179. static void
  180. CreateDeviceName(
  181.     EDBG_ADDR *pMyAddr,
  182.     char *szBuf
  183.     )
  184. {
  185.     strcpy(szBuf,PLATFORM_STRING);
  186.     szBuf += strlen(szBuf);
  187.     itoa10(((pMyAddr->wMAC[2]>>8) | ((pMyAddr->wMAC[2] & 0x00ff) << 8)), szBuf);
  188. }
  192. #ifdef TODO
  193. //  This routine programs the serial EEPROM and sets the
  194. //  Ethernet Address to 00 50 F2 08 NN NN (N=Debug board number).
  195. static void SetSerialNumber(USHORT dbgBoardSerialNumber) {
  196.     USHORT i;
  198.     EdbgOutputDebugString("SetSerialNumber: %u rn", dbgBoardSerialNumber);
  200.     if ((dbgBoardSerialNumber <0) || (dbgBoardSerialNumber > 32000)) {
  201.         EdbgOutputDebugString("Error Serial Number between 0 and 32000n");
  202.     }
  204.     for (i=0;i<16;i+=2) {
  205.         // Set all switch Areas to the same
  206.         SMCWriteEEPROM((UINT16)(0x0+i), 0xB0);
  207.         SMCWriteEEPROM((UINT16)(0x1+i), 0x1866);
  208.     }
  209.     for (i=16;i<0x20;i++) {
  210.         SMCWriteEEPROM(i,0x0);
  211.         }
  213.                                     // Avenger is 00-50-F2-03-XX-XX
  214.                                     // Trango  is 00-50-F2-08-XX-XX
  215.                                     // Catfish is 00-50-F2-08-XX-XX ??
  216.     SMCWriteEEPROM(0x20, 0x5000);   // Is 00-50-??-??-??-??
  217.     SMCWriteEEPROM(0x21, 0x08F2);   // Is ??-??-F2-08-??-??
  218.     SMCWriteEEPROM(0x22, htons((UINT16)(dbgBoardSerialNumber)));
  219.     SMCWriteEEPROM(0x23, 0x389D);
  220.     SMCWriteEEPROM(0x24, 0x4595);
  221.     SMCWriteEEPROM(0x25, 0xFFFF);
  222.     SMCWriteEEPROM(0x26, 0x00FC);
  223.     SMCWriteEEPROM(0x27, 0x0000);
  224.     SMCWriteEEPROM(0x28, 0x5765);
  225.     SMCWriteEEPROM(0x29, 0x2776);
  226.     SMCWriteEEPROM(0x2A, 0x6520);
  227.     SMCWriteEEPROM(0x2B, 0x7374);
  228.     SMCWriteEEPROM(0x2C, 0x696C);
  229.     SMCWriteEEPROM(0x2D, 0x6C20);
  230.     SMCWriteEEPROM(0x2E, 0x676F);
  231.     SMCWriteEEPROM(0x2F, 0x7420);
  232. }
  233. #endif
  235. //
  236. //  Functions called from blcommon
  237. //
  239. /*
  240.     @func   BOOL | OEMVerifyMemory | Verify that the memory to be used by the downloaded BIN file is valid.  This function also decides whether the image is the
  241.                                      bootloader or not based on its address (this information is used later when deciding how to store the image in flash).
  242.     @rdesc  TRUE = Address specified is valid memory, FALSE = Address specified is *not* valid memory.
  243.     @comm
  244.     @xref
  245. */
  246. BOOL OEMVerifyMemory(DWORD dwStartAddr, DWORD dwLength)
  247. {
  248.     RETAILMSG(1, (TEXT("OEMVerifyMemory: StartAddr: 0x%x, Length:0x%x rn"), dwStartAddr, dwLength));
  250.     // Is the image being downloaded the bootloader?
  251.     if ((dwStartAddr >= EBOOT_STORE_ADDRESS) &&
  252.         ((dwStartAddr + dwLength - 1) < (EBOOT_STORE_ADDRESS + EBOOT_STORE_MAX_LENGTH)))
  253.     {
  254.         RETAILMSG(1, (TEXT("Downloading Bootloader imagern")));
  255.         g_ImageType = IMAGE_TYPE_LOADER;     // Bootloader image.
  256.         return TRUE;
  257.     }
  259.     // if it's MXIP don't test address to allow PPC images using funky addresses in their .BIN regions
  260.     else if ( g_BINRegionInfo.dwNumRegions > 1 )
  261.     {
  262.         RETAILMSG(1, (TEXT("Downloading %d regions of MXIP imagern"), g_BINRegionInfo.dwNumRegions));
  263.         // 1st region is RAMIMAGE, remaining are MXIP
  264.         g_ImageType = IMAGE_TYPE_RAMIMAGE | IMAGE_TYPE_BINFS | IMAGE_TYPE_MXIP;
  265.         return TRUE;
  266.     }
  268.     // Is it a ram image?
  269.     else if ((dwStartAddr >= ROM_RAMIMAGE_START) &&
  270.         ((dwStartAddr + dwLength - 1) < (ROM_RAMIMAGE_START + ROM_RAMIMAGE_SIZE)))
  271.     {
  272.         RETAILMSG(1, (TEXT("Downloading RAM imagern")));
  273.         g_ImageType = IMAGE_TYPE_RAMIMAGE;
  274.         return TRUE;
  275.     }
  277.     // HACKHACK: get around MXIP images with funky addresses
  278.     RETAILMSG(1, (TEXT("*** Downloading BIN image type ***rn")));
  279.     return TRUE;
  281. }
  284. /*
  285.     @func   void | OEMMultiBINNotify | Called by blcommon to nofity the OEM code of the number, size, and location of one or more BIN regions,
  286.                                        this routine collects the information and uses it when temporarily caching a flash image in RAM prior to final storage.
  287.     @rdesc  N/A.
  288.     @comm
  289.     @xref
  290. */
  291. void OEMMultiBINNotify(const PMultiBINInfo pInfo)
  292. {
  293.     BYTE nCount;
  295.     if (!pInfo || !pInfo->dwNumRegions)
  296.     {
  297.         EdbgOutputDebugString("WARNING: OEMMultiBINNotify: Invalid BIN region descriptor(s).rn");
  298.         return;
  299.     }
  301.     g_dwMinImageStart = pInfo->Region[0].dwRegionStart;
  303.     EdbgOutputDebugString("rnOEMMultiBINNotify: Download BIN file information:rn");
  304.     EdbgOutputDebugString("-----------------------------------------------------rn");
  305.     for (nCount = 0 ; nCount < pInfo->dwNumRegions ; nCount++)
  306.     {
  307.         EdbgOutputDebugString("[%d]: Base Address=0x%x  Length=0x%xrn" ,
  308.             nCount, pInfo->Region[nCount].dwRegionStart, pInfo->Region[nCount].dwRegionLength);
  309.         if (pInfo->Region[nCount].dwRegionStart < g_dwMinImageStart)
  310.         {
  311.             g_dwMinImageStart = pInfo->Region[nCount].dwRegionStart;
  312.             if (g_dwMinImageStart == 0)
  313.             {
  314.                 EdbgOutputDebugString("WARNING: OEMMultiBINNotify: Bad start address for region (%d).rn", nCount);
  315.                 return;
  316.             }
  317.         }
  318.     }
  320.     memcpy((LPBYTE)&g_BINRegionInfo, (LPBYTE)pInfo, sizeof(MultiBINInfo));
  322.     EdbgOutputDebugString("-----------------------------------------------------rn");
  323. }
  326. BOOL OEMReportError(DWORD dwReason, DWORD dwReserved)
  327. {
  328.     EdbgOutputDebugString("OEMReportError(%d, %d)rn", dwReason, dwReserved);
  329.     return TRUE;
  330. }
  333. /*
  334.     @func   BOOL | OEMDebugInit | Function wrapper for OEMInitDebugSerial.
  335.     @rdesc  TRUE = Success, FALSE = Failure.
  336.     @comm
  337.     @xref
  338. */
  339. BOOL OEMDebugInit()
  340. {
  341.     // Assign callback functions to be usec by blcommon.
  342.     //
  343.     g_pOEMReportError    = OEMReportError;
  344.     g_pOEMVerifyMemory   = OEMVerifyMemory;     // Verify memory to be used by downloaded image...
  345.     g_pOEMMultiBINNotify = OEMMultiBINNotify;   // Notified of all the BIN files to be downloaded...
  347.     OEMInitDebugSerial();
  348.     return TRUE;
  349. }
  352. /*
  353.     @func   BOOL | BootMonitor | Manages the bootloader monitor.
  354.     @rdesc  TRUE = user selected download image, FALSE = user selected launch stored image.
  355.     @comm
  356.     @xref
  357. */
  358. static BOOLEAN BootMonitor( )
  359. {
  360.     int  KeySelect = 0;
  361.     BOOLEAN bConfigChanged = FALSE;
  362.     BOOLEAN bDownload = TRUE;
  364.     while(1)
  365.     {
  366.         KeySelect = 0;
  368.         EdbgOutputDebugString ( "rnEthernet Boot Loader Configuration:rn");
  369.         EdbgOutputDebugString ( "---------------------------------------rn");
  370.         EdbgOutputDebugString ( "1) IP address: %srn", inet_ntoa(g_pBootCfg->EdbgAddr.dwIP));
  371.         EdbgOutputDebugString ( "   Subnet mask: %srn", inet_ntoa(g_pBootCfg->SubnetMask));
  372.         EdbgOutputDebugString ( "2) Boot delay: %d secondsrn", g_pBootCfg->BootDelay);
  373.         EdbgOutputDebugString ( "3) DHCP: %srn", (g_pBootCfg->ConfigFlags & CONFIG_FLAGS_DHCP) ? "ENABLED" : "DISABLED");
  374.         EdbgOutputDebugString ( "4) Reset TOC to defaultrn");
  375.         EdbgOutputDebugString ( "5) Startup image: %srn", (g_pBootCfg->ConfigFlags & BOOT_TYPE_DIRECT) ? "LAUNCH EXISTING" : "DOWNLOAD NEW");
  376.         EdbgOutputDebugString ( "6) Program RAM image into Boot Media: %srn", (g_pBootCfg->ConfigFlags & TARGET_TYPE_NAND) ? "ENABLED" : "DISABLED");
  377.         EdbgOutputDebugString ( "7) MAC address: %B:%B:%B:%B:%B:%Brn",
  378.                                g_pBootCfg->EdbgAddr.wMAC[0] & 0x00FF, g_pBootCfg->EdbgAddr.wMAC[0] >> 8,
  379.                                g_pBootCfg->EdbgAddr.wMAC[1] & 0x00FF, g_pBootCfg->EdbgAddr.wMAC[1] >> 8,
  380.                                g_pBootCfg->EdbgAddr.wMAC[2] & 0x00FF, g_pBootCfg->EdbgAddr.wMAC[2] >> 8);
  381.         EdbgOutputDebugString ( "8) Kernel Debugger: %srn", (g_pBootCfg->ConfigFlags & CONFIG_FLAGS_DEBUGGER) ? "ENABLED" : "DISABLED");
  382.         EdbgOutputDebugString ( "9) Format Boot Media for BinFSrn");
  383.         EdbgOutputDebugString ( "rn");
  385.         // N.B: we need this option here since BinFS is really a RAM image, where you "format" the media
  386.         // with an MBR. There is no way to parse the image to say it's ment to be BinFS enabled.
  387.         EdbgOutputDebugString ( "B) Support BinFS: %srn", (g_pTOC->id[g_dwTocEntry].dwImageType & IMAGE_TYPE_BINFS) ? "ENABLED" : "DISABLED");
  389.         EdbgOutputDebugString ( "D) DOWNLOAD image now(Etherent)rn");
  390. //        EdbgOutputDebugString ( "E) Image descriptor Entry: %u rn", g_dwTocEntry);
  391.         EdbgOutputDebugString ( "F) Low-level FORMAT Boot Mediarn");
  392.         EdbgOutputDebugString ( "L) LAUNCH existing Boot Media imagern");
  393. EdbgOutputDebugString ( "R) Read Configuration rn");
  394.         EdbgOutputDebugString ( "U) DOWNLOAD image now(USB)rn");
  395. EdbgOutputDebugString ( "W) Write Configuration Right Nowrn");
  396.         EdbgOutputDebugString ( "X) DOWNLOAD image to boot media, then LAUNCH it off the mediarn");
  397.         EdbgOutputDebugString ( "---------------------------------------rn");
  399.         EdbgOutputDebugString ( "rnEnter your selection: ");
  401.         while (! ( ( (KeySelect >= '0') && (KeySelect <= '9') ) ||
  402.                  ( (KeySelect == 'B') || (KeySelect == 'b') )   ||
  403.                  ( (KeySelect == 'E') || (KeySelect == 'e') )   ||
  404.                  ( (KeySelect == 'F') || (KeySelect == 'f') )   ||
  405.                  ( (KeySelect == 'D') || (KeySelect == 'd') )   ||
  406.                  ( (KeySelect == 'L') || (KeySelect == 'l') )   ||
  407.                  ( (KeySelect == 'R') || (KeySelect == 'r') )   ||
  408.                  ( (KeySelect == 'U') || (KeySelect == 'u') )   ||
  409.                  ( (KeySelect == 'W') || (KeySelect == 'w') )   ||
  410.                  ( (KeySelect == 'X') || (KeySelect == 'x') )
  411.                ))
  412.         {
  413.             KeySelect = OEMReadDebugByte();
  414.         }
  416.         EdbgOutputDebugString ( "%crn", KeySelect);
  417.         switch(KeySelect)
  418.         {
  419.         case '1':           // Change IP/Subnet address.
  420.             if ( GetUserIPAddr(&g_pBootCfg->EdbgAddr, &g_pBootCfg->SubnetMask) ) {
  421.                 g_pBootCfg->ConfigFlags &= ~CONFIG_FLAGS_DHCP;   // clear DHCP flag
  422.                 bConfigChanged = TRUE;
  423.             }
  424.             continue;
  425.             break;
  426.         case '2':           // Change autoboot delay.
  427.             SetDelay(g_pBootCfg);
  428.             bConfigChanged = TRUE;
  429.             continue;
  430.             break;
  431.         case '3':           // Toggle static/DHCP mode.
  432.             g_pBootCfg->ConfigFlags = (g_pBootCfg->ConfigFlags ^ CONFIG_FLAGS_DHCP);
  433.             bConfigChanged = TRUE;
  434.             continue;
  435.             break;
  436.         case '4':           // Reset TOC configuration.
  437.             RETAILMSG(1, (TEXT("Resetting default TOC...rn")));
  438.             TOC_Init(DEFAULT_IMAGE_DESCRIPTOR, (IMAGE_TYPE_RAMIMAGE|IMAGE_TYPE_BINFS), 0, 0, 0);
  439.             if ( !TOC_Write() ) {
  440.                 RETAILMSG(1, (TEXT("TOC_Write Failed!rn")));
  441.             }
  442.             RETAILMSG(1, (TEXT("...TOC completern")));
  443.             continue;
  444.             break;
  445.         case '5':           // Toggle download/launch status.
  446.             g_pBootCfg->ConfigFlags = (g_pBootCfg->ConfigFlags ^ BOOT_TYPE_DIRECT);
  447.             bConfigChanged = TRUE;
  448.             break;
  449.         case '6':           // Toggle boot media image store.
  450.             g_pBootCfg->ConfigFlags = (g_pBootCfg->ConfigFlags ^ TARGET_TYPE_NAND);
  451.             bConfigChanged = TRUE;
  452.             break;
  453.         case '7':           // Configure MAC address.
  454.             SetCS8900MACAddress();
  455.             bConfigChanged = TRUE;
  456.             continue;
  457.             break;
  458.         case '8':           // Toggle KD
  459.             g_pBootCfg->ConfigFlags = (g_pBootCfg->ConfigFlags ^ CONFIG_FLAGS_DEBUGGER);
  460.             g_bWaitForConnect = (g_pBootCfg->ConfigFlags & CONFIG_FLAGS_DEBUGGER) ? TRUE : FALSE;
  461.             bConfigChanged = TRUE;
  462.             continue;
  463.             break;
  464.         case '9':
  465.             // format the boot media for BinFS
  466.             // N.B: this does not destroy our OEM reserved sections (TOC, bootloaders, etc)
  467.             if ( !g_bBootMediaExist ) {
  468.                 RETAILMSG(1, (TEXT("ERROR: BootMonitor: boot media does not exist.rn")));
  469.                 continue;
  470.             }
  471.             // N.B: format offset by # of reserved blocks,
  472.             // decrease the ttl # blocks available by that amount.
  473.             if ( !BP_LowLevelFormat( g_dwImageStartBlock,
  474.                                      NUM_BLOCKS - g_dwImageStartBlock,
  475.                                      0) )
  476.             {
  477.                 RETAILMSG(1, (TEXT("ERROR: BootMonitor: Low-level boot media format failed.rn")));
  478.                 continue;
  479.             }
  480.             break;
  481.         case 'B':
  482.         case 'b':
  483.             g_pTOC->id[g_dwTocEntry].dwImageType = (g_pTOC->id[g_dwTocEntry].dwImageType ^ IMAGE_TYPE_BINFS);
  484.             g_ImageType = g_pTOC->id[g_dwTocEntry].dwImageType;
  485.             bConfigChanged = TRUE;
  486.             break;
  487.         case 'E':
  488.         case 'e':
  489.             // TODO
  490.             break;
  491.         case 'F':
  492.         case 'f':
  493.             // low-level format
  494.             // N.B: this erases images, BinFs, FATFS, user data, etc.
  495.             // However, we don't format Bootloaders & TOC bolcks; use JTAG for this.
  496.             if ( !g_bBootMediaExist ) {
  497.                 RETAILMSG(1, (TEXT("ERROR: BootMonitor: boot media does not exist.rn")));
  498.                 continue;
  499.             } else {
  500.                 DWORD i;
  501.                 SectorInfo si;
  503.                 // to keep bootpart off of our reserved blocks we must mark it as bad, reserved & read-only
  504.                 si.bOEMReserved = OEM_BLOCK_RESERVED | OEM_BLOCK_READONLY;
  505.                 si.bBadBlock    = BADBLOCKMARK;
  506.                 si.dwReserved1  = 0;
  507.                 si.wReserved2   = 0;
  509.                 RETAILMSG(1, (TEXT("Reserving Blocks [0x%x - 0x%x] ...rn"), 0, IMAGE_START_BLOCK-1));
  510.                 for (i = 0; i < IMAGE_START_SECTOR; i++) {
  511.                     FMD_WriteSector(i, NULL, &si, 1);
  512.                 }
  513.                 RETAILMSG(1, (TEXT("...reserve complete.rn")));
  515.                 RETAILMSG(1, (TEXT("Low-level format Blocks [0x%x - 0x%x] ...rn"), IMAGE_START_BLOCK, NUM_BLOCKS-1));
  516.                 for (i = IMAGE_START_BLOCK; i < NUM_BLOCKS; i++) {
  517.                     FMD_EraseBlock(i);
  518.                 }
  519.                 RETAILMSG(1, (TEXT("...erase complete.rn")));
  520.             } break;
  521.         case 'D':           // Download? Yes.
  522.         case 'd':
  523.             bDownload = TRUE;
  524.             goto MENU_DONE;
  525.         case 'L':           // Download? No.
  526.         case 'l':
  527.             bDownload = FALSE;
  528.             goto MENU_DONE;
  529.         case 'R':
  530.         case 'r':
  531. TOC_Read();
  532. continue;
  533.             // TODO
  534.             break;
  535.         case 'U':           // Download? No.
  536.         case 'u':
  537.             g_bWaitForConnect = FALSE;
  538.             bConfigChanged = TRUE;
  539. g_bUSBDownload = TRUE;
  540.             bDownload = TRUE;
  541.             goto MENU_DONE;
  542.         case 'W':           // Configuration Write
  543.         case 'w':
  544.             if (!TOC_Write())
  545.             {
  546.                 RETAILMSG(1, (TEXT("WARNING: MainMenu: Failed to store updated eboot configuration in flash.rn")));
  547.             }
  548.             else
  549.             {
  550.                 RETAILMSG(1, (TEXT("Successfully Writtenrn")));
  551.                 bConfigChanged = FALSE;
  552.             }
  553.             break;
  554.         case 'X':           // Download to media, then launch that
  555.         case 'x':
  556.             bDownload = TRUE;
  557.             bConfigChanged = TRUE;
  558.             g_pBootCfg->ConfigFlags |= TARGET_TYPE_NAND | BOOT_TYPE_DIRECT;
  559.             goto MENU_DONE;
  560.         default:
  561.             break;
  562.         }
  563.     }
  565. MENU_DONE:
  566.     // If eboot settings were changed by user, save them.
  567.     //
  568.     if (bConfigChanged && !TOC_Write( ) )
  569.     {
  570.         RETAILMSG(1, (TEXT("WARNING: BootMonitor: Failed to store updated eboot configuration in flash.rn")));
  571.     }
  573.     return(bDownload);
  574. }
  577. /*
  578.     @func   BOOL | OEMPlatformInit | Initialize the platform hardware.
  579.     @rdesc  TRUE = Success, FALSE = Failure.
  580.     @comm
  581.     @xref
  582. */
  583. BOOL OEMPlatformInit()
  584. {
  585.     SYSTEMTIME  st;
  586.     SYSTEMTIME  defst = {2002, 1, 0, 1, 12, 0, 0, 0};
  587.     DWORD dwStartTime, dwPrevTime, dwCurrTime;
  588.     int   cKeySelect = 0;
  589.     DWORD dwBootDelay = 10; // seconds. N.B: change for retail device!
  591. #ifdef SIMULATOR
  592.     EdbgOutputDebugString("Microsoft Windows CE SMDK2440 Bootloader *** SIMULATOR *** rn");
  593. #else
  594.     EdbgOutputDebugString("Microsoft Windows CE SMDK2440 Bootloader Version %d.%d Built %s %s rn",
  595.                           EBOOT_VERSION_MAJOR, EBOOT_VERSION_MINOR, __DATE__, __TIME__);
  596. #endif
  598.     //  Initialize the globals
  599.     //
  600.     memset((LPVOID) &(pDriverGlobals->eth), 0, DBG_ETH_GLOBALS_SIZE);
  601.     memset((LPVOID) &g_TOC, 0, sizeof(g_TOC));
  603.     // This should not change unless reserved blocks are added/removed;
  604.     // made global to do the calc only once.
  605.     g_dwImageStartBlock = IMAGE_START_BLOCK;
  607.     // Check real time clock, initialize if necessary (used for polling in net routines)
  608.     //
  609.     OEMGetRealTime(&st);
  610.     if ((st.wYear < 2000) ||
  611.         (st.wMonth < 1) ||
  612.         (st.wMonth > 12) ||
  613.         (st.wDay < 1) ||
  614.         (st.wDay > 31) ||
  615.         (st.wHour > 23) ||
  616.         (st.wMinute > 59) ||
  617.         (st.wSecond > 59) ||
  618.         (st.wMilliseconds > 999)) {
  619.         OEMSetRealTime(&defst);
  620.     }
  621.     else {
  622.         OEMSetRealTime(&st);
  623.     }
  625. if (!InitUSB())
  626.     {
  627.         DEBUGMSG(1, (TEXT("OEMPlatformInit: Failed to initialize USB.rn")));
  628.         return(FALSE);
  629.     }
  631. Isr_Init();
  633.     // Try to initialize the boot media block driver and BinFS partition.
  634.     //
  635.     if ( !BP_Init((LPBYTE)BINFS_RAM_START, BINFS_RAM_LENGTH, NULL, NULL, NULL) )
  636.     {
  637.         EdbgOutputDebugString("WARNING: OEMPlatformInit failed to initialize Boot Media.rnrn");
  638.         g_bBootMediaExist = FALSE;
  639.     }
  640.     else
  641.         g_bBootMediaExist = TRUE;
  644.     // Try to retrieve TOC (and Boot config) from boot media
  645.     //
  646.     if ( !TOC_Read( ) ) {
  648.         // use default settings
  649.         TOC_Init(DEFAULT_IMAGE_DESCRIPTOR, (IMAGE_TYPE_RAMIMAGE|IMAGE_TYPE_BINFS), 0, 0, 0);
  650.     }
  652.     // Start boot monitor prompt
  653.     //
  654.     dwBootDelay = g_pBootCfg->BootDelay;
  656.     if (g_pBootCfg->ConfigFlags & BOOT_TYPE_DIRECT)
  657.     {
  658.         EdbgOutputDebugString ( "Press [ENTER] to launch image stored on boot media, or [SPACE] to enter boot monitor.rn");
  659.         EdbgOutputDebugString ( "rnInitiating image launch in %d seconds. ", dwBootDelay--);
  660.     } else
  661.     {
  662.         EdbgOutputDebugString ( "Press [ENTER] to download image now, or [SPACE] to enter boot monitor.rn");
  663.         EdbgOutputDebugString ( "rnInitiating image download in %d seconds. ", dwBootDelay--);
  664.     }
  665.     dwStartTime = OEMEthGetSecs();
  666.     dwPrevTime  = dwStartTime;
  667.     dwCurrTime  = dwStartTime;
  669.     // allow the user to break into boot monitor
  670.     while((dwCurrTime - dwStartTime) < dwBootDelay)
  671.     {
  672.         cKeySelect = OEMReadDebugByte();
  673.         if ((cKeySelect == 0x20) || (cKeySelect == 0x0d))
  674.             break;
  675.         dwCurrTime = OEMEthGetSecs();
  677.         if (dwCurrTime > dwPrevTime)
  678.         {
  679.             int i=0, j;
  681.             // 1 Second has elapsed - update the countdown timer.
  682.             dwPrevTime = dwCurrTime;
  683.             if (dwBootDelay < 9)
  684.                 i = 11;
  685.             else if (dwBootDelay < 99)
  686.                 i = 12;
  687.             else if (dwBootDelay < 999)
  688.                 i = 13;
  690.             for(j = 0; j < i; j++)
  691.                 OEMWriteDebugByte((BYTE)0x08); // print back space
  692.             EdbgOutputDebugString ( "%d seconds. ", dwBootDelay--);
  693.         }
  694.     }
  696.     EdbgOutputDebugString ( "rn");
  697.     switch(cKeySelect)
  698.     {
  699.     case 0x20: // Boot monitor.
  700.         g_bDownloadImage = BootMonitor( );
  701.         break;
  702.     case 0x00: // Fall through if no keys were pressed -or-
  703.     case 0x0d: // the user cancelled the countdown.
  704.     default:
  705.         if (g_pBootCfg->ConfigFlags & BOOT_TYPE_DIRECT)
  706.         {
  707.             EdbgOutputDebugString ( "rnLaunching image from boot media ... rn");
  708.             g_bDownloadImage = FALSE;
  709.         }
  710.         else
  711.         {
  712.             EdbgOutputDebugString ( "rnStarting auto-download ... rn");
  713.             g_bDownloadImage = TRUE;
  714.         }
  715.         break;
  716.     }
  718.     // NOTE - right now, we assume that if we're downloading, it's done over Ethernet.
  719.     // In the future, this may include other transports (USB, etc.).
  720.     //
  721.     if ( !g_bDownloadImage )
  722.     {
  723.         // User doesn't want to download image - load it from the boot media.
  724.         // We could read an entire nk.bin or nk.nb0 into ram and jump.
  725.         if ( !VALID_TOC(g_pTOC) ) {
  726.             EdbgOutputDebugString("OEMPlatformInit: ERROR_INVALID_TOC, can not autoboot.rn");
  727.             return FALSE;
  728.         }
  730.         switch (g_ImageType) {
  731.             case IMAGE_TYPE_LOADER:
  732.                 EdbgOutputDebugString("OEMPlatformInit: IMAGE_TYPE_LOADERrn");
  733.                 break;
  735.             case IMAGE_TYPE_RAMIMAGE:
  736.                 EdbgOutputDebugString("OEMPlatformInit: IMAGE_TYPE_RAMIMAGErn");
  737.                 if ( !ReadRamImageFromBootMedia( ) ) {
  738.                     RETAILMSG(1, (TEXT("OEMPlatformInit ERROR: Failed to load kernel region into RAM.rn")));
  739.                     return FALSE;
  740.                 }
  741.                 break;
  743.             case (IMAGE_TYPE_RAMIMAGE|IMAGE_TYPE_BINFS):
  744.             case (IMAGE_TYPE_RAMIMAGE|IMAGE_TYPE_BINFS|IMAGE_TYPE_MXIP):
  745.                 EdbgOutputDebugString("OEMPlatformInit: IMAGE_TYPE_RAMIMAGE|IMAGE_TYPE_BINFS|IMAGE_TYPE_MXIPrn");
  746.                 // N.B: this assumes the image is setup as multi-bin for BinFS.
  747.                 if ( !ReadKernelRegionFromBootMedia( ) ) {
  748.                     RETAILMSG(1, (TEXT("OEMPlatformInit ERROR: Failed to load kernel region into RAM.rn")));
  749.                     return FALSE;
  750.                 }
  751.                 break;
  753.             default:
  754.                 EdbgOutputDebugString("OEMPlatformInit ERROR: unknown image type: 0x%x rn", g_ImageType );
  755.                 return FALSE;
  756.         }
  757.     }
  759.     // If user specified a static IP address, use it (don't use DHCP).
  760.     //
  761.     if (g_bDownloadImage && !(g_pBootCfg->ConfigFlags & CONFIG_FLAGS_DHCP))
  762.     {
  763.         pDriverGlobals->eth.TargetAddr.dwIP = g_pBootCfg->EdbgAddr.dwIP;
  764.         pDriverGlobals->eth.SubnetMask      = g_pBootCfg->SubnetMask;
  765.     }
  768.     // Configure Ethernet controller.
  769. if ( g_pBootCfg->ConfigFlags & CONFIG_FLAGS_DEBUGGER )
  770. {
  771. if (!InitEthDevice(g_pBootCfg))
  772. {
  773. DEBUGMSG(1, (TEXT("OEMPlatformInit: Failed to initialize Ethernet controller.rn")));
  774. return(FALSE);
  775. }
  776. }
  778.     return TRUE;
  779. }
  782. /*
  783.     @func   DWORD | OEMPreDownload | Complete pre-download tasks - get IP address, initialize TFTP, etc.
  785.     @rdesc  BL_DOWNLOAD = Platform Builder is asking us to download an image,
  786.             BL_JUMP = Platform Builder is requesting we jump to an existing image,
  787.             BL_ERROR = Failure.
  788.     @comm
  789.     @xref
  790. */
  791. DWORD OEMPreDownload()
  792. {
  793.     char szDeviceName[EDBG_MAX_DEV_NAMELEN];
  794.     BOOL fGotJumpImg = FALSE;
  795.     DWORD DHCPLeaseTime = 0, *pDHCPLeaseTime = &DHCPLeaseTime;
  797.     // If user wants to jump to existing image with no KD - skip download...
  798.     //
  799.     if ( !g_bDownloadImage && !g_bWaitForConnect)
  800.     {
  801.         return(BL_JUMP);
  802.     }
  804.     if ( !g_bDownloadImage && g_bWaitForConnect )
  805.         fGotJumpImg = TRUE;
  807.     //
  808.     // Create device name based on MAC address.
  809.     //
  810.     memset(szDeviceName, 0, EDBG_MAX_DEV_NAMELEN);
  811.     CreateDeviceName(&g_pBootCfg->EdbgAddr, szDeviceName);
  812.     EdbgOutputDebugString("Using device name: '%s'n", szDeviceName);
  814.     // initialize TFTP transport
  815.     //
  816.     if ( !(g_pBootCfg->ConfigFlags & CONFIG_FLAGS_DHCP) ) {
  817.         pDHCPLeaseTime = NULL;  // the pDHCPLeaseTime parameter is overloaded.
  818.                                 // NULL indicates static IP
  819.         pDriverGlobals->eth.EdbgFlags = EDBG_FLAGS_STATIC_IP;
  820.     }
  822. #ifndef SIMULATOR
  823. if ( g_bUSBDownload == FALSE )
  824. {
  825. if (g_bDownloadImage &&
  826. !EbootInitEtherTransport (&g_pBootCfg->EdbgAddr, &g_pBootCfg->SubnetMask, &fGotJumpImg, pDHCPLeaseTime,
  827. EBOOT_VERSION_MAJOR, EBOOT_VERSION_MINOR, PLATFORM_STRING, szDeviceName, EDBG_CPUID, 0)) {
  828. return BL_ERROR;
  829. }
  830. }
  831. #endif
  833. //    SMCSetOptions(OPT_BROADCAST_FILTERING);
  835.     // update DHCP lease time
  836.     pDriverGlobals->eth.DHCPLeaseTime = DHCPLeaseTime;
  838. if ( g_bUSBDownload == TRUE )
  839.     EdbgOutputDebugString("Please send the Image through USBrn");
  841.     return fGotJumpImg? BL_JUMP : BL_DOWNLOAD;
  842. }
  845. /*
  846.     @func   void | OEMLaunch | Executes the stored/downloaded image.
  847.     @rdesc  N/A.
  848.     @comm
  849.     @xref
  850. */
  851. void OEMLaunch(DWORD dwImageStart, DWORD dwImageLength, DWORD dwLaunchAddr, const ROMHDR *pRomHdr)
  852. {
  853.     EDBG_OS_CONFIG_DATA *pCfgData;
  854.     EDBG_ADDR EshellHostAddr = {0,0,0};
  856.     EdbgOutputDebugString("::OEMLaunch, ImageStart:0x%x, ImageLength:0x%x, LaunchAddr:0x%xrn",
  857.         dwImageStart, dwImageLength, dwLaunchAddr);
  859.     // Wait for Platform Builder to connect after the download and send us IP and port settings for service
  860.     // connections - also sends us KITL flags.  This information is used later by the OS (KITL).
  861.     //
  862. #ifndef SIMULATOR
  863.     if ( g_bDownloadImage && g_bWaitForConnect )
  864.     {
  865.         EdbgOutputDebugString ("EbootWaitForHostConenctrn");
  866.         pCfgData = EbootWaitForHostConnect (&g_pBootCfg->EdbgAddr, &EshellHostAddr);
  867.         if (!pCfgData) {
  868.             EdbgOutputDebugString ("EbootWaitForHostConenct failed, spin foreverrn");
  869.             SPIN_FOREVER;
  870.         }
  871.         if (pCfgData->Flags & EDBG_FL_DBGMSG) {
  872.             EdbgOutputDebugString("Enabling debug messages over Ethernet, IP: %s, port:%un",
  873.                 inet_ntoa(pCfgData->DbgMsgIPAddr),ntohs(pCfgData->DbgMsgPort));
  874.             memcpy(&pDriverGlobals->eth.DbgHostAddr.wMAC,&EshellHostAddr.wMAC,6);
  875.             pDriverGlobals->eth.DbgHostAddr.dwIP  = pCfgData->DbgMsgIPAddr;
  876.             pDriverGlobals->eth.DbgHostAddr.wPort = pCfgData->DbgMsgPort;
  877.         }
  878.         if (pCfgData->Flags & EDBG_FL_PPSH) {
  879.             EdbgOutputDebugString("Enabling CESH over Ethernet,           IP: %s, port:%un",
  880.                 inet_ntoa(pCfgData->PpshIPAddr),ntohs(pCfgData->PpshPort));
  881.             memcpy(&pDriverGlobals->eth.PpshHostAddr.wMAC,&EshellHostAddr.wMAC,6);
  882.             pDriverGlobals->eth.PpshHostAddr.dwIP  = pCfgData->PpshIPAddr;
  883.             pDriverGlobals->eth.PpshHostAddr.wPort = pCfgData->PpshPort;
  884.         }
  885.         if (pCfgData->Flags & EDBG_FL_KDBG) {
  886.             EdbgOutputDebugString("Enabling KDBG over Ethernet,           IP: %s, port:%un",
  887.                 inet_ntoa(pCfgData->KdbgIPAddr),ntohs(pCfgData->KdbgPort));
  888.             memcpy(&pDriverGlobals->eth.KdbgHostAddr.wMAC,&EshellHostAddr.wMAC,6);
  889.             pDriverGlobals->eth.KdbgHostAddr.dwIP  = pCfgData->KdbgIPAddr;
  890.             pDriverGlobals->eth.KdbgHostAddr.wPort = pCfgData->KdbgPort;
  891.         }
  893.         memcpy(&pDriverGlobals->eth.DownloadHostAddr,&EshellHostAddr,sizeof(EDBG_ADDR));
  894.         pDriverGlobals->eth.etherFlags = pCfgData->Flags;
  895.         pDriverGlobals->eth.KitlTransport = pCfgData->KitlTransport;
  896.         EdbgOutputDebugString ("KitlTransport: 0x%xrn", pCfgData->KitlTransport);
  897.         pDriverGlobals->eth.EbootMagicNum = EBOOT_MAGIC_NUM;
  898.     }
  899.     else if ( !g_bDownloadImage && g_bWaitForConnect)
  900.     {
  901.         EdbgOutputDebugString ("Eboot setup Kitl from media bootrn");
  902.         pDriverGlobals->eth.KitlTransport = KTS_ETHER;
  903.         pDriverGlobals->eth.EbootMagicNum = EBOOT_MAGIC_NUM;
  904.     }
  905. #endif
  907.     // Update address info, in driver globals, and in EEPROM if necessary
  908.     memcpy (&pDriverGlobals->eth.TargetAddr, &g_pBootCfg->EdbgAddr, sizeof(g_pBootCfg->EdbgAddr));
  909.     pDriverGlobals->eth.SubnetMask = g_pBootCfg->SubnetMask;
  911.     // If the user requested an image be stored on media, do so now.  For multiple RAM BIN files, we need to map
  912.     // its RAM address to a flash address - the image base address offset in RAM is maintained in flash.
  913.     //
  915.     // Remember kernel launch address or recall stored address if this download didn't provide one
  916.     // (i.e., we didn't download the kernel region).
  917.     if (g_bDownloadImage && (g_pBootCfg->ConfigFlags & TARGET_TYPE_NAND))
  918.     {
  919. if (dwImageStart && dwImageLength)
  920. {
  921. g_pTOC->id[g_dwTocEntry].dwLoadAddress = dwImageStart;
  922. g_pTOC->id[g_dwTocEntry].dwTtlSectors = FILE_TO_SECTOR_SIZE(dwImageLength);
  923. }
  925.         switch ( g_ImageType ) {
  926.             case IMAGE_TYPE_LOADER:
  927.                 EdbgOutputDebugString("OEMLaunch: IMAGE_TYPE_LOADERrn");
  928.                 if ( !WriteRamImageToBootMedia(g_dwTocEntry) ) {
  929.                     RETAILMSG(1, (TEXT("OEMLaunch ERROR: Failed to write image to boot media.rn")));
  930.                     SPIN_FOREVER;
  931.                 }
  932.                 break;
  934.             case IMAGE_TYPE_RAMIMAGE:
  935.                 EdbgOutputDebugString("OEMLaunch: IMAGE_TYPE_RAMIMAGErn");
  936.                 if ( !WriteRamImageToBootMedia(g_dwTocEntry) ) {
  937.                     RETAILMSG(1, (TEXT("OEMLaunch ERROR: Failed to write image to boot media.rn")));
  938.                     SPIN_FOREVER;
  939.                 }
  940.                 break;
  942.             case (IMAGE_TYPE_RAMIMAGE|IMAGE_TYPE_BINFS|IMAGE_TYPE_MXIP):
  943.             case (IMAGE_TYPE_RAMIMAGE|IMAGE_TYPE_BINFS):
  944.                 EdbgOutputDebugString("OEMLaunch: (%s|IMAGE_TYPE_BINFS)rn",
  945.                     (g_ImageType & IMAGE_TYPE_MXIP) ? "IMAGE_TYPE_MXIP" : "IMAGE_TYPE_RAMIMAGE");
  946.                 if ( !WriteRegionsToBootMedia(dwImageStart, dwImageLength, dwLaunchAddr) ) {
  947.                     EdbgOutputDebugString("WARNING: OEMLaunch: Failed to store BinFS regions to boot media.rn");
  948.                     SPIN_FOREVER;
  949.                 }
  950.                 break;
  952.             default:
  953.                 EdbgOutputDebugString("OEMLaunch ERROR: unknown image type: 0x%x rn",
  954.                     g_pTOC->id[g_dwTocEntry].dwImageType);
  955.                 SPIN_FOREVER;
  956.         }
  957.     }
  959. // Remember kernel launch address or recall stored address if this download didn't provide one (i.e., we didn't download the kernel region).
  960. //
  961. if (dwLaunchAddr && (g_pTOC->id[g_dwTocEntry].dwJumpAddress != dwLaunchAddr))
  962. {
  963. g_pTOC->id[g_dwTocEntry].dwJumpAddress = dwLaunchAddr;
  964. if ( !TOC_Write() ) {
  965.             EdbgOutputDebugString("*** OEMLaunch ERROR: TOC_Write failed! Next boot may not load from disk *** rn");
  966. }
  967.         TOC_Print();
  968. }
  969. else
  970. {
  971. dwLaunchAddr= g_pTOC->id[g_dwTocEntry].dwJumpAddress;
  972. EdbgOutputDebugString("INFO: using TOC[%d] dwJumpAddress: 0x%xrn", g_dwTocEntry, dwLaunchAddr);
  973. }
  975.     EdbgOutputDebugString("rnJumping to image at virtual address 0x%Xhrn", dwLaunchAddr);
  977.     //  Our Launch function takes Physical address, so we need to convert it
  978.     //  to physical address
  980.     dwLaunchAddr = ToPhysicalAddr(dwLaunchAddr);
  981.     EdbgOutputDebugString("rn::: Physical Launch Address: 0x%Xhrn",dwLaunchAddr);
  983.     Launch(dwLaunchAddr);
  985.     // never returned
  986.     SPIN_FOREVER;
  987. }
  990. /*
  991.     @func   BOOL | OEMReadData | Generically read download data (abstracts actual transport read call).
  992.     @rdesc  TRUE = Success, FALSE = Failure.
  993.     @comm
  994.     @xref
  995. */
  996. BOOL OEMReadData (DWORD cbData, LPBYTE pbData)
  997. {
  998. if ( g_bUSBDownload == FALSE )
  999. {
  1000. return EbootEtherReadData(cbData, pbData);
  1001. }
  1002. else
  1003. {
  1004. return UbootReadData(cbData, pbData);
  1005. }
  1006. }
  1009. /*
  1010.     @func   void | OEMShowProgress | Displays download progress for the user.
  1011.     @rdesc  N/A.
  1012.     @comm
  1013.     @xref
  1014. */
  1015. void OEMShowProgress (DWORD dwPacketNum)
  1016. {
  1017. }
  1020. #define BACKSPACE   8
  1021. #define IPADDR_MAX  15
  1022. // Read IP from command line
  1023. static BOOL ReadIPLine (char *pbuf, DWORD dwTimeout)
  1024. {
  1025.     DWORD dwCurrSec = OEMEthGetSecs ();
  1026.     char ch;
  1027.     int nLen = 0;
  1028.     while (OEMEthGetSecs () - dwCurrSec < dwTimeout) {
  1029.         ch = (CHAR)OEMReadDebugByte();
  1030.         switch (ch) {
  1031.         case OEM_DEBUG_COM_ERROR:
  1032.         case OEM_DEBUG_READ_NODATA:
  1033.             // no data or error, keep reading
  1034.             break;
  1036.         case BACKSPACE:
  1037.             nLen --;
  1038.             OEMWriteDebugByte (ch);
  1039.             break;
  1041.         case 'r':
  1042.         case 'n':
  1043.             OEMWriteDebugByte ('n');
  1044.             pbuf[nLen] = 0;
  1045.             return TRUE;
  1047.         default:
  1048.             if ((ch == '.' || (ch >= '0' && ch <= '9')) && (nLen < IPADDR_MAX)) {
  1049.                 pbuf[nLen ++] = ch;
  1050.                 OEMWriteDebugByte (ch);
  1051.             }
  1052.         }
  1053.     }
  1055.     return FALSE;   // timeout
  1056. }
  1059. // get users IP / SubnetMask
  1060. // return TRUE is changes made to either, else FALSE.
  1061. static BOOL GetUserIPAddr (EDBG_ADDR *pMyAddr, DWORD *pdwSubnetMask)
  1062. {
  1063.     char  szbuf[IPADDR_MAX+1];
  1064.     uchar changes = 0;
  1066.     memset(szbuf, 0, sizeof(szbuf));
  1068.     EdbgOutputDebugString ("rnEnter IP address, or CR for default (%s): ", inet_ntoa(pMyAddr->dwIP));
  1069.     ReadIPLine (szbuf, INFINITE);
  1070.     if (szbuf[0]) {
  1071.         pMyAddr->dwIP = inet_addr(szbuf);
  1072.         changes++;
  1073.         memset(szbuf, 0, sizeof(szbuf));
  1074.     }
  1076.     EdbgOutputDebugString ("rnEnter Subnet Masks, or CR for default (%s): ", inet_ntoa(*pdwSubnetMask));
  1077.     ReadIPLine (szbuf, INFINITE);
  1078.     if (szbuf[0]) {
  1079.         *pdwSubnetMask = inet_addr (szbuf);
  1080.         changes++;
  1081.     }
  1083.     EdbgOutputDebugString ( "rnUsing IP Address %s, subnet mask %srn",
  1084.                 inet_ntoa (pMyAddr->dwIP), inet_ntoa (*pdwSubnetMask));
  1086.     return (changes ? TRUE : FALSE);
  1087. }
  1089. static ULONG mystrtoul(PUCHAR pStr, UCHAR nBase)
  1090. {
  1091.     UCHAR nPos=0;
  1092.     BYTE c;
  1093.     ULONG nVal = 0;
  1094.     UCHAR nCnt=0;
  1095.     ULONG n=0;
  1097.     // fulllibc doesn't implement isctype or iswctype, which are needed by
  1098.     // strtoul, rather than including coredll code, here's our own simple strtoul.
  1100.     if (pStr == NULL)
  1101.         return(0);
  1103.     for (nPos=0 ; nPos < strlen(pStr) ; nPos++)
  1104.     {
  1105. //        c = tolower(*(pStr + strlen(pStr) - 1 - nPos));
  1106.         c = (*(pStr + strlen(pStr) - 1 - nPos));
  1107.         if (c >= '0' && c <= '9')
  1108.             c -= '0';
  1109.         else if (c >= 'a' && c <= 'f')
  1110.         {
  1111.             c -= 'a';
  1112.             c  = (0xa + c);
  1113.         }
  1115.         for (nCnt = 0, n = 1 ; nCnt < nPos ; nCnt++)
  1116.         {
  1117.             n *= nBase;
  1118.         }
  1119.         nVal += (n * c);
  1120.     }
  1122.     return(nVal);
  1123. }
  1125. // since the startup code is in OAL and it branch to main, we'll just
  1126. // implement a pseudo 'main' instead of changing the startup code
  1127. void main (void)
  1128. {
  1129.     BootloaderMain ();
  1131.     SPIN_FOREVER;
  1132. }
  1134. VOID SC_WriteDebugLED(WORD wIndex, DWORD dwPattern)
  1135. {
  1136.     OEMWriteDebugLED(wIndex,dwPattern);
  1137. }
  1139. /*
  1140.     @func   void | SetDelay | Accepts an autoboot delay value from user input.
  1141.     @rdesc  N/A.
  1142.     @comm    
  1143.     @xref   
  1144. */
  1145. static void SetDelay()
  1146. {
  1147.     CHAR szCount[16];
  1148.     USHORT cwNumChars = 0;
  1149.     USHORT InChar = 0;
  1151.     EdbgOutputDebugString("rnEnter maximum number of seconds to delay [1-255]: ");
  1153.     while(!((InChar == 0x0d) || (InChar == 0x0a)))
  1154.     {
  1155.         InChar = OEMReadDebugByte();
  1156.         if (InChar != OEM_DEBUG_COM_ERROR && InChar != OEM_DEBUG_READ_NODATA) 
  1157.         {
  1158.             // If it's a number or a period, add it to the string.
  1159.             //
  1160.             if ((InChar >= '0' && InChar <= '9')) 
  1161.             {
  1162.                 if (cwNumChars < 16) 
  1163.                 {
  1164.                     szCount[cwNumChars++] = (char)InChar;
  1165.                     OEMWriteDebugByte((BYTE)InChar);
  1166.                 }
  1167.             }
  1168.             // If it's a backspace, back up.
  1169.             //
  1170.             else if (InChar == 8) 
  1171.             {
  1172.                 if (cwNumChars > 0) 
  1173.                 {
  1174.                     cwNumChars--;
  1175.                     OEMWriteDebugByte((BYTE)InChar);
  1176.                 }
  1177.             }
  1178.         }
  1179.     }
  1181.     // If it's a carriage return with an empty string, don't change anything.
  1182.     //
  1183.     if (cwNumChars) 
  1184.     {
  1185.         szCount[cwNumChars] = '';
  1186.         g_pBootCfg->BootDelay = atoi(szCount);
  1187.         if (g_pBootCfg->BootDelay > 255)
  1188.         {
  1189.             g_pBootCfg->BootDelay = 255;
  1190.         } 
  1191.         else if (g_pBootCfg->BootDelay < 1)
  1192.         {
  1193.             g_pBootCfg->BootDelay = 1;
  1194.         }
  1195.     }
  1196. }
  1200. static void CvtMAC(USHORT MacAddr[3], char *pszDottedD ) 
  1201. {
  1202.     DWORD cBytes;
  1203.     char *pszLastNum;
  1204.     int atoi (const char *s);
  1205.     int i=0;    
  1206.     BYTE *p = (BYTE *)MacAddr;
  1208.     // Replace the dots with NULL terminators
  1209.     pszLastNum = pszDottedD;
  1210.     for(cBytes = 0 ; cBytes < 6 ; cBytes++)
  1211.     {
  1212.         while(*pszDottedD != '.' && *pszDottedD != '')
  1213.         {
  1214.             pszDottedD++;
  1215.         }
  1216.         if (pszDottedD == '' && cBytes != 5)
  1217.         {
  1218.             // zero out the rest of MAC address
  1219.             while(i++ < 6)
  1220.             {
  1221.                 *p++ = 0;
  1222.             }
  1223.             break;
  1224.         }
  1225.         *pszDottedD = '';
  1226.         *p++ = (BYTE)(mystrtoul(pszLastNum, 16) & 0xFF);
  1227.         i++;
  1228.         pszLastNum = ++pszDottedD;
  1229.     }
  1230. }
  1234. static void SetCS8900MACAddress()
  1235. {
  1236.     CHAR szDottedD[24];
  1237.     USHORT cwNumChars = 0;
  1238.     USHORT InChar = 0;
  1240.     memset(szDottedD, '0', 24);
  1242.     EdbgOutputDebugString ( "rnEnter new MAC address in hexadecimal (hh.hh.hh.hh.hh.hh): ");
  1244.     while(!((InChar == 0x0d) || (InChar == 0x0a)))
  1245.     {
  1246.         InChar = OEMReadDebugByte();
  1247. //        InChar = tolower(InChar);
  1248.         if (InChar != OEM_DEBUG_COM_ERROR && InChar != OEM_DEBUG_READ_NODATA) 
  1249.         {
  1250.             // If it's a hex number or a period, add it to the string.
  1251.             //
  1252.             if (InChar == '.' || (InChar >= '0' && InChar <= '9') || (InChar >= 'a' && InChar <= 'f')) 
  1253.             {
  1254.                 if (cwNumChars < 17) 
  1255.                 {
  1256.                     szDottedD[cwNumChars++] = (char)InChar;
  1257.                     OEMWriteDebugByte((BYTE)InChar);
  1258.                 }
  1259.             }
  1260.             else if (InChar == 8)       // If it's a backspace, back up.
  1261.             {
  1262.                 if (cwNumChars > 0) 
  1263.                 {
  1264.                     cwNumChars--;
  1265.                     OEMWriteDebugByte((BYTE)InChar);
  1266.                 }
  1267.             }
  1268.         }
  1269.     }
  1271.     EdbgOutputDebugString ( "rn");
  1273.     // If it's a carriage return with an empty string, don't change anything.
  1274.     //
  1275.     if (cwNumChars) 
  1276.     {
  1277.         szDottedD[cwNumChars] = '';
  1278.         CvtMAC(g_pBootCfg->EdbgAddr.wMAC, szDottedD);
  1280.         EdbgOutputDebugString("INFO: MAC address set to: %x:%x:%x:%x:%x:%xrn",
  1281.                   g_pBootCfg->EdbgAddr.wMAC[0] & 0x00FF, g_pBootCfg->EdbgAddr.wMAC[0] >> 8,
  1282.                   g_pBootCfg->EdbgAddr.wMAC[1] & 0x00FF, g_pBootCfg->EdbgAddr.wMAC[1] >> 8,
  1283.                   g_pBootCfg->EdbgAddr.wMAC[2] & 0x00FF, g_pBootCfg->EdbgAddr.wMAC[2] >> 8);
  1284.     }
  1285.     else
  1286.     {
  1287.         EdbgOutputDebugString("WARNING: SetCS8900MACAddress: Invalid MAC address.rn");
  1288.     }
  1289. }