void sys_adc_calibration(u8 write, u16 *offset, u16 *gain)
{
flash_t flash;
u8* pbuf;
if(write){
// backup
pbuf = (unsigned char*)RtlMalloc(FLASH_SECTOR_SIZE);
if(!pbuf) return;
flash_stream_read(&flash, FLASH_SYSTEM_DATA_ADDR, FLASH_SECTOR_SIZE, pbuf);
memcpy((char*)pbuf+FLASH_ADC_PARA_OFFSET, offset, 2);
memcpy((char*)pbuf+FLASH_ADC_PARA_OFFSET+2, gain, 2);
flash_erase_sector(&flash, FLASH_RESERVED_DATA_BASE);
flash_stream_write(&flash, FLASH_RESERVED_DATA_BASE, FLASH_SECTOR_SIZE, pbuf);
// Write
flash_stream_read(&flash, FLASH_RESERVED_DATA_BASE, FLASH_SECTOR_SIZE, pbuf);
flash_erase_sector(&flash, FLASH_SYSTEM_DATA_ADDR);
flash_stream_write(&flash, FLASH_SYSTEM_DATA_ADDR, FLASH_SECTOR_SIZE, pbuf);
RtlMfree(pbuf, FLASH_SECTOR_SIZE);
printf("\n\rStore ADC calibration success.");
}
flash_stream_read(&flash, FLASH_ADC_PARA_BASE, 2, (u8*)offset);
flash_stream_read(&flash, FLASH_ADC_PARA_BASE+2, 2, (u8*)gain);
printf("\n\rADC offset = 0x%04X, gain = 0x%04X.\n\r", *offset, *gain);
}
// Mandatory function to save controller pairing to persistent storage
// called when HAP controller pairing update
void HAPPlatformSavePairings(HAPPersistentPairing_t *pairing, int num)
{
uint8_t *flash_buffer = (uint8_t *) malloc(FLASH_DATA_LEN);
flash_stream_read(&flash, FLASH_DATA_ADDR, FLASH_DATA_LEN, flash_buffer);
flash_erase_sector(&flash, FLASH_DATA_ADDR);
memcpy(flash_buffer + HAP_FLASH_PAIRING_OFFSET, pairing, sizeof(HAPPersistentPairing_t) * num);
flash_stream_write(&flash, FLASH_DATA_ADDR, FLASH_DATA_LEN, flash_buffer);
free(flash_buffer);
}
// Mandatory function to save accessory key pair to persistent storage
// called when HAP accessory key pair generation
void HAPPlatformSaveKeypair(HAPPersistentKeypair_t *keypair)
{
uint8_t *flash_buffer = (uint8_t *) malloc(FLASH_DATA_LEN);
flash_stream_read(&flash, FLASH_DATA_ADDR, FLASH_DATA_LEN, flash_buffer);
flash_erase_sector(&flash, FLASH_DATA_ADDR);
memcpy(flash_buffer + HAP_FLASH_KEYPAIR_OFFSET, keypair, sizeof(HAPPersistentKeypair_t));
flash_stream_write(&flash, FLASH_DATA_ADDR, FLASH_DATA_LEN, flash_buffer);
free(flash_buffer);
}
void FlashSetupcodeRead(char *buf)
{
PersistentSetupcode_t setupcode;
flash_stream_read(&flash, FLASH_DATA_ADDR + FLASH_SETUPCODE_OFFSET , sizeof(PersistentSetupcode_t), &setupcode);
if(setupcode.len == 10)
strcpy(buf, setupcode.code);
else
*buf = 0;
}
void sys_clear_ota_signature(void)
{
flash_t flash;
u32 ota_offset=0xFFFFFFFF, part1_offset, part2_offset;
u8 signature[OTA_Signature_len+1];
flash_stream_read(&flash, 0x18, 4, (u8*)&part1_offset);
part1_offset = (part1_offset&0xFFFF) * 1024;
flash_stream_read(&flash, part1_offset+OTA_Signature_offset, OTA_Signature_len, signature);
if(!memcmp((char const*)signature, OTA_Signature, OTA_Signature_len)){
ota_offset = part1_offset;
}
flash_stream_read(&flash, FLASH_SYSTEM_DATA_ADDR, 4, (u8*)&part2_offset);
flash_stream_read(&flash, part2_offset+OTA_Signature_offset, OTA_Signature_len, signature);
if(!memcmp((char const*)signature, OTA_Signature, OTA_Signature_len)){
ota_offset = part2_offset;
}
printf("\n\rOTA offset = 0x%08X", ota_offset);
if(ota_offset < OTA_valid_offset){
flash_stream_read(&flash, ota_offset+OTA_Signature_offset, OTA_Signature_len, signature);
signature[OTA_Signature_len] = '\0';
printf("\n\rSignature = %s", signature);
if(!memcmp((char const*)signature, OTA_Signature, OTA_Signature_len)){
memcpy((char*)signature, OTA_Clear, OTA_Signature_len);
flash_stream_write(&flash, ota_offset+OTA_Signature_offset, OTA_Signature_len, signature);
flash_stream_read(&flash, ota_offset+OTA_Signature_offset, OTA_Signature_len, signature);
signature[OTA_Signature_len] = '\0';
printf("\n\rSignature = %s", signature);
printf("\n\rClear OTA signature success.");
}
}
}
void sys_recover_ota_signature(void)
{
flash_t flash;
u32 ota_offset=0xFFFFFFFF, part1_offset, part2_offset;
u8 signature[OTA_Signature_len+1];
u8* pbuf;
flash_stream_read(&flash, 0x18, 4, (u8*)&part1_offset);
part1_offset = (part1_offset&0xFFFF) * 1024;
flash_stream_read(&flash, part1_offset+OTA_Signature_offset, OTA_Signature_len, signature);
if(!memcmp((char const*)signature, OTA_Clear, OTA_Signature_len)){
ota_offset = part1_offset;
}
flash_stream_read(&flash, FLASH_SYSTEM_DATA_ADDR, 4, (u8*)&part2_offset);
flash_stream_read(&flash, part2_offset+OTA_Signature_offset, OTA_Signature_len, signature);
if(!memcmp((char const*)signature, OTA_Clear, OTA_Signature_len)){
ota_offset = part2_offset;
}
printf("\n\rOTA offset = 0x%08X", ota_offset);
if(ota_offset < OTA_valid_offset){
flash_stream_read(&flash, ota_offset+OTA_Signature_offset, OTA_Signature_len, signature);
signature[OTA_Signature_len] = '\0';
printf("\n\rSignature = %s", signature);
if(!memcmp((char const*)signature, OTA_Clear, OTA_Signature_len)){
// backup
pbuf = (unsigned char*)RtlMalloc(FLASH_SECTOR_SIZE);
if(!pbuf) return;
flash_stream_read(&flash, ota_offset, FLASH_SECTOR_SIZE, pbuf);
memcpy((char*)pbuf+OTA_Signature_offset, OTA_Signature, OTA_Signature_len);
flash_erase_sector(&flash, FLASH_RESERVED_DATA_BASE);
flash_stream_write(&flash, FLASH_RESERVED_DATA_BASE, FLASH_SECTOR_SIZE, pbuf);
// Write
flash_stream_read(&flash, FLASH_RESERVED_DATA_BASE, FLASH_SECTOR_SIZE, pbuf);
flash_erase_sector(&flash, ota_offset);
flash_stream_write(&flash, ota_offset, FLASH_SECTOR_SIZE, pbuf);
flash_stream_read(&flash, ota_offset+OTA_Signature_offset, OTA_Signature_len, signature);
signature[OTA_Signature_len] = '\0';
printf("\n\rSignature = %s", signature);
RtlMfree(pbuf, FLASH_SECTOR_SIZE);
printf("\n\rRecover OTA signature success.");
}
}
}
void LoadWifiConfig()
{
flash_t flash;
rtw_wifi_config_t local_config;
uint32_t address;
address = DATA_SECTOR;
//memset(&local_config,0,sizeof(rtw_wifi_config_t));
printf("\r\nLoadWifiConfig(): Read from FLASH!\n");
// flash_Read(address, &local_config, sizeof(local_config));
flash_stream_read(&flash, address, sizeof(rtw_wifi_config_t),(uint8_t *)(&local_config));
printf("\r\nLoadWifiConfig(): local_config.boot_mode=0x%x\n", local_config.boot_mode);
printf("\r\nLoadWifiConfig(): local_config.ssid=%s\n", local_config.ssid);
printf("\r\nLoadWifiConfig(): local_config.channel=%d\n", local_config.channel);
printf("\r\nLoadWifiConfig(): local_config.security_type=%d\n", local_config.security_type);
printf("\r\nLoadWifiConfig(): local_config.password=%s\n", local_config.password);
if(local_config.boot_mode == 0x77665502)
{
wifi_setting.mode = RTW_MODE_AP;
if(local_config.ssid_len > 32)
local_config.ssid_len = 32;
memcpy(wifi_setting.ssid, local_config.ssid, local_config.ssid_len);
wifi_setting.ssid[local_config.ssid_len] = '\0';
wifi_setting.channel = local_config.channel;
if(local_config.security_type == 1)
wifi_setting.security_type = RTW_SECURITY_WPA2_AES_PSK;
else
wifi_setting.security_type = RTW_SECURITY_OPEN;
if(local_config.password_len > 32)
local_config.password_len = 32;
memcpy(wifi_setting.password, local_config.password, local_config.password_len);
wifi_setting.password[local_config.password_len] = '\0';
}
else
{
LoadWifiSetting();
}
}
void FlashSetupcodeWrite(char *code)
{
if(strlen(code) == 10) {
PersistentSetupcode_t setupcode;
memset(&setupcode, 0, sizeof(PersistentSetupcode_t));
setupcode.len = 10;
strcpy(setupcode.code, code);
uint8_t *flash_buffer = (uint8_t *) malloc(FLASH_DATA_LEN);
flash_stream_read(&flash, FLASH_DATA_ADDR, FLASH_DATA_LEN, flash_buffer);
flash_erase_sector(&flash, FLASH_DATA_ADDR);
memcpy(flash_buffer + FLASH_SETUPCODE_OFFSET, &setupcode, sizeof(PersistentSetupcode_t));
flash_stream_write(&flash, FLASH_DATA_ADDR, FLASH_DATA_LEN, flash_buffer);
free(flash_buffer);
}
}
int OTAClass::beginLocal(uint16_t port, bool reboot_when_success) {
int ret = -1;
// variables for image processing
flash_t flash;
uint32_t img2_addr, img2_len, img3_addr, img3_len;
uint32_t img_upper_bound;
uint32_t checksum = 0;
uint32_t signature1, signature2;
// variables for network processing
int server_socket = -1;
int client_socket = -1;
struct sockaddr_in localHost;
struct sockaddr_in client_addr;
int socket_error, socket_timeout;
socklen_t optlen;
// variables for OTA
unsigned char *buf = NULL;
int read_bytes = 0, processed_len;
uint32_t file_info[3];
uint32_t ota_len;
uint32_t ota_blk_size = 0;
int i, n;
do {
sync_ota_addr();
get_image_info(&img2_addr, &img2_len, &img3_addr, &img3_len);
img_upper_bound = img2_addr + 0x10 + img2_len; // image2 base + header + len
if (img3_len > 0) {
img_upper_bound += 0x10 + img3_len; // image 3 header + len
}
if ((ota_addr & 0xfff != 0) || (ota_addr == ~0x0) || (ota_addr < img_upper_bound)) {
OTA_PRINTF("Invalid OTA address: %08X\r\n", ota_addr);
break;
}
buf = (unsigned char *) malloc (BUFSIZE);
if (buf == NULL) {
OTA_PRINTF("Fail to allocate memory\r\n");
break;
}
server_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (server_socket < 0) {
OTA_PRINTF("Fail to create socket\r\n");
break;
}
memset(&localHost, 0, sizeof(localHost));
localHost.sin_family = AF_INET;
localHost.sin_port = htons(port);
localHost.sin_addr.s_addr = INADDR_ANY;
if (lwip_bind(server_socket, (struct sockaddr *)&localHost, sizeof(localHost)) < 0) {
OTA_PRINTF("Bind fail\r\n");
break;
}
if (lwip_listen(server_socket , 1) < 0) {
OTA_PRINTF("Listen fail\r\n");
break;
}
OTA_PRINTF("Wait for client\r\n");
n = (int) sizeof( client_addr );
memset(&client_addr, 0, sizeof(client_addr));
client_socket = lwip_accept(server_socket, (struct sockaddr *) &client_addr, (socklen_t *)&n);
OTA_PRINTF("Client connected. IP:%s port:%d\r\n\r\n", inet_ntoa(client_addr.sin_addr.s_addr), ntohs(client_addr.sin_port));
socket_timeout = DEFAULT_IMAGE_DOWNLOAD_TIMEOUT;
lwip_setsockopt(client_socket, SOL_SOCKET, SO_RCVTIMEO, &socket_timeout, sizeof(socket_timeout));
OTA_PRINTF("Read OTA info...\r\n");
read_bytes = read(client_socket, file_info, sizeof(file_info));
if (read_bytes < 0) {
OTA_PRINTF("Fail to read OTA info\r\n");
break;
}
if (file_info[2] == 0) {
OTA_PRINTF("OTA image len is 0\r\n");
break;
}
ota_len = file_info[2];
ota_blk_size = ((ota_len - 1) / 4096) + 1;
for (i = 0; i < ota_blk_size; i++) {
flash_erase_sector(&flash, ota_addr + i * 4096);
}
OTA_PRINTF("Start download\r\n");
// Now download OTA image
processed_len = 0;
while( processed_len < ota_len ) {
memset(buf, 0, BUFSIZE);
read_bytes = read(client_socket, buf, BUFSIZE);
if (read_bytes < 0) {
optlen = sizeof(socket_error);
getsockopt(client_socket, SOL_SOCKET, SO_ERROR, &socket_error, &optlen);
if (socket_error == EAGAIN) {
// socket timeout
}
break;
}
if (flash_stream_write(&flash, ota_addr + processed_len, read_bytes, buf) < 0) {
OTA_PRINTF("Write sector fail\r\n");
break;
}
processed_len += read_bytes;
}
if (processed_len != ota_len) {
OTA_PRINTF("Download fail\r\n");
break;
}
// Read OTA image from flash and calculate checksum
checksum = processed_len = 0;
while ( processed_len < ota_len ) {
n = (processed_len + BUFSIZE < ota_len) ? BUFSIZE : (ota_len - processed_len);
flash_stream_read(&flash, ota_addr + processed_len, n, buf);
for (i=0; i<n; i++) checksum += (buf[i] & 0xFF);
processed_len += n;
}
if (checksum != file_info[0]) {
OTA_PRINTF("Bad checksum:%d expected:%d\r\n", checksum, file_info[0]);
break;
}
// Put signature for OTA image
flash_write_word(&flash, ota_addr + 8, 0x35393138);
flash_write_word(&flash, ota_addr + 12, 0x31313738);
flash_read_word(&flash, ota_addr + 8, &signature1);
flash_read_word(&flash, ota_addr + 12, &signature2);
if (signature1 != 0x35393138 || signature2 != 0x31313738) {
OTA_PRINTF("Put signature fail\r\n");
break;
}
// Mark image 2 as old image
flash_write_word(&flash, img2_addr + 8, 0x35393130);
ret = 0;
OTA_PRINTF("OTA success\r\n");
} while (0);
if (buf != NULL) {
free(buf);
}
if (server_socket >= 0) {
close(server_socket);
}
if (client_socket >= 0) {
close(client_socket);
}
if (ret < 0) {
OTA_PRINTF("OTA fail\r\n");
} else {
if (reboot_when_success) {
sys_reset();
}
}
return ret;
}
void main(void)
{
flash_t flash;
uint32_t address = FLASH_APP_BASE;
#if 1
uint32_t val32_to_write = 0x13572468;
uint32_t val32_to_read;
int loop = 0;
int result = 0;
for(loop = 0; loop < 10; loop++)
{
flash_read_word(&flash, address, &val32_to_read);
DBG_8195A("Read Data 0x%x\n", val32_to_read);
flash_erase_sector(&flash, address);
flash_write_word(&flash, address, val32_to_write);
flash_read_word(&flash, address, &val32_to_read);
DBG_8195A("Read Data 0x%x\n", val32_to_read);
// verify result
result = (val32_to_write == val32_to_read) ? 1 : 0;
//printf("\r\nResult is %s\r\n", (result) ? "success" : "fail");
DBG_8195A("\r\nResult is %s\r\n", (result) ? "success" : "fail");
result = 0;
}
#else
int VERIFY_SIZE = 256;
int SECTOR_SIZE = 16;
uint8_t writedata[VERIFY_SIZE];
uint8_t readdata[VERIFY_SIZE];
uint8_t verifydata = 0;
int loop = 0;
int index = 0;
int sectorindex = 0;
int result = 0;
int resultsector = 0;
int testloop = 0;
for(testloop = 0; testloop < 1; testloop++){
address = FLASH_APP_BASE;
for(sectorindex = 0; sectorindex < 4080; sectorindex++){
result = 0;
//address += SECTOR_SIZE;
flash_erase_sector(&flash, address);
//DBG_8195A("Address = %x \n", address);
for(loop = 0; loop < SECTOR_SIZE; loop++){
for(index = 0; index < VERIFY_SIZE; index++)
{
writedata[index] = verifydata + index;
}
flash_stream_write(&flash, address, VERIFY_SIZE, &writedata);
flash_stream_read(&flash, address, VERIFY_SIZE, &readdata);
for(index = 0; index < VERIFY_SIZE; index++)
{
//DBG_8195A("Address = %x, Writedata = %x, Readdata = %x \n",address,writedata[index],readdata[index]);
if(readdata[index] != writedata[index]){
DBG_8195A("Error: Loop = %d, Address = %x, Writedata = %x, Readdata = %x \n",testloop,address,writedata[index],readdata[index]);
}
else{
result++;
//DBG_8195A(ANSI_COLOR_BLUE"Correct: Loop = %d, Address = %x, Writedata = %x, Readdata = %x \n"ANSI_COLOR_RESET,testloop,address,writedata[index],readdata[index]);
}
}
address += VERIFY_SIZE;
}
if(result == VERIFY_SIZE * SECTOR_SIZE){
//DBG_8195A("Sector %d Success \n", sectorindex);
resultsector++;
}
}
if(resultsector == 4079){
DBG_8195A("Test Loop %d Success \n", testloop);
}
resultsector = 0;
verifydata++;
}
//DBG_8195A("%d Sector Success \n", resultsector);
DBG_8195A("Test Done");
#endif
for(;;);
}
// Mandatory function to load controller pairing from persistent storage
// called when HAP initialization
void HAPPlatformLoadPairings(HAPPersistentPairing_t *pairing, int num)
{
flash_stream_read(&flash, FLASH_DATA_ADDR + HAP_FLASH_PAIRING_OFFSET , sizeof(HAPPersistentPairing_t) * num, pairing);
}
// Mandatory function to load accessory key pair from persistent storage
// called when HAP initialization
void HAPPlatformLoadKeypair(HAPPersistentKeypair_t *keypair)
{
flash_stream_read(&flash, FLASH_DATA_ADDR + HAP_FLASH_KEYPAIR_OFFSET , sizeof(HAPPersistentKeypair_t), keypair);
}
static int uartadapter_load_wifi_config()
{
flash_t flash;
uint8_t *data;
uint32_t channel;
uint8_t pscan_config;
char key_id;
rtw_network_info_t wifi = {0};
int ret = SC_SUCCESS;
data = (uint8_t *)rtw_zmalloc(FAST_RECONNECT_DATA_LEN);
flash_stream_read(&flash, FAST_RECONNECT_DATA, FAST_RECONNECT_DATA_LEN, (uint8_t *)data);
if(*((uint32_t *) data) != ~0x0)
{
ua_printf(UA_INFO, "AP Profile read from FLASH, try to connect");
memcpy(psk_essid, (uint8_t *)data, NDIS_802_11_LENGTH_SSID + 4);
memcpy(psk_passphrase, (uint8_t *)data + NDIS_802_11_LENGTH_SSID + 4, (IW_PASSPHRASE_MAX_SIZE + 1));
memcpy(wpa_global_PSK, (uint8_t *)data + NDIS_802_11_LENGTH_SSID + 4 + (IW_PASSPHRASE_MAX_SIZE + 1), A_SHA_DIGEST_LEN * 2);
memcpy(&channel, (uint8_t *)data + NDIS_802_11_LENGTH_SSID + 4 + (IW_PASSPHRASE_MAX_SIZE + 1) + A_SHA_DIGEST_LEN * 2, 4);
sprintf(&key_id,"%d",(channel >> 28));
channel &= 0xff;
pscan_config = PSCAN_ENABLE | PSCAN_FAST_SURVEY;
//set partial scan for entering to listen beacon quickly
//wifi_set_pscan_chan((uint8_t *)&channel, &pscan_config, 1);
#ifdef CONFIG_AUTO_RECONNECT
wifi_set_autoreconnect(1);
#endif
//set wifi connect
wifi.ssid.len = (int)strlen((char*)psk_essid);
memcpy(wifi.ssid.val, psk_essid, wifi.ssid.len);
wifi.key_id = key_id;
//open mode
if(!strlen((char*)psk_passphrase)){
wifi.security_type = RTW_SECURITY_OPEN;
}
//wep mode
else if( strlen((char*)psk_passphrase) == 5 || strlen((char*)psk_passphrase) == 13){
wifi.security_type = RTW_SECURITY_WEP_PSK;
wifi.password = (unsigned char *)psk_passphrase;
wifi.password_len = (int)strlen((char const *)psk_passphrase);
}
//WPA/WPA2
else{
wifi.security_type = RTW_SECURITY_WPA2_AES_PSK;
wifi.password = (unsigned char *)psk_passphrase;
wifi.password_len = (int)strlen((char const *)psk_passphrase);
}
ret = uartadapter_connect_wifi(&wifi, channel, pscan_config);
//print_simple_config_result((enum ua_sc_result)ret);
if(data)
rtw_mfree(data, FAST_RECONNECT_DATA_LEN);
if(ret == SC_SUCCESS)
return RTW_SUCCESS;
else
return RTW_ERROR;
}else{
