/* //device/system/reference-ril/reference-ril.c
**
** Copyright 2006, The Android Open Source Project
+** Copyright (c) 2012, The Linux Foundation. All rights reserved.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** limitations under the License.
*/
+#include <telephony/ril_cdma_sms.h>
+#include <telephony/librilutils.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
#define WORKAROUND_FAKE_CGEV 1
#endif
+/* Modem Technology bits */
+#define MDM_GSM 0x01
+#define MDM_WCDMA 0x02
+#define MDM_CDMA 0x04
+#define MDM_EVDO 0x08
+#define MDM_LTE 0x10
+
+typedef struct {
+ int supportedTechs; // Bitmask of supported Modem Technology bits
+ int currentTech; // Technology the modem is currently using (in the format used by modem)
+ int isMultimode;
+
+ // Preferred mode bitmask. This is actually 4 byte-sized bitmasks with different priority values,
+ // in which the byte number from LSB to MSB give the priority.
+ //
+ // |MSB| | |LSB
+ // value: |00 |00 |00 |00
+ // byte #: |3 |2 |1 |0
+ //
+ // Higher byte order give higher priority. Thus, a value of 0x0000000f represents
+ // a preferred mode of GSM, WCDMA, CDMA, and EvDo in which all are equally preferrable, whereas
+ // 0x00000201 represents a mode with GSM and WCDMA, in which WCDMA is preferred over GSM
+ int32_t preferredNetworkMode;
+ int subscription_source;
+
+} ModemInfo;
+
+static ModemInfo *sMdmInfo;
+// TECH returns the current technology in the format used by the modem.
+// It can be used as an l-value
+#define TECH(mdminfo) ((mdminfo)->currentTech)
+// TECH_BIT returns the bitmask equivalent of the current tech
+#define TECH_BIT(mdminfo) (1 << ((mdminfo)->currentTech))
+#define IS_MULTIMODE(mdminfo) ((mdminfo)->isMultimode)
+#define TECH_SUPPORTED(mdminfo, tech) ((mdminfo)->supportedTechs & (tech))
+#define PREFERRED_NETWORK(mdminfo) ((mdminfo)->preferredNetworkMode)
+// CDMA Subscription Source
+#define SSOURCE(mdminfo) ((mdminfo)->subscription_source)
+
+static int net2modem[] = {
+ MDM_GSM | MDM_WCDMA, // 0 - GSM / WCDMA Pref
+ MDM_GSM, // 1 - GSM only
+ MDM_WCDMA, // 2 - WCDMA only
+ MDM_GSM | MDM_WCDMA, // 3 - GSM / WCDMA Auto
+ MDM_CDMA | MDM_EVDO, // 4 - CDMA / EvDo Auto
+ MDM_CDMA, // 5 - CDMA only
+ MDM_EVDO, // 6 - EvDo only
+ MDM_GSM | MDM_WCDMA | MDM_CDMA | MDM_EVDO, // 7 - GSM/WCDMA, CDMA, EvDo
+ MDM_LTE | MDM_CDMA | MDM_EVDO, // 8 - LTE, CDMA and EvDo
+ MDM_LTE | MDM_GSM | MDM_WCDMA, // 9 - LTE, GSM/WCDMA
+ MDM_LTE | MDM_CDMA | MDM_EVDO | MDM_GSM | MDM_WCDMA, // 10 - LTE, CDMA, EvDo, GSM/WCDMA
+ MDM_LTE, // 11 - LTE only
+};
+
+static int32_t net2pmask[] = {
+ MDM_GSM | (MDM_WCDMA << 8), // 0 - GSM / WCDMA Pref
+ MDM_GSM, // 1 - GSM only
+ MDM_WCDMA, // 2 - WCDMA only
+ MDM_GSM | MDM_WCDMA, // 3 - GSM / WCDMA Auto
+ MDM_CDMA | MDM_EVDO, // 4 - CDMA / EvDo Auto
+ MDM_CDMA, // 5 - CDMA only
+ MDM_EVDO, // 6 - EvDo only
+ MDM_GSM | MDM_WCDMA | MDM_CDMA | MDM_EVDO, // 7 - GSM/WCDMA, CDMA, EvDo
+ MDM_LTE | MDM_CDMA | MDM_EVDO, // 8 - LTE, CDMA and EvDo
+ MDM_LTE | MDM_GSM | MDM_WCDMA, // 9 - LTE, GSM/WCDMA
+ MDM_LTE | MDM_CDMA | MDM_EVDO | MDM_GSM | MDM_WCDMA, // 10 - LTE, CDMA, EvDo, GSM/WCDMA
+ MDM_LTE, // 11 - LTE only
+};
+
+static int is3gpp2(int radioTech) {
+ switch (radioTech) {
+ case RADIO_TECH_IS95A:
+ case RADIO_TECH_IS95B:
+ case RADIO_TECH_1xRTT:
+ case RADIO_TECH_EVDO_0:
+ case RADIO_TECH_EVDO_A:
+ case RADIO_TECH_EVDO_B:
+ case RADIO_TECH_EHRPD:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
typedef enum {
SIM_ABSENT = 0,
SIM_NOT_READY = 1,
SIM_READY = 2, /* SIM_READY means the radio state is RADIO_STATE_SIM_READY */
SIM_PIN = 3,
SIM_PUK = 4,
- SIM_NETWORK_PERSONALIZATION = 5
+ SIM_NETWORK_PERSONALIZATION = 5,
+ RUIM_ABSENT = 6,
+ RUIM_NOT_READY = 7,
+ RUIM_READY = 8,
+ RUIM_PIN = 9,
+ RUIM_PUK = 10,
+ RUIM_NETWORK_PERSONALIZATION = 11
} SIM_Status;
static void onRequest (int request, void *data, size_t datalen, RIL_Token t);
static const struct timeval TIMEVAL_CALLSTATEPOLL = {0,500000};
static const struct timeval TIMEVAL_0 = {0,0};
+static int s_ims_registered = 0; // 0==unregistered
+static int s_ims_services = 1; // & 0x1 == sms over ims supported
+static int s_ims_format = 1; // FORMAT_3GPP(1) vs FORMAT_3GPP2(2);
+static int s_ims_cause_retry = 0; // 1==causes sms over ims to temp fail
+static int s_ims_cause_perm_failure = 0; // 1==causes sms over ims to permanent fail
+static int s_ims_gsm_retry = 0; // 1==causes sms over gsm to temp fail
+static int s_ims_gsm_fail = 0; // 1==causes sms over gsm to permanent fail
+
#ifdef WORKAROUND_ERRONEOUS_ANSWER
// Max number of times we'll try to repoll when we think
// we have a AT+CLCC race condition
static int s_expectAnswer = 0;
#endif /* WORKAROUND_ERRONEOUS_ANSWER */
+static int s_cell_info_rate_ms = INT_MAX;
+static int s_mcc = 0;
+static int s_mnc = 0;
+static int s_lac = 0;
+static int s_cid = 0;
+
static void pollSIMState (void *param);
static void setRadioState(RIL_RadioState newState);
+static void setRadioTechnology(ModemInfo *mdm, int newtech);
+static int query_ctec(ModemInfo *mdm, int *current, int32_t *preferred);
+static int parse_technology_response(const char *response, int *current, int32_t *preferred);
+static int techFromModemType(int mdmtype);
static int clccStateToRILState(int state, RIL_CallState *p_state)
return 0;
error:
- LOGE("invalid CLCC line\n");
+ RLOGE("invalid CLCC line\n");
return -1;
}
goto error;
}
}
- setRadioState(RADIO_STATE_SIM_NOT_READY);
+ setRadioState(RADIO_STATE_ON);
}
at_response_free(p_response);
return;
error:
at_response_free(p_response);
- LOGE("requestQueryNetworkSelectionMode must never return error when radio is on");
+ RLOGE("requestQueryNetworkSelectionMode must never return error when radio is on");
RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
}
&& p_calls[i].state == RIL_CALL_ACTIVE
&& s_repollCallsCount < REPOLL_CALLS_COUNT_MAX
) {
- LOGI(
+ RLOGI(
"Hit WORKAROUND_ERRONOUS_ANSWER case."
" Repoll count: %d\n", s_repollCallsCount);
s_repollCallsCount++;
{
ATResponse *p_response = NULL;
int err;
- int response[2];
char *line;
+ int count =0;
+ int numofElements=sizeof(RIL_SignalStrength_v6)/sizeof(int);
+ int response[numofElements];
err = at_send_command_singleline("AT+CSQ", "+CSQ:", &p_response);
err = at_tok_start(&line);
if (err < 0) goto error;
- err = at_tok_nextint(&line, &(response[0]));
- if (err < 0) goto error;
-
- err = at_tok_nextint(&line, &(response[1]));
- if (err < 0) goto error;
+ for (count =0; count < numofElements; count ++) {
+ err = at_tok_nextint(&line, &(response[count]));
+ if (err < 0) goto error;
+ }
RIL_onRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response));
return;
error:
- LOGE("requestSignalStrength must never return an error when radio is on");
+ RLOGE("requestSignalStrength must never return an error when radio is on");
RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
at_response_free(p_response);
}
-static void requestRegistrationState(int request, void *data,
+/**
+ * networkModePossible. Decides whether the network mode is appropriate for the
+ * specified modem
+ */
+static int networkModePossible(ModemInfo *mdm, int nm)
+{
+ if ((net2modem[nm] & mdm->supportedTechs) == net2modem[nm]) {
+ return 1;
+ }
+ return 0;
+}
+static void requestSetPreferredNetworkType( int request, void *data,
+ size_t datalen, RIL_Token t )
+{
+ ATResponse *p_response = NULL;
+ char *cmd = NULL;
+ int value = *(int *)data;
+ int current, old;
+ int err;
+ int32_t preferred = net2pmask[value];
+
+ RLOGD("requestSetPreferredNetworkType: current: %x. New: %x", PREFERRED_NETWORK(sMdmInfo), preferred);
+ if (!networkModePossible(sMdmInfo, value)) {
+ RIL_onRequestComplete(t, RIL_E_MODE_NOT_SUPPORTED, NULL, 0);
+ return;
+ }
+ if (query_ctec(sMdmInfo, ¤t, NULL) < 0) {
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+ return;
+ }
+ old = PREFERRED_NETWORK(sMdmInfo);
+ RLOGD("old != preferred: %d", old != preferred);
+ if (old != preferred) {
+ asprintf(&cmd, "AT+CTEC=%d,\"%x\"", current, preferred);
+ RLOGD("Sending command: <%s>", cmd);
+ err = at_send_command_singleline(cmd, "+CTEC:", &p_response);
+ free(cmd);
+ if (err || !p_response->success) {
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+ return;
+ }
+ PREFERRED_NETWORK(sMdmInfo) = value;
+ if (!strstr( p_response->p_intermediates->line, "DONE") ) {
+ int current;
+ int res = parse_technology_response(p_response->p_intermediates->line, ¤t, NULL);
+ switch (res) {
+ case -1: // Error or unable to parse
+ break;
+ case 1: // Only able to parse current
+ case 0: // Both current and preferred were parsed
+ setRadioTechnology(sMdmInfo, current);
+ break;
+ }
+ }
+ }
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
+}
+
+static void requestGetPreferredNetworkType(int request, void *data,
+ size_t datalen, RIL_Token t)
+{
+ int preferred;
+ unsigned i;
+
+ switch ( query_ctec(sMdmInfo, NULL, &preferred) ) {
+ case -1: // Error or unable to parse
+ case 1: // Only able to parse current
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+ break;
+ case 0: // Both current and preferred were parsed
+ for ( i = 0 ; i < sizeof(net2pmask) / sizeof(int32_t) ; i++ ) {
+ if (preferred == net2pmask[i]) {
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, &i, sizeof(int));
+ return;
+ }
+ }
+ RLOGE("Unknown preferred mode received from modem: %d", preferred);
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+ break;
+ }
+
+}
+
+static void requestCdmaPrlVersion(int request, void *data,
+ size_t datalen, RIL_Token t)
+{
+ int err;
+ char * responseStr;
+ ATResponse *p_response = NULL;
+ const char *cmd;
+ char *line;
+
+ err = at_send_command_singleline("AT+WPRL?", "+WPRL:", &p_response);
+ if (err < 0 || !p_response->success) goto error;
+ line = p_response->p_intermediates->line;
+ err = at_tok_start(&line);
+ if (err < 0) goto error;
+ err = at_tok_nextstr(&line, &responseStr);
+ if (err < 0 || !responseStr) goto error;
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, strlen(responseStr));
+ at_response_free(p_response);
+ return;
+error:
+ at_response_free(p_response);
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+}
+
+static void requestCdmaBaseBandVersion(int request, void *data,
+ size_t datalen, RIL_Token t)
+{
+ int err;
+ char * responseStr;
+ ATResponse *p_response = NULL;
+ const char *cmd;
+ const char *prefix;
+ char *line, *p;
+ int commas;
+ int skip;
+ int count = 4;
+
+ // Fixed values. TODO: query modem
+ responseStr = strdup("1.0.0.0");
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, sizeof(responseStr));
+ free(responseStr);
+}
+
+static void requestCdmaDeviceIdentity(int request, void *data,
size_t datalen, RIL_Token t)
{
int err;
char *line, *p;
int commas;
int skip;
- int count = 3;
+ int count = 4;
+ // Fixed values. TODO: Query modem
+ responseStr[0] = "----";
+ responseStr[1] = "----";
+ responseStr[2] = "77777777";
- if (request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
- cmd = "AT+CREG?";
- prefix = "+CREG:";
- } else if (request == RIL_REQUEST_DATA_REGISTRATION_STATE) {
- cmd = "AT+CGREG?";
- prefix = "+CGREG:";
+ err = at_send_command_numeric("AT+CGSN", &p_response);
+ if (err < 0 || p_response->success == 0) {
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+ return;
} else {
- assert(0);
+ responseStr[3] = p_response->p_intermediates->line;
+ }
+
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, count*sizeof(char*));
+ at_response_free(p_response);
+
+ return;
+error:
+ RLOGE("requestCdmaDeviceIdentity must never return an error when radio is on");
+ at_response_free(p_response);
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+}
+
+static void requestCdmaGetSubscriptionSource(int request, void *data,
+ size_t datalen, RIL_Token t)
+{
+ int err;
+ int *ss = (int *)data;
+ ATResponse *p_response = NULL;
+ char *cmd = NULL;
+ char *line = NULL;
+ int response;
+
+ asprintf(&cmd, "AT+CCSS?");
+ if (!cmd) goto error;
+
+ err = at_send_command_singleline(cmd, "+CCSS:", &p_response);
+ if (err < 0 || !p_response->success)
goto error;
+
+ line = p_response->p_intermediates->line;
+ err = at_tok_start(&line);
+ if (err < 0) goto error;
+
+ err = at_tok_nextint(&line, &response);
+ free(cmd);
+ cmd = NULL;
+
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response));
+
+ return;
+error:
+ free(cmd);
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+}
+
+static void requestCdmaSetSubscriptionSource(int request, void *data,
+ size_t datalen, RIL_Token t)
+{
+ int err;
+ int *ss = (int *)data;
+ ATResponse *p_response = NULL;
+ char *cmd = NULL;
+
+ if (!ss || !datalen) {
+ RLOGE("RIL_REQUEST_CDMA_SET_SUBSCRIPTION without data!");
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+ return;
}
+ asprintf(&cmd, "AT+CCSS=%d", ss[0]);
+ if (!cmd) goto error;
- err = at_send_command_singleline(cmd, prefix, &p_response);
+ err = at_send_command(cmd, &p_response);
+ if (err < 0 || !p_response->success)
+ goto error;
+ free(cmd);
+ cmd = NULL;
- if (err != 0) goto error;
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
+
+ RIL_onUnsolicitedResponse(RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED, ss, sizeof(ss[0]));
+ return;
+error:
+ free(cmd);
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+}
+
+static void requestCdmaSubscription(int request, void *data,
+ size_t datalen, RIL_Token t)
+{
+ int err;
+ int response[5];
+ char * responseStr[5];
+ ATResponse *p_response = NULL;
+ const char *cmd;
+ const char *prefix;
+ char *line, *p;
+ int commas;
+ int skip;
+ int count = 5;
+
+ // Fixed values. TODO: Query modem
+ responseStr[0] = "8587777777"; // MDN
+ responseStr[1] = "1"; // SID
+ responseStr[2] = "1"; // NID
+ responseStr[3] = "8587777777"; // MIN
+ responseStr[4] = "1"; // PRL Version
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, count*sizeof(char*));
+
+ return;
+error:
+ RLOGE("requestRegistrationState must never return an error when radio is on");
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+}
+
+static void requestCdmaGetRoamingPreference(int request, void *data,
+ size_t datalen, RIL_Token t)
+{
+ int roaming_pref = -1;
+ ATResponse *p_response = NULL;
+ char *line;
+ int res;
+
+ res = at_send_command_singleline("AT+WRMP?", "+WRMP:", &p_response);
+ if (res < 0 || !p_response->success) {
+ goto error;
+ }
line = p_response->p_intermediates->line;
+ res = at_tok_start(&line);
+ if (res < 0) goto error;
+
+ res = at_tok_nextint(&line, &roaming_pref);
+ if (res < 0) goto error;
+
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, &roaming_pref, sizeof(roaming_pref));
+ return;
+error:
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+}
+
+static void requestCdmaSetRoamingPreference(int request, void *data,
+ size_t datalen, RIL_Token t)
+{
+ int *pref = (int *)data;
+ ATResponse *p_response = NULL;
+ char *line;
+ int res;
+ char *cmd = NULL;
+
+ asprintf(&cmd, "AT+WRMP=%d", *pref);
+ if (cmd == NULL) goto error;
+
+ res = at_send_command(cmd, &p_response);
+ if (res < 0 || !p_response->success)
+ goto error;
+
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
+ free(cmd);
+ return;
+error:
+ free(cmd);
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+}
+
+static int parseRegistrationState(char *str, int *type, int *items, int **response)
+{
+ int err;
+ char *line = str, *p;
+ int *resp = NULL;
+ int skip;
+ int count = 3;
+ int commas;
+
+ RLOGD("parseRegistrationState. Parsing: %s",str);
err = at_tok_start(&line);
if (err < 0) goto error;
if (*p == ',') commas++;
}
+ resp = (int *)calloc(commas + 1, sizeof(int));
+ if (!resp) goto error;
switch (commas) {
case 0: /* +CREG: <stat> */
- err = at_tok_nextint(&line, &response[0]);
+ err = at_tok_nextint(&line, &resp[0]);
if (err < 0) goto error;
- response[1] = -1;
- response[2] = -1;
+ resp[1] = -1;
+ resp[2] = -1;
break;
case 1: /* +CREG: <n>, <stat> */
err = at_tok_nextint(&line, &skip);
if (err < 0) goto error;
- err = at_tok_nextint(&line, &response[0]);
+ err = at_tok_nextint(&line, &resp[0]);
if (err < 0) goto error;
- response[1] = -1;
- response[2] = -1;
+ resp[1] = -1;
+ resp[2] = -1;
if (err < 0) goto error;
break;
case 2: /* +CREG: <stat>, <lac>, <cid> */
- err = at_tok_nextint(&line, &response[0]);
+ err = at_tok_nextint(&line, &resp[0]);
if (err < 0) goto error;
- err = at_tok_nexthexint(&line, &response[1]);
+ err = at_tok_nexthexint(&line, &resp[1]);
if (err < 0) goto error;
- err = at_tok_nexthexint(&line, &response[2]);
+ err = at_tok_nexthexint(&line, &resp[2]);
if (err < 0) goto error;
break;
case 3: /* +CREG: <n>, <stat>, <lac>, <cid> */
err = at_tok_nextint(&line, &skip);
if (err < 0) goto error;
- err = at_tok_nextint(&line, &response[0]);
+ err = at_tok_nextint(&line, &resp[0]);
if (err < 0) goto error;
- err = at_tok_nexthexint(&line, &response[1]);
+ err = at_tok_nexthexint(&line, &resp[1]);
if (err < 0) goto error;
- err = at_tok_nexthexint(&line, &response[2]);
+ err = at_tok_nexthexint(&line, &resp[2]);
if (err < 0) goto error;
break;
/* special case for CGREG, there is a fourth parameter
case 4: /* +CGREG: <n>, <stat>, <lac>, <cid>, <networkType> */
err = at_tok_nextint(&line, &skip);
if (err < 0) goto error;
- err = at_tok_nextint(&line, &response[0]);
+ err = at_tok_nextint(&line, &resp[0]);
if (err < 0) goto error;
- err = at_tok_nexthexint(&line, &response[1]);
+ err = at_tok_nexthexint(&line, &resp[1]);
if (err < 0) goto error;
- err = at_tok_nexthexint(&line, &response[2]);
+ err = at_tok_nexthexint(&line, &resp[2]);
if (err < 0) goto error;
- err = at_tok_nexthexint(&line, &response[3]);
+ err = at_tok_nexthexint(&line, &resp[3]);
if (err < 0) goto error;
count = 4;
break;
default:
goto error;
}
+ s_lac = resp[1];
+ s_cid = resp[2];
+ if (response)
+ *response = resp;
+ if (items)
+ *items = commas + 1;
+ if (type)
+ *type = techFromModemType(TECH(sMdmInfo));
+ return 0;
+error:
+ free(resp);
+ return -1;
+}
- asprintf(&responseStr[0], "%d", response[0]);
- asprintf(&responseStr[1], "%x", response[1]);
- asprintf(&responseStr[2], "%x", response[2]);
+#define REG_STATE_LEN 15
+#define REG_DATA_STATE_LEN 6
+static void requestRegistrationState(int request, void *data,
+ size_t datalen, RIL_Token t)
+{
+ int err;
+ int *registration;
+ char **responseStr = NULL;
+ ATResponse *p_response = NULL;
+ const char *cmd;
+ const char *prefix;
+ char *line;
+ int i = 0, j, numElements = 0;
+ int count = 3;
+ int type, startfrom;
- if (count > 3)
- asprintf(&responseStr[3], "%d", response[3]);
+ RLOGD("requestRegistrationState");
+ if (request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
+ cmd = "AT+CREG?";
+ prefix = "+CREG:";
+ numElements = REG_STATE_LEN;
+ } else if (request == RIL_REQUEST_DATA_REGISTRATION_STATE) {
+ cmd = "AT+CGREG?";
+ prefix = "+CGREG:";
+ numElements = REG_DATA_STATE_LEN;
+ } else {
+ assert(0);
+ goto error;
+ }
- RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, count*sizeof(char*));
+ err = at_send_command_singleline(cmd, prefix, &p_response);
+
+ if (err != 0) goto error;
+
+ line = p_response->p_intermediates->line;
+
+ if (parseRegistrationState(line, &type, &count, ®istration)) goto error;
+
+ responseStr = malloc(numElements * sizeof(char *));
+ if (!responseStr) goto error;
+ memset(responseStr, 0, numElements * sizeof(char *));
+ /**
+ * The first '4' bytes for both registration states remain the same.
+ * But if the request is 'DATA_REGISTRATION_STATE',
+ * the 5th and 6th byte(s) are optional.
+ */
+ if (is3gpp2(type) == 1) {
+ RLOGD("registration state type: 3GPP2");
+ // TODO: Query modem
+ startfrom = 3;
+ if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
+ asprintf(&responseStr[3], "8"); // EvDo revA
+ asprintf(&responseStr[4], "1"); // BSID
+ asprintf(&responseStr[5], "123"); // Latitude
+ asprintf(&responseStr[6], "222"); // Longitude
+ asprintf(&responseStr[7], "0"); // CSS Indicator
+ asprintf(&responseStr[8], "4"); // SID
+ asprintf(&responseStr[9], "65535"); // NID
+ asprintf(&responseStr[10], "0"); // Roaming indicator
+ asprintf(&responseStr[11], "1"); // System is in PRL
+ asprintf(&responseStr[12], "0"); // Default Roaming indicator
+ asprintf(&responseStr[13], "0"); // Reason for denial
+ asprintf(&responseStr[14], "0"); // Primary Scrambling Code of Current cell
+ } else if (request == RIL_REQUEST_DATA_REGISTRATION_STATE) {
+ asprintf(&responseStr[3], "8"); // Available data radio technology
+ }
+ } else { // type == RADIO_TECH_3GPP
+ RLOGD("registration state type: 3GPP");
+ startfrom = 0;
+ asprintf(&responseStr[1], "%x", registration[1]);
+ asprintf(&responseStr[2], "%x", registration[2]);
+ if (count > 3)
+ asprintf(&responseStr[3], "%d", registration[3]);
+ }
+ asprintf(&responseStr[0], "%d", registration[0]);
+
+ /**
+ * Optional bytes for DATA_REGISTRATION_STATE request
+ * 4th byte : Registration denial code
+ * 5th byte : The max. number of simultaneous Data Calls
+ */
+ if(request == RIL_REQUEST_DATA_REGISTRATION_STATE) {
+ // asprintf(&responseStr[4], "3");
+ // asprintf(&responseStr[5], "1");
+ }
+
+ for (j = startfrom; j < numElements; j++) {
+ if (!responseStr[i]) goto error;
+ }
+ free(registration);
+ registration = NULL;
+
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, numElements*sizeof(responseStr));
+ for (j = 0; j < numElements; j++ ) {
+ free(responseStr[j]);
+ responseStr[j] = NULL;
+ }
+ free(responseStr);
+ responseStr = NULL;
at_response_free(p_response);
return;
error:
- LOGE("requestRegistrationState must never return an error when radio is on");
+ if (responseStr) {
+ for (j = 0; j < numElements; j++) {
+ free(responseStr[j]);
+ responseStr[j] = NULL;
+ }
+ free(responseStr);
+ responseStr = NULL;
+ }
+ RLOGE("requestRegistrationState must never return an error when radio is on");
RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
at_response_free(p_response);
}
err = at_tok_nextstr(&line, &(response[i]));
if (err < 0) goto error;
+ // Simple assumption that mcc and mnc are 3 digits each
+ if (strlen(response[i]) == 6) {
+ if (sscanf(response[i], "%3d%3d", &s_mcc, &s_mnc) != 2) {
+ RLOGE("requestOperator expected mccmnc to be 6 decimal digits");
+ }
+ }
}
if (i != 3) {
return;
error:
- LOGE("requestOperator must not return error when radio is on");
+ RLOGE("requestOperator must not return error when radio is on");
RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
at_response_free(p_response);
}
+static void requestCdmaSendSMS(void *data, size_t datalen, RIL_Token t)
+{
+ int err = 1; // Set to go to error:
+ RIL_SMS_Response response;
+ RIL_CDMA_SMS_Message* rcsm;
+
+ RLOGD("requestCdmaSendSMS datalen=%d, sizeof(RIL_CDMA_SMS_Message)=%d",
+ datalen, sizeof(RIL_CDMA_SMS_Message));
+
+ // verify data content to test marshalling/unmarshalling:
+ rcsm = (RIL_CDMA_SMS_Message*)data;
+ RLOGD("TeleserviceID=%d, bIsServicePresent=%d, \
+ uServicecategory=%d, sAddress.digit_mode=%d, \
+ sAddress.Number_mode=%d, sAddress.number_type=%d, ",
+ rcsm->uTeleserviceID, rcsm->bIsServicePresent,
+ rcsm->uServicecategory,rcsm->sAddress.digit_mode,
+ rcsm->sAddress.number_mode,rcsm->sAddress.number_type);
+
+ if (err != 0) goto error;
+
+ // Cdma Send SMS implementation will go here:
+ // But it is not implemented yet.
+
+ memset(&response, 0, sizeof(response));
+ response.messageRef = 1;
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response));
+ return;
+
+error:
+ // Cdma Send SMS will always cause send retry error.
+ response.messageRef = -1;
+ RIL_onRequestComplete(t, RIL_E_SMS_SEND_FAIL_RETRY, &response, sizeof(response));
+}
+
static void requestSendSMS(void *data, size_t datalen, RIL_Token t)
{
int err;
RIL_SMS_Response response;
ATResponse *p_response = NULL;
+ memset(&response, 0, sizeof(response));
+ ALOGD("requestSendSMS datalen =%d", datalen);
+
+ if (s_ims_gsm_fail != 0) goto error;
+ if (s_ims_gsm_retry != 0) goto error2;
+
smsc = ((const char **)data)[0];
pdu = ((const char **)data)[1];
if (err != 0 || p_response->success == 0) goto error;
- memset(&response, 0, sizeof(response));
-
/* FIXME fill in messageRef and ackPDU */
-
+ response.messageRef = 1;
RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response));
at_response_free(p_response);
return;
error:
- RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+ response.messageRef = -2;
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, &response, sizeof(response));
+ at_response_free(p_response);
+ return;
+error2:
+ // send retry error.
+ response.messageRef = -1;
+ RIL_onRequestComplete(t, RIL_E_SMS_SEND_FAIL_RETRY, &response, sizeof(response));
at_response_free(p_response);
+ return;
+}
+
+static void requestImsSendSMS(void *data, size_t datalen, RIL_Token t)
+{
+ RIL_IMS_SMS_Message *p_args;
+ RIL_SMS_Response response;
+
+ memset(&response, 0, sizeof(response));
+
+ ALOGD("requestImsSendSMS: datalen=%d, "
+ "registered=%d, service=%d, format=%d, ims_perm_fail=%d, "
+ "ims_retry=%d, gsm_fail=%d, gsm_retry=%d",
+ datalen, s_ims_registered, s_ims_services, s_ims_format,
+ s_ims_cause_perm_failure, s_ims_cause_retry, s_ims_gsm_fail,
+ s_ims_gsm_retry);
+
+ // figure out if this is gsm/cdma format
+ // then route it to requestSendSMS vs requestCdmaSendSMS respectively
+ p_args = (RIL_IMS_SMS_Message *)data;
+
+ if (0 != s_ims_cause_perm_failure ) goto error;
+
+ // want to fail over ims and this is first request over ims
+ if (0 != s_ims_cause_retry && 0 == p_args->retry) goto error2;
+
+ if (RADIO_TECH_3GPP == p_args->tech) {
+ return requestSendSMS(p_args->message.gsmMessage,
+ datalen - sizeof(RIL_RadioTechnologyFamily),
+ t);
+ } else if (RADIO_TECH_3GPP2 == p_args->tech) {
+ return requestCdmaSendSMS(p_args->message.cdmaMessage,
+ datalen - sizeof(RIL_RadioTechnologyFamily),
+ t);
+ } else {
+ ALOGE("requestImsSendSMS invalid format value =%d", p_args->tech);
+ }
+
+error:
+ response.messageRef = -2;
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, &response, sizeof(response));
+ return;
+
+error2:
+ response.messageRef = -1;
+ RIL_onRequestComplete(t, RIL_E_SMS_SEND_FAIL_RETRY, &response, sizeof(response));
}
static void requestSetupDataCall(void *data, size_t datalen, RIL_Token t)
int retry = 10;
const char *pdp_type;
- ALOGD("requesting data connection to APN '%s'", apn);
+ RLOGD("requesting data connection to APN '%s'", apn);
fd = open ("/dev/qmi", O_RDWR);
if (fd >= 0) { /* the device doesn't exist on the emulator */
- ALOGD("opened the qmi device\n");
+ RLOGD("opened the qmi device\n");
asprintf(&cmd, "up:%s", apn);
len = strlen(cmd);
} while (written < 0 && errno == EINTR);
if (written < 0) {
- LOGE("### ERROR writing to /dev/qmi");
+ RLOGE("### ERROR writing to /dev/qmi");
close(fd);
goto error;
}
} while (rlen < 0 && errno == EINTR);
if (rlen < 0) {
- LOGE("### ERROR reading from /dev/qmi");
+ RLOGE("### ERROR reading from /dev/qmi");
close(fd);
goto error;
} else {
status[rlen] = '\0';
- ALOGD("### status: %s", status);
+ RLOGD("### status: %s", status);
}
} while (strncmp(status, "STATE=up", 8) && strcmp(status, "online") && --retry);
close(fd);
if (retry == 0) {
- LOGE("### Failed to get data connection up\n");
+ RLOGE("### Failed to get data connection up\n");
goto error;
}
qmistatus = system("netcfg rmnet0 dhcp");
- ALOGD("netcfg rmnet0 dhcp: status %d\n", qmistatus);
+ RLOGD("netcfg rmnet0 dhcp: status %d\n", qmistatus);
if (qmistatus < 0) goto error;
} else if (ackSuccess == 0) {
err = at_send_command("AT+CNMA=2", NULL);
} else {
- LOGE("unsupported arg to RIL_REQUEST_SMS_ACKNOWLEDGE\n");
+ RLOGE("unsupported arg to RIL_REQUEST_SMS_ACKNOWLEDGE\n");
goto error;
}
} else
goto error;
- err = at_send_command_singleline(cmd, "+CPIN:", &p_response);
- free(cmd);
+ err = at_send_command_singleline(cmd, "+CPIN:", &p_response);
+ free(cmd);
+
+ if (err < 0 || p_response->success == 0) {
+error:
+ RIL_onRequestComplete(t, RIL_E_PASSWORD_INCORRECT, NULL, 0);
+ } else {
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
+ }
+ at_response_free(p_response);
+}
+
+
+static void requestSendUSSD(void *data, size_t datalen, RIL_Token t)
+{
+ const char *ussdRequest;
+
+ ussdRequest = (char *)(data);
+
+
+ RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
+
+// @@@ TODO
+
+}
+
+static void requestExitEmergencyMode(void *data, size_t datalen, RIL_Token t)
+{
+ int err;
+ ATResponse *p_response = NULL;
+
+ err = at_send_command("AT+WSOS=0", &p_response);
if (err < 0 || p_response->success == 0) {
-error:
- RIL_onRequestComplete(t, RIL_E_PASSWORD_INCORRECT, NULL, 0);
- } else {
- RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+ return;
}
- at_response_free(p_response);
-}
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
+}
-static void requestSendUSSD(void *data, size_t datalen, RIL_Token t)
+// TODO: Use all radio types
+static int techFromModemType(int mdmtype)
{
- const char *ussdRequest;
+ int ret = -1;
+ switch (1 << mdmtype) {
+ case MDM_CDMA:
+ ret = RADIO_TECH_1xRTT;
+ break;
+ case MDM_EVDO:
+ ret = RADIO_TECH_EVDO_A;
+ break;
+ case MDM_GSM:
+ ret = RADIO_TECH_GPRS;
+ break;
+ case MDM_WCDMA:
+ ret = RADIO_TECH_HSPA;
+ break;
+ case MDM_LTE:
+ ret = RADIO_TECH_LTE;
+ break;
+ }
+ return ret;
+}
- ussdRequest = (char *)(data);
+static void requestGetCellInfoList(void *data, size_t datalen, RIL_Token t)
+{
+ uint64_t curTime = ril_nano_time();
+ RIL_CellInfo ci[1] =
+ {
+ { // ci[0]
+ 1, // cellInfoType
+ 1, // registered
+ curTime - 1000, // Fake some time in the past
+ { // union CellInfo
+ { // RIL_CellInfoGsm gsm
+ { // gsm.cellIdneityGsm
+ s_mcc, // mcc
+ s_mnc, // mnc
+ s_lac, // lac
+ s_cid, // cid
+ 0 // psc
+ },
+ { // gsm.signalStrengthGsm
+ 10, // signalStrength
+ 0 // bitErrorRate
+ }
+ }
+ }
+ }
+ };
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, ci, sizeof(ci));
+}
- RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
-// @@@ TODO
+static void requestSetCellInfoListRate(void *data, size_t datalen, RIL_Token t)
+{
+ // For now we'll save the rate but no RIL_UNSOL_CELL_INFO_LIST messages
+ // will be sent.
+ assert (datalen == sizeof(int));
+ s_cell_info_rate_ms = ((int *)data)[0];
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
}
-
/*** Callback methods from the RIL library to us ***/
/**
ATResponse *p_response;
int err;
- ALOGD("onRequest: %s", requestToString(request));
+ RLOGD("onRequest: %s", requestToString(request));
/* Ignore all requests except RIL_REQUEST_GET_SIM_STATUS
* when RADIO_STATE_UNAVAILABLE.
case RIL_REQUEST_SEND_SMS:
requestSendSMS(data, datalen, t);
break;
+ case RIL_REQUEST_CDMA_SEND_SMS:
+ requestCdmaSendSMS(data, datalen, t);
+ break;
+ case RIL_REQUEST_IMS_SEND_SMS:
+ requestImsSendSMS(data, datalen, t);
+ break;
case RIL_REQUEST_SETUP_DATA_CALL:
requestSetupDataCall(data, datalen, t);
break;
int i;
const char ** cur;
- ALOGD("got OEM_HOOK_STRINGS: 0x%8p %lu", data, (long)datalen);
+ RLOGD("got OEM_HOOK_STRINGS: 0x%8p %lu", data, (long)datalen);
for (i = (datalen / sizeof (char *)), cur = (const char **)data ;
i > 0 ; cur++, i --) {
- ALOGD("> '%s'", *cur);
+ RLOGD("> '%s'", *cur);
}
// echo back strings
requestEnterSimPin(data, datalen, t);
break;
+ case RIL_REQUEST_IMS_REGISTRATION_STATE:
+ {
+ int reply[2];
+ //0==unregistered, 1==registered
+ reply[0] = s_ims_registered;
+
+ //to be used when changed to include service supporated info
+ //reply[1] = s_ims_services;
+
+ // FORMAT_3GPP(1) vs FORMAT_3GPP2(2);
+ reply[1] = s_ims_format;
+
+ ALOGD("IMS_REGISTRATION=%d, format=%d ",
+ reply[0], reply[1]);
+ if (reply[1] != -1) {
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, reply, sizeof(reply));
+ } else {
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+ }
+ break;
+ }
+
+ case RIL_REQUEST_VOICE_RADIO_TECH:
+ {
+ int tech = techFromModemType(TECH(sMdmInfo));
+ if (tech < 0 )
+ RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
+ else
+ RIL_onRequestComplete(t, RIL_E_SUCCESS, &tech, sizeof(tech));
+ }
+ break;
+ case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE:
+ requestSetPreferredNetworkType(request, data, datalen, t);
+ break;
+
+ case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE:
+ requestGetPreferredNetworkType(request, data, datalen, t);
+ break;
+
+ case RIL_REQUEST_GET_CELL_INFO_LIST:
+ requestGetCellInfoList(data, datalen, t);
+ break;
+
+ case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE:
+ requestSetCellInfoListRate(data, datalen, t);
+ break;
+
+ /* CDMA Specific Requests */
+ case RIL_REQUEST_BASEBAND_VERSION:
+ if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
+ requestCdmaBaseBandVersion(request, data, datalen, t);
+ break;
+ } // Fall-through if tech is not cdma
+
+ case RIL_REQUEST_DEVICE_IDENTITY:
+ if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
+ requestCdmaDeviceIdentity(request, data, datalen, t);
+ break;
+ } // Fall-through if tech is not cdma
+
+ case RIL_REQUEST_CDMA_SUBSCRIPTION:
+ if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
+ requestCdmaSubscription(request, data, datalen, t);
+ break;
+ } // Fall-through if tech is not cdma
+
+ case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:
+ if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
+ requestCdmaSetSubscriptionSource(request, data, datalen, t);
+ break;
+ } // Fall-through if tech is not cdma
+
+ case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE:
+ if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
+ requestCdmaGetSubscriptionSource(request, data, datalen, t);
+ break;
+ } // Fall-through if tech is not cdma
+
+ case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:
+ if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
+ requestCdmaGetRoamingPreference(request, data, datalen, t);
+ break;
+ } // Fall-through if tech is not cdma
+
+ case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:
+ if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
+ requestCdmaSetRoamingPreference(request, data, datalen, t);
+ break;
+ } // Fall-through if tech is not cdma
+
+ case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE:
+ if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
+ requestExitEmergencyMode(data, datalen, t);
+ break;
+ } // Fall-through if tech is not cdma
+
default:
+ RLOGD("Request not supported. Tech: %d",TECH(sMdmInfo));
RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
break;
}
}
static void
+setRadioTechnology(ModemInfo *mdm, int newtech)
+{
+ RLOGD("setRadioTechnology(%d)", newtech);
+
+ int oldtech = TECH(mdm);
+
+ if (newtech != oldtech) {
+ RLOGD("Tech change (%d => %d)", oldtech, newtech);
+ TECH(mdm) = newtech;
+ if (techFromModemType(newtech) != techFromModemType(oldtech)) {
+ int tech = techFromModemType(TECH(sMdmInfo));
+ if (tech > 0 ) {
+ RIL_onUnsolicitedResponse(RIL_UNSOL_VOICE_RADIO_TECH_CHANGED,
+ &tech, sizeof(tech));
+ }
+ }
+ }
+}
+
+static void
setRadioState(RIL_RadioState newState)
{
+ RLOGD("setRadioState(%d)", newState);
RIL_RadioState oldState;
pthread_mutex_lock(&s_state_mutex);
* Currently, this doesn't happen, but if that changes then these
* will need to be dispatched on the request thread
*/
- if (sState == RADIO_STATE_SIM_READY) {
- onSIMReady();
- } else if (sState == RADIO_STATE_SIM_NOT_READY) {
+ if (sState == RADIO_STATE_ON) {
onRadioPowerOn();
}
}
}
+/** Returns RUIM_NOT_READY on error */
+static SIM_Status
+getRUIMStatus()
+{
+ ATResponse *p_response = NULL;
+ int err;
+ int ret;
+ char *cpinLine;
+ char *cpinResult;
+
+ if (sState == RADIO_STATE_OFF || sState == RADIO_STATE_UNAVAILABLE) {
+ ret = SIM_NOT_READY;
+ goto done;
+ }
+
+ err = at_send_command_singleline("AT+CPIN?", "+CPIN:", &p_response);
+
+ if (err != 0) {
+ ret = SIM_NOT_READY;
+ goto done;
+ }
+
+ switch (at_get_cme_error(p_response)) {
+ case CME_SUCCESS:
+ break;
+
+ case CME_SIM_NOT_INSERTED:
+ ret = SIM_ABSENT;
+ goto done;
+
+ default:
+ ret = SIM_NOT_READY;
+ goto done;
+ }
+
+ /* CPIN? has succeeded, now look at the result */
+
+ cpinLine = p_response->p_intermediates->line;
+ err = at_tok_start (&cpinLine);
+
+ if (err < 0) {
+ ret = SIM_NOT_READY;
+ goto done;
+ }
+
+ err = at_tok_nextstr(&cpinLine, &cpinResult);
+
+ if (err < 0) {
+ ret = SIM_NOT_READY;
+ goto done;
+ }
+
+ if (0 == strcmp (cpinResult, "SIM PIN")) {
+ ret = SIM_PIN;
+ goto done;
+ } else if (0 == strcmp (cpinResult, "SIM PUK")) {
+ ret = SIM_PUK;
+ goto done;
+ } else if (0 == strcmp (cpinResult, "PH-NET PIN")) {
+ return SIM_NETWORK_PERSONALIZATION;
+ } else if (0 != strcmp (cpinResult, "READY")) {
+ /* we're treating unsupported lock types as "sim absent" */
+ ret = SIM_ABSENT;
+ goto done;
+ }
+
+ at_response_free(p_response);
+ p_response = NULL;
+ cpinResult = NULL;
+
+ ret = SIM_READY;
+
+done:
+ at_response_free(p_response);
+ return ret;
+}
+
/** Returns SIM_NOT_READY on error */
static SIM_Status
getSIMStatus()
char *cpinLine;
char *cpinResult;
+ RLOGD("getSIMStatus(). sState: %d",sState);
if (sState == RADIO_STATE_OFF || sState == RADIO_STATE_UNAVAILABLE) {
ret = SIM_NOT_READY;
goto done;
NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN },
// SIM_NETWORK_PERSONALIZATION = 5
{ RIL_APPTYPE_SIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK,
- NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }
+ NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN },
+ // RUIM_ABSENT = 6
+ { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN,
+ NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },
+ // RUIM_NOT_READY = 7
+ { RIL_APPTYPE_RUIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN,
+ NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },
+ // RUIM_READY = 8
+ { RIL_APPTYPE_RUIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY,
+ NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },
+ // RUIM_PIN = 9
+ { RIL_APPTYPE_RUIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN,
+ NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN },
+ // RUIM_PUK = 10
+ { RIL_APPTYPE_RUIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN,
+ NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN },
+ // RUIM_NETWORK_PERSONALIZATION = 11
+ { RIL_APPTYPE_RUIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK,
+ NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }
};
RIL_CardState card_state;
int num_apps;
num_apps = 0;
} else {
card_state = RIL_CARDSTATE_PRESENT;
- num_apps = 1;
+ num_apps = 2;
}
// Allocate and initialize base card status.
// that reflects sim_status for gsm.
if (num_apps != 0) {
// Only support one app, gsm
- p_card_status->num_applications = 1;
+ p_card_status->num_applications = 2;
p_card_status->gsm_umts_subscription_app_index = 0;
+ p_card_status->cdma_subscription_app_index = 1;
// Get the correct app status
p_card_status->applications[0] = app_status_array[sim_status];
+ p_card_status->applications[1] = app_status_array[sim_status + RUIM_ABSENT];
}
*pp_card_status = p_card_status;
case SIM_PUK:
case SIM_NETWORK_PERSONALIZATION:
default:
- setRadioState(RADIO_STATE_SIM_LOCKED_OR_ABSENT);
+ RLOGI("SIM ABSENT or LOCKED");
+ RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0);
return;
case SIM_NOT_READY:
return;
case SIM_READY:
- setRadioState(RADIO_STATE_SIM_READY);
+ RLOGI("SIM_READY");
+ onSIMReady();
+ RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0);
return;
}
}
}
/**
+ * Parse the response generated by a +CTEC AT command
+ * The values read from the response are stored in current and preferred.
+ * Both current and preferred may be null. The corresponding value is ignored in that case.
+ *
+ * @return: -1 if some error occurs (or if the modem doesn't understand the +CTEC command)
+ * 1 if the response includes the current technology only
+ * 0 if the response includes both current technology and preferred mode
+ */
+int parse_technology_response( const char *response, int *current, int32_t *preferred )
+{
+ int err;
+ char *line, *p;
+ int ct;
+ int32_t pt = 0;
+ char *str_pt;
+
+ line = p = strdup(response);
+ RLOGD("Response: %s", line);
+ err = at_tok_start(&p);
+ if (err || !at_tok_hasmore(&p)) {
+ RLOGD("err: %d. p: %s", err, p);
+ free(line);
+ return -1;
+ }
+
+ err = at_tok_nextint(&p, &ct);
+ if (err) {
+ free(line);
+ return -1;
+ }
+ if (current) *current = ct;
+
+ RLOGD("line remaining after int: %s", p);
+
+ err = at_tok_nexthexint(&p, &pt);
+ if (err) {
+ free(line);
+ return 1;
+ }
+ if (preferred) {
+ *preferred = pt;
+ }
+ free(line);
+
+ return 0;
+}
+
+int query_supported_techs( ModemInfo *mdm, int *supported )
+{
+ ATResponse *p_response;
+ int err, val, techs = 0;
+ char *tok;
+ char *line;
+
+ RLOGD("query_supported_techs");
+ err = at_send_command_singleline("AT+CTEC=?", "+CTEC:", &p_response);
+ if (err || !p_response->success)
+ goto error;
+ line = p_response->p_intermediates->line;
+ err = at_tok_start(&line);
+ if (err || !at_tok_hasmore(&line))
+ goto error;
+ while (!at_tok_nextint(&line, &val)) {
+ techs |= ( 1 << val );
+ }
+ if (supported) *supported = techs;
+ return 0;
+error:
+ at_response_free(p_response);
+ return -1;
+}
+
+/**
+ * query_ctec. Send the +CTEC AT command to the modem to query the current
+ * and preferred modes. It leaves values in the addresses pointed to by
+ * current and preferred. If any of those pointers are NULL, the corresponding value
+ * is ignored, but the return value will still reflect if retreiving and parsing of the
+ * values suceeded.
+ *
+ * @mdm Currently unused
+ * @current A pointer to store the current mode returned by the modem. May be null.
+ * @preferred A pointer to store the preferred mode returned by the modem. May be null.
+ * @return -1 on error (or failure to parse)
+ * 1 if only the current mode was returned by modem (or failed to parse preferred)
+ * 0 if both current and preferred were returned correctly
+ */
+int query_ctec(ModemInfo *mdm, int *current, int32_t *preferred)
+{
+ ATResponse *response = NULL;
+ int err;
+ int res;
+
+ RLOGD("query_ctec. current: %d, preferred: %d", (int)current, (int) preferred);
+ err = at_send_command_singleline("AT+CTEC?", "+CTEC:", &response);
+ if (!err && response->success) {
+ res = parse_technology_response(response->p_intermediates->line, current, preferred);
+ at_response_free(response);
+ return res;
+ }
+ RLOGE("Error executing command: %d. response: %x. status: %d", err, (int)response, response? response->success : -1);
+ at_response_free(response);
+ return -1;
+}
+
+int is_multimode_modem(ModemInfo *mdm)
+{
+ ATResponse *response;
+ int err;
+ char *line;
+ int tech;
+ int32_t preferred;
+
+ if (query_ctec(mdm, &tech, &preferred) == 0) {
+ mdm->currentTech = tech;
+ mdm->preferredNetworkMode = preferred;
+ if (query_supported_techs(mdm, &mdm->supportedTechs)) {
+ return 0;
+ }
+ return 1;
+ }
+ return 0;
+}
+
+/**
+ * Find out if our modem is GSM, CDMA or both (Multimode)
+ */
+static void probeForModemMode(ModemInfo *info)
+{
+ ATResponse *response;
+ int err;
+ assert (info);
+ // Currently, our only known multimode modem is qemu's android modem,
+ // which implements the AT+CTEC command to query and set mode.
+ // Try that first
+
+ if (is_multimode_modem(info)) {
+ RLOGI("Found Multimode Modem. Supported techs mask: %8.8x. Current tech: %d",
+ info->supportedTechs, info->currentTech);
+ return;
+ }
+
+ /* Being here means that our modem is not multimode */
+ info->isMultimode = 0;
+
+ /* CDMA Modems implement the AT+WNAM command */
+ err = at_send_command_singleline("AT+WNAM","+WNAM:", &response);
+ if (!err && response->success) {
+ at_response_free(response);
+ // TODO: find out if we really support EvDo
+ info->supportedTechs = MDM_CDMA | MDM_EVDO;
+ info->currentTech = MDM_CDMA;
+ RLOGI("Found CDMA Modem");
+ return;
+ }
+ if (!err) at_response_free(response);
+ // TODO: find out if modem really supports WCDMA/LTE
+ info->supportedTechs = MDM_GSM | MDM_WCDMA | MDM_LTE;
+ info->currentTech = MDM_GSM;
+ RLOGI("Found GSM Modem");
+}
+
+/**
* Initialize everything that can be configured while we're still in
* AT+CFUN=0
*/
at_handshake();
+ probeForModemMode(sMdmInfo);
/* note: we don't check errors here. Everything important will
be handled in onATTimeout and onATReaderClosed */
/* assume radio is off on error */
if (isRadioOn() > 0) {
- setRadioState (RADIO_STATE_SIM_NOT_READY);
+ setRadioState (RADIO_STATE_ON);
}
}
pthread_mutex_unlock(&s_state_mutex);
}
+static void sendUnsolImsNetworkStateChanged()
+{
+#if 0 // to be used when unsol is changed to return data.
+ int reply[2];
+ reply[0] = s_ims_registered;
+ reply[1] = s_ims_services;
+ reply[1] = s_ims_format;
+#endif
+ RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED,
+ NULL, 0);
+}
+
/**
* Called by atchannel when an unsolicited line appears
* This is called on atchannel's reader thread. AT commands may
*/
static void onUnsolicited (const char *s, const char *sms_pdu)
{
- char *line = NULL;
+ char *line = NULL, *p;
int err;
/* Ignore unsolicited responses until we're initialized.
/* TI specific -- NITZ time */
char *response;
- line = strdup(s);
- at_tok_start(&line);
+ line = p = strdup(s);
+ at_tok_start(&p);
- err = at_tok_nextstr(&line, &response);
+ err = at_tok_nextstr(&p, &response);
+ free(line);
if (err != 0) {
- LOGE("invalid NITZ line %s\n", s);
+ RLOGE("invalid NITZ line %s\n", s);
} else {
RIL_onUnsolicitedResponse (
RIL_UNSOL_NITZ_TIME_RECEIVED,
} else if (strStartsWith(s, "+CME ERROR: 150")) {
RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL);
#endif /* WORKAROUND_FAKE_CGEV */
+ } else if (strStartsWith(s, "+CTEC: ")) {
+ int tech, mask;
+ switch (parse_technology_response(s, &tech, NULL))
+ {
+ case -1: // no argument could be parsed.
+ RLOGE("invalid CTEC line %s\n", s);
+ break;
+ case 1: // current mode correctly parsed
+ case 0: // preferred mode correctly parsed
+ mask = 1 << tech;
+ if (mask != MDM_GSM && mask != MDM_CDMA &&
+ mask != MDM_WCDMA && mask != MDM_LTE) {
+ RLOGE("Unknown technology %d\n", tech);
+ } else {
+ setRadioTechnology(sMdmInfo, tech);
+ }
+ break;
+ }
+ } else if (strStartsWith(s, "+CCSS: ")) {
+ int source = 0;
+ line = p = strdup(s);
+ if (!line) {
+ RLOGE("+CCSS: Unable to allocate memory");
+ return;
+ }
+ if (at_tok_start(&p) < 0) {
+ free(line);
+ return;
+ }
+ if (at_tok_nextint(&p, &source) < 0) {
+ RLOGE("invalid +CCSS response: %s", line);
+ free(line);
+ return;
+ }
+ SSOURCE(sMdmInfo) = source;
+ RIL_onUnsolicitedResponse(RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED,
+ &source, sizeof(source));
+ } else if (strStartsWith(s, "+WSOS: ")) {
+ char state = 0;
+ int unsol;
+ line = p = strdup(s);
+ if (!line) {
+ RLOGE("+WSOS: Unable to allocate memory");
+ return;
+ }
+ if (at_tok_start(&p) < 0) {
+ free(line);
+ return;
+ }
+ if (at_tok_nextbool(&p, &state) < 0) {
+ RLOGE("invalid +WSOS response: %s", line);
+ free(line);
+ return;
+ }
+ free(line);
+
+ unsol = state ?
+ RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE : RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE;
+
+ RIL_onUnsolicitedResponse(unsol, NULL, 0);
+
+ } else if (strStartsWith(s, "+WPRL: ")) {
+ int version = -1;
+ line = p = strdup(s);
+ if (!line) {
+ RLOGE("+WPRL: Unable to allocate memory");
+ return;
+ }
+ if (at_tok_start(&p) < 0) {
+ RLOGE("invalid +WPRL response: %s", s);
+ free(line);
+ return;
+ }
+ if (at_tok_nextint(&p, &version) < 0) {
+ RLOGE("invalid +WPRL response: %s", s);
+ free(line);
+ return;
+ }
+ free(line);
+ RIL_onUnsolicitedResponse(RIL_UNSOL_CDMA_PRL_CHANGED, &version, sizeof(version));
+ } else if (strStartsWith(s, "+CFUN: 0")) {
+ setRadioState(RADIO_STATE_OFF);
}
}
/* Called on command or reader thread */
static void onATReaderClosed()
{
- LOGI("AT channel closed\n");
+ RLOGI("AT channel closed\n");
at_close();
s_closed = 1;
/* Called on command thread */
static void onATTimeout()
{
- LOGI("AT channel timeout; closing\n");
+ RLOGI("AT channel timeout; closing\n");
at_close();
s_closed = 1;
ret = at_open(fd, onUnsolicited);
if (ret < 0) {
- LOGE ("AT error %d on at_open\n", ret);
+ RLOGE ("AT error %d on at_open\n", ret);
return 0;
}
sleep(1);
waitForClose();
- LOGI("Re-opening after close");
+ RLOGI("Re-opening after close");
}
}
usage(argv[0]);
return NULL;
}
- LOGI("Opening loopback port %d\n", s_port);
+ RLOGI("Opening loopback port %d\n", s_port);
break;
case 'd':
s_device_path = optarg;
- LOGI("Opening tty device %s\n", s_device_path);
+ RLOGI("Opening tty device %s\n", s_device_path);
break;
case 's':
s_device_path = optarg;
s_device_socket = 1;
- LOGI("Opening socket %s\n", s_device_path);
+ RLOGI("Opening socket %s\n", s_device_path);
break;
default:
return NULL;
}
+ sMdmInfo = calloc(1, sizeof(ModemInfo));
+ if (!sMdmInfo) {
+ RLOGE("Unable to alloc memory for ModemInfo");
+ return NULL;
+ }
pthread_attr_init (&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
ret = pthread_create(&s_tid_mainloop, &attr, mainLoop, NULL);
if (s_port == 0) {
usage(argv[0]);
}
- LOGI("Opening loopback port %d\n", s_port);
+ RLOGI("Opening loopback port %d\n", s_port);
break;
case 'd':
s_device_path = optarg;
- LOGI("Opening tty device %s\n", s_device_path);
+ RLOGI("Opening tty device %s\n", s_device_path);
break;
case 's':
s_device_path = optarg;
s_device_socket = 1;
- LOGI("Opening socket %s\n", s_device_path);
+ RLOGI("Opening socket %s\n", s_device_path);
break;
default:
OSDN Git Service
