main.c

arm4 driver for freescale imx35

    }
    else 
    {
        OALLog(L"WARN: Boot config wasn't found, using defaults\r\n");
        memset(&g_bootCfg, 0, sizeof(g_bootCfg));
        g_bootCfg.signature = BOOT_CFG_SIGNATURE;
        g_bootCfg.version = BOOT_CFG_VERSION;
        g_bootCfg.bootDevLoc.IfcType = Internal;
        g_bootCfg.bootDevLoc.BusNumber = 0;
        g_bootCfg.bootDevLoc.LogicalLoc = OMAP5912_USBD_REGS_PA;
        g_bootCfg.kitlDevLoc.IfcType = Internal;
        g_bootCfg.kitlDevLoc.BusNumber = 0;
        g_bootCfg.kitlDevLoc.LogicalLoc = OMAP5912_USBD_REGS_PA; 
        g_bootCfg.kitlFlags |= OAL_KITL_FLAGS_DHCP|OAL_KITL_FLAGS_ENABLED;
        g_bootCfg.kitlFlags |= OAL_KITL_FLAGS_VMINI|OAL_KITL_FLAGS_EXTNAME;
        g_bootCfg.ipAddress = 0;
        g_bootCfg.ipMask = 0;
        g_bootCfg.ipRoute = 0;
        strcpy(g_bootCfg.binName, "NK.bin");
    }

    // Call configuration menu
    BLMenu();

    // Image download depends on protocol
    g_eboot.bootDeviceType = OALKitlDeviceType( &g_bootCfg.bootDevLoc, g_bootDevices );

    switch (g_eboot.bootDeviceType)
    {
    case OAL_KITL_TYPE_ETH:
       rc = BLEthDownload(&g_bootCfg, g_bootDevices);
       break;
    case OAL_KITL_TYPE_FLASH:
        rc =BLSDMMCDownload(&g_bootCfg, g_bootDevices);
       break;
    default:
       OALLog(L"WARN: Unknown boot device type.\r\n");
       SpinForever();
    }
    
    return rc;
}



//------------------------------------------------------------------------------
//
//  Function:  OEMLaunch
//
//  This function is the last one called by the boot framework and it is
//  responsible for to launching the image.
//
VOID OEMLaunch(ULONG start, ULONG size, ULONG launch, const ROMHDR *pRomHeader)
{
    BSP_ARGS *pArgs = OALPAtoCA(IMAGE_SHARE_ARGS_PA);


    OALMSG(OAL_FUNC, (L"+OEMLaunch(0x%08x, 0x%08x, 0x%08x, 0x%08x - %d/%d)\r\n", start, size,launch, pRomHeader, g_eboot.bootDeviceType, g_eboot.type));

    // Initialize shared ARGS structure
        memset(pArgs, 0, IMAGE_SHARE_ARGS_SIZE);
        pArgs->header.signature = OAL_ARGS_SIGNATURE;
        pArgs->header.oalVersion = OAL_ARGS_VERSION;
        pArgs->header.bspVersion = BSP_ARGS_VERSION;
        pArgs->kitl.flags = g_bootCfg.kitlFlags;
        pArgs->kitl.devLoc = g_bootCfg.kitlDevLoc;
        pArgs->kitl.ipAddress = g_bootCfg.ipAddress;
        pArgs->kitl.ipMask = g_bootCfg.ipMask;
        pArgs->kitl.ipRoute = g_bootCfg.ipRoute;

    // Depending on protocol there can be some action required
    switch (g_eboot.bootDeviceType)
        {
        case OAL_KITL_TYPE_ETH:
            BLEthConfig(pArgs);
            switch (g_eboot.type)
                {
                case DOWNLOAD_TYPE_EBOOT:
                    OALMSG(OAL_INFO, (L"Bootloader downloaded and written to flash.  Please reset system.\r\n"));
                    SetLEDValue(0xaa);
                         while(TRUE);
                default:
                    launch = (UINT32)OEMMapMemAddr(start, launch);
                    break;
                }
            break;
        case OAL_KITL_TYPE_FLASH:
            launch = (UINT32)OEMMapMemAddr(start, launch);
            break;
        }

    // Check if we get launch address
    if (launch == (UINT32)INVALID_HANDLE_VALUE)
    {
        OALMSG(OAL_ERROR, (L"ERROR: OEMLaunch: Unknown image launch address\r\n"));
        SpinForever();
    }        

    // Print message, flush caches and jump to image
    OALLog(L"INFO: Lauching Windows CE .NET by jumping to 0x%08x...\r\n\r\n\r\n", launch);
    SetLEDValue(0xaa);

    OEMDebugDeinit();

    JumpTo(launch);
}


//------------------------------------------------------------------------------
//
//  Function:   OEMReadData
//
//  This function is called to read data from the transport during
//  the download process.
//
BOOL OEMReadData(ULONG size, UCHAR *pData)
{
    switch (g_eboot.bootDeviceType)
    {
    case OAL_KITL_TYPE_ETH:
        return EbootEtherReadData(size, pData);
    case OAL_KITL_TYPE_FLASH:
        return BLSDMMCReadData(size, pData);
    default:
        return FALSE;
    }
}


//------------------------------------------------------------------------------
//
//  Function:  OEMShowProgress
//
//  This function is called during the download process to visualise
//  download progress.
//
void OEMShowProgress (DWORD dwPacketNum) 
{
    SetLEDValue((UCHAR)(1<<dwPacketNum%8));
}


