565cmf_dbug.c

motorola 针对coldfire 5275 评估板的Dbug bootloader源程序

            }
            sm_block_b0_enabled = TRUE;
            sm_block_b1_enabled = FALSE;
            break;
            
        case 3: /*both small blocks enabled*/
            for (i = 0; i < 8; i++)
            {
                uc3f_b[i].size = cmf_block_b_sben[i].size;
                uc3f_b[i].offset = cmf_block_b_sben[i].offset;
            }
            sm_block_b0_enabled = TRUE;
            sm_block_b1_enabled = TRUE;
            break;
    }
    #endif
return;
}
/********************************************************************/

ADDRESS 
C3F_sector_start(ADDRESS addr)
{   
    /* 
     * Returns beginning of sector containing ADDRESS 
     */
    int i;
    
    for (i = 0; i < CMF_FLASH_BLOCKS_A; i++)
    {
        if (addr >= (ADDRESS)((ADDRESS)pUC3F + uc3f_a[i].offset) &&
            addr <= (ADDRESS)((ADDRESS)pUC3F + uc3f_a[i].offset + (uc3f_a[i].size - 1)) )
        {
            return (ADDRESS)((ADDRESS)pUC3F + uc3f_a[i].offset);
        }
    }
    for (i=0; i < 2; i++) /*checking in Module A small blocks*/
    {
        if ((sm_block_a0_enabled || sm_block_a1_enabled) &&
             addr >= (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_a[i].offset)  &&
             addr <= (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_a[i].offset + (cmf_sm_blocks_a[i].size - 1)) )
        {
            return (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_a[i].offset);
        }
    }
    #if (defined (CPU_MPC565) || defined (CPU_MPC566))
    for (i = 0; i < CMF_FLASH_BLOCKS_B; i++)
    {
        if (addr >= (ADDRESS)((ADDRESS)pUC3F + uc3f_b[i].offset) &&
            addr <= (ADDRESS)((ADDRESS)pUC3F + uc3f_b[i].offset + (uc3f_b[i].size - 1)))
        {
            return (ADDRESS)((ADDRESS)pUC3F + uc3f_b[i].offset);
        }
    }
    for (i=0; i < 2; i++) /*checking in Module B small blocks*/
    {
        if ((sm_block_b0_enabled || sm_block_b1_enabled) &&
             addr >= (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_b[i].offset) &&
             addr <= (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_b[i].offset + (cmf_sm_blocks_b[i].size - 1)))
        {
            return (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_b[i].offset);
        }
    }
    #endif
    return NULL;
}

/********************************************************************/
ADDRESS 
C3F_sector_end(ADDRESS addr)
{
    /* Returns end of sector containing ADDRESS */
    int i;
    
    for (i = 0; i < CMF_FLASH_BLOCKS_A; i++)
    {
        if (addr >= (ADDRESS)((ADDRESS)pUC3F + uc3f_a[i].offset) &&
            addr <= (ADDRESS)((ADDRESS)pUC3F + uc3f_a[i].offset + (uc3f_a[i].size - 1)) )
        {
            return (ADDRESS)((ADDRESS)pUC3F + uc3f_a[i].offset + uc3f_a[i].size -1);
        }
    }
    for (i=0; i < 2; i++) /*checking in Module A small blocks*/
    {
        if ((sm_block_a0_enabled || sm_block_a1_enabled) &&
             addr >= (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_a[i].offset)  &&
             addr <= (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_a[i].offset + (cmf_sm_blocks_a[i].size - 1)) )
        {
            return (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_a[i].offset + cmf_sm_blocks_a[i].size -1);
        }
    }
    #if (defined (CPU_MPC565) || defined (CPU_MPC566))
    for (i = 0; i < CMF_FLASH_BLOCKS_B; i++)
    {
        if (addr >= (ADDRESS)((ADDRESS)pUC3F + uc3f_b[i].offset) &&
            addr <= (ADDRESS)((ADDRESS)pUC3F + uc3f_b[i].offset + (uc3f_b[i].size - 1)))
        {
            return (ADDRESS)((ADDRESS)pUC3F + uc3f_b[i].offset + cmf_sm_blocks_b[i].size -1);
        }
    }
    for (i=0; i < 2; i++) /*checking in Module B small blocks*/
    {
        if ((sm_block_b0_enabled || sm_block_b1_enabled) &&
             addr >= (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_b[i].offset) &&
             addr <= (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_b[i].offset + (cmf_sm_blocks_b[i].size - 1)))
        {
            return (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_b[i].offset + cmf_sm_blocks_b[i].size -1);
        }
    }
    #endif                   
    return NULL;
}

/********************************************************************/

/********************************************************************/

