sharpflash.c

norflash的文件系统。 用于中低端手机开发的参考

 *
 * parameters:
 *    FsmDevObjHdrT * DevObjP - device object
 *    uint8 * buf - buffer contains the data to be written.
 *    uint32 Addr - the destination address within flash device.
 *    uint32 length - The amount of data, in bytes, to be written.
 * 
 * return:
 *   HW_ERR_NONE, HW_ERR_SYSTEM, HW_ERR_PARAM, HW_ERR_WRITE.
 *
 *****************************************************************************/

uint32 FsmSharpFlashWrite(FsmDevObjHdrT *DevObjP, uint8 *buf, uint32 addr, uint32 len)
{
    uint8 *dst_byte_ptr, *src_byte_ptr;
    FLASH_DATA_PTR  dst_data_ptr;
    FLASH_DATA      tmp_buf[BUFFER_SIZE / sizeof(FLASH_DATA)];
    
    uint32 dst_offset;
    uint32 byte_size, data_size;
    uint32 status = HW_ERR_NONE;
    
    uint8  suspended = (uint8)FALSE;
    
    FsmFlashDevT *pDev;
    
    pDev = (FsmFlashDevT *)DevObjP;
    
    /* Validate the address. */
#ifdef VALIDATE_ADDRESS
    if ((addr + len) > (pDev->BlockSize * pDev->Blocks))
    {
        return HW_ERR_PARAM;
    }
#endif /* VALIDATE_ADDRESS */

    /* If nothing to write, return. */
    if (len == 0)
    {
        return HW_ERR_NONE;
    }
    
    addr += pDev->DevStartAddr;
    
    /* Align addresses. */
    dst_data_ptr = (FLASH_DATA_PTR)ALIGN_ADDRESS(addr);
    dst_offset = UNALIGNED_BYTES(addr);
    dst_byte_ptr = (uint8 *)tmp_buf + dst_offset;
    data_size = BUFFER_SIZE - dst_offset;
    src_byte_ptr = buf;
    
    /* get flash write mutex. */
    if (FsmGetMtxSem(pDev->DevWriteLock) != ERR_NONE)
    {
        if(FsmStarting == FALSE)
        {
            return HW_ERR_SYSTEM;
        }
    }
    
    /* Suspend if flash is busy erasing. */
    *dst_data_ptr = FLASH_COMMAND_STATUS;
    if ((*dst_data_ptr & FLASH_STATUS_READY) != FLASH_STATUS_READY)
    {
        *dst_data_ptr = FLASH_COMMAND_SUSPEND;
        *dst_data_ptr = FLASH_COMMAND_STATUS;
        while ((*dst_data_ptr & FLASH_STATUS_READY) != FLASH_STATUS_READY)
        {
        }
        
        if (*dst_data_ptr & FLASH_STATUS_ERASE_SUSPENDED)
        {
            suspended = (uint8)TRUE;
        }
    }
    
    while ((len > 0) && (status == HW_ERR_NONE))
    {
        byte_size = GET_MIN(data_size, len);
        
        /* Calculate the number of FLASH_DATA to wirte. */
        data_size = (byte_size + dst_offset + sizeof(FLASH_DATA) - 1) /
            sizeof(FLASH_DATA);
                  
        /*
         * fill the temp buffer with F's if the amount of data is
         * not the size of the hardware buffer
         */
        if (byte_size != BUFFER_SIZE)
        {
            /* temp_buffer[0] = ALL_F;*/
            /*temp_buffer[data_size] = ALL_F;*/
            FsmMemorySet((uint8 *)tmp_buf, 0xff, BUFFER_SIZE);
        }
        FsmMemoryMove(dst_byte_ptr, src_byte_ptr, byte_size);
        
        /* Write buffer. */
        status = WriteToFlash(dst_data_ptr, tmp_buf, data_size);
        
        /* update pointers/variables */
        dst_data_ptr += data_size;
        dst_byte_ptr = (uint8 *)tmp_buf;
        src_byte_ptr += byte_size;
        len -= byte_size;
        data_size = BUFFER_SIZE;
        dst_offset = 0;
    }
    
    /* place the partition back into read array mode */
    dst_data_ptr--;
    *dst_data_ptr = FLASH_COMMAND_READ;
    
    /* Resume if flash was suspended. */
    if (suspended)
    {
        *dst_data_ptr = FLASH_COMMAND_RESUME;
    }

    /* release flash wirte semaphore, and return. */
    FsmReleaseMtxSem(pDev->DevWriteLock);
   
    return status;
}