//------------------------------------------------------------------------------
//
//  Function:  OEMShowProgress
//
//  This function is called for error report
//
BOOL OEMReportError(DWORD dwReason, DWORD dwReserved)
{
	SpinForever();
	return FALSE;
}


//------------------------------------------------------------------------------
//
//  Function:  OEMMultiBinNotify
//
//  This function check download type
//
VOID OEMMultiBinNotify( MultiBINInfo *pInfo )
{
    BOOL rc = FALSE;
    UINT32 base = IMAGE_EBOOT_RAM_PA;
    UINT32 start, length;
    UINT32 ix;

    OALMSGS(OAL_FUNC, (
        L"+OEMMultiBinNotify(0x%08x -> %d)\r\n", pInfo, pInfo->dwNumRegions
        ));
    OALMSG(OAL_INFO, (
        L"Download file information:\r\n"
        ));
    OALMSG(OAL_INFO, (
        L"-----------------------------------------------------------\r\n"
        ));

    // Copy information to EBOOT structure and set also save address
    g_eboot.numRegions = pInfo->dwNumRegions;
    for (ix = 0; ix < pInfo->dwNumRegions; ix++)
        {
        g_eboot.region[ix].start = pInfo->Region[ix].dwRegionStart;
        g_eboot.region[ix].length = pInfo->Region[ix].dwRegionLength;
        g_eboot.region[ix].base = base;
        base += g_eboot.region[ix].length;
        OALMSG(OAL_INFO, (
            L"[%d]: Address=0x%08x  Length=0x%08x  Save=0x%08x\r\n",
            ix, g_eboot.region[ix].start, g_eboot.region[ix].length,
            g_eboot.region[ix].base
            ));
        }
    OALMSG(OAL_INFO, (
        L"-----------------------------------------------------------\r\n"
        ));

    // Determine type of image downloaded
    if (g_eboot.numRegions > 1) 
    {
        OALMSG(OAL_ERROR, (L"ERROR: MultiXIP image is not supported\r\n"));
        goto cleanUp;
    }

    base = g_eboot.region[0].base;
    start = g_eboot.region[0].start;
    length = g_eboot.region[0].length; 
    if (start == IMAGE_EBOOT_CODE_PA)
    {
        g_eboot.type = DOWNLOAD_TYPE_EBOOT;
        memset((VOID*)base, 0x00, length);
    }
    else 
    {
        g_eboot.type = DOWNLOAD_TYPE_RAM;
    }

    rc = TRUE;
    
cleanUp:
    if (!rc) 
    {
        SpinForever();
    }
    OALMSGS(OAL_FUNC, (L"-OEMMultiBinNotify\r\n"));
}

//------------------------------------------------------------------------------
//
//  Function:  OEMMapMemAddr
//
//  This function maps image relative address to memory address. It is used
//  by boot loader to verify some parts of downloaded image.
//
//  For OMAP5912 EBOOT mapping depends on download type. Download type is
//  set in OMEMultiBinNotify.
//
UINT8* OEMMapMemAddr(    DWORD image, DWORD address )
{
    UINT8 *pAddress = NULL;

    OALMSG(OAL_FUNC, (L"+OEMMapMemAddr(0x%08x, 0x%08x)\r\n", image, address));

    switch (g_eboot.type)
        {
        case DOWNLOAD_TYPE_EBOOT:
            pAddress = (UINT8*)(g_eboot.region[0].base + address - image);
            break;
        case DOWNLOAD_TYPE_RAM:
            pAddress = BLVAtoPA(address);
            break;
        default:
            OALMSG(OAL_ERROR, (L"ERROR: OEMMapMemAddr: Invalid download type %d\r\n", g_eboot.type));
            break;
        }

    OALMSGS(OAL_FUNC, (L"-OEMMapMemAddr(pAddress = 0x%08x)\r\n", pAddress));
    return pAddress;
}

//------------------------------------------------------------------------------
//
//  Function:  OEMIsFlashAddr
//
//  This function determines whether the address provided lies in a platform's
//  flash or RAM address range.
//
//  For OMAP5912 EBOOT decision depends on download type. Download type is
//  set in OMEMultiBinNotify.
//
BOOL OEMIsFlashAddr(ULONG address)
{
    BOOL rc;

    OALMSG(OAL_FUNC, (L"+OEMIsFlashAddr(0x%08x)\r\n", address));

    // Depending on download type
    switch (g_eboot.type)
        {
        case DOWNLOAD_TYPE_EBOOT:
            rc = TRUE;
            break;
        default:
            rc = FALSE;
            break;
        }

    OALMSG(OAL_FUNC, (L"-OEMIsFlashAddr(rc = %d)\r\n", rc));
    return rc;
}


//------------------------------------------------------------------------------
//
//  Function:  OALGetTickCount
//
UINT32 OALGetTickCount()
{
    static UINT32 tcr0 = 0xFFFFFF, base = 0;
    UINT32 tcr1;
    INT32 delta;

    tcr1 = INREG32(&g_pTimerRegs->TCR);
    delta = tcr0 - tcr1;
    if (delta < 0) delta += 0xFFFFFF;
    base += delta;
    tcr0 = tcr1;
    return base/OMAP5912_TIMER32K_COUNTS_PER_1MS;
}



//------------------------------------------------------------------------------
//
//  Function:  OEMEthGetSecs
//
//  This function returns relative time in seconds.
//
DWORD OEMKitlGetSecs()
{
    return OALGetTickCount()/1000;
}