UINT32 C3F_EraseAll()
{
    pFLASHERASE FlashErase = (pFLASHERASE) FlashErase_C;   // Assign function pointer

    // Erase all blocks including shadow
    printf("\nErasing Flash...");
//    returnCode = EraseAndBlankCheck(&testAddress, &testData, CallBack);// Erase the part and check for blanked */

    // erase all C3F main arrays and shadow rows

    enabledBDM = 0;                         // Not enter into BDM after each operation
    // Erase all blocks and shadows
    for (m = 0; m < numModules; m++)
    {
        enabledBlocks[m] = 0xFF;            // Select all blocks in module m to erase
        enabledSBlocks[m] = 0x00;           // De-select all small blocks in module m
    }
    // Call FlashErase
    returnCode = (*FlashErase)( enabledBDM, CallBack, enabledBlocks, enabledSBlocks, arrayBase);

    if(returnCode != C3F_OK){
        return (failmessage("Erase",returnCode));
    }
    return C3F_OK;
}

/********************************************************************/
UINT32 C3F_erase(ADDRESS start, int bytes, void (*putchar)(char))
{
    int i, erased_bytes = 0;
    ADDRESS addr = start;
    pFLASHERASE FlashErase = (pFLASHERASE) FlashErase_C;   /* Assign function pointer */
    enabledBDM = 0;                         /* Do not enter into BDM after each operation*/
    
    C3F_module_setup();         /* Checks for small blocks, etc. */
    
    if (bytes == 0)
        return 0;

    enabledBlocks[0] = 0x00;    /* De-select all blocks in module A*/
    enabledSBlocks[0] = 0x00;   /* De-select all small blocks in module A*/
    enabledBlocks[1] = 0x00;    /* De-select all blocks in module B*/
    enabledSBlocks[1] = 0x00;   /* De-select all small blocks in module B*/
    

    while (erased_bytes < bytes)
    {
        for (i = 0; i < CMF_FLASH_BLOCKS_A; i++)
        {
            if (addr >= (ADDRESS)((ADDRESS)pUC3F + uc3f_a[i].offset) &&
                addr <= (ADDRESS)((ADDRESS)pUC3F + uc3f_a[i].offset + (uc3f_a[i].size - 1)) )
            {
                enabledBlocks[0] = enabledBlocks[0] | block_mask[i];
                addr = addr + uc3f_a[i].size; 
                erased_bytes = erased_bytes + uc3f_a[i].size;
                printf(".",i);
                break;
            }
        }
        for (i=0; i < 2; i++) /*checking in Module A small blocks*/
        {
            if ((sm_block_a0_enabled || sm_block_a1_enabled) &&
                 addr >= (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_a[i].offset)  &&
                 addr <= (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_a[i].offset + (cmf_sm_blocks_a[i].size - 1)) )
            {
                enabledSBlocks[0] = enabledSBlocks[0] | sm_block_mask[i];
                addr = addr + cmf_sm_blocks_a[i].size;
                erased_bytes = erased_bytes + cmf_sm_blocks_a[i].size;
                printf(".",i);
                break;
            }
        }
        #if (defined (CPU_MPC565) || defined (CPU_MPC566))
        for (i = 0; i < CMF_FLASH_BLOCKS_B; i++)
        {
            if (addr >= (ADDRESS)((ADDRESS)pUC3F + uc3f_b[i].offset) &&
                addr <= (ADDRESS)((ADDRESS)pUC3F + uc3f_b[i].offset + (uc3f_b[i].size - 1)))
            {
                enabledBlocks[1] = enabledBlocks[1] | block_mask[i];
                addr = addr + uc3f_b[i].size;
                erased_bytes = erased_bytes + uc3f_b[i].size;
                printf(".",i);
                break;
            }
        }
        for (i=0; i < 2; i++) /*checking in Module B small blocks*/
        {
            if ((sm_block_b0_enabled || sm_block_b1_enabled) &&
                 addr >= (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_b[i].offset) &&
                 addr <= (ADDRESS)((ADDRESS)pUC3F + cmf_sm_blocks_b[i].offset + (cmf_sm_blocks_b[i].size - 1)))
            {
                enabledSBlocks[1] = enabledSBlocks[1] | sm_block_mask[i];
                addr = addr + cmf_sm_blocks_b[i].size;
                erased_bytes = erased_bytes + cmf_sm_blocks_b[i].size;
                printf(".",i);
                break;
            }
        }
        #endif
    }
    returnCode = (*FlashErase)( enabledBDM, CallBack, enabledBlocks, enabledSBlocks, arrayBase);

    if(returnCode != C3F_OK)
    {
       (failmessage("Erase",returnCode));
       erased_bytes = 0;
    }
    
    return erased_bytes;
}
/********************************************************************/

void C3F_SetShadow()   // Set shadow configuration
{
   UC3F_A.UC3FMCR.R = 0x48FF0000;   /* UC3FMCR  Module A */
   #if (defined (CPU_MPC565) || defined (CPU_MPC566)) 
        UC3F_B.UC3FMCR.R = 0x48FF0000;   /* UC3FMCR Module B */
   #endif 
}

/********************************************************************/

void C3F_ClearShadow(){ // Clear shadow configuration

   UC3F_A.UC3FMCR.R = 0x40FF0000;   /* UC3FMCR  Module A */
   #if (defined (CPU_MPC565) || defined (CPU_MPC566)) 
        UC3F_B.UC3FMCR.R = 0x40FF0000;   /* UC3FMCR Module B */
   #endif
}

