static void requestRadioPower(void *data, size_t datalen, RIL_Token t) { int onOff; int err=0; ATResponse *p_response = NULL; assert (datalen >= sizeof(int *)); onOff = ((int *)data)[0]; if (onOff == 0 && sState != RADIO_STATE_OFF) { if (first_cfun == 0) { stop_pppd(); wait_for_pppd_down(); err = at_send_command("AT+CFUN=0", &p_response); if (err < 0) goto error; } else { first_cfun = 0; } setRadioState(RADIO_STATE_OFF); } else if (onOff > 0 && sState == RADIO_STATE_OFF) { err = at_send_command("AT+CFUN=1", &p_response); if (err < 0|| p_response->success == 0) { // Some stacks return an error when there is no SIM, // but they really turn the RF portion on // So, if we get an error, let's check to see if it // turned on anyway if (getRadioPower() != 1) { goto error; } } setRadioState(RADIO_STATE_SIM_NOT_READY); } at_response_free(p_response); RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); return; error: at_response_free(p_response); RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); }
/** * SIM ready means any commands that access the SIM will work, including: * AT+CPIN, AT+CSMS, AT+CNMI, AT+CRSM * (all SMS-related commands). */ void pollSIMState(void *param) { if (((int) param) != 1 && getRadioState() != RADIO_STATE_SIM_NOT_READY && getRadioState() != RADIO_STATE_SIM_LOCKED_OR_ABSENT) /* No longer valid to poll. */ return; switch (getSIMStatus()) { case SIM_NOT_READY: ALOGI("SIM_NOT_READY, poll for sim state."); enqueueRILEvent(RIL_EVENT_QUEUE_PRIO, pollSIMState, NULL, &TIMEVAL_SIMPOLL); return; case SIM_PIN2: case SIM_PUK2: case SIM_PUK2_PERM_BLOCKED: case SIM_READY: setRadioState(RADIO_STATE_SIM_READY); enqueueRILEvent(RIL_EVENT_QUEUE_PRIO, setPollSIMState, (void *) 1, NULL); return; case SIM_ABSENT: setRadioState(RADIO_STATE_SIM_LOCKED_OR_ABSENT); enqueueRILEvent(RIL_EVENT_QUEUE_PRIO, setPollSIMState, (void *) 0, NULL); return; case SIM_PIN: case SIM_PUK: case SIM_NETWORK_PERSO: case SIM_NETWORK_SUBSET_PERSO: case SIM_SERVICE_PROVIDER_PERSO: case SIM_CORPORATE_PERSO: case SIM_SIM_PERSO: case SIM_STERICSSON_LOCK: case SIM_BLOCKED: case SIM_PERM_BLOCKED: case SIM_NETWORK_PERSO_PUK: case SIM_NETWORK_SUBSET_PERSO_PUK: case SIM_SERVICE_PROVIDER_PERSO_PUK: case SIM_CORPORATE_PERSO_PUK: /* pass through, do not break */ default: setRadioState(RADIO_STATE_SIM_LOCKED_OR_ABSENT); enqueueRILEvent(RIL_EVENT_QUEUE_PRIO, setPollSIMState, (void *) 1, NULL); return; } }
void CDStarRepeaterRXThread::receiveModem() { for (;;) { DSMT_TYPE type = m_modem->read(); if (type == DSMTT_NONE) return; switch (m_rxState) { case DSRXS_LISTENING: if (type == DSMTT_HEADER) { CHeaderData* header = m_modem->readHeader(); receiveHeader(header); } else if (type == DSMTT_DATA) { unsigned char data[20U]; unsigned int length = m_modem->readData(data, 20U); setRadioState(DSRXS_PROCESS_SLOW_DATA); receiveSlowData(data, length); } break; case DSRXS_PROCESS_SLOW_DATA: if (type == DSMTT_DATA) { unsigned char data[20U]; unsigned int length = m_modem->readData(data, 20U); receiveSlowData(data, length); } else if (type == DSMTT_EOT || type == DSMTT_LOST) { setRadioState(DSRXS_LISTENING); } break; case DSRXS_PROCESS_DATA: if (type == DSMTT_DATA) { unsigned char data[20U]; unsigned int length = m_modem->readData(data, 20U); receiveRadioData(data, length); } else if (type == DSMTT_EOT || type == DSMTT_LOST) { unsigned char data[20U]; ::memcpy(data, END_PATTERN_BYTES, DV_FRAME_LENGTH_BYTES); processRadioFrame(data, FRAME_END); setRadioState(DSRXS_LISTENING); endOfRadioData(); } break; } } }
/* Called on command or reader thread */ static void onATReaderClosed() { RLOGI("AT channel closed\n"); at_close(); s_closed = 1; setRadioState (RADIO_STATE_UNAVAILABLE); }
/* Called on command or reader thread */ static void onATReaderClosed(RILChannelCtx *p_channel) { RLOGI("AT channel closed\n"); at_close(p_channel); assert(0); s_closed = 1; setRadioState (RADIO_STATE_UNAVAILABLE, getRILIdByChannelCtx(p_channel)); }
/* Called on command thread */ static void onATTimeout() { RLOGI("AT channel timeout; closing\n"); at_close(); s_closed = 1; /* FIXME cause a radio reset here */ setRadioState (RADIO_STATE_UNAVAILABLE); }
/* Called on command thread */ static void onATTimeout(RILChannelCtx *p_channel) { RLOGI("AT channel timeout; closing\n"); at_close(p_channel); assert(0); s_closed = 1; /* FIXME cause a radio reset here */ setRadioState (RADIO_STATE_UNAVAILABLE, getRILIdByChannelCtx(p_channel)); }
void onSimHotswap(const char *s) { if (strcmp ("*EESIMSWAP:0", s) == 0) { ALOGD("%s() SIM Removed", __func__); s_simRemoved = 1; /* Toggle radio state since Android won't * poll the sim state unless the radio * state has changed from the previous * value */ setRadioState(RADIO_STATE_SIM_NOT_READY); setRadioState(RADIO_STATE_SIM_LOCKED_OR_ABSENT); enqueueRILEvent(RIL_EVENT_QUEUE_PRIO, setPollSIMState, (void *) 0, NULL); } else if (strcmp ("*EESIMSWAP:1", s) == 0) { ALOGD("%s() SIM Inserted", __func__); s_simRemoved = 0; set_pending_hotswap(1); enqueueRILEvent(RIL_EVENT_QUEUE_PRIO, setPollSIMState, (void *) 1, NULL); } else ALOGD("%s() Unknown SIM Hot Swap Event: %s", __func__, s); }
/* Sets the current satellite state to the given state, if a transition from the current state is valid; returns whether the state change was made (i.e. was valid) CAN be called consistently (i.e. if state == CurrentState), which will ensure all correct tasks for a state are running, etc. */ bool set_sat_state_helper(sat_state_t state) { // setting the state to the current state is not wrong, // but we don't want to actually change task states every time this is called // when the state is the current state if (state == current_sat_state) { return true; } sat_state_t prev_sat_state = current_sat_state; switch(state) { case INITIAL: return false; // only done initially (via direct set) case ANTENNA_DEPLOY: ; print("\n\nCHANGED STATE to ANTENNA_DEPLOY\n\n"); set_all_task_states(ANTENNA_DEPLOY_TASK_STATES, ANTENNA_DEPLOY, prev_sat_state); // turn radio off and don't confirm (won't confirm going off) // (this is the only state that can be re-entered where the transmit task is suspended) setRadioState(false, false); return prev_sat_state == INITIAL || prev_sat_state == LOW_POWER; case HELLO_WORLD: ; print("\n\nCHANGED STATE to HELLO_WORLD\n\n"); set_all_task_states(HELLO_WORLD_TASK_STATES, HELLO_WORLD, prev_sat_state); return prev_sat_state == ANTENNA_DEPLOY; case IDLE_NO_FLASH: ; print("\n\nCHANGED STATE to IDLE_NO_FLASH\n\n"); set_all_task_states(IDLE_NO_FLASH_TASK_STATES, IDLE_NO_FLASH, prev_sat_state); return prev_sat_state == IDLE_FLASH || prev_sat_state == HELLO_WORLD || prev_sat_state == LOW_POWER; case IDLE_FLASH: ; print("\n\nCHANGED STATE to IDLE_FLASH\n\n"); set_all_task_states(IDLE_FLASH_TASK_STATES, IDLE_FLASH, prev_sat_state); return prev_sat_state == IDLE_NO_FLASH; case LOW_POWER: ; print("\n\nCHANGED STATE to LOW_POWER\n\n"); set_all_task_states(LOW_POWER_TASK_STATES, LOW_POWER, prev_sat_state); return prev_sat_state == ANTENNA_DEPLOY || prev_sat_state == HELLO_WORLD || prev_sat_state == IDLE_NO_FLASH || prev_sat_state == IDLE_FLASH; default: log_error(ELOC_STATE_HANDLING, ECODE_UNEXPECTED_CASE, false); configASSERT(false); // bad state ID } return false; }
CDStarRepeaterTXRXThread::CDStarRepeaterTXRXThread(const wxString& type) : m_type(type), m_modem(NULL), m_protocolHandler(NULL), m_controller(NULL), m_rptCallsign(), m_rxHeader(NULL), m_txHeader(NULL), m_networkQueue(NULL), m_writeNum(0U), m_readNum(0U), m_radioSeqNo(0U), m_networkSeqNo(0U), m_watchdogTimer(1000U, NETWORK_TIMEOUT), m_registerTimer(1000U), m_statusTimer(1000U, 0U, 100U), // 100ms m_heartbeatTimer(1000U, 1U), // 1s m_rptState(DSRS_LISTENING), m_rxState(DSRXS_LISTENING), m_slowDataDecoder(), m_tx(false), m_transmitting(false), m_space(0U), m_killed(false), m_activeHangTimer(1000U), m_disable(false), m_lastData(NULL), m_ambe(), m_ambeFrames(0U), m_ambeSilence(0U), m_ambeBits(1U), m_ambeErrors(0U), m_lastAMBEBits(0U), m_lastAMBEErrors(0U), m_headerTime(), m_packetTime(), m_packetCount(0U), m_packetSilence(0U) { m_networkQueue = new COutputQueue*[NETWORK_QUEUE_COUNT]; for (unsigned int i = 0U; i < NETWORK_QUEUE_COUNT; i++) m_networkQueue[i] = new COutputQueue((DV_FRAME_LENGTH_BYTES + 2U) * 200U, NETWORK_RUN_FRAME_COUNT); // 4s worth of data); m_lastData = new unsigned char[DV_FRAME_MAX_LENGTH_BYTES]; setRepeaterState(DSRS_LISTENING); setRadioState(DSRXS_LISTENING); }
void CDVRPTRRepeaterRXThread::receiveHeader(unsigned char* data, unsigned int length) { CHeaderData* header = new CHeaderData(data, length, false); wxLogMessage(wxT("Radio header decoded - My: %s/%s Your: %s Rpt1: %s Rpt2: %s Flags: %02X %02X %02X"), header->getMyCall1().c_str(), header->getMyCall2().c_str(), header->getYourCall().c_str(), header->getRptCall1().c_str(), header->getRptCall2().c_str(), header->getFlag1(), header->getFlag2(), header->getFlag3()); bool res = processRadioHeader(header); if (res) { // A valid header and is a DV packet m_radioSeqNo = 20U; setRadioState(DSRXS_PROCESS_DATA); } else { // This is a DD packet or some other problem // wxLogMessage(wxT("Invalid header")); } }
void CDStarRepeaterRXThread::receiveHeader(CHeaderData* header) { wxASSERT(header != NULL); wxLogMessage(wxT("Radio header decoded - My: %s/%s Your: %s Rpt1: %s Rpt2: %s Flags: %02X %02X %02X"), header->getMyCall1().c_str(), header->getMyCall2().c_str(), header->getYourCall().c_str(), header->getRptCall1().c_str(), header->getRptCall2().c_str(), header->getFlag1(), header->getFlag2(), header->getFlag3()); bool res = processRadioHeader(header); if (res) { // A valid header and is a DV packet m_radioSeqNo = 20U; setRadioState(DSRXS_PROCESS_DATA); } else { // This is a DD packet or some other problem // wxLogMessage(wxT("Invalid header")); } }
CDVRPTRRepeaterRXThread::CDVRPTRRepeaterRXThread() : wxThread(wxTHREAD_JOINABLE), m_dvrptr(NULL), m_protocolHandler(NULL), m_rxHeader(NULL), m_radioSeqNo(0U), m_pollTimer(1000U, 60U), // 60s m_rptState(DSRS_LISTENING), m_rxState(DSRXS_LISTENING), m_slowDataDecoder(), m_killed(false), m_ambe(), m_ambeFrames(0U), m_ambeSilence(0U), m_ambeBits(1U), m_ambeErrors(0U), m_lastAMBEBits(0U), m_lastAMBEErrors(0U) { setRadioState(DSRXS_LISTENING); }
CDStarRepeaterRXThread::CDStarRepeaterRXThread(const wxString& type) : m_type(type), m_modem(NULL), m_protocolHandler(NULL), m_rxHeader(NULL), m_radioSeqNo(0U), m_registerTimer(1000U), m_rptState(DSRS_LISTENING), m_rxState(DSRXS_LISTENING), m_slowDataDecoder(), m_killed(false), m_ambe(), m_ambeFrames(0U), m_ambeSilence(0U), m_ambeBits(1U), m_ambeErrors(0U), m_lastAMBEBits(0U), m_lastAMBEErrors(0U) { setRadioState(DSRXS_LISTENING); }
void CDStarRepeaterRXThread::receiveSlowData(unsigned char* data, unsigned int) { unsigned int errs; errs = countBits(data[VOICE_FRAME_LENGTH_BYTES + 0U] ^ DATA_SYNC_BYTES[0U]); errs += countBits(data[VOICE_FRAME_LENGTH_BYTES + 1U] ^ DATA_SYNC_BYTES[1U]); errs += countBits(data[VOICE_FRAME_LENGTH_BYTES + 2U] ^ DATA_SYNC_BYTES[2U]); // The data sync has been seen, a fuzzy match is used, two bit errors or less if (errs <= MAX_DATA_SYNC_BIT_ERRS) { // wxLogMessage(wxT("Found data sync at frame %u, errs: %u"), m_radioSeqNo, errs); m_radioSeqNo = 0U; m_slowDataDecoder.sync(); } else if (m_radioSeqNo == 20U) { // wxLogMessage(wxT("Assuming data sync")); m_radioSeqNo = 0U; m_slowDataDecoder.sync(); } else { m_radioSeqNo++; m_slowDataDecoder.addData(data + VOICE_FRAME_LENGTH_BYTES); CHeaderData* header = m_slowDataDecoder.getHeaderData(); if (header == NULL) return; wxLogMessage(wxT("Radio header from slow data - My: %s/%s Your: %s Rpt1: %s Rpt2: %s Flags: %02X %02X %02X BER: 0%%"), header->getMyCall1().c_str(), header->getMyCall2().c_str(), header->getYourCall().c_str(), header->getRptCall1().c_str(), header->getRptCall2().c_str(), header->getFlag1(), header->getFlag2(), header->getFlag3()); if (header != NULL) { bool res = processRadioHeader(header); if (res) { // A valid header and is a DV packet, go to normal data relaying setRadioState(DSRXS_PROCESS_DATA); } else { // This is a DD packet or some other problem // wxLogMessage(wxT("Invalid header")); } } } }
CSoundCardRepeaterRXThread::CSoundCardRepeaterRXThread() : wxThread(wxTHREAD_JOINABLE), m_soundcard(NULL), m_protocolHandler(NULL), m_controller(NULL), m_goertzel(DSTAR_RADIO_SAMPLE_RATE, GOERTZEL_FREQ, GOERTZEL_N, 0.1F), m_inBuffer(DSTAR_RADIO_SAMPLE_RATE * 1U), // One second of data m_reader(NULL), m_demodulator(), m_bitBuffer(DV_FRAME_LENGTH_BITS), m_rxState(DSRXS_LISTENING), m_frameMatcher(FRAME_SYNC_LENGTH_BITS, FRAME_SYNC_BITS), m_dataMatcher(DATA_FRAME_LENGTH_BITS, DATA_SYNC_BITS), m_endMatcher(END_PATTERN_LENGTH_BITS, END_PATTERN_BITS), m_header(NULL), m_headerBER(0U), m_radioSeqNo(0U), m_radioSyncsLost(0U), m_pollTimer(1000U, 60U), // 60s m_rptState(DSRS_LISTENING), m_slowDataDecoder(), m_squelch(false), m_squelchCount(0U), m_noise(0.0F), m_noiseCount(0U), m_killed(false), m_squelchMode(SM_NORMAL), m_ambe(), m_ambeFrames(0U), m_ambeSilence(0U), m_ambeBits(1U), m_ambeErrors(0U), m_lastAMBEBits(0U), m_lastAMBEErrors(0U) { setRadioState(DSRXS_LISTENING); }
/* loads stored state from persistent storage and sets up correct boot parameters */ void configure_state_from_reboot(void) { // send first read command read_state_from_storage(); #ifdef OVERRIDE_INIT_SAT_STATE current_sat_state = OVERRIDE_INIT_SAT_STATE; current_task_states = OVERRIDE_INIT_TASK_STATES; #else // based on satellite state, set initial state // (it will actually be set as tasks come online) // (this is done differently than during normal satellite operation, // because we're still initializing and tasks can't be simply suspended // right now (RTOS isn't even running yet). So, we configure what // needs to be done and configure tasks as they boot up and report // to the function below that they're ready) sat_state_t state_at_reboot = cache_get_sat_state(); if (state_at_reboot == INITIAL || state_at_reboot == ANTENNA_DEPLOY || state_at_reboot == HELLO_WORLD) { current_sat_state = INITIAL; // the distinction between these two is related to T_STATE_ANY; // we use boot_task_states to explicitly set state for all tasks on boot // (so at the end of this it won't contain any T_STATE_ANYs), // while current_task_states signifies the current abstract state current_task_states = INITIAL_TASK_STATES; } else { current_sat_state = IDLE_NO_FLASH; current_task_states = IDLE_NO_FLASH_TASK_STATES; } #endif // always start antenna deploy task current_task_states.states[ANTENNA_DEPLOY_TASK] = true; // add any errors we can from MRAM cache // (NOTE; no one should've logged any yet, or else they may be overwritten!) populate_error_stacks(&error_equistack); // if the satellite restarted because of the watchdog, log that as an error so we know enum system_reset_cause cause = system_get_reset_cause(); if (cause == SYSTEM_RESET_CAUSE_WDT) { log_error(ELOC_WATCHDOG, ECODE_WATCHDOG_DID_KICK, true); } else if (cause == SYSTEM_RESET_CAUSE_SOFTWARE) { log_error(ELOC_WATCHDOG, ECODE_SOFTWARE_RESET, false); // mostly for debug; hopefully no aliens are hacking us } else if (cause == SYSTEM_RESET_CAUSE_EXTERNAL_RESET) { log_error(ELOC_WATCHDOG, ECODE_SAT_RESET, true); } // if we had to rewrite program memory due to corruption, log a low-pri error if (cache_get_prog_mem_rewritten()) { log_error(ELOC_BOOTLOADER, ECODE_REWROTE_PROG_MEM, false); update_sat_event_history(0, 0, 0, 0, 0, 0, 1); // rare enough that the double-write here is fine } // note we've rebooted increment_reboot_count(); // initial hardware settings (last because they have delays) setRadioState(false, false); // turn radio off and don't confirm (won't confirm going off) }
static void initializeCallback(void *param) { RLOGE ("[Emu]get in initializeCallback"); ATResponse *p_response = NULL; int err; RILId rid = *((RILId *)param); char property_value[5] = { 0 }; int current_share_modem = 0; current_share_modem = MTK_SHARE_MODEM_CURRENT; setRadioState (RADIO_STATE_OFF,rid); err = at_handshake(getDefaultChannelCtx(rid)); RLOGI("AT handshake: %d",err); /* note: we don't check errors here. Everything important will be handled in onATTimeout and onATReaderClosed */ /* atchannel is tolerant of echo but it must */ /* have verbose result codes */ at_send_command("ATE0Q0V1", NULL, getDefaultChannelCtx(rid)); /* No auto-answer */ at_send_command("ATS0=0", NULL,getDefaultChannelCtx(rid)); /* Extended errors */ at_send_command("AT+CMEE=1", NULL, getDefaultChannelCtx(rid)); /* Network registration events */ err = at_send_command("AT+CREG=2", &p_response, getDefaultChannelCtx(rid)); /* some handsets -- in tethered mode -- don't support CREG=2 */ if (err < 0 || p_response->success == 0) { at_send_command("AT+CREG=1", NULL, getDefaultChannelCtx(rid)); } at_response_free(p_response); /* GPRS registration events */ at_send_command("AT+CGREG=1", NULL, getDefaultChannelCtx(rid)); /* Call Waiting notifications */ at_send_command("AT+CCWA=1", NULL, getDefaultChannelCtx(rid)); //[Emu]TODO diff /* mtk00924: enable Call Progress notifications */ at_send_command("AT+ECPI=4294967295", NULL, getDefaultChannelCtx(rid)); /* Alternating voice/data off */ /* at_send_command("AT+CMOD=0", NULL, getDefaultChannelCtx(rid)); */ /* Not muted */ /* at_send_command("AT+CMUT=0", NULL, getDefaultChannelCtx(rid)); */ //[Emu]TODO diff /* +CSSU unsolicited supp service notifications */ at_send_command("AT+CSSN=1,1", NULL, getDefaultChannelCtx(rid)); //[Emu]TODO diff /* connected line identification on */ at_send_command("AT+COLP=1", NULL, getDefaultChannelCtx(rid)); //[Emu]TODO diff /* HEX character set */ at_send_command("AT+CSCS=\"UCS2\"", NULL, getDefaultChannelCtx(rid)); /* USSD unsolicited */ at_send_command("AT+CUSD=1", NULL, getDefaultChannelCtx(rid)); /* Enable +CGEV GPRS event notifications, but don't buffer */ at_send_command("AT+CGEREP=1,0", NULL, getDefaultChannelCtx(rid)); /* SMS PDU mode */ at_send_command("AT+CMGF=0", NULL, getDefaultChannelCtx(rid)); /* Initial CID table */ initialCidTable(); //[Emu]TODO diff /* Enable getting NITZ, include TZ and Operator Name*/ /* To Receive +CIEV: 9 and +CIEV: 10*/ //[Emu]TODO_1_ changed // at_send_command("AT+CTZR=1", NULL, getDefaultChannelCtx(rid)); //[Emu]TODO diff /* Enable getting CFU info +ECFU and speech info +ESPEECH*/ // at_send_command("AT+EINFO=114", NULL, getDefaultChannelCtx(rid)); //[Emu]TODO diff /* Enable get ECSQ URC */ //at_send_command("AT+ECSQ=2", NULL, getDefaultChannelCtx(rid)); //[Emu]TODO diff /* Enable get +CIEV:7 URC to receive SMS SIM Storage Status*/ // at_send_command("AT+CMER=1,0,0,2,0", NULL, getDefaultChannelCtx(rid)); //[Emu]TODO diff #ifdef MTK_VT3G324M_SUPPORT at_send_command("AT+CRC=1", NULL, getDefaultChannelCtx(rid)); #endif #ifdef MTK_GEMINI requestSimReset(rid); RLOGD("start rild bootup flow [%d, %d, %d, %d]", isDualTalkMode(), rid, RIL_is3GSwitched(), current_share_modem); if (isDualTalkMode()) { if (rid == MTK_RIL_SOCKET_1) { flightModeBoot(); bootupGetIccid(rid); //query ICCID after AT+ESIMS bootupGetImei(rid); bootupGetImeisv(rid); bootupGetBasebandVersion(rid); bootupGetCalData(rid); RLOGD("get SIM inserted status (DT) [%d]", sim_inserted_status); RIL_onUnsolicitedResponse(RIL_UNSOL_SIM_INSERTED_STATUS, &sim_inserted_status, sizeof(int), rid); } } else { if (current_share_modem == 1) { if (rid == MTK_RIL_SOCKET_1) { flightModeBoot(); bootupGetIccid(rid); //query ICCID after AT+ESIMS bootupGetImei(rid); bootupGetImeisv(rid); bootupGetBasebandVersion(rid); bootupGetCalData(rid); RLOGD("get SIM inserted status (Single) [%d]", sim_inserted_status); RIL_onUnsolicitedResponse(RIL_UNSOL_SIM_INSERTED_STATUS, &sim_inserted_status, sizeof(int), rid); } } else if (rid == MTK_RIL_SOCKET_2) { flightModeBoot(); bootupGetIccid(MTK_RIL_SOCKET_1); bootupGetIccid(MTK_RIL_SOCKET_2); bootupGetImei(MTK_RIL_SOCKET_1); bootupGetImei(MTK_RIL_SOCKET_2); bootupGetImeisv(MTK_RIL_SOCKET_1); bootupGetImeisv(MTK_RIL_SOCKET_2); bootupGetBasebandVersion(MTK_RIL_SOCKET_1); bootupGetBasebandVersion(MTK_RIL_SOCKET_2); bootupGetCalData(MTK_RIL_SOCKET_1); RLOGD("get SIM inserted status [%d]", sim_inserted_status); RIL_onUnsolicitedResponse(RIL_UNSOL_SIM_INSERTED_STATUS, &sim_inserted_status, sizeof(int), rid); } } #else flightModeBoot(); bootupGetIccid(rid); bootupGetImei(rid); bootupGetImeisv(rid); bootupGetBasebandVersion(rid); bootupGetCalData(rid); #endif /* MTK_GEMINI */ //[Emu]TODO diff /* assume radio is off on error */ if (isRadioOn(rid) > 0) { setRadioState (RADIO_STATE_SIM_NOT_READY,rid); } }
void onSimStateChanged(const char *s) { int state; char *tok = NULL; char *line = NULL; /* let the status from EESIMSWAP override * that of ESIMSR */ if (s_simRemoved) return; line = tok = strdup(s); if (NULL == line) { ALOGE("%s() failed to allocate memory!", __func__); return; } if (at_tok_start(&line) < 0) goto error; if (at_tok_nextint(&line, &state) < 0) goto error; /* * s_simResetting is used to coordinate state changes during sim resetting, * i.e. ESIMSR state changing from 7 to 4 or 5. */ switch (state) { case 7: /* SIM STATE POWER OFF, or indicating no SIM inserted. */ s_simResetting = 1; setRadioState(RADIO_STATE_SIM_LOCKED_OR_ABSENT); break; case 4: /* SIM STATE WAIT FOR PIN */ if (s_simResetting) { s_simResetting = 0; /* * Android will not poll for SIM state if Radio State has no * changes. Therefore setRadioState twice to make Android poll for * Sim state when there is a PIN state change. */ setRadioState(RADIO_STATE_SIM_NOT_READY); setRadioState(RADIO_STATE_SIM_LOCKED_OR_ABSENT); } break; case 5: /* SIM STATE ACTIVE */ if (s_simResetting) { s_simResetting = 0; /* * Android will not poll for SIM state if Radio State has no * changes. Therefore setRadioState twice to make Android poll for * Sim state when there is a PIN state change. */ setRadioState(RADIO_STATE_SIM_NOT_READY); setRadioState(RADIO_STATE_SIM_READY); } break; case 2: /* SIM STATE BLOCKED */ case 3: /* SIM STATE BLOCKED FOREVER */ setRadioState(RADIO_STATE_SIM_LOCKED_OR_ABSENT); break; default: /* * s_simResetting should not be changed in the states between SIM POWER * OFF to SIM STATE WAIT FOR PIN or SIM STATE ACTIVE. */ break; } RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0); finally: free(tok); return; error: ALOGE("Error in %s", __func__); goto finally; }
static void initializeCallback(void *param) { ATResponse *p_response = NULL; int err; setRadioState (RADIO_STATE_OFF); at_handshake(); /* note: we don't check errors here. Everything important will be handled in onATTimeout and onATReaderClosed */ /* atchannel is tolerant of echo but it must */ /* have verbose result codes */ at_send_command("ATE0Q0V1", NULL); /* No auto-answer */ at_send_command("ATS0=0", NULL); /* Extended errors */ at_send_command("AT+CMEE=1", NULL); /* Network registration events */ err = at_send_command("AT+CREG=2", &p_response); /* some handsets -- in tethered mode -- don't support CREG=2 */ if (err < 0 || p_response->success == 0) { at_send_command("AT+CREG=1", NULL); } at_response_free(p_response); /* GPRS registration events */ at_send_command("AT+CGREG=1", NULL); /* Call Waiting notifications */ at_send_command("AT+CCWA=1", NULL); /* Alternating voice/data off */ at_send_command("AT+CMOD=0", NULL); /* Not muted */ at_send_command("AT+CMUT=0", NULL); /* +CSSU unsolicited supp service notifications */ at_send_command("AT+CSSN=0,1", NULL); /* no connected line identification */ at_send_command("AT+COLP=0", NULL); /* HEX character set */ at_send_command("AT+CSCS=\"HEX\"", NULL); /* USSD unsolicited */ at_send_command("AT+CUSD=1", NULL); /* Enable +CGEV GPRS event notifications, but don't buffer */ at_send_command("AT+CGEREP=1,0", NULL); /* SMS PDU mode */ at_send_command("AT+CMGF=0", NULL); #ifdef USE_TI_COMMANDS at_send_command("AT%CPI=3", NULL); /* TI specific -- notifications when SMS is ready (currently ignored) */ at_send_command("AT%CSTAT=1", NULL); #endif /* USE_TI_COMMANDS */ /* assume radio is off on error */ if (isRadioOn() > 0) { setRadioState (RADIO_STATE_SIM_NOT_READY); } }
void CDVRPTRRepeaterRXThread::receiveRadio() { for (;;) { unsigned char data[50U]; unsigned int length; DATA_QUEUE_TYPE type = m_dvrptr->readQueue(data, length); switch (type) { case DQT_NONE: return; case DQT_HEADER: // CUtils::dump(wxT("DQT_HEADER"), data, length); break; case DQT_DATA: // CUtils::dump(wxT("DQT_DATA"), data, length); break; case DQT_EOT: // wxLogMessage(wxT("DQT_EOT")); break; case DQT_LOST: // wxLogMessage(wxT("DQT_LOST")); break; default: wxLogMessage(wxT("type=%d"), int(type)); CUtils::dump(wxT("DQT_???"), data, length); break; } switch (m_rxState) { case DSRXS_LISTENING: if (type == DQT_HEADER) { receiveHeader(data, length); } else if (type == DQT_DATA) { setRadioState(DSRXS_PROCESS_SLOW_DATA); } break; case DSRXS_PROCESS_SLOW_DATA: if (type == DQT_DATA) { receiveSlowData(data, length); } else if (type == DQT_EOT) { setRadioState(DSRXS_LISTENING); } else if (type == DQT_LOST) { setRadioState(DSRXS_LISTENING); } break; case DSRXS_PROCESS_DATA: if (type == DQT_DATA) { receiveRadioData(data, length); } else if (type == DQT_EOT) { processRadioFrame(data, FRAME_END); setRadioState(DSRXS_LISTENING); endOfRadioData(); } else if (type == DQT_LOST) { ::memcpy(data, NULL_FRAME_DATA_BYTES, DV_FRAME_LENGTH_BYTES); processRadioFrame(data, FRAME_END); setRadioState(DSRXS_LISTENING); endOfRadioData(); } break; } } }
void CSoundCardRepeaterTXRXThread::radioStateMachine(bool bit) { switch (m_rxState) { case DSRXS_LISTENING: { unsigned int errs1 = m_frameMatcher.add(bit); unsigned int errs2 = m_dataMatcher.add(bit); // The frame sync has been seen, an exact match only if (errs1 == 0U) { // wxLogMessage(wxT("Found frame sync")); setRadioState(DSRXS_PROCESS_HEADER); } // The data sync has been seen, an exact match only if (errs2 == 0U) { // wxLogMessage(wxT("Found data sync")); setRadioState(DSRXS_PROCESS_SLOW_DATA); } } break; case DSRXS_PROCESS_HEADER: m_bitBuffer.add(bit); if (m_bitBuffer.getLength() == FEC_SECTION_LENGTH_BITS) { CHeaderData* header = processFECHeader(); if (header != NULL) { bool res = processRadioHeader(header); if (res) { // A valid header and is a DV packet m_radioSeqNo = 20U; m_radioSyncsLost = 0U; setRadioState(DSRXS_PROCESS_DATA); } else { // This is a DD packet or some other problem // wxLogMessage(wxT("Invalid header")); setRadioState(DSRXS_LISTENING); } } else { // The checksum failed setRadioState(DSRXS_LISTENING); } } break; case DSRXS_PROCESS_DATA: { m_bitBuffer.add(bit); unsigned int errs1 = m_endMatcher.add(bit); unsigned int errs2 = m_dataMatcher.add(bit); // The end pattern has been seen, a fuzzy match is used, four bit errors or less if (errs1 <= MAX_END_PATTERN_BIT_ERRS) { // wxLogMessage(wxT("Found end pattern, errs: %u"), errs1); processRadioFrame(FRAME_END); setRadioState(DSRXS_LISTENING); endOfRadioData(); break; } if (m_bitBuffer.getLength() == DV_FRAME_LENGTH_BITS) { // The squelch is closed so replace the data with silence if (m_squelchCount >= MAX_SQUELCH_COUNT) { m_bitBuffer.clear(); // Add AMBE silence and slow data for (unsigned int i = 0U; i < DV_FRAME_LENGTH_BITS; i++) m_bitBuffer.add(NULL_FRAME_DATA_BITS[i]); } // The data sync has been seen, a fuzzy match is used, two bit errors or less if (errs2 <= MAX_DATA_SYNC_BIT_ERRS) { // wxLogMessage(wxT("Found data sync at frame %u, errs: %u"), m_radioSeqNo, errs2); m_radioSeqNo = 0U; m_radioSyncsLost = 0U; processRadioFrame(FRAME_SYNC); } else if (m_radioSeqNo == 20U) { // wxLogMessage(wxT("Regenerating data sync")); m_radioSeqNo = 0U; m_radioSyncsLost++; if (m_radioSyncsLost == MAX_LOST_SYNCS) { // wxLogMessage(wxT("Lost sync")); processRadioFrame(FRAME_END); setRadioState(DSRXS_LISTENING); endOfRadioData(); } else { processRadioFrame(FRAME_SYNC); } } else { m_radioSeqNo++; processRadioFrame(FRAME_NORMAL); } m_squelchCount = 0U; m_bitBuffer.clear(); } } break; case DSRXS_PROCESS_SLOW_DATA: { m_bitBuffer.add(bit); unsigned int errs1 = m_endMatcher.add(bit); unsigned int errs2 = m_dataMatcher.add(bit); // The end pattern has been seen, a fuzzy match is used, four bit errors or less if (errs1 <= MAX_END_PATTERN_BIT_ERRS) { // wxLogMessage(wxT("Found end pattern, errs: %u"), errs1); setRadioState(DSRXS_LISTENING); break; } if (m_bitBuffer.getLength() == DV_FRAME_LENGTH_BITS) { // The squelch is closed so abort the slow data search if (m_squelchCount >= MAX_SQUELCH_COUNT) { setRadioState(DSRXS_LISTENING); break; } // The data sync has been seen, a fuzzy match is used, two bit errors or less if (errs2 <= MAX_DATA_SYNC_BIT_ERRS) { // wxLogMessage(wxT("Found data sync at frame %u, errs: %u"), m_radioSeqNo, errs2); m_radioSeqNo = 0U; m_radioSyncsLost = 0U; processSlowData(true); } else if (m_radioSeqNo == 20U) { // wxLogMessage(wxT("Assuming data sync")); m_radioSeqNo = 0U; m_radioSyncsLost++; if (m_radioSyncsLost == MAX_LOST_SYNCS) { // wxLogMessage(wxT("Lost sync")); setRadioState(DSRXS_LISTENING); } else { processSlowData(true); } } else { m_radioSeqNo++; CHeaderData* header = processSlowData(false); if (header != NULL) { bool res = processRadioHeader(header); if (res) { // A valid header and is a DV packet, go to normal data relaying setRadioState(DSRXS_PROCESS_DATA); } else { // This is a DD packet or some other problem // wxLogMessage(wxT("Invalid header")); } } } m_squelchCount = 0U; m_bitBuffer.clear(); } } break; } }
CSoundCardRepeaterTXRXThread::CSoundCardRepeaterTXRXThread() : m_soundcard(NULL), m_protocolHandler(NULL), m_controller(NULL), m_goertzel(DSTAR_RADIO_SAMPLE_RATE, GOERTZEL_FREQ, GOERTZEL_N, 0.1F), m_pttDelay(NULL), m_audioDelay(NULL), m_stopped(true), m_inBuffer(DSTAR_RADIO_SAMPLE_RATE * 1U), // One second of data m_outBuffer(DSTAR_RADIO_SAMPLE_RATE * 1U), // One second of data m_networkBuffer(DSTAR_GMSK_SYMBOL_RATE * 2U), // Two seconds of data m_networkRun(0U), m_networkStarted(false), m_rptCallsign(), m_reader(NULL), m_demodulator(), m_modulator(), m_bitBuffer(DV_FRAME_LENGTH_BITS), m_rxState(DSRXS_LISTENING), m_frameMatcher(FRAME_SYNC_LENGTH_BITS, FRAME_SYNC_BITS), m_dataMatcher(DATA_FRAME_LENGTH_BITS, DATA_SYNC_BITS), m_endMatcher(END_PATTERN_LENGTH_BITS, END_PATTERN_BITS), m_writer(NULL), m_rxHeader(NULL), m_txHeader(NULL), m_headerBER(0U), m_radioSeqNo(0U), m_radioSyncsLost(0U), m_networkSeqNo(0U), m_watchdogTimer(1000U, 2U), // 2s m_pollTimer(1000U, 60U), // 60s m_hangTimer(1000U, 0U, 0U), // 0ms m_rptState(DSRS_LISTENING), m_slowDataDecoder(), m_tx(false), m_squelch(false), m_squelchCount(0U), m_noise(0.0F), m_noiseCount(0U), m_killed(false), m_rxLevel(1.0F), m_txLevel(1.0F), m_squelchMode(SM_NORMAL), m_activeHangTimer(1000U), m_disable(false), m_lastData(NULL), m_ambe(), m_ambeFrames(0U), m_ambeSilence(0U), m_ambeBits(1U), m_ambeErrors(0U), m_lastAMBEBits(0U), m_lastAMBEErrors(0U), m_radioCount(0U), m_networkCount(0U), m_transmitCount(0U), m_timeCount(0U), m_lastHour(0U), m_headerTime(), m_packetTime(), m_packetCount(0U), m_packetSilence(0U) { m_lastData = new unsigned char[DV_FRAME_MAX_LENGTH_BYTES]; setRadioState(DSRXS_LISTENING); setRepeaterState(DSRS_LISTENING); }