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);
}
