OSStatus platform_flash_read( const platform_flash_t *peripheral, volatile uint32_t* start_address, uint8_t* data ,uint32_t length )
{
OSStatus err = kNoErr;
require_action_quiet( peripheral != NULL, exit, err = kParamErr);
require_action( (*start_address >= peripheral->flash_start_addr)
&& (*start_address + length) <= ( peripheral->flash_start_addr + peripheral->flash_length), exit, err = kParamErr);
if( peripheral->flash_type == FLASH_TYPE_EMBEDDED ){
memcpy(data, (void *)(*start_address), length);
*start_address += length;
}
#ifdef USE_MICO_SPI_FLASH
else if( peripheral->flash_type == FLASH_TYPE_SPI ){
err = sflash_read( &sflash_handle, *start_address, data, length );
require_noerr(err, exit);
*start_address += length;
}
#endif
else{
err = kTypeErr;
goto exit;
}
exit:
return err;
}
OSStatus platform_flash_read( platform_flash_driver_t *driver, volatile uint32_t* FlashAddress, uint8_t* Data ,uint32_t DataLength )
{
OSStatus err = kNoErr;
require_action_quiet( driver != NULL, exit, err = kParamErr);
require_action_quiet( driver->initialized != false, exit, err = kNotInitializedErr);
require_action( (*FlashAddress >= driver->peripheral->flash_start_addr)
&& (*FlashAddress + DataLength) <= (driver->peripheral->flash_start_addr + driver->peripheral->flash_length), exit, err = kParamErr);
#ifndef NO_MICO_RTOS
mico_rtos_lock_mutex( &driver->flash_mutex );
#endif
if( driver->peripheral->flash_type == FLASH_TYPE_INTERNAL ){
memcpy(Data, (void *)(*FlashAddress), DataLength);
*FlashAddress += DataLength;
}
#ifdef USE_MICO_SPI_FLASH
else if( driver->peripheral->flash_type == FLASH_TYPE_SPI ){
err = sflash_read( &sflash_handle, *FlashAddress, Data, DataLength );
require_noerr(err, exit_with_mutex);
*FlashAddress += DataLength;
}
#endif
else{
err = kTypeErr;
goto exit_with_mutex;
}
exit_with_mutex:
#ifndef NO_MICO_RTOS
mico_rtos_unlock_mutex( &driver->flash_mutex );
#endif
exit:
return err;
}
int
sysFlashRead(uint off, uchar *buf, uint numbytes)
{
uint read, total_read = 0;
if (flashutl_cmd->type == SFLASH) {
while (numbytes) {
read = sflash_read(sih, cc, off, numbytes, buf);
numbytes -= read;
buf += read;
off += read;
total_read += read;
}
} else {
ASSERT(!(off & (flashutl_wsz - 1)));
ASSERT(!(numbytes & (flashutl_wsz - 1)));
while (numbytes) {
flash_writeword((unsigned long)buf, flash_readword(FLASH_ADDR(off)));
numbytes -= flashutl_wsz;
buf += flashutl_wsz;
off += flashutl_wsz;
total_read += flashutl_wsz;
}
}
return (total_read);
}
LOCAL int
flashRead(int sectorNum, char *buff, unsigned int offset, unsigned int count)
{
unsigned char *curBuffPtr, *sectorOffsetPtr;
unsigned int len = count;
int bytes;
if (sectorNum < 0 || sectorNum >= flashSectorCount) {
printf("flashRead(): Illegal sector %d\n", sectorNum);
return (ERROR);
}
curBuffPtr = (unsigned char *)buff;
sectorOffsetPtr = (unsigned char *)((sectorNum * FLASH_SECTOR_SIZE) + offset);
/* Read holding block */
while (len) {
if ((bytes = sflash_read(sih, cc, (unsigned int)sectorOffsetPtr, len, curBuffPtr)) < 0) {
printf("flashRead(): Failed: Sector %d, address 0x%x\n",
sectorNum, (int)sectorOffsetPtr);
return (ERROR);
}
sectorOffsetPtr += bytes;
len -= bytes;
curBuffPtr += bytes;
}
return (OK);
}
static int
sflash_mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
{
struct sflash_mtd *sflash = (struct sflash_mtd *) mtd->priv;
int bytes, ret = 0;
/* Check address range */
if (len == 0){
*retlen = 0;
return 0;
}
if (!len)
return 0;
if ((from + len) > mtd->size)
return -EINVAL;
down(&sflash->lock);
*retlen = 0;
while (len) {
if ((bytes = sflash_read(sflash->sbh, sflash->cc, (uint) from, len, buf)) < 0) {
ret = bytes;
break;
}
from += (loff_t) bytes;
len -= bytes;
buf += bytes;
*retlen += bytes;
}
up(&sflash->lock);
return ret;
}
int
sysFlashRead(uint off, uchar *buf, uint numbytes)
{
uint read, total_read=0;
uint16 *src, *dst;
if (flashutl_cmd->type == SFLASH) {
while (numbytes) {
read = sflash_read(cc, off, numbytes, buf);
numbytes -= read;
buf += read;
off += read;
total_read += read;
}
} else {
ASSERT(!(off & 1));
ASSERT(!(numbytes & 1));
src = (uint16*)(flashutl_base + off);
dst = (uint16*)buf;
while(numbytes) {
*dst++ = *src++;
numbytes-=2;
total_read+=2;
}
}
return(total_read);
}
/*
* writes the appropriate range of flash, a NULL buf simply erases
* the region of flash
*/
int
sflash_commit(si_t *sih, chipcregs_t *cc, uint offset, uint len, const uchar *buf)
{
struct sflash *sfl;
uchar *block = NULL, *cur_ptr, *blk_ptr;
uint blocksize = 0, mask, cur_offset, cur_length, cur_retlen, remainder;
uint blk_offset, blk_len, copied;
int bytes, ret = 0;
osl_t *osh;
ASSERT(sih);
osh = si_osh(sih);
/* Check address range */
if (len <= 0)
return 0;
sfl = &sflash;
if ((offset + len) > sfl->size)
return -1;
blocksize = sfl->blocksize;
mask = blocksize - 1;
/* Allocate a block of mem */
if (!(block = MALLOC(osh, blocksize)))
return -1;
while (len) {
/* Align offset */
cur_offset = offset & ~mask;
cur_length = blocksize;
cur_ptr = block;
remainder = blocksize - (offset & mask);
if (len < remainder)
cur_retlen = len;
else
cur_retlen = remainder;
/* buf == NULL means erase only */
if (buf) {
/* Copy existing data into holding block if necessary */
if ((offset & mask) || (len < blocksize)) {
blk_offset = cur_offset;
blk_len = cur_length;
blk_ptr = cur_ptr;
/* Copy entire block */
while (blk_len) {
copied = sflash_read(sih, cc, blk_offset, blk_len, blk_ptr);
blk_offset += copied;
blk_len -= copied;
blk_ptr += copied;
}
}
/* Copy input data into holding block */
memcpy(cur_ptr + (offset & mask), buf, cur_retlen);
}
/* Erase block */
if ((ret = sflash_erase(sih, cc, (uint) cur_offset)) < 0)
goto done;
while (sflash_poll(sih, cc, (uint) cur_offset));
/* buf == NULL means erase only */
if (!buf) {
offset += cur_retlen;
len -= cur_retlen;
continue;
}
/* Write holding block */
while (cur_length > 0) {
if ((bytes = sflash_write(sih, cc,
(uint) cur_offset,
(uint) cur_length,
(uchar *) cur_ptr)) < 0) {
ret = bytes;
goto done;
}
while (sflash_poll(sih, cc, (uint) cur_offset));
cur_offset += bytes;
cur_length -= bytes;
cur_ptr += bytes;
}
offset += cur_retlen;
len -= cur_retlen;
buf += cur_retlen;
}
ret = len;
done:
if (block)
MFREE(osh, block, blocksize);
return ret;
}