/********************************************************************/

int C3F_program(ADDRESS dest, ADDRESS source, int bytes, int erase, 
                void (*func)(void), void (*putchar)(char))
{
    pFLASHPROGRAM       FlashProgram       = (pFLASHPROGRAM)        FlashProgram_C;
    pFLASHVERIFY        FlashVerify        = (pFLASHVERIFY)         FlashVerify_C;

    //printf("Programming Internal Flash...\n");
    returnCode = (*FlashProgram)(enabledBDM, CallBack, dest, bytes, source, arrayBase);
    if(returnCode != C3F_OK)
    {
        printf("Error Programming Code: 0x%08X\n", returnCode);
        return(NULL);
    }
    returnCode = (*FlashVerify)(enabledBDM,CallBack,dest,bytes,source,&compareAddress,&compareData,&compareSourceData,arrayBase);
    if(returnCode != C3F_OK)
    {
        printf("Flash did not program correctly S-Record line beginning with %08X\n",source);
    }
    return(bytes);

}

/********************************************************************/

UINT32
C3F_ChangeCensor (void)
{
    pCHANGECENSOR       ChangeCensor       = (pCHANGECENSOR)        ChangeCensor_C;
    
    enabledBDM = 0;
    module = C3F_MODULE_A;
    censorValue = C3F_NO_CENSORSHIP1;
    deviceMode = DEVICE_CENSORED + 2;   
    
printf("Modifying Censor Bit");
returnCode = (*ChangeCensor)( enabledBDM,
                              CallBack,
                              module,
                              censorValue,
                              deviceMode,
                              arrayBase);
/* printf("returnCode = %08X",returnCode); */
return returnCode;
}

/********************************************************************/

UINT32 failmessage(char *msg, UINT32 code)
{
    printf("\n");
    printf(msg);
    printf(" Failed.  Status Code ");
    
    switch( code )
    {    
        case 0x00000001:
            printf("C3F_INFO_LOCK_B");
            break;
        case 0x00000002:
            printf("C3F_INFO_LOCK_A");
            break;
        case 0x00000004:
            printf("C3F_INFO_EPEE_B");
            break;
        case 0x00000008:
            printf("C3F_INFO_EPEE_A");
            break;
        case 0x00000010:
            printf("C3F_INFO_BOEPEE_B");
            break;
        case 0x00000020:
            printf("C3F_INFO_BOEPEE_A");
            break;
        case 0x00000040:
            printf("C3F_INFO_HVS_B");
            break;
        case 0x00000080:
            printf("C3F_INFO_HVS_A");
            break;
        case 0x00000100:
            printf("C3F_INFO_CENSOR_B");
            break;
        case 0x00000200:
            printf("C3F_INFO_CENSOR_A");
            break;
        case 0x00000400:
            printf("C3F_INFO_STOP_B");
            break;
        case 0x00000800:
            printf("C3F_INFO_STOP_A");
            break;
        case 0x00001000:
            printf("C3F_INFO_FLEN");
            break;
        case 0x00002000:
            printf("C3F_INFO_FLASHID");
            break;
        case 0x00004000:
            printf("C3F_ERROR_INVALID_ENABLED_BLOCK");
            break;
        case 0x00008000:
            printf("C3F_UNUSED_FLAG3");
            break;
        case 0x00010000:
            printf("C3F_UNUSED_FLAG4");
            break;
        case 0x00020000:
            printf("C3F_ERROR_PARTID");
            break;
        case 0x00040000:
            printf("C3F_ERROR_ALIGNMENT");
            break;
        case 0x00080000:
            printf("C3F_ERROR_SHADOW_RANGE");
            break;
        case 0x00100000:
            printf("C3F_ERROR_ARRAY_RANGE");
            break;
        case 0x00200000:
            printf("C3F_ERROR_ENABLED_SMALL_BLOCK");
            break;
        case 0x00400000:
            printf("C3F_ERROR_ERASE_PEGOOD");
            break;
        case 0x00800000:
            printf("C3F_ERROR_PROGRAM_VERIFICATION");
            break;
        case 0x01000000:
            printf("C3F_ERROR_PROGRAM_PEGOOD");
            break;
        case 0x02000000:
            printf("C3F_ERROR_NOT_BLANK");
            break;
        case 0x04000000:
            printf("C3F_ERROR_SRC_DEST_VERIFY");
            break;
        case 0x08000000:
            printf("C3F_ERROR_CENSOR_MODULE");
            break;
        case 0x10000000:
            printf("C3F_ERROR_CENSOR_VALUE");
            break;
        case 0x20000000:
            printf("C3F_ERROR_CENSOR_DEVICE_MODE");
            break;
        case 0x40000000:
            printf("C3F_ERROR_CENSOR_INVALID_REQUEST");
            break;
        case 0x80000000:
            printf("C3F_ERROR_CENSOR_PEGOOD");
            break;
        default:
            printf("Unknown Error");
            break;
    }
    
    printf("\n");
    return code;
}