main.c

freescale i.mx31 BSP CE5.0全部源码

                    case CONFIG_AUTOBOOT_DEVICE_NAND:
                        if(ReadKernelRegionFromNand(pBootCfg))
                            g_DownloadImage = FALSE;
                        else
                            OALMSG(OAL_ERROR, (TEXT("ERROR: Failed to load kernel region into RAM.\r\n")));
                        break;
#endif
                    default:
                        OALMSG(OAL_ERROR, (TEXT("ERROR: Invalid auto boot setting.\r\n")));
                        pBootCfg->ConfigFlags &= ~CONFIG_FLAGS_AUTOBOOT;
                        break;
                }
                OALWriteBootCFG(pBootCfg);
            }
            break;
    }
    
    if(g_DownloadImage)
    {
        // Configure Ethernet controller.
        //
        OALMSG(OAL_FUNC, (TEXT("OEMPlatformInit: mac %x%x%x.\r\n"),
            g_MyAddr.wMAC[0], g_MyAddr.wMAC[1], g_MyAddr.wMAC[2]));
        if (!OEMEthHardwareInit(pBSPArgs, &g_MyAddr))
        {
            OALMSG(OAL_ERROR, (TEXT("ERROR: OEMPlatformInit: Failed to initialize Ethernet controller.\r\n")));
            return FALSE;
        }
    }
    else
        memcpy(pBSPArgs->kitl.mac, g_MyAddr.wMAC, 6);

    return TRUE;
}

//------------------------------------------------------------------------------
//
//  Function:        OEMPreDownload
//
//  This function is used to determine if download is required and initialise 
//  the ethernet transport .
//
//  Parameters:        
//
//
//  Returns:        
//             DWORD BL_JUMP - No download needed, jump directly to image
//            DWORD BL_DOWNLOAD - download image through the ethernet transport
//------------------------------------------------------------------------------
DWORD OEMPreDownload (void)
{
    BOOL fGotJumpImg = FALSE;
    DWORD DHCPLeaseTime = 0, *pDHCPLeaseTime = &DHCPLeaseTime;
    DWORD dwBootFlags = 0;

    // Create device name based on Ethernet address 
    // (this is how Platform Builder identifies this device).
    OALKitlCreateName(BSP_DEVICE_PREFIX, pBSPArgs->kitl.mac, pBSPArgs->deviceId);
    OALMSG(OAL_INFO, (L"INFO: *** Device Name '%hs' ***\r\n", pBSPArgs->deviceId));

    if ((pBootCfg->ConfigFlags & CONFIG_FLAGS_DHCP) == 0)
    {
        // Static IP address.
        pBSPArgs->kitl.ipAddress  = pBootCfg->IPAddr;
        pBSPArgs->kitl.ipMask     = pBootCfg->SubnetMask;
        pBSPArgs->kitl.flags     &= ~OAL_KITL_FLAGS_DHCP;
        OALMSG(OAL_FUNC, (TEXT("INFO: Subnet mask is: %s\r\n"), inet_ntoa(pBSPArgs->kitl.ipMask))); 
        OALMSG(OAL_FUNC, (TEXT("INFO: Static IP address: %s\r\n"), inet_ntoa(pBSPArgs->kitl.ipAddress))); 
    }
    else
    {
        pBSPArgs->kitl.ipAddress = 0;
        pBSPArgs->kitl.ipMask    = 0;
        pBSPArgs->kitl.flags     |= OAL_KITL_FLAGS_DHCP;
    }
        
    // user wants to launch the image in flash
    if (!g_DownloadImage)
    {
        g_bWaitForConnect = FALSE;
        fGotJumpImg = TRUE;
    }
    else
    {    
        if ((pBootCfg->ConfigFlags & CONFIG_FLAGS_DHCP) == 0)
             pDHCPLeaseTime = NULL;  // the pDHCPLeaseTime parameter is overloaded.
                                // NULL indicates static IP

        // Initialize the the TFTP transport.
        //
        g_MyAddr.dwIP = pBSPArgs->kitl.ipAddress;
        g_MyAddr.wPort = 0;

        if (!EbootInitEtherTransport(&g_MyAddr,
                                 &pBSPArgs->kitl.ipMask,
                                 &fGotJumpImg,
                                 pDHCPLeaseTime,
                                 EBOOT_VERSION_MAJOR,
                                 EBOOT_VERSION_MINOR,
                                 BSP_DEVICE_PREFIX,
                                 pBSPArgs->deviceId,
                                 EDBG_CPUID,
                                 dwBootFlags))
        {
            OALMSG(OAL_ERROR, (TEXT("ERROR: OEMPreDownload: Failed to initialize Ethernet connection.\r\n")));
            return BL_ERROR;
        }

        // If the user wanted a DHCP address, we presumably have it now - save it for the OS to use.
        //
        if (pBootCfg->ConfigFlags & CONFIG_FLAGS_DHCP)
        {
            // DHCP address.
            pBSPArgs->kitl.ipAddress  = g_MyAddr.dwIP;
        }
    }

    OALMSG(OAL_FUNC, (TEXT("OEMPreDownload: pBSPArgs->kitl.mac = 0x%x%x%x\r\n"), 
            pBSPArgs->kitl.mac[0], pBSPArgs->kitl.mac[1], pBSPArgs->kitl.mac[2])); 

    return fGotJumpImg? BL_JUMP : BL_DOWNLOAD;
}

