static void getNextBlock(uint32_t currentAddress) { unsigned char *msg = NULL; size_t size; createDataReq_u32(&msg, currentAddress, StartDescriptorAddress + OFFSET_TO_POINTER, &size); /* Clear any pending flags and flush queue*/ wifiEngineState.cmdReplyPending = 0; wei_clear_cmd_queue(); wei_send_cmd_raw((char *)msg, size); /* Start transmission of next 256 bytes */ createDataReq_u32(&msg, START_TRANSMISSION, StartTxBmDesc , &size); /* Clear any pending flags and flush queue*/ wifiEngineState.cmdReplyPending = 0; wei_clear_cmd_queue(); wei_send_cmd_raw((char *)msg, size); /* Request signal host attention */ createDataReq_u32(&msg, START_TRANSMISSION, signalHostAttentionAddress, &size); /* Clear any pending flags and flush queue*/ wifiEngineState.cmdReplyPending = 0; wei_clear_cmd_queue(); wei_send_cmd_raw((char *)msg, size); }
static void sendCommitSuicideRequest(void) { hic_message_context_t msg_ref; char *cmd; int size; /* Send commit suicide request */ Mlme_CreateMessageContext(msg_ref); if (Mlme_CreateCommitSuicideReq(&msg_ref)) { /* Clear any pending flags and flush queue*/ wifiEngineState.cmdReplyPending = 0; wei_clear_cmd_queue(); if (! packer_HIC_Pack(&msg_ref)) { return; } cmd = msg_ref.packed; size = msg_ref.packed_size; msg_ref.packed = NULL; if (wei_send_cmd_raw(cmd, size)!= WIFI_ENGINE_SUCCESS) { DE_TRACE_STATIC(TR_WARN, "Failed to send HIC_CTRL_COMMIT_SUICIDE_REQ\n"); } } else { DE_TRACE_STATIC(TR_WARN, "Failed to create suicide request\n"); } Mlme_ReleaseMessageContext(msg_ref); }
static void sendScbErrorRequest(void) { hic_message_context_t msg_ref; char *dst_str; char *cmd; int size; DE_TRACE_STATIC(TR_ALWAYS,"sendScbErrorRequest()\n"); core_dump_state = W4_SCB_ERROR_CFM; /* Send scb error request */ Mlme_CreateMessageContext(msg_ref); dst_str = (char*)DriverEnvironment_Nonpaged_Malloc(sizeof(SCB_ERROR_KEY_STRING)); if (Mlme_CreateScbErrorReq(&msg_ref, dst_str)) { /* Clear any pending flags and flush queue*/ wifiEngineState.cmdReplyPending = 0; wei_clear_cmd_queue(); if (! packer_HIC_Pack(&msg_ref)) { return ; } cmd = msg_ref.packed; size = msg_ref.packed_size; msg_ref.packed = NULL; if (wei_send_cmd_raw(cmd, size) != WIFI_ENGINE_SUCCESS) { DE_TRACE_STATIC(TR_WARN, "Failed to send HIC_CTRL_SCB_ERROR_REQ\n"); } } DriverEnvironment_Nonpaged_Free(dst_str); Mlme_ReleaseMessageContext(msg_ref); }
/*! * @brief Check if any data or command has been queued. * * * @return Nothing */ void WiFiEngine_PsCheckQueues(void) { #if (DE_CCX == CFG_INCLUDED) if(connected) { DE_TRACE_STATIC(TR_PS, "NIKS: ccx_handle_wakeup called from wakeup_ind->WiFiEngine_PsCheckQueues\n"); ccx_handle_wakeup(); } #endif if((wifiEngineState.ps_queue_cnt == 0) && QUEUE_EMPTY(&cmd_queue)) { /* No command or data queued */ DE_TRACE_STATIC(TR_PS, "Data and command queue empty\n"); } else { if(wifiEngineState.ps_queue_cnt > 0) { DE_TRACE_STATIC(TR_PS, "wifiEngineState.ps_queue_cnt > 0\n"); if(connected) { wifiEngineState.dataPathState = DATA_PATH_OPENED; DriverEnvironment_handle_driver_wakeup(); } else { DE_TRACE_STATIC(TR_PS, "WifiEngine main state not driverConnected ignore queue count\n"); DE_TRACE_INT(TR_PS, "WifiEngine main state: %d \n", wifiEngineState.main_state ); } } if(!QUEUE_EMPTY(&cmd_queue)) { DE_TRACE_STATIC(TR_PS, "!QUEUE_EMPTY(&cmd_queue)\n"); /* Send a queued cmd if one is ready */ wei_send_cmd_raw(NULL, 0); } } }
/*! * @brief Handles packet received when core dump is enabled. * * @param pkt Received packet. * * @return * - Always returns WIFI_ENGINE_SUCCESS */ void WiFiEngine_HandleCoreDumpPkt(char* pkt) { size_t size; unsigned char *msg = NULL; if (!WES_TEST_FLAG(WES_FLAG_HW_PRESENT)) return; switch(core_dump_state) { case W4_SCB_ERROR_CFM: { unsigned char tx_desc[TX_DESC_SIZE]; hic_message_context_t msg_ref; uint8_t messageId; uint8_t messageType; Blob_t blob; Mlme_CreateMessageContext(msg_ref); INIT_BLOB(&blob, pkt, 1500); /* XXX */ /* Remove HIC header and add type/id info to msg_ref */ packer_HIC_Unpack(&msg_ref, &blob); messageId = msg_ref.msg_id; messageType = msg_ref.msg_type; msg_ref.packed = NULL; Mlme_ReleaseMessageContext(msg_ref); if((messageType == HIC_MESSAGE_TYPE_CTRL) && (messageId == HIC_CTRL_SCB_ERROR_CFM)) { /* Handle confirm message */ if(handleSCBErrorCfm(pkt) == 0) { /* SCB_ERROR_CFM has error code 0, this means that firmware. * is executing "normally" (no scb error has occured). * However a command timeout has occured so it would be nice * to force firmware in scb error and try to get a core dump. */ DE_TRACE_STATIC(TR_ALWAYS,"Cancel timer\n"); DriverEnvironment_CancelTimer(wifiEngineState.cmd_timer_id); DE_TRACE_STATIC(TR_ALWAYS,"Suicide requested\n"); sendCommitSuicideRequest(); wifiEngineState.core_dump_state = WEI_CORE_DUMP_DISABLED; return; } if(m_ext_ctx) { /* Coredump already started */ DriverEnvironment_Core_Dump_Abort( registry.network.basic.enableCoredump, registry.network.basic.restartTargetAfterCoredump, m_objId, m_errCode, &m_ext_ctx); } else { DriverEnvironment_indicate(WE_IND_CORE_DUMP_START, NULL, 0); } DriverEnvironment_Core_Dump_Started( registry.network.basic.enableCoredump, registry.network.basic.restartTargetAfterCoredump, m_objId, m_errCode, dump_total_size(dump_address_table), dump_total_size(dump_address_table), &m_ext_ctx); /* Turn off traces */ //trace_mask &= ~(TR_CMD | TR_NOISE | TR_PS | TR_HIGH_RES | TR_DATA ); trace_mask = 0; DriverEnvironment_Enable_Boot(); /* This is to prevent command timeout logic to re-start the timer */ WES_SET_FLAG(WES_FLAG_CMD_TIMEOUT_RUNNING); /* Initiate physical bm-descriptor to point to tx-descriptors */ createDataReq_u32(&msg, StartDescriptorAddress, StartTxBmDesc + OFFSET_TO_POINTER_BM_DESC, &size); /* Clear any pending flags and flush queue*/ wifiEngineState.cmdReplyPending = 0; wei_clear_cmd_queue(); wei_send_cmd_raw((char *)msg, size); /* Initiate targets tx-descriptor to be used */ createTxDescriptor(tx_desc); createDataReq(&msg, tx_desc, sizeof(tx_desc), StartDescriptorAddress, &size); /* Clear any pending flags and flush queue*/ wifiEngineState.cmdReplyPending = 0; wei_clear_cmd_queue(); wei_send_cmd_raw((char *)msg, size); core_dump_state = W4_MEMORY_DUMP; /* * if m_ext_ctx==NULL we are not interested in the coredump and can restart the target directly * Not sure of how to do this in a safe way so will go ahead with the coredump anyway for now and fix this later */ if(m_ext_ctx==NULL) { trace_mask = old_trace_mask; DriverEnvironment_Core_Dump_Complete( FALSE, registry.network.basic.restartTargetAfterCoredump, m_objId, m_errCode, &m_ext_ctx); DriverEnvironment_indicate(WE_IND_CORE_DUMP_COMPLETE, NULL, 0); DriverEnvironment_CancelTimer(wifiEngineState.cmd_timer_id); WES_CLEAR_FLAG(WES_FLAG_CMD_TIMEOUT_RUNNING); return; } currentRegion = dump_address_table; currentAddress = dump_region_start(currentRegion); getNextBlock(currentAddress); } else { DE_TRACE_INT2(TR_ALWAYS, "unexpected message %u.%u\n", messageType, messageId); } } break; case W4_MEMORY_DUMP: { uint32_t len; /* Store recevied packet in a file */ len = HIC_MESSAGE_LENGTH_GET(pkt); /* Move beyond size */ pkt += 2; len -= 2; /* Write dumpfile header (for nrx600 coredumps) */ if (dump_address_table == dump_address_table_nrx600 && m_ext_ctx && currentAddress == dump_region_start(currentRegion)) { DriverEnvironment_Core_Dump_Write(m_ext_ctx, (char *)currentRegion, sizeof(*currentRegion)); } len = DE_MIN(len, dump_region_end(currentRegion) - currentAddress); /* Copy to buffer */ if (m_ext_ctx) { DriverEnvironment_Core_Dump_Write(m_ext_ctx, pkt, len); } currentAddress += len; if(currentAddress >= dump_region_end(currentRegion)) { /* end of region, skip forward */ currentRegion++; currentAddress = dump_region_start(currentRegion); if(dump_region_size(currentRegion) == 0) { /* Complete - Start store data on a file and restart driver */ trace_mask = old_trace_mask; DE_TRACE_STATIC(TR_ALWAYS,"Coredump complete - cancel timer\n"); DriverEnvironment_CancelTimer(wifiEngineState.cmd_timer_id); WES_CLEAR_FLAG(WES_FLAG_CMD_TIMEOUT_RUNNING); DriverEnvironment_Core_Dump_Complete(registry.network.basic.enableCoredump && m_ext_ctx != NULL, /* see driverenv.h */ registry.network.basic.restartTargetAfterCoredump, m_objId, m_errCode, &m_ext_ctx); DriverEnvironment_indicate(WE_IND_CORE_DUMP_COMPLETE, NULL, 0); return; } } getNextBlock(currentAddress); } break; default: DE_BUG_ON(TRUE, "Invalid core dump state\n"); break; } }