uint8_t nvmem_write_patch(unsigned long ulFileId, unsigned long spLength, const uint8_t *spData) { uint8_t status = 0; uint16_t offset = 0; uint8_t *spDataPtr = (uint8_t*)spData; while ((status == 0) && (spLength >= SP_PORTION_SIZE)) { status = nvmem_write(ulFileId, SP_PORTION_SIZE, offset, spDataPtr); offset += SP_PORTION_SIZE; spLength -= SP_PORTION_SIZE; spDataPtr += SP_PORTION_SIZE; } if (status !=0) { /* NVMEM error occurred */ return status; } if (spLength != 0) { /* if reached here, a reminder is left */ status = nvmem_write(ulFileId, spLength, offset, spDataPtr); } return status; }
/***************************************************************************** * \brief Write data to nvmem. * * program a patch to a specific file ID. * The SP data is assumed to be organized in 2-dimentional. * Each line is 150 bytes long. * Actual programming is applied in 150 bytes portions (SP_PORTION_SIZE). * * \param[in] ulFileId nvmem file id:\n * NVMEM_WLAN_DRIVER_SP_FILEID, * NVMEM_WLAN_FW_SP_FILEID, * \param[in] spLength number of bytes to write * \param[in] spData SP data to write * * \return on succes 0, error otherwise. * * \sa * \note * \warning * *****************************************************************************/ unsigned char nvmem_write_patch(unsigned long ulFileId, unsigned long spLength, const unsigned char *spData) { unsigned char status = 0; unsigned short offset = 0; unsigned char* spDataPtr = (unsigned char*)spData; while ((status == 0) && (spLength >= SP_PORTION_SIZE)) { status = nvmem_write(ulFileId, SP_PORTION_SIZE, offset, spDataPtr); offset += SP_PORTION_SIZE; spLength -= SP_PORTION_SIZE; spDataPtr += SP_PORTION_SIZE; } if (status !=0) { // NVMEM error occured return status; } if (spLength != 0) { // if reached here, a reminder is left status = nvmem_write(ulFileId, spLength, offset, spDataPtr); } return status; }
UINT8 nvmem_write_patch(UINT32 ulFileId, UINT32 spLength, const UINT8 *spData) { UINT8 status = 0; UINT16 offset = 0; UINT8* spDataPtr = (UINT8*)spData; while ((status == 0) && (spLength >= SP_PORTION_SIZE)) { status = nvmem_write(ulFileId, SP_PORTION_SIZE, offset, spDataPtr); offset += SP_PORTION_SIZE; spLength -= SP_PORTION_SIZE; spDataPtr += SP_PORTION_SIZE; } if (status !=0) { // NVMEM error occurred return status; } if (spLength != 0) { // if reached here, a reminder is left status = nvmem_write(ulFileId, spLength, offset, spDataPtr); } return status; }
unsigned char nvmem_write_patch(unsigned long ulFileId, unsigned long spLength, const uint8_t *spData) { unsigned char status = 0; unsigned short offset = 0; unsigned char* spDataPtr = (unsigned char*)spData; uint8_t rambuffer[SP_PORTION_SIZE]; while ((status == 0) && (spLength >= SP_PORTION_SIZE)) { Serial.println("#"); for (uint8_t i=0; i<SP_PORTION_SIZE; i++) { //#ifdef TEENSY3 //rambuffer[i] = *(spData + i + offset); //#else //rambuffer[i] = pgm_read_byte(spData + i + offset); //#endif while (Serial.available() <= 0) ; rambuffer[i] = Serial.read(); } #if (DEBUG_MODE == 1) PRINT_F("Writing: "); printDec16(offset); PRINT_F("\t"); for (uint8_t i=0; i<SP_PORTION_SIZE; i++) { PRINT_F("0x"); printHex(rambuffer[i]); PRINT_F(", "); } PRINT_F("\n\r"); #endif status = nvmem_write(ulFileId, SP_PORTION_SIZE, offset, rambuffer); //status = 0; offset += SP_PORTION_SIZE; spLength -= SP_PORTION_SIZE; spDataPtr += SP_PORTION_SIZE; } if (status !=0) { // NVMEM error occurred return status; } if (spLength != 0) { Serial.println("#"); for (int i=0; i<spLength; i++) { while (Serial.available() <= 0) ; rambuffer[i] = Serial.read(); } // if reached here, a reminder is left status = nvmem_write(ulFileId, spLength, offset, rambuffer); //status = 0; } return status; }
//***************************************************************************** // //! fat_write_content //! //! \param[in] file_address array of file address in FAT table:\n //! this is the absolute address of the file in the EEPROM. //! \param[in] file_length array of file length in FAT table:\n //! this is the upper limit of the file size in the EEPROM. //! //! \return on succes 0, error otherwise //! //! \brief parse the FAT table from eeprom // //***************************************************************************** static unsigned char fat_write_content(unsigned short const *file_address, unsigned short const *file_length) { unsigned short index = 0; unsigned char ucStatus; unsigned char fatTable[48]; unsigned char* fatTablePtr = fatTable; // // First, write the magic number. // ucStatus = nvmem_write(16, 2, 0, (unsigned char*)"LS"); for (; index <= NVMEM_RM_FILEID; index++) { // // Write address low char and mark as allocated. // *fatTablePtr++ = (unsigned char)(file_address[index] & 0xff) | BIT0; // // Write address high char. // *fatTablePtr++ = (unsigned char)((file_address[index]>>8) & 0xff); // // Write length low char. // *fatTablePtr++ = (unsigned char)(file_length[index] & 0xff); // // Write length high char. // *fatTablePtr++ = (unsigned char)((file_length[index]>>8) & 0xff); } // // Second, write the FAT. // Write in two parts to work with tiny driver. // ucStatus = nvmem_write(16, 24, 4, fatTable); ucStatus = nvmem_write(16, 24, 24+4, &fatTable[24]); // // Third, we want to erase any user files. // memset(fatTable, 0, sizeof(fatTable)); ucStatus = nvmem_write(16, 16, 52, fatTable); return ucStatus; }
UINT8 nvmem_write_patch(UINT32 ulFileId, UINT32 spLength, const UINT8 *spData) { UINT8 status = 0; UINT16 offset = 0; UINT8* spDataPtr = (UINT8*)spData; UINT8 rambuffer[SP_PORTION_SIZE]; while ((status == 0) && (spLength >= SP_PORTION_SIZE)) { for (UINT8 i=0; i<SP_PORTION_SIZE; i++) { rambuffer[i] = pgm_read_byte(spData + i + offset); } #if (DEBUG_MODE == 1) PRINT_F("Writing: "); printDec16(offset); PRINT_F("\t"); for (UINT8 i=0; i<SP_PORTION_SIZE; i++) { PRINT_F("0x"); printHex(rambuffer[i]); PRINT_F(", "); } PRINT_F("\n\r"); #endif status = nvmem_write(ulFileId, SP_PORTION_SIZE, offset, rambuffer); offset += SP_PORTION_SIZE; spLength -= SP_PORTION_SIZE; spDataPtr += SP_PORTION_SIZE; } if (status !=0) { // NVMEM error occurred return status; } if (spLength != 0) { memcpy_P(rambuffer, spDataPtr, SP_PORTION_SIZE); // if reached here, a reminder is left status = nvmem_write(ulFileId, spLength, offset, rambuffer); } return status; }
unsigned char nvmem_write_patch(unsigned long ulFileId, unsigned long spLength, const uint8_t *spData) { unsigned char status = 0; unsigned short offset = 0; unsigned char* spDataPtr = (unsigned char*)spData; uint8_t rambuffer[SP_PORTION_SIZE]; while ((status == 0) && (spLength >= SP_PORTION_SIZE)) { for (uint8_t i=0; i<SP_PORTION_SIZE; i++) { rambuffer[i] = pgm_read_byte(spData + i + offset); } #if (DEBUG_MODE == 1) PRINT_F("Writing: "); printDec16(offset); PRINT_F("\t"); for (uint8_t i=0; i<SP_PORTION_SIZE; i++) { PRINT_F("0x"); printHex(rambuffer[i]); PRINT_F(", "); } PRINT_F("\n\r"); #endif status = nvmem_write(ulFileId, SP_PORTION_SIZE, offset, rambuffer); offset += SP_PORTION_SIZE; spLength -= SP_PORTION_SIZE; spDataPtr += SP_PORTION_SIZE; } if (status !=0) { // NVMEM error occurred return status; } if (spLength != 0) { memcpy_P(rambuffer, spDataPtr, SP_PORTION_SIZE); // if reached here, a reminder is left status = nvmem_write(ulFileId, spLength, offset, rambuffer); } return status; }
/* * This function is used to update NV memory. The write is to a memory copy of * NV. At the end of the current command, any changes are written to the actual * NV memory. */ void _plat__NvMemoryWrite(unsigned int startOffset, unsigned int size, void *data) { assert(startOffset + size <= NV_MEMORY_SIZE); /* Copy the data to the NV image */ #ifdef CONFIG_FLASH_NVMEM nvmem_write(startOffset, size, data, NVMEM_TPM); #else memcpy(&s_NV[startOffset], data, size); #endif }
void SPARK_WLAN_Loop(void) { static int cofd_count = 0; if(SPARK_WLAN_RESET || SPARK_WLAN_SLEEP) { if(SPARK_WLAN_STARTED) { if (LED_RGB_OVERRIDE) { LED_Signaling_Stop(); } WLAN_CONNECTED = 0; WLAN_DHCP = 0; SPARK_WLAN_RESET = 0; SPARK_WLAN_STARTED = 0; SPARK_SOCKET_CONNECTED = 0; SPARK_HANDSHAKE_COMPLETED = 0; SPARK_FLASH_UPDATE = 0; SPARK_LED_FADE = 0; Spark_Error_Count = 0; cofd_count = 0; CC3000_Write_Enable_Pin(WLAN_DISABLE); //wlan_stop(); Delay(100); if(WLAN_SMART_CONFIG_START) { //Workaround to enter smart config when socket connect had blocked wlan_start(0); SPARK_WLAN_STARTED = 1; /* Start CC3000 Smart Config Process */ Start_Smart_Config(); } LED_SetRGBColor(RGB_COLOR_GREEN); LED_On(LED_RGB); } } else { if(!SPARK_WLAN_STARTED) { wlan_start(0); SPARK_WLAN_STARTED = 1; } } if(WLAN_SMART_CONFIG_START) { /* Start CC3000 Smart Config Process */ Start_Smart_Config(); } else if (WLAN_MANUAL_CONNECT > 0 && !WLAN_DHCP) { wlan_ioctl_set_connection_policy(DISABLE, DISABLE, DISABLE); /* Edit the below line before use*/ wlan_connect(WLAN_SEC_WPA2, _ssid, strlen(_ssid), NULL, (unsigned char*)_password, strlen(_password)); WLAN_MANUAL_CONNECT = -1; } // Complete Smart Config Process: // 1. if smart config is done // 2. CC3000 established AP connection // 3. DHCP IP is configured // then send mDNS packet to stop external SmartConfig application if ((WLAN_SMART_CONFIG_STOP == 1) && (WLAN_DHCP == 1) && (WLAN_CONNECTED == 1)) { unsigned char loop_index = 0; while (loop_index < 3) { mdnsAdvertiser(1,device_name,strlen(device_name)); loop_index++; } WLAN_SMART_CONFIG_STOP = 0; } if(SPARK_SOCKET_HANDSHAKE == 0) { if(SPARK_SOCKET_CONNECTED || SPARK_HANDSHAKE_COMPLETED) { Spark_Disconnect(); SPARK_FLASH_UPDATE = 0; SPARK_LED_FADE = 0; SPARK_HANDSHAKE_COMPLETED = 0; SPARK_SOCKET_CONNECTED = 0; LED_SetRGBColor(RGB_COLOR_GREEN); LED_On(LED_RGB); } return; } if(TimingSparkConnectDelay != 0) { return; } if(WLAN_DHCP && !SPARK_WLAN_SLEEP && !SPARK_SOCKET_CONNECTED) { Delay(100); netapp_ipconfig(&ip_config); if(Spark_Error_Count) { LED_SetRGBColor(RGB_COLOR_RED); while(Spark_Error_Count != 0) { LED_On(LED_RGB); Delay(500); LED_Off(LED_RGB); Delay(500); Spark_Error_Count--; } //Send the Error Count to Cloud: NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET] //To Do //Reset Error Count NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET] = 0; nvmem_write(NVMEM_SPARK_FILE_ID, 1, ERROR_COUNT_FILE_OFFSET, &NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET]); } LED_SetRGBColor(RGB_COLOR_CYAN); LED_On(LED_RGB); if(Spark_Connect() >= 0) { cofd_count = 0; SPARK_SOCKET_CONNECTED = 1; TimingCloudHandshakeTimeout = 0; } else { if(SPARK_WLAN_RESET) return; if ((cofd_count += RESET_ON_CFOD) == MAX_FAILED_CONNECTS) { SPARK_WLAN_RESET = RESET_ON_CFOD; ERROR("Resetting CC3000 due to %d failed connect attempts", MAX_FAILED_CONNECTS); } if(Internet_Test() < 0) { //No Internet Connection if ((cofd_count += RESET_ON_CFOD) == MAX_FAILED_CONNECTS) { SPARK_WLAN_RESET = RESET_ON_CFOD; ERROR("Resetting CC3000 due to %d failed connect attempts", MAX_FAILED_CONNECTS); } Spark_Error_Count = 2; } else { //Cloud not Reachable Spark_Error_Count = 3; } NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET] = Spark_Error_Count; nvmem_write(NVMEM_SPARK_FILE_ID, 1, ERROR_COUNT_FILE_OFFSET, &NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET]); SPARK_SOCKET_CONNECTED = 0; } } if (SPARK_SOCKET_CONNECTED) { if (!SPARK_HANDSHAKE_COMPLETED) { int err = Spark_Handshake(); if (err) { if (0 > err) { // Wrong key error, red LED_SetRGBColor(0xff0000); } else if (1 == err) { // RSA decryption error, orange LED_SetRGBColor(0xff6000); } else if (2 == err) { // RSA signature verification error, magenta LED_SetRGBColor(0xff00ff); } LED_On(LED_RGB); Cloud_Handshake_Error_Count++; TimingSparkConnectDelay = Cloud_Handshake_Error_Count * TIMING_CLOUD_HANDSHAKE_TIMEOUT; } else { SPARK_HANDSHAKE_COMPLETED = 1; Cloud_Handshake_Error_Count = 0; TimingCloudActivityTimeout = 0; } } if (!Spark_Communication_Loop()) { if (LED_RGB_OVERRIDE) { LED_Signaling_Stop(); } SPARK_FLASH_UPDATE = 0; SPARK_LED_FADE = 0; SPARK_HANDSHAKE_COMPLETED = 0; SPARK_SOCKET_CONNECTED = 0; } } }
void SPARK_WLAN_Setup(void (*presence_announcement_callback)(void)) { announce_presence = presence_announcement_callback; /* Initialize CC3000's CS, EN and INT pins to their default states */ CC3000_WIFI_Init(); /* Configure & initialize CC3000 SPI_DMA Interface */ CC3000_SPI_DMA_Init(); /* WLAN On API Implementation */ wlan_init(WLAN_Async_Callback, WLAN_Firmware_Patch, WLAN_Driver_Patch, WLAN_BootLoader_Patch, CC3000_Read_Interrupt_Pin, CC3000_Interrupt_Enable, CC3000_Interrupt_Disable, CC3000_Write_Enable_Pin); Delay(100); /* Trigger a WLAN device */ wlan_start(0); SPARK_LED_FADE = 0; SPARK_WLAN_STARTED = 1; /* Mask out all non-required events from CC3000 */ wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE | HCI_EVNT_WLAN_UNSOL_INIT | HCI_EVNT_WLAN_ASYNC_PING_REPORT); if(NVMEM_SPARK_Reset_SysFlag == 0x0001 || nvmem_read(NVMEM_SPARK_FILE_ID, NVMEM_SPARK_FILE_SIZE, 0, NVMEM_Spark_File_Data) != NVMEM_SPARK_FILE_SIZE) { /* Delete all previously stored wlan profiles */ wlan_ioctl_del_profile(255); /* Create new entry for Spark File in CC3000 EEPROM */ nvmem_create_entry(NVMEM_SPARK_FILE_ID, NVMEM_SPARK_FILE_SIZE); memset(NVMEM_Spark_File_Data,0, arraySize(NVMEM_Spark_File_Data)); nvmem_write(NVMEM_SPARK_FILE_ID, NVMEM_SPARK_FILE_SIZE, 0, NVMEM_Spark_File_Data); NVMEM_SPARK_Reset_SysFlag = 0x0000; Save_SystemFlags(); } if(WLAN_MANUAL_CONNECT == 0) { if(NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET] == 0) { WLAN_SMART_CONFIG_START = 1; } else if(NVMEM_Spark_File_Data[WLAN_POLICY_FILE_OFFSET] == 0) { wlan_ioctl_set_connection_policy(DISABLE, DISABLE, ENABLE); NVMEM_Spark_File_Data[WLAN_POLICY_FILE_OFFSET] = 1; nvmem_write(NVMEM_SPARK_FILE_ID, 1, WLAN_POLICY_FILE_OFFSET, &NVMEM_Spark_File_Data[WLAN_POLICY_FILE_OFFSET]); } } if((WLAN_MANUAL_CONNECT > 0) || !WLAN_SMART_CONFIG_START) { LED_SetRGBColor(RGB_COLOR_GREEN); LED_On(LED_RGB); } nvmem_read_sp_version(patchVer); if (patchVer[1] == 24)//19 for old patch { /* Latest Patch Available after flashing "cc3000-patch-programmer.bin" */ } Clear_NetApp_Dhcp(); Set_NetApp_Timeout(); }
/******************************************************************************* * Function Name : Start_Smart_Config. * Description : The function triggers a smart configuration process on CC3000. * Input : None. * Output : None. * Return : None. *******************************************************************************/ void Start_Smart_Config(void) { WLAN_SMART_CONFIG_FINISHED = 0; WLAN_SMART_CONFIG_STOP = 0; WLAN_SERIAL_CONFIG_DONE = 0; WLAN_CONNECTED = 0; WLAN_DHCP = 0; WLAN_CAN_SHUTDOWN = 0; SPARK_SOCKET_CONNECTED = 0; SPARK_HANDSHAKE_COMPLETED = 0; SPARK_FLASH_UPDATE = 0; SPARK_LED_FADE = 0; LED_SetRGBColor(RGB_COLOR_BLUE); LED_On(LED_RGB); /* Reset all the previous configuration */ wlan_ioctl_set_connection_policy(DISABLE, DISABLE, DISABLE); NVMEM_Spark_File_Data[WLAN_POLICY_FILE_OFFSET] = 0; nvmem_write(NVMEM_SPARK_FILE_ID, 1, WLAN_POLICY_FILE_OFFSET, &NVMEM_Spark_File_Data[WLAN_POLICY_FILE_OFFSET]); /* Wait until CC3000 is disconnected */ while (WLAN_CONNECTED == 1) { //Delay 100ms Delay(100); hci_unsolicited_event_handler(); } /* Create new entry for AES encryption key */ nvmem_create_entry(NVMEM_AES128_KEY_FILEID,16); /* Write AES key to NVMEM */ aes_write_key((unsigned char *)(&smartconfigkey[0])); wlan_smart_config_set_prefix((char*)aucCC3000_prefix); /* Start the SmartConfig start process */ wlan_smart_config_start(1); WiFiCredentialsReader wifi_creds_reader(wifi_add_profile_callback); /* Wait for SmartConfig/SerialConfig to finish */ while (!(WLAN_SMART_CONFIG_FINISHED | WLAN_SERIAL_CONFIG_DONE)) { if(WLAN_DELETE_PROFILES && wlan_ioctl_del_profile(255) == 0) { int toggle = 25; while(toggle--) { LED_Toggle(LED_RGB); Delay(50); } NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET] = 0; nvmem_write(NVMEM_SPARK_FILE_ID, 1, WLAN_PROFILE_FILE_OFFSET, &NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET]); WLAN_DELETE_PROFILES = 0; } else { LED_Toggle(LED_RGB); Delay(250); wifi_creds_reader.read(); } } LED_On(LED_RGB); /* read count of wlan profiles stored */ nvmem_read(NVMEM_SPARK_FILE_ID, 1, WLAN_PROFILE_FILE_OFFSET, &NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET]); // if(NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET] >= 7) // { // if(wlan_ioctl_del_profile(255) == 0) // NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET] = 0; // } if(WLAN_SMART_CONFIG_FINISHED) { /* Decrypt configuration information and add profile */ wlan_profile_index = wlan_smart_config_process(); } if(wlan_profile_index != -1) { NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET] = wlan_profile_index + 1; } /* write count of wlan profiles stored */ nvmem_write(NVMEM_SPARK_FILE_ID, 1, WLAN_PROFILE_FILE_OFFSET, &NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET]); /* Configure to connect automatically to the AP retrieved in the Smart config process */ wlan_ioctl_set_connection_policy(DISABLE, DISABLE, ENABLE); NVMEM_Spark_File_Data[WLAN_POLICY_FILE_OFFSET] = 1; nvmem_write(NVMEM_SPARK_FILE_ID, 1, WLAN_POLICY_FILE_OFFSET, &NVMEM_Spark_File_Data[WLAN_POLICY_FILE_OFFSET]); /* Reset the CC3000 */ wlan_stop(); Delay(100); wlan_start(0); SPARK_WLAN_STARTED = 1; /* Mask out all non-required events */ wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE | HCI_EVNT_WLAN_UNSOL_INIT | HCI_EVNT_WLAN_ASYNC_PING_REPORT); LED_SetRGBColor(RGB_COLOR_GREEN); LED_On(LED_RGB); Set_NetApp_Timeout(); WLAN_SMART_CONFIG_START = 0; }
unsigned char nvmem_set_mac_address(unsigned char *mac) { return nvmem_write(NVMEM_MAC_FILEID, MAC_ADDR_LEN, 0, mac); }
UINT8 nvmem_set_mac_address(UINT8 *mac) { return nvmem_write(NVMEM_MAC_FILEID, MAC_ADDR_LEN, 0, mac); }
uint8_t nvmem_set_mac_address(uint8_t *mac) { return nvmem_write(NVMEM_MAC_FILEID, MAC_ADDR_LEN, 0, mac); }
void patch_prog_start() { unsigned short index; unsigned char *pRMParams; printf("Initializing module...\n"); // Init module and request to load with no patches. // This is in order to overwrite restrictions to // write to specific places in EEPROM. initDriver(1); // Read MAC address. mac_status = nvmem_get_mac_address(cMacFromEeprom); return_status = 1; printf("Reading RM parameters...\n"); while ((return_status) && (counter < 3)) { // Read RM parameters. // Read in 16 parts to work with tiny driver. return_status = 0; pRMParams = cRMParamsFromEeprom; for (index = 0; index < 16; index++) { return_status |= nvmem_read(NVMEM_RM_FILEID, 8, 8*index, pRMParams); pRMParams += 8; } counter++; } // If RM file is not valid, load the default one. if (counter == 3) { printf("RM is not valid, loading default one...\n"); pRMParams = (unsigned char *)cRMdefaultParams; } else { printf("RM is valid.\n"); pRMParams = cRMParamsFromEeprom; } return_status = 1; printf("Writing new FAT\n"); while (return_status) { // Write new FAT. return_status = fat_write_content(aFATEntries[0], aFATEntries[1]); } return_status = 1; printf("Writing RM parameters...\n"); while (return_status) { // Write RM parameters. // Write in 4 parts to work with tiny driver. return_status = 0; for (index = 0; index < 4; index++) { return_status |= nvmem_write(NVMEM_RM_FILEID, 32, 32*index, (pRMParams + 32*index)); } } return_status = 1; // Write back the MAC address, only if exists. if (mac_status == 0) { // Zero out MCAST bit if set. cMacFromEeprom[0] &= 0xfe; printf("Writing back MAC address..\n"); while (return_status) { return_status = nvmem_set_mac_address(cMacFromEeprom); } } // Update driver ucStatus_Dr = 1; printf("Updating driver patch...\n"); while (ucStatus_Dr) { // Writing driver patch to EEPRROM - PROTABLE CODE // Note that the array itself is changing between the // different Service Packs. ucStatus_Dr = nvmem_write_patch(NVMEM_WLAN_DRIVER_SP_FILEID, drv_length, wlan_drv_patch); } // Update firmware ucStatus_FW = 1; printf("Updating firmware patch...\n"); while (ucStatus_FW) { // Writing FW patch to EEPRROM - PROTABLE CODE // Note that the array itself is changing between the // different Service Packs. ucStatus_FW = nvmem_write_patch(NVMEM_WLAN_FW_SP_FILEID, fw_length, fw_patch); } printf("Update complete, resetting module\n"\ "If this doesn't work, reset manually...\n"); wlan_stop(); systick_sleep(500); // Re-Init module and request to load with patches. initDriver(0); // If MAC does not exist, it is recommended // that the user will write a valid mac address. if (mac_status != 0) { printf("MAC address is not valid, please write a new one\n"); } // Patch update done printf("All done, call wlan.patch_version()\n"); }
void SPARK_WLAN_Loop(void) { if(SPARK_WLAN_RESET || SPARK_WLAN_SLEEP) { if(SPARK_WLAN_STARTED) { if (LED_RGB_OVERRIDE) { LED_Signaling_Stop(); } WLAN_CONNECTED = 0; WLAN_DHCP = 0; SPARK_WLAN_RESET = 0; SPARK_WLAN_STARTED = 0; SPARK_SOCKET_CONNECTED = 0; SPARK_HANDSHAKE_COMPLETED = 0; SPARK_FLASH_UPDATE = 0; SPARK_LED_FADE = 0; Spark_Error_Count = 0; TimingSparkCommTimeout = 0; CC3000_Write_Enable_Pin(WLAN_DISABLE); Delay(100); if(WLAN_SMART_CONFIG_START) { //Workaround to enter smart config when socket connect had blocked wlan_start(0); SPARK_WLAN_STARTED = 1; /* Start CC3000 Smart Config Process */ Start_Smart_Config(); } LED_SetRGBColor(RGB_COLOR_GREEN); LED_On(LED_RGB); } } else { if(!SPARK_WLAN_STARTED) { wlan_start(0); SPARK_WLAN_STARTED = 1; } } if(WLAN_SMART_CONFIG_START) { /* Start CC3000 Smart Config Process */ Start_Smart_Config(); } else if (WLAN_MANUAL_CONNECT && !WLAN_DHCP) { wlan_ioctl_set_connection_policy(DISABLE, DISABLE, DISABLE); /* Edit the below line before use*/ wlan_connect(WLAN_SEC_WPA2, _ssid, strlen(_ssid), NULL, (unsigned char*)_password, strlen(_password)); WLAN_MANUAL_CONNECT = 0; } // Complete Smart Config Process: // 1. if smart config is done // 2. CC3000 established AP connection // 3. DHCP IP is configured // then send mDNS packet to stop external SmartConfig application if ((WLAN_SMART_CONFIG_STOP == 1) && (WLAN_DHCP == 1) && (WLAN_CONNECTED == 1)) { unsigned char loop_index = 0; while (loop_index < 3) { mdnsAdvertiser(1,device_name,strlen(device_name)); loop_index++; } WLAN_SMART_CONFIG_STOP = 0; } if(WLAN_DHCP && !SPARK_WLAN_SLEEP && !SPARK_SOCKET_CONNECTED) { Delay(100); netapp_ipconfig(&ip_config); #if defined (USE_SPARK_CORE_V02) if(Spark_Error_Count) { LED_SetRGBColor(RGB_COLOR_RED); while(Spark_Error_Count != 0) { LED_On(LED_RGB); Delay(500); LED_Off(LED_RGB); Delay(500); Spark_Error_Count--; } //Send the Error Count to Cloud: NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET] //To Do //Reset Error Count NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET] = 0; nvmem_write(NVMEM_SPARK_FILE_ID, 1, ERROR_COUNT_FILE_OFFSET, &NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET]); } LED_SetRGBColor(RGB_COLOR_CYAN); LED_On(LED_RGB); #endif if(Spark_Connect() < 0) { if(SPARK_WLAN_RESET) return; if(Internet_Test() < 0) { //No Internet Connection Spark_Error_Count = 2; } else { //Cloud not Reachable Spark_Error_Count = 3; } NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET] = Spark_Error_Count; nvmem_write(NVMEM_SPARK_FILE_ID, 1, ERROR_COUNT_FILE_OFFSET, &NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET]); SPARK_SOCKET_CONNECTED = 0; } else { SPARK_SOCKET_CONNECTED = 1; } } }