//------------------------------------------------------------------------------
//
//  Function:        OEMReadData
//
//  This function is used to read data from the    ethernet transport. Calls
//    EbootEtherReadData from eboot.lib which in turn    will call OEMEthGetFrame()
//
//  PARAMETERS:        
//            cbData
//                [in] amount of data to be read
//
//            pbData
//                [out] pointer to the read buffer store
//
//  RETURNS:        
//            FALSE on error during downloading
//------------------------------------------------------------------------------
BOOL OEMReadData (DWORD cbData, LPBYTE pbData)
{
    return EbootEtherReadData(cbData,pbData);
}

//------------------------------------------------------------------------------
//
//  Function:        OEMShowProgress
//
//  This function can be used to show the download progress. 
//
//  Parameters:        
//            dwPacketNum
//                [in] Currently downloaded packet number
//
//  Returns:        
//             
//------------------------------------------------------------------------------
void OEMShowProgress (DWORD dwPacketNum)
{
}

//------------------------------------------------------------------------------
//
//  Function:        OEMLaunch
//
//  This function collects post-download connection information from Platform 
//    Builder and    updates the global BSP_ARGS. It jumps to the newly downloaded 
//    image and should never return.
//
//  Parameters:        
//            dwImageStart
//                [in] start address of image to jump to
//
//            dwImageLength
//                [in] size of image
//
//            dwLaunchAddr
//                [in] launch address of image(virtual).
//
//            pRomHdr
//                [in] ptr to ROM HDR area of image
//
//  Returns:        
//
//------------------------------------------------------------------------------
void OEMLaunch (DWORD dwImageStart, DWORD dwImageLength, DWORD dwLaunchAddr, const ROMHDR *pRomHdr)
{
    EDBG_OS_CONFIG_DATA *pCfgData; 
    EDBG_ADDR EshellHostAddr;
    EDBG_ADDR DeviceAddr;
    DWORD dwPhysLaunchAddr;
    BYTE *pMacBytes = (BYTE *) &DeviceAddr.wMAC;
    
    if(g_bWaitForConnect)
    {
        OALMSG(OAL_INFO, (TEXT ("Download successful! Jumping to image at %Xh...\r\n"), dwLaunchAddr));

        if (g_DownloadImage && !OEMIsFlashAddr(dwImageStart))
        {
            memset(&EshellHostAddr, 0, sizeof(EDBG_ADDR));

            DeviceAddr.dwIP  = pBSPArgs->kitl.ipAddress;
            memcpy(DeviceAddr.wMAC, pBSPArgs->kitl.mac, (3 * sizeof(UINT16)));
            DeviceAddr.wPort = 0;

            OALMSG(OAL_FUNC, (TEXT ("Calling EbootWaitForHostConnect IP = 0x%x, MAC = %x-%x-%x-%x-%x-%x...\r\n"), 
                DeviceAddr.dwIP, pMacBytes[0], pMacBytes[1], pMacBytes[2], pMacBytes[3], pMacBytes[4], pMacBytes[5]));
            
            if (!(pCfgData = EbootWaitForHostConnect(&DeviceAddr, &EshellHostAddr)))
            {
                OALMSG(OAL_ERROR, (TEXT("ERROR: OEMLaunch: EbootWaitForHostConnect failed.\r\n")));
                SpinForever();
            }

            OALMSG(OAL_FUNC, (TEXT("Returned from EbootWaitForHostConnect...\r\n")));
            
            // If the user selected "passive" KITL (i.e., don't connect to the target at boot time), set the
            // flag in the args structure so the OS image can honor it when it boots.
            //
            if (pCfgData->KitlTransport & KTS_PASSIVE_MODE)
            {
                pBSPArgs->kitl.flags |= OAL_KITL_FLAGS_PASSIVE;
            }
        }
            
        // We need to clear RAM if user download new image frm warm-boot
        OALMSG(OAL_INFO, (TEXT("Clearing RAM\n\r")));
        memset((void*)pRomHdr->ulRAMFree, 0, sizeof(DWORD)*3);
    }
    
    //Check whether the launch address is valid,
    //if it's not, get last known good address
    if (!dwLaunchAddr)
    {
        dwLaunchAddr = pBootCfg->LaunchAddress;
    }
    else if (pBootCfg->LaunchAddress != dwLaunchAddr)
    {
        // Download address if different with previous one  
        pBootCfg->LaunchAddress = dwLaunchAddr;
    }

#if NAND_BOOT_SUPPORT
    // Write RAM image to NAND if required.
    if( (g_DownloadImage == TRUE) &&
        (pBootCfg->ConfigFlags & CONFIG_FLAGS_SAVETOFLASH) &&
        (OEMIsFlashAddr(dwLaunchAddr) == FALSE) &&
        (IsNandDevicePresent() == TRUE))
    {
        if(WriteRegionsToNand(pBootCfg))
        {
            OALMSG(OAL_INFO, (TEXT("INFO: OEMLaunch: Stored image to NAND.\r\n")));
        }
        else
            OALMSG(OAL_ERROR, (TEXT("WARNING: OEMLaunch: Failed to store image to NAND.\r\n")));
    }
    else
        OALMSG(OAL_FUNC, (TEXT("INFO: OEMLaunch: No need to store image to NAND.\r\n")));
    
    DeinitPartitionMgr();
#endif

    // Jump to downloaded image (use the physical address since 
    // we'll be turning the MMU off)...
    dwPhysLaunchAddr = (DWORD)OALVAtoPA((void *)dwLaunchAddr);
    OALMSG(OAL_INFO, (TEXT("INFO: OEMLaunch: Jumping to Virtual Address 0x%Xh...\r\n\r\n\r\n"), dwLaunchAddr));
    Launch(dwPhysLaunchAddr);

    // never reached
    OALMSG(OAL_ERROR, (TEXT("ERROR: Fatal error in Ethernet Bootloader, halting...\n")));
    SpinForever();
}