/******************************************************************************
 * FsmSharpFlashCopy()
 *
 * descriptions:
 *   copy data from one flash location to another.
 *
 * parameters:
 *    FsmDevObjHdrT * DevObjP - device object
 *    uint32 DstAddr - The starting address within flash to copy data to.
 *    uint32 SrcAddr - The starting address within flash to read the data from.
 *    uint32 length - The amount of data, in bytes, to be copied.
 * 
 *
 * return:
 *   HW_ERR_NONE.
 *
 *****************************************************************************/

 uint32 FsmSharpFlashCopy(FsmDevObjHdrT *DevObjP, uint32 DstAddr, uint32 SrcAddr, uint32 len)
{
    uint8   *dst_byte_ptr, *src_byte_ptr;
    volatile FLASH_DATA_PTR  dst_data_ptr;
    volatile FLASH_DATA_PTR  src_data_ptr;
    FLASH_DATA  tmp_buf[BUFFER_SIZE / sizeof(FLASH_DATA)];

    uint32      dst_offset;
    uint32      byte_size, data_size;
    uint32    status = HW_ERR_NONE;

    uint8   suspended = (uint8)FALSE;
    
    FsmFlashDevT *pDev;
    
    pDev = (FsmFlashDevT *)DevObjP;
    
    /* Validate addresses. */
#ifdef VALIDATE_ADDRESS
    if ((SrcAddr + len) > (pDev->BlockSize * pDev->Blocks))
    {
        return HW_ERR_PARAM;
    }

    if ((DstAddr + len) > (pDev->BlockSize * pDev->Blocks))
    {
        return HW_ERR_PARAM;
    }
#endif  /* VALIDATE_ADDRESS */

    /* If nothing to copy, return. */
    if (len == 0)
    {
        return HW_ERR_NONE;
    }
    
    SrcAddr += pDev->DevStartAddr;
    DstAddr += pDev->DevStartAddr;
    
    /* Align addresses and determine buffer size. */
    dst_data_ptr = (volatile FLASH_DATA_PTR)ALIGN_ADDRESS(DstAddr);
    dst_offset = UNALIGNED_BYTES(DstAddr);
    dst_byte_ptr = (uint8 *)tmp_buf + dst_offset;
    data_size = BUFFER_SIZE - dst_offset;
    src_byte_ptr = (uint8 *)SrcAddr;
    
    /* get flash write mutex. */
    if (FsmGetMtxSem(pDev->DevWriteLock) != HW_ERR_NONE)
    {
        if (FsmStarting == FALSE)
        {
            return HW_ERR_SYSTEM;
        }
    }
    
    /* Suspend if flash is busy erasing. */
    *dst_data_ptr = FLASH_COMMAND_STATUS;
    if ((*dst_data_ptr & FLASH_STATUS_READY) != FLASH_STATUS_READY)
    {
        *dst_data_ptr = FLASH_COMMAND_SUSPEND;
        *dst_data_ptr = FLASH_COMMAND_STATUS;
        while ((*dst_data_ptr & FLASH_STATUS_READY) != FLASH_STATUS_READY)
        {
        }

        if (*dst_data_ptr & FLASH_STATUS_ERASE_SUSPENDED)
        {
            suspended = (uint8)TRUE;
        }
    }
    
    while ((len > 0) && (status == HW_ERR_NONE))
    {
        byte_size = GET_MIN(data_size, len);
        
        /* Calculate the number of FLASH_DATA to write. */
        data_size = (byte_size + dst_offset + sizeof(FLASH_DATA) - 1) /
            sizeof(FLASH_DATA);
        
        /* Fill in the temp buffer with 'F's if the amount of data is not
         * equal to the size of the hardware buffer.
         */
        if (byte_size != BUFFER_SIZE)
        {
            FsmMemorySet((uint8 *)tmp_buf, 0xff, BUFFER_SIZE);
        }
        
        src_data_ptr = (volatile FLASH_DATA_PTR)ALIGN_ADDRESS(SrcAddr);
        /* Set to read state. */
        *src_data_ptr = FLASH_COMMAND_READ;
        
        FsmMemoryMove(dst_byte_ptr, src_byte_ptr, (uint16)byte_size);
        
        /* Write buffer. */
        status = WriteToFlash(dst_data_ptr, tmp_buf, data_size);
        
        /* Update pointers. */
        dst_data_ptr += data_size;
        dst_byte_ptr = (uint8 *)tmp_buf;
        src_byte_ptr += byte_size;
        len -= byte_size;
        data_size = BUFFER_SIZE;
        dst_offset = 0;
    }
    
    /* Place the partition back into read array mode. */
    dst_data_ptr--;
    *dst_data_ptr = FLASH_COMMAND_READ;
    
    /* Resume if flash was suspended. */
    if (suspended)
    {
        *dst_data_ptr = FLASH_COMMAND_RESUME;
    }
    
    
    /* release flash write mutex. */
    FsmReleaseMtxSem(pDev->DevWriteLock);
    
    return HW_ERR_NONE;
}


