GitHub/zTC1
1
0
Fork 0
mirror of https://github.com/oopuuu/zTC1.git synced 2025-12-17 23:48:13 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
f99425e6312297d9a2e314998aa38c827e9d0dde
zTC1/mico-os/platform/MCU/LPC5410x/peripherals/platform_flash.c

720 lines
21 KiB
C
Raw Blame History

/**
******************************************************************************
* @file platform_flash.c
* @author William Xu
* @version V1.0.0
* @date 05-May-2014
* @brief This file provides flash operation functions.
******************************************************************************
* UNPUBLISHED PROPRIETARY SOURCE CODE
* Copyright (c) 2016 MXCHIP Inc.
*
* The contents of this file may not be disclosed to third parties, copied or
* duplicated in any form, in whole or in part, without the prior written
* permission of MXCHIP Corporation.
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "platform_logging.h"
#include "platform_peripheral.h"
#include "platform.h"
#include "platform_config.h"
#include "stdio.h"
#ifdef USE_MICO_SPI_FLASH
#include "spi_flash.h"
#endif
/* Private constants --------------------------------------------------------*/
#define ADDR_FLASH_SECTOR_0 ((uint32_t)0x00000000) /* Base @ of Sector 0, 32 Kbyte */
#define ADDR_FLASH_SECTOR_1 ((uint32_t)0x00008000) /* Base @ of Sector 1, 32 Kbyte */
#define ADDR_FLASH_SECTOR_2 ((uint32_t)0x00010000) /* Base @ of Sector 2, 32 Kbyte */
#define ADDR_FLASH_SECTOR_3 ((uint32_t)0x00018000) /* Base @ of Sector 3, 32 Kbyte */
#define ADDR_FLASH_SECTOR_4 ((uint32_t)0x00020000) /* Base @ of Sector 4, 32 Kbyte */
#define ADDR_FLASH_SECTOR_5 ((uint32_t)0x00028000) /* Base @ of Sector 5, 32 Kbyte */
#define ADDR_FLASH_SECTOR_6 ((uint32_t)0x00030000) /* Base @ of Sector 6, 32 Kbyte */
#define ADDR_FLASH_SECTOR_7 ((uint32_t)0x00038000) /* Base @ of Sector 7, 32 Kbyte */
#define ADDR_FLASH_SECTOR_8 ((uint32_t)0x00040000) /* Base @ of Sector 8, 32 Kbyte */
#define ADDR_FLASH_SECTOR_9 ((uint32_t)0x00048000) /* Base @ of Sector 9, 32 Kbyte */
#define ADDR_FLASH_SECTOR_10 ((uint32_t)0x00050000) /* Base @ of Sector 10, 32 Kbyte */
#define ADDR_FLASH_SECTOR_11 ((uint32_t)0x00058000) /* Base @ of Sector 11, 32 Kbyte */
#define ADDR_FLASH_SECTOR_12 ((uint32_t)0x00060000) /* Base @ of Sector 12, 32 Kbyte */
#define ADDR_FLASH_SECTOR_13 ((uint32_t)0x00068000) /* Base @ of Sector 13, 32 Kbyte */
#define ADDR_FLASH_SECTOR_14 ((uint32_t)0x00070000) /* Base @ of Sector 14, 32 Kbyte */
#define ADDR_FLASH_SECTOR_15 ((uint32_t)0x00078000) /* Base @ of Sector 15, 32 Kbyte */
#define ADDR_FLASH_SECTOR_16 ((uint32_t)0x00080000) /* Base @ of Sector 16, 32 Kbyte */
/* End of the Flash address */
#define FLASH_START_ADDRESS (uint32_t)0x00000000
#define FLASH_END_ADDRESS (uint32_t)0x0007FFFF
#define FLASH_SIZE (FLASH_END_ADDRESS - FLASH_START_ADDRESS + 1)
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
#ifdef USE_MICO_SPI_FLASH
static sflash_handle_t sflash_handle = {0x0, 0x0, SFLASH_WRITE_NOT_ALLOWED};
#endif
/* Private function prototypes -----------------------------------------------*/
static uint32_t _GetSector( uint32_t Address );
static OSStatus _GetAddress(uint32_t sector, uint32_t *startAddress, uint32_t *endAddress);
static OSStatus internalFlashInitialize( void );
static OSStatus internalFlashErase(uint32_t StartAddress, uint32_t EndAddress);
static OSStatus internalFlashWrite(volatile uint32_t* FlashAddress, uint32_t* Data ,uint32_t DataLength);
#ifdef MCU_EBANLE_FLASH_PROTECT
static uint32_t _GetWRPSector(uint32_t Address);
static OSStatus internalFlashProtect(uint32_t StartAddress, uint32_t EndAddress, bool enable);
#endif
#ifdef USE_MICO_SPI_FLASH
static OSStatus spiFlashErase(uint32_t StartAddress, uint32_t EndAddress);
#endif
OSStatus platform_flash_init( const platform_flash_t *peripheral )
{
OSStatus err = kNoErr;
require_action_quiet( peripheral != NULL, exit, err = kParamErr);
if( peripheral->flash_type == FLASH_TYPE_EMBEDDED ){
err = internalFlashInitialize();
require_noerr(err, exit);
}
#ifdef USE_MICO_SPI_FLASH
else if( peripheral->flash_type == FLASH_TYPE_SPI ){
err = init_sflash( &sflash_handle, 0, SFLASH_WRITE_ALLOWED );
require_noerr(err, exit);
}
#endif
else{
err = kTypeErr;
goto exit;
}
exit:
return err;
}
OSStatus platform_flash_erase( const platform_flash_t *peripheral, uint32_t start_address, uint32_t end_address )
{
OSStatus err = kNoErr;
require_action_quiet( peripheral != NULL, exit, err = kParamErr);
require_action( start_address >= peripheral->flash_start_addr
&& end_address <= peripheral->flash_start_addr + peripheral->flash_length - 1, exit, err = kParamErr);
if( peripheral->flash_type == FLASH_TYPE_EMBEDDED ){
err = internalFlashErase( start_address, end_address );
require_noerr(err, exit);
}
#ifdef USE_MICO_SPI_FLASH
else if( peripheral->flash_type == FLASH_TYPE_SPI ){
err = spiFlashErase( start_address, end_address );
require_noerr(err, exit);
}
#endif
else{
err = kTypeErr;
goto exit;
}
exit:
return err;
}
OSStatus platform_flash_write( 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 ){
err = internalFlashWrite( start_address, (uint32_t *)data, length);
require_noerr(err, exit);
}
#ifdef USE_MICO_SPI_FLASH
else if( peripheral->flash_type == FLASH_TYPE_SPI ){
err = sflash_write( &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( 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_enable_protect( const platform_flash_t *peripheral, uint32_t start_address, uint32_t end_address )
{
OSStatus err = kNoErr;
require_action_quiet( peripheral != NULL, exit, err = kParamErr);
require_action( start_address >= peripheral->flash_start_addr
&& end_address <= peripheral->flash_start_addr + peripheral->flash_length - 1, exit, err = kParamErr);
if( peripheral->flash_type == FLASH_TYPE_EMBEDDED ){
#ifdef MCU_EBANLE_FLASH_PROTECT
err = internalFlashProtect( start_address, end_address, true );
#endif
require_noerr(err, exit);
}
#ifdef USE_MICO_SPI_FLASH
else if( peripheral->flash_type == FLASH_TYPE_SPI ){
err = kNoErr;
goto exit;
}
#endif
else{
err = kTypeErr;
goto exit;
}
exit:
return err;
}
OSStatus platform_flash_disable_protect( const platform_flash_t *peripheral, uint32_t start_address, uint32_t end_address )
{
OSStatus err = kNoErr;
require_action_quiet( peripheral != NULL, exit, err = kParamErr);
require_action( start_address >= peripheral->flash_start_addr
&& end_address <= peripheral->flash_start_addr + peripheral->flash_length - 1, exit, err = kParamErr);
if( peripheral->flash_type == FLASH_TYPE_EMBEDDED ){
#ifdef MCU_EBANLE_FLASH_PROTECT
err = internalFlashProtect( start_address, end_address, false );
#endif
require_noerr(err, exit);
}
#ifdef USE_MICO_SPI_FLASH
else if( peripheral->flash_type == FLASH_TYPE_SPI ){
err = kNoErr;
goto exit;
}
#endif
else{
err = kTypeErr;
goto exit;
}
exit:
return err;
}
static uint32_t s_wpage_buff[64];
#ifdef BOOTLOADER
static uint32_t s_wlast_buff_datacount=0;
static uint32_t s_wlast_buff_flashaddr=0;
static uint32_t s_flashwritecount=0;
#endif
static uint32_t s_intflash_offset=0;
OSStatus internalFlashInitialize( void )
{
platform_log_trace();
// FLASH_Unlock();
// /* Clear pending flags (if any) */
// FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
// FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
s_intflash_offset=0;
#ifdef BOOTLOADER
s_wlast_buff_datacount=0;
s_wlast_buff_flashaddr=0;
s_flashwritecount=0;
#endif
return kNoErr;
}
OSStatus internalFlashErase(uint32_t StartAddress, uint32_t EndAddress)
{
platform_log_trace();
OSStatus err = kNoErr;
uint32_t StartSector, EndSector, i = 0, j = 0, ret_code; // Magicoe added ret_code
/* Get the sector where start the user flash area */
StartSector = _GetSector(StartAddress);
EndSector = _GetSector(EndAddress);
for(i = StartSector; i <= EndSector; i ++)
{
/* Device voltage range supposed to be [2.7V to 3.6V], the operation will
be done by word */
_GetAddress(i, &StartAddress, &EndAddress);
for(j=StartAddress; j<=EndAddress; j+=8){
if( (*(uint32_t *)(j))!=0xFFFFFFFF )
break;
}
if( j>EndAddress )
continue;
ret_code = Chip_IAP_PreSectorForReadWrite(i, i);
/* Error checking */
if (ret_code != IAP_CMD_SUCCESS) {
err = kWriteErr;
return err;
//DEBUGOUT("Command failed to execute, return code is: %x\r\n", ret_code);
}
ret_code = Chip_IAP_EraseSector(i, i);
if (ret_code != IAP_CMD_SUCCESS) {
err = kWriteErr;
return err;
//DEBUGOUT("Command failed to execute, return code is: %x\r\n", ret_code);
}
// require_action(FLASH_EraseSector(i, VoltageRange_3) == FLASH_COMPLETE, exit, err = kWriteErr);
}
return err;
}
#ifdef MCU_EBANLE_FLASH_PROTECT
OSStatus internalFlashProtect(uint32_t StartAddress, uint32_t EndAddress, bool enable)
{
OSStatus err = kNoErr;
uint16_t WRP = 0x0;
uint32_t StartSector, EndSector, i = 0;
bool needupdate = false;
/* Get the sector where start the user flash area */
StartSector = _GetWRPSector(StartAddress);
EndSector = _GetWRPSector(EndAddress);
for(i = StartSector; i <= EndSector; i=i<<1)
{
WRP = FLASH_OB_GetWRP();
if( ( enable == true && (WRP & i) == 0x0 ) ||
( enable == false && (WRP & i) ) ) {
continue;
}
if( needupdate == false){
FLASH_OB_Unlock( );
needupdate = true;
}
if( enable == true )
FLASH_OB_WRPConfig( i, ENABLE );
else
FLASH_OB_WRPConfig( i, DISABLE );
}
if( needupdate == true){
FLASH_OB_Launch( );
FLASH_OB_Lock( );
}
return err;
}
#endif
#ifdef USE_MICO_SPI_FLASH
OSStatus spiFlashErase(uint32_t StartAddress, uint32_t EndAddress)
{
platform_log_trace();
OSStatus err = kNoErr;
uint32_t StartSector, EndSector, i = 0;
/* Get the sector where start the user flash area */
StartSector = StartAddress>>12;
EndSector = EndAddress>>12;
for(i = StartSector; i <= EndSector; i += 1)
{
/* Device voltage range supposed to be [2.7V to 3.6V], the operation will
be done by word */
require_action(sflash_sector_erase(&sflash_handle, i<<12) == kNoErr, exit, err = kWriteErr);
}
exit:
return err;
}
#endif
OSStatus internalFlashWrite(volatile uint32_t* FlashAddress, uint32_t* Data ,uint32_t DataLength)
{
platform_log_trace();
OSStatus err = kNoErr;
uint32_t i = 0;
uint32_t StartSector;
uint32_t DataLengthRemain = DataLength;
uint32_t DataLengthWR = 0;
uint8_t * ppage_buff=(uint8_t *)s_wpage_buff;
uint8_t * pData = (uint8_t *) Data;
// uint32_t wr_addr = (*FlashAddress) + s_intflash_offset;
uint32_t wr_addr = (*FlashAddress);
StartSector = _GetSector(wr_addr);
{
uint32_t dataPos=0;
uint32_t startAddrPage = (wr_addr/256)*256;
if(wr_addr%256)
{
uint32_t startAddrInPage = wr_addr%256;
// for(i=0;i<s_wlast_page;i++)
for(i=0;i<256;i++)
{
ppage_buff[i]= *((uint8_t*)(startAddrPage+i));
}
if(DataLength>(256-startAddrInPage))
DataLengthWR=(256-startAddrInPage);
else
DataLengthWR =DataLength;
for(i=0;i<DataLengthWR;i++)
{
ppage_buff[i+startAddrInPage]= *((uint8_t*)(pData+dataPos+i));
}
dataPos +=DataLengthWR;
{
StartSector = _GetSector(startAddrPage);
Chip_IAP_PreSectorForReadWrite(StartSector, StartSector);
// Chip_IAP_ErasePage(startAddrPage/256,startAddrPage/256);
Chip_IAP_PreSectorForReadWrite(StartSector, StartSector);
Chip_IAP_CopyRamToFlash(startAddrPage, (uint32_t *)ppage_buff, 256);
startAddrPage +=256;
DataLengthRemain -=DataLengthWR;
}
}
while(DataLengthRemain>0)
{
if(DataLengthRemain>=256)
{
StartSector = _GetSector(startAddrPage);
#ifndef BOOTLOADER
Chip_IAP_PreSectorForReadWrite(StartSector, StartSector);
// Chip_IAP_ErasePage(startAddrPage/256,startAddrPage/256);
#endif
Chip_IAP_PreSectorForReadWrite(StartSector, StartSector);
Chip_IAP_CopyRamToFlash(startAddrPage, (uint32_t *)(pData+dataPos), 256);
startAddrPage +=256;
dataPos +=256;
DataLengthRemain -=256;
}else
{
for(i=0;i<256;i++)
{
ppage_buff[i]= *((uint8_t*)(startAddrPage+i));
}
for(i=0;i<DataLengthRemain;i++)
{
ppage_buff[i]= *((uint8_t*)(pData+dataPos+i));
}
StartSector = _GetSector(startAddrPage);
Chip_IAP_PreSectorForReadWrite(StartSector, StartSector);
// Chip_IAP_ErasePage(startAddrPage/256,startAddrPage/256);
Chip_IAP_PreSectorForReadWrite(StartSector, StartSector);
//modify
// Chip_IAP_CopyRamToFlash(startAddrPage, (uint32_t *)ppage_buff, 256);
Chip_IAP_CopyRamToFlash(startAddrPage, (uint32_t *)ppage_buff, DataLengthRemain);
DataLengthRemain =0;
}
}
}
s_intflash_offset +=DataLength;
require_noerr(err, exit);
exit:
return err;
}
OSStatus internalFlashFinalize( void )
{
#ifdef BOOTLOADER
uint32_t StartSector = 0;
uint32_t i=0;
uint8_t * ppage_buff=(uint8_t *)s_wpage_buff;
if(s_wlast_buff_datacount>0)
{
for(i=s_wlast_buff_datacount;i<256;i++)
ppage_buff[i]=0xff;
StartSector = _GetSector(s_wlast_buff_flashaddr+s_flashwritecount);
Chip_IAP_PreSectorForReadWrite(StartSector, StartSector);
Chip_IAP_CopyRamToFlash(s_wlast_buff_flashaddr+s_flashwritecount, (uint32_t *)ppage_buff, 256);
s_flashwritecount =0;
s_wlast_buff_datacount=0;
s_wlast_buff_flashaddr=0;
}
#endif
//FLASH_Lock();
return kNoErr;
}
/**
* @brief Gets the sector of a given address
* @param Address: Flash address
* @retval The sector of a given address
*/
static uint32_t _GetSector(uint32_t Address)
{
uint32_t sector = 0;
if(Address < ADDR_FLASH_SECTOR_1)/* && (Address >= ADDR_FLASH_SECTOR_0))*/
{
sector = 0;
}
else if((Address < ADDR_FLASH_SECTOR_2) && (Address >= ADDR_FLASH_SECTOR_1))
{
sector = 1;
}
else if((Address < ADDR_FLASH_SECTOR_3) && (Address >= ADDR_FLASH_SECTOR_2))
{
sector = 2;
}
else if((Address < ADDR_FLASH_SECTOR_4) && (Address >= ADDR_FLASH_SECTOR_3))
{
sector = 3;
}
else if((Address < ADDR_FLASH_SECTOR_5) && (Address >= ADDR_FLASH_SECTOR_4))
{
sector = 4;
}
else if((Address < ADDR_FLASH_SECTOR_6) && (Address >= ADDR_FLASH_SECTOR_5))
{
sector = 5;
}
else if((Address < ADDR_FLASH_SECTOR_7) && (Address >= ADDR_FLASH_SECTOR_6))
{
sector = 6;
}
else if((Address < ADDR_FLASH_SECTOR_8) && (Address >= ADDR_FLASH_SECTOR_7))
{
sector = 7;
}
else if((Address < ADDR_FLASH_SECTOR_9) && (Address >= ADDR_FLASH_SECTOR_8))
{
sector = 8;
}
else if((Address < ADDR_FLASH_SECTOR_10) && (Address >= ADDR_FLASH_SECTOR_9))
{
sector = 9;
}
else if((Address < ADDR_FLASH_SECTOR_11) && (Address >= ADDR_FLASH_SECTOR_10))
{
sector = 10;
}
else if((Address < ADDR_FLASH_SECTOR_12) && (Address >= ADDR_FLASH_SECTOR_11))
{
sector = 11;
}
else if((Address < ADDR_FLASH_SECTOR_13) && (Address >= ADDR_FLASH_SECTOR_12))
{
sector = 12;
}
else if((Address < ADDR_FLASH_SECTOR_14) && (Address >= ADDR_FLASH_SECTOR_13))
{
sector = 13;
}
else if((Address < ADDR_FLASH_SECTOR_15) && (Address >= ADDR_FLASH_SECTOR_14))
{
sector = 14;
}
else if((Address < ADDR_FLASH_SECTOR_16) && (Address >= ADDR_FLASH_SECTOR_15))
{
sector = 15;
}
else/*(Address < FLASH_END_ADDR) && (Address >= ADDR_FLASH_SECTOR_11))*/
{
sector = 15;
}
return sector;
}
#ifdef MCU_EBANLE_FLASH_PROTECT
/**
* @brief Gets the sector of a given address
* @param Address: Flash address
* @retval The sector of a given address
*/
static uint32_t _GetWRPSector(uint32_t Address)
{
uint32_t sector = 0;
if((Address < ADDR_FLASH_SECTOR_1) && (Address >= ADDR_FLASH_SECTOR_0))
{
sector = OB_WRP_Sector_0;
}
else if((Address < ADDR_FLASH_SECTOR_2) && (Address >= ADDR_FLASH_SECTOR_1))
{
sector = OB_WRP_Sector_1;
}
else if((Address < ADDR_FLASH_SECTOR_3) && (Address >= ADDR_FLASH_SECTOR_2))
{
sector = OB_WRP_Sector_2;
}
else if((Address < ADDR_FLASH_SECTOR_4) && (Address >= ADDR_FLASH_SECTOR_3))
{
sector = OB_WRP_Sector_3;
}
else if((Address < ADDR_FLASH_SECTOR_5) && (Address >= ADDR_FLASH_SECTOR_4))
{
sector = OB_WRP_Sector_4;
}
else if((Address < ADDR_FLASH_SECTOR_6) && (Address >= ADDR_FLASH_SECTOR_5))
{
sector = OB_WRP_Sector_5;
}
else if((Address < ADDR_FLASH_SECTOR_7) && (Address >= ADDR_FLASH_SECTOR_6))
{
sector = OB_WRP_Sector_6;
}
else if((Address < ADDR_FLASH_SECTOR_8) && (Address >= ADDR_FLASH_SECTOR_7))
{
sector = OB_WRP_Sector_7;
}
else if((Address < ADDR_FLASH_SECTOR_9) && (Address >= ADDR_FLASH_SECTOR_8))
{
sector = OB_WRP_Sector_8;
}
else if((Address < ADDR_FLASH_SECTOR_10) && (Address >= ADDR_FLASH_SECTOR_9))
{
sector = OB_WRP_Sector_9;
}
else if((Address < ADDR_FLASH_SECTOR_11) && (Address >= ADDR_FLASH_SECTOR_10))
{
sector = OB_WRP_Sector_10;
}
else/*(Address < FLASH_END_ADDR) && (Address >= ADDR_FLASH_SECTOR_11))*/
{
sector = OB_WRP_Sector_11;
}
return sector;
}
#endif
/**
* @brief Gets the address of a given sector
* @param Sector: The sector of a given address
* @retval Flash address if the sector start
*/
static OSStatus _GetAddress(uint32_t sector, uint32_t *startAddress, uint32_t *endAddress)
{
OSStatus err = kNoErr;
if(sector == 0)
{
*startAddress = ADDR_FLASH_SECTOR_0;
*endAddress = ADDR_FLASH_SECTOR_1 - 1;
}
else if(sector == 1)
{
*startAddress = ADDR_FLASH_SECTOR_1;
*endAddress = ADDR_FLASH_SECTOR_2 - 1;
}
else if(sector == 2)
{
*startAddress = ADDR_FLASH_SECTOR_2;
*endAddress = ADDR_FLASH_SECTOR_3 - 1;
}
else if(sector == 3)
{
*startAddress = ADDR_FLASH_SECTOR_3;
*endAddress = ADDR_FLASH_SECTOR_4 - 1;
}
else if(sector == 4)
{
*startAddress = ADDR_FLASH_SECTOR_4;
*endAddress = ADDR_FLASH_SECTOR_5 - 1;
}
else if(sector == 5)
{
*startAddress = ADDR_FLASH_SECTOR_5;
*endAddress = ADDR_FLASH_SECTOR_6 - 1;
}
else if(sector == 6)
{
*startAddress = ADDR_FLASH_SECTOR_6;
*endAddress = ADDR_FLASH_SECTOR_7 - 1;
}
else if(sector == 7)
{
*startAddress = ADDR_FLASH_SECTOR_7;
*endAddress = ADDR_FLASH_SECTOR_8 - 1;
}
else if(sector == 8)
{
*startAddress = ADDR_FLASH_SECTOR_8;
*endAddress = ADDR_FLASH_SECTOR_9 - 1;
}
else if(sector == 9)
{
*startAddress = ADDR_FLASH_SECTOR_9;
*endAddress = ADDR_FLASH_SECTOR_10 - 1;
}
else if(sector == 10)
{
*startAddress = ADDR_FLASH_SECTOR_10;
*endAddress = ADDR_FLASH_SECTOR_11 - 1;
}
else if(sector == 11)
{
*startAddress = ADDR_FLASH_SECTOR_11;
*endAddress = FLASH_END_ADDRESS - 1;
}
else if(sector == 12)
{
*startAddress = ADDR_FLASH_SECTOR_12;
*endAddress = FLASH_END_ADDRESS - 1;
}
else if(sector == 13)
{
*startAddress = ADDR_FLASH_SECTOR_13;
*endAddress = FLASH_END_ADDRESS - 1;
}
else if(sector == 14)
{
*startAddress = ADDR_FLASH_SECTOR_14;
*endAddress = FLASH_END_ADDRESS - 1;
}
else if(sector == 15)
{
*startAddress = ADDR_FLASH_SECTOR_15;
*endAddress = FLASH_END_ADDRESS - 1;
}
else
err = kNotFoundErr;
return err;
}
Reference in New Issue View Git Blame Copy Permalink