//------------------------------------------------------------------------------
// PRIVATE FUNCTIONS
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
//  Function:        MainMenu
//
//  Manages the bootloader main menu.
//
//  Parameters:        
//            pBootCfg
//                [in/out] ptr to bootloader configuration structure
//
//  Returns:        
//             TRUE if image download is required and FALSE otherwise
//------------------------------------------------------------------------------
static BOOL MainMenu(BOOT_CFG *pBootCfg)
{
    BYTE selection = 0;
    BOOL bConfigChanged = FALSE;
    BOOL bDownloadImage = FALSE;

    while(TRUE)
    {
        selection = 0;

        //show menu                
        EdbgOutputDebugString ( "\r\n\r\nEthernet Boot Loader Configuration:\r\n\r\n");
        EdbgOutputDebugString("0) MAC Address: %B:%B:%B:%B:%B:%B\r\n",
                      g_MyAddr.wMAC[0] & 0xFF, g_MyAddr.wMAC[0] >> 8,
                      g_MyAddr.wMAC[1] & 0xFF, g_MyAddr.wMAC[1] >> 8,
                      g_MyAddr.wMAC[2] & 0xFF, g_MyAddr.wMAC[2] >> 8);
        EdbgOutputDebugString ( "1) Static IP address: %s\r\n",inet_ntoa(pBootCfg->IPAddr));
        EdbgOutputDebugString ( "2) Static Subnet mask: %s\r\n", inet_ntoa(pBootCfg->SubnetMask));
        EdbgOutputDebugString ( "3) DHCP: %s\r\n", ((pBootCfg->ConfigFlags & CONFIG_FLAGS_DHCP)? "Enabled":"Disabled"));
        EdbgOutputDebugString ( "4) Reset to factory default configuration\r\n");
        EdbgOutputDebugString ( "5) Save current Eboot Configuration\r\n");
        EdbgOutputDebugString ( "6) AutoBoot: %s", ((pBootCfg->ConfigFlags & CONFIG_FLAGS_AUTOBOOT)? "Enabled":"Disabled\r\n"));
        if((pBootCfg->ConfigFlags & CONFIG_FLAGS_AUTOBOOT))
        {
            switch(pBootCfg->BootDevice)
            {
                case CONFIG_AUTOBOOT_DEVICE_NOR:
                    EdbgOutputDebugString(" NOR\r\n");
                    break;
                case CONFIG_AUTOBOOT_DEVICE_NAND:
                    EdbgOutputDebugString(" NAND\r\n");
                    break;
                default:
                    EdbgOutputDebugString(" NOR\r\n");
                    pBootCfg->BootDevice = CONFIG_AUTOBOOT_DEVICE_NOR;
                    bConfigChanged = TRUE;
                    break;
            }
        }
#if NAND_BOOT_SUPPORT
        EdbgOutputDebugString ( "7) NAND Flash Menu\r\n");
#endif
        EdbgOutputDebugString ( "D) Download OS or new EBoot image now\r\n");
        EdbgOutputDebugString ( "L) Launch existing OS Image from NOR Flash\r\n");
        EdbgOutputDebugString ( "R) Launch existing OS image from RAM\r\n");
        EdbgOutputDebugString ( "\r\n\r\nEnter your selection: ");

        while (!(selection >= '0' && selection <= '7')  
                    && selection != 'D' && selection != 'd'
                    && selection != 'L' && selection != 'l'
                    && selection != 'R' && selection != 'r' 
                    )