/******************************************************************************
 * FsmSharpFlashErase()
 *
 * descriptions:
 *   erase a flash block.
 *
 * parameters:
 *    FsmDevObjHdrT * DevObjP - device object
 *    uint32 Addr - The starting address of the flash block to be erased.
 *
 * return:
 *   HW_ERR_NONE,  HW_ERR_SYSTEM, HW_ERR_PARAM, HW_ERR_ERASE.
 *
 *****************************************************************************/

uint32 FsmSharpFlashErase(FsmDevObjHdrT *DevObjP, uint32 addr)
{
    volatile FLASH_DATA_PTR flash_ptr;
    uint32 status;
    
    FsmFlashDevT *pDev;
    
    pDev = (FsmFlashDevT *)DevObjP;
    
    /* Validate address. */
#ifdef VALIDATE_ADDRESS
    if (addr > (pDev->BlockSize * pDev->Blocks))
    {
        return HW_ERR_PARAM;
    }
#endif /* VALIDATE_ADDRESS */

    /* Align address. */
    addr += pDev->DevStartAddr;
    flash_ptr = (volatile FLASH_DATA_PTR)ALIGN_ADDRESS(addr);
    
    /* get flash erase mutex. */
    if ((FsmGetMtxSem(pDev->DevEraseLock) != HW_ERR_NONE))
    {
        if (FsmStarting == FALSE)
        {
            return HW_ERR_SYSTEM;
        }
    }

    
    /* Performing erasion. */
    DISABLE_INTERRUPTS();
    UNLOCK_BLOCK(flash_ptr);
    *flash_ptr = FLASH_COMMAND_ERASE;
    *flash_ptr = FLASH_COMMAND_CONFIRM;
    ENABLE_INTERRUPTS();
    
    /* Wait until flash is done. */
    while ((*flash_ptr & FLASH_STATUS_READY) != FLASH_STATUS_READY)
    {
    }
    
    /* Lock block. */
    DISABLE_INTERRUPTS();
    LOCK_BLOCK(flash_ptr);
    ENABLE_INTERRUPTS();
    
    /* Check for errors. */
    if (*flash_ptr & FLASH_STATUS_ERROR)
    {
        *flash_ptr = FLASH_COMMAND_CLEAR;
        status = HW_ERR_ERASE;
    }
    else
    {
        status = HW_ERR_NONE;
    }
    
    /* release flash erase mutex. */
    FsmReleaseMtxSem(pDev->DevEraseLock);
    
    /* Reset to read state. */
    *flash_ptr = FLASH_COMMAND_READ;
    
    return status;
}

/******************************************************************************
 * FsmSharpFlashCtrl()
 *
 * descriptions:
 *   flash driver io control.
 *
 * parameters:
 *    FsmDevObjHdrT * DevObjP - device object
 *    uint32 CtrlCode - command to be executed.
 *    void *arg - argument that is command specified
 *
 * return:
 *   HW_ERR_NONE.
 *
 *****************************************************************************/

uint32 FsmSharpFlashCtrl(FsmDevObjHdrT *DevObjP, uint32 CtrlCode, void *arg)
{
    return HW_ERR_NONE;
}

/*****************************************************************************
* $Log: sharpflash.c $
* Revision 1.4  2004/03/17 12:58:09  zgy
* Revision 1.2  2004/03/16 15:56:26  jjs
* Initial revision
*****************************************************************************/