flashdrv.c

56f8300E系列dsp的BOOTloader

            asm( bra endloop );

continue_loop:
        asm( nop );
        asm( nop );
end_cmp_loop:
        asm( nop );
        asm( nop );
endloop:        
#endif  //0


    
    asm( move.w #0x0001, X:(BSP_PERIPH_BASE + archoff_Flash_ModuleControlReg) ); /* select P Flash register bank */
    asm( move.w #0, X:(BSP_PERIPH_BASE + archoff_Flash_ProtectionReg) ); /* unsecure data flash */ 
   
    asm( do X0, end_data_loop );

        asm( move.w X:(R3), Y1 );
#if 1
        asm( move.w X:(R4), A1 );
        asm( cmp.w A, Y1 );
        asm( beq  continue_data_loop );
#endif //0

inc_loop:  /* check if CBEIF is set */
        asm( brclr #0x80, X:(BSP_PERIPH_BASE + archoff_Flash_UserStatusReg ), inc_loop  );

    repeat_loop: 
        asm(bfset #0x0300,SR); /* dis isrs!!! */
        asm( move.w Y1, X:(R4) ); /* select data flash programming */
        asm( move.w #0x20, X:(BSP_PERIPH_BASE + archoff_Flash_CommandReg) ); /* program command */
        asm( move.w #0x80, X:(BSP_PERIPH_BASE + archoff_Flash_UserStatusReg) ); /* clear CBEIF flag */
        asm( move.w X:(BSP_PERIPH_BASE + archoff_Flash_UserStatusReg ), Y0 );
        asm(bfclr #0x0300,SR);

        asm( brclr #0x20, Y0, end_PVIOL ); /* wait until PVIOL flag is set */ 
        asm( move.w #0x20, X:(BSP_PERIPH_BASE + archoff_Flash_UserStatusReg) ); /* clear PVIOL flag */
        asm( bra repeat_loop );
    end_PVIOL: 

        asm( brclr #0x10, Y0, end_ACCERR );  /* wait until ACCERR flag is set */ 
        asm( move.w #0x10, X:(BSP_PERIPH_BASE + archoff_Flash_UserStatusReg) ); /* clear ACCERR flag */
        asm( bra repeat_loop );
    end_ACCERR: 

    wait_CCIF:  /* check if CCIF is set */
        asm( brclr #0x40, X:(BSP_PERIPH_BASE + archoff_Flash_UserStatusReg ), wait_CCIF  );

    continue_data_loop:
        asm( adda #1, R3);
        asm( adda #1, R4);  /* update array pointers */
        asm( nop ); /* nop is needed */
        asm( nop );
        asm( nop );
end_data_loop:
    ;
}

/*****************************************************************************
* Module:         ioctlFLASH_RAW_WRITE_BOOT
* Description:    write page from internal buffer
* Arguments:      page number
* Range Issues:     
* Special Issues:  
*****************************************************************************/
void ioctlFLASH_RAW_WRITE_BOOT(unsigned int page )
{

    asm( move.w Y0, X0 );   /* save page */
    asm( jsr ioctlFLASH_RAW_ERASE_BOOT );   /* Y, R0, R1 changed */

    asm( asll.w  #PAGE_SIZE_LOG, X0);           /* convert page to lenght */
    asm( adda 0x20000, X0, R0 );                 /* 0x20000 - P: boot address page */
    asm( move.w  #PAGE_SIZE_IN_WORDS, X0 );     /* load page size */ 
    asm( move.l  # flash_tmp_buf.buf32, R1 );   /* load modified address */
    
    asm( move.w #0x0002, X:(BSP_PERIPH_BASE + archoff_Flash_ModuleControlReg) ); /* select P Flash register bank */
    asm( move.w #0, X:(BSP_PERIPH_BASE + archoff_Flash_ProtectionBootReg) );
   
    inc_loop:  /* check if CBEIF is set */

        asm( brclr #0x80, X:(BSP_PERIPH_BASE + archoff_Flash_UserStatusReg ), inc_loop  );

    repeat_loop:  
        /* dis isrs!!! */
        asm( tfra R0, R3 );
        asm( move.w X:(R1), Y1 );
        asm( move.w Y1, P:(R3)+ ); /* select data flash programming */
        asm( move.w #0x20, X:(BSP_PERIPH_BASE + archoff_Flash_CommandReg) ); /* program command */
        asm( move.w #0x80, X:(BSP_PERIPH_BASE + archoff_Flash_UserStatusReg) ); /* clear CBEIF flag */

        asm( move.w X:(BSP_PERIPH_BASE + archoff_Flash_UserStatusReg ), Y0 );

        asm( brclr #0x20, Y0, end_PVIOL ); /* wait until PVIOL flag is set */ 
        asm( move.w #0x20, X:(BSP_PERIPH_BASE + archoff_Flash_UserStatusReg) ); /* clear PVIOL flag */
        asm( bra repeat_loop );
    end_PVIOL:

        asm( brclr #0x10, Y0, end_ACCERR );  /* wait until ACCERR flag is set */ 
        asm( move.w #0x10, X:(BSP_PERIPH_BASE + archoff_Flash_UserStatusReg) ); /* clear ACCERR flag */
        asm( bra repeat_loop );
    end_ACCERR:

    wait_CCIF:  /* check if CCIF is set */
        asm( brclr #0x40, X:(BSP_PERIPH_BASE + archoff_Flash_UserStatusReg ), wait_CCIF  );
 
        asm( adda #1, R1);
        asm( adda #1, R0);  /* update array pointers */

    asm( dec.w X0 );
    asm( bne inc_loop );
    
}
/*****************************************************************************
* Module:         mainFlashConfig()
* Description:    Function to initialize flash device.
* Range Issues:   critical for chip  
* Special Issues:  see configguration for dependences 
*****************************************************************************/
void mainFlashConfig()
{
    extern const unsigned int flash_divider;
    /*  Clock Divider Register, check "Clock Divider Loaded" */
    if( 1 /*!( periphMemRead(&ArchIO.Flash.ClockDividerReg) & 0x80) */ ) 
    { 
         /* initialize with prescaler, PRDIV8 + FLASH_DIVIDER /
         150[kHz] < (system_clk/(2*8))/(EEP_nwDIV+1) < 200[kHz] 
         then system_clk = 52Mhz and EEP_nwDIV = 16 then HFM_clk = 191.2[kHz]
         */
        periphMemWrite( flash_divider, &ArchIO.Flash.ClockDividerReg ); 

    }
    else  
    { 
        /* Note that DSP is reseted only during software debugging by CodeWarrior. 
           The reset must be performed here in order to modify HFMCLKD register to 
           reflect new IPBus frequency set by the PLL. If the DSP wasn't reseted 
           than the HFCLKD register could be modified - it is write once register */  
    
        /* periphMemWrite( 0x10 , &ArchIO.Sim.ControlReg); */
    } 
} 


/*****************************************************************************
* Module(s):      flashPmemOpen, flashXmemOpen, flashBootOpen
* Description:    Open specified Flash device for user. 
* Returns:        Device descriptor if success
*                 -1 if specified device name is not Flash device name
* Arguments:      pName - BSP Flash device name
*                 OFlags - open mode flags. 
*                          O_NONBLOCK mode is not supported.
*                          蝨her flags are ignored
* Range Issues:   None
* Special Issues: For executive loop only 
*****************************************************************************/
handle_t flashPmemOpen(const char * pName, int OFlags, ...)
{
   // assert(!((UWord16)OFlags & O_NONBLOCK)); /* NonBlocking Mode is not supported for Flash Driver */

    mainFlashConfig();
    PmemFlash.flags = OFlags;
    return (handle_t)&PmemFlash;
}

handle_t flashXmemOpen(const char * pName, int OFlags, ...)
{
   // assert(!((UWord16)OFlags & O_NONBLOCK)); /* NonBlocking Mode is not supported for Flash Driver */

    mainFlashConfig();
    XmemFlash.flags = OFlags;
    return (handle_t)&XmemFlash;
}

handle_t flashBootOpen(const char * pName, int OFlags, ...)
{
   // assert(!((UWord16)OFlags & O_NONBLOCK)); /* NonBlocking Mode is not supported for Flash Driver */
    mainFlashConfig();
    BootFlash.flags = OFlags;
    return (handle_t)&BootFlash;
}




/*****************************************************************************
* Module:         flashClose()
* Description:    Close specified Flash device
* Returns:        0 
* Arguments:      pHangle - device descriptor
* Range Issues:   None
* Special Issues:  For executive loop only, Just change device state to 0.
*****************************************************************************/
int flashClose(handle_t FileDesc)
{
   return 0;
}




/*****************************************************************************
* Module:         UpdatePageContex
* Description:    get length for next operation
* Returns:        available length for operation
* Arguments:      pHangle - device descriptor, n_bytes - user buffer size
* Range Issues:   
*  ***|********|********|********|********|********|**      
* Special Issues:  optimize on asm in future
*****************************************************************************/
unsigned int UpdatePageContex( handle_t hndl, size_t n_bytes )
{
    unsigned int res_len;

    res_len = 0;
    ((struct sflashDesc*)hndl)->tpage = ((struct sflashDesc*)hndl)->seek >> ((struct sflashDesc*)hndl)->pagesizelog; 

    if( ((struct sflashDesc*)hndl)->tpage < ((struct sflashDesc*)hndl)->lastpage )
    {
        res_len = 1 << ((struct sflashDesc*)hndl)->pagesizelog;
        
        ((struct sflashDesc*)hndl)->toffs = 
              ( res_len - 1 ) & ((struct sflashDesc*)hndl)->seek ;

        res_len = res_len - ((struct sflashDesc*)hndl)->toffs;

        if( n_bytes < res_len )
        {
            res_len = n_bytes;
        }
    }
    return res_len;
}




/*****************************************************************************
*
* Module:         flashRead()
*
* Description:    Read or verify flash context,. 
* Returns:        Actual processed size
* Arguments:      pHandle - device descriptor
*                 pBuffer - pointer to users buffer
*                 nbytes - User buffer size
* Special Issues:  For executive loop only. 
*****************************************************************************/
ssize_t flashRead(handle_t hndl, void * pBuffer, size_t nbytes)
{
    unsigned int len;
    ssize_t num = 0;
    
    do{
        len = UpdatePageContex(hndl, nbytes);    /* get new lenght */
        if( len == 0) 
            break;
        /* raw read from flash, 1 - read offset */
        ((struct sflashDesc*)hndl)->rawRead( ((struct sflashDesc*)hndl)->tpage ); 
        if( ((struct sflashDesc*)hndl)->flags & O_READ_COMPARE )
        {
            pBuffer = compareWithBuf( ((struct sflashDesc*)hndl)->toffs,
                                    (char*)pBuffer, len );
            if( pBuffer == 0 )
                return -1;      /* !!! seek unpredictable */
        }
        else
        {
            pBuffer = copyFromBuf( ((struct sflashDesc*)hndl)->toffs,
                                    (char*)pBuffer, len );
        }
        num += len;
        ((struct sflashDesc*)hndl)->seek += len;
    }while( nbytes -= len );

    return num;
}
    

/*****************************************************************************
*
* Module:         flashWrite()
*
* Description:    Write data from user buffer into flash. 
*
*                 Determine page to write, 
*                 Check is it empty page or not
*                 If not empty, 
*                    save data from this page into driver buffer and erase page                    
*                 Merge saved data and data from user buffer
*                 Program data from driver buffer into flash page
*                 Continue while end of user buffer
*
* Returns:        Actual processed size
*
* Arguments:      pHandle - device descriptor
*                 pBuffer - pointer to users buffer
*                 Size - User buffer size
*        
* Special Issues:  For executive loop only
*****************************************************************************/
ssize_t flashWrite(handle_t hndl, const void * pBuffer, size_t n_bytes)
{
    unsigned int len;
    ssize_t num = 0;
    
    do{
        len = UpdatePageContex(hndl, n_bytes);    /* get new lenght */
        if( len == 0) 
            break;
        /* raw read from flash */
        ((struct sflashDesc*)hndl)->rawRead( ((struct sflashDesc*)hndl)->tpage ); 
        pBuffer = copyToBuf( ((struct sflashDesc*)hndl)->toffs, (char*)pBuffer, len );
//        ((struct sflashDesc*)hndl)->rawErase( ((struct sflashDesc*)hndl)->tpage ); 
        ((struct sflashDesc*)hndl)->rawWrite( ((struct sflashDesc*)hndl)->tpage ); 
        num += len;
        ((struct sflashDesc*)hndl)->seek += len;
    }while( n_bytes -= len);

    return num;
}
    



/*****************************************************************************
* Module:         ioctlFLASH_CMD_SEEK()
* Description:    Function to change device modes.
* Returns:        0
* Arguments:      pHandle  - device descriptor
*                 pParams  - pointer to optional command parameters
* Range Issues:   Casting of long to pointer, impact to P flash  
* Special Issues:  Looking for decision for long value 
*****************************************************************************/
UWord16 ioctlFLASH_CMD_SEEK(handle_t hndl, unsigned long seek )
{
    ((struct sflashDesc*)hndl)->seek = seek;
    return 0;
}

UWord16 ioctlFLASH_RESET(handle_t hndl, unsigned long params )
{
    ((struct sflashDesc*)hndl)->seek = 0;
    return 0;
}

UWord16 ioctlFLASH_MODE_VERIFY(handle_t hndl, unsigned long params )
{

}

#if 0
/*****************************************************************************/

UWord16 ioctlFLASH_ERASE_PMEM(handle_t hndl, unsigned long params )
{
//    ioctlFLASH_RAW_ERASE_PMEM(((struct sflashDesc*)hndl)->page );
}
UWord16 ioctlFLASH_ERASE_XMEM(handle_t hndl, unsigned long params )
{
//    ioctlFLASH_RAW_ERASE_XMEM(((struct sflashDesc*)hndl)->page );
}
UWord16 ioctlFLASH_ERASE_BOOT(handle_t hndl, unsigned long params )
{
//    ioctlFLASH_RAW_ERASE_BOOT(((struct sflashDesc*)hndl)->page );
}

UWord16 ioctlFLASH_READ_PMEM(handle_t hndl, unsigned long params )
{
//    ioctlFLASH_RAW_READ_PMEM(((struct sflashDesc*)hndl)->page );
}
UWord16 ioctlFLASH_READ_XMEM(handle_t hndl, unsigned long params )
{
//    ioctlFLASH_RAW_READ_XMEM(((struct sflashDesc*)hndl)->page );
}
UWord16 ioctlFLASH_READ_BOOT(handle_t hndl, unsigned long params )
{
//    ioctlFLASH_RAW_READ_BOOT(((struct sflashDesc*)hndl)->page );
}

UWord16 ioctlFLASH_WRITE_PMEM(handle_t hndl, unsigned long params )
{
//    ioctlFLASH_RAW_WRITE_PMEM(((struct sflashDesc*)hndl)->page );
}
UWord16 ioctlFLASH_WRITE_XMEM(handle_t hndl, unsigned long params )
{
//    ioctlFLASH_RAW_WRITE_XMEM(((struct sflashDesc*)hndl)->page );
}
UWord16 ioctlFLASH_WRITE_BOOT(handle_t hndl, unsigned long params )
{
//    ioctlFLASH_RAW_WRITE_PMEM(((struct sflashDesc*)hndl)->page );
}


#endif