| /* //device/system/reference-ril/reference-ril.c |
| ** |
| ** Copyright 2006, The Android Open Source Project |
| ** |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| */ |
| |
| #include <telephony/ril_cdma_sms.h> |
| #include <telephony/librilutils.h> |
| #include <stdio.h> |
| #include <assert.h> |
| #include <string.h> |
| #include <errno.h> |
| #include <unistd.h> |
| #include <sys/cdefs.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <inttypes.h> |
| #include <fcntl.h> |
| #include <pthread.h> |
| #include <alloca.h> |
| #include "atchannel.h" |
| #include "at_tok.h" |
| #include "misc.h" |
| #include <getopt.h> |
| #include <sys/socket.h> |
| #include <cutils/properties.h> |
| #include <cutils/sockets.h> |
| #include <termios.h> |
| #include <sys/wait.h> |
| #include <stdbool.h> |
| #include <net/if.h> |
| #include <netinet/in.h> |
| |
| #include "ril.h" |
| |
| #define LOG_TAG "RIL" |
| #include <utils/Log.h> |
| |
| static void *noopRemoveWarning( void *a ) { return a; } |
| #define RIL_UNUSED_PARM(a) noopRemoveWarning((void *)&(a)); |
| |
| #define MAX_AT_RESPONSE 0x1000 |
| |
| /* pathname returned from RIL_REQUEST_SETUP_DATA_CALL / RIL_REQUEST_SETUP_DEFAULT_PDP */ |
| // This is used if Wifi is not supported, plain old eth0 |
| #define PPP_TTY_PATH_ETH0 "eth0" |
| // This is used if Wifi is supported to separate radio and wifi interface |
| #define PPP_TTY_PATH_RADIO0 "radio0" |
| |
| // Default MTU value |
| #define DEFAULT_MTU 1500 |
| |
| #ifdef USE_TI_COMMANDS |
| |
| // Enable a workaround |
| // 1) Make incoming call, do not answer |
| // 2) Hangup remote end |
| // Expected: call should disappear from CLCC line |
| // Actual: Call shows as "ACTIVE" before disappearing |
| #define WORKAROUND_ERRONEOUS_ANSWER 1 |
| |
| // Some varients of the TI stack do not support the +CGEV unsolicited |
| // response. However, they seem to send an unsolicited +CME ERROR: 150 |
| #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_PIN = 3, |
| SIM_PUK = 4, |
| SIM_NETWORK_PERSONALIZATION = 5, |
| RUIM_ABSENT = 6, |
| RUIM_NOT_READY = 7, |
| RUIM_READY = 8, |
| RUIM_PIN = 9, |
| RUIM_PUK = 10, |
| RUIM_NETWORK_PERSONALIZATION = 11, |
| ISIM_ABSENT = 12, |
| ISIM_NOT_READY = 13, |
| ISIM_READY = 14, |
| ISIM_PIN = 15, |
| ISIM_PUK = 16, |
| ISIM_NETWORK_PERSONALIZATION = 17, |
| } SIM_Status; |
| |
| static void onRequest (int request, void *data, size_t datalen, RIL_Token t); |
| static RIL_RadioState currentState(); |
| static int onSupports (int requestCode); |
| static void onCancel (RIL_Token t); |
| static const char *getVersion(); |
| static int isRadioOn(); |
| static SIM_Status getSIMStatus(); |
| static int getCardStatus(RIL_CardStatus_v6 **pp_card_status); |
| static void freeCardStatus(RIL_CardStatus_v6 *p_card_status); |
| static void onDataCallListChanged(void *param); |
| |
| extern const char * requestToString(int request); |
| |
| /*** Static Variables ***/ |
| static const RIL_RadioFunctions s_callbacks = { |
| RIL_VERSION, |
| onRequest, |
| currentState, |
| onSupports, |
| onCancel, |
| getVersion |
| }; |
| |
| #ifdef RIL_SHLIB |
| static const struct RIL_Env *s_rilenv; |
| |
| #define RIL_onRequestComplete(t, e, response, responselen) s_rilenv->OnRequestComplete(t,e, response, responselen) |
| #define RIL_onUnsolicitedResponse(a,b,c) s_rilenv->OnUnsolicitedResponse(a,b,c) |
| #define RIL_requestTimedCallback(a,b,c) s_rilenv->RequestTimedCallback(a,b,c) |
| #endif |
| |
| static RIL_RadioState sState = RADIO_STATE_UNAVAILABLE; |
| |
| static pthread_mutex_t s_state_mutex = PTHREAD_MUTEX_INITIALIZER; |
| static pthread_cond_t s_state_cond = PTHREAD_COND_INITIALIZER; |
| |
| static int s_port = -1; |
| static const char * s_device_path = NULL; |
| static int s_device_socket = 0; |
| |
| /* trigger change to this with s_state_cond */ |
| static int s_closed = 0; |
| |
| static int sFD; /* file desc of AT channel */ |
| static char sATBuffer[MAX_AT_RESPONSE+1]; |
| static char *sATBufferCur = NULL; |
| |
| static const struct timeval TIMEVAL_SIMPOLL = {1,0}; |
| 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 |
| #define REPOLL_CALLS_COUNT_MAX 4 |
| |
| // Line index that was incoming or waiting at last poll, or -1 for none |
| static int s_incomingOrWaitingLine = -1; |
| // Number of times we've asked for a repoll of AT+CLCC |
| static int s_repollCallsCount = 0; |
| // Should we expect a call to be answered in the next CLCC? |
| 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) |
| |
| { |
| switch(state) { |
| case 0: *p_state = RIL_CALL_ACTIVE; return 0; |
| case 1: *p_state = RIL_CALL_HOLDING; return 0; |
| case 2: *p_state = RIL_CALL_DIALING; return 0; |
| case 3: *p_state = RIL_CALL_ALERTING; return 0; |
| case 4: *p_state = RIL_CALL_INCOMING; return 0; |
| case 5: *p_state = RIL_CALL_WAITING; return 0; |
| default: return -1; |
| } |
| } |
| |
| /** |
| * Note: directly modified line and has *p_call point directly into |
| * modified line |
| */ |
| static int callFromCLCCLine(char *line, RIL_Call *p_call) |
| { |
| //+CLCC: 1,0,2,0,0,\"+18005551212\",145 |
| // index,isMT,state,mode,isMpty(,number,TOA)? |
| |
| int err; |
| int state; |
| int mode; |
| |
| err = at_tok_start(&line); |
| if (err < 0) goto error; |
| |
| err = at_tok_nextint(&line, &(p_call->index)); |
| if (err < 0) goto error; |
| |
| err = at_tok_nextbool(&line, &(p_call->isMT)); |
| if (err < 0) goto error; |
| |
| err = at_tok_nextint(&line, &state); |
| if (err < 0) goto error; |
| |
| err = clccStateToRILState(state, &(p_call->state)); |
| if (err < 0) goto error; |
| |
| err = at_tok_nextint(&line, &mode); |
| if (err < 0) goto error; |
| |
| p_call->isVoice = (mode == 0); |
| |
| err = at_tok_nextbool(&line, &(p_call->isMpty)); |
| if (err < 0) goto error; |
| |
| if (at_tok_hasmore(&line)) { |
| err = at_tok_nextstr(&line, &(p_call->number)); |
| |
| /* tolerate null here */ |
| if (err < 0) return 0; |
| |
| // Some lame implementations return strings |
| // like "NOT AVAILABLE" in the CLCC line |
| if (p_call->number != NULL |
| && 0 == strspn(p_call->number, "+0123456789") |
| ) { |
| p_call->number = NULL; |
| } |
| |
| err = at_tok_nextint(&line, &p_call->toa); |
| if (err < 0) goto error; |
| } |
| |
| p_call->uusInfo = NULL; |
| |
| return 0; |
| |
| error: |
| RLOGE("invalid CLCC line\n"); |
| return -1; |
| } |
| |
| static int parseSimResponseLine(char* line, RIL_SIM_IO_Response* response) { |
| int err; |
| |
| err = at_tok_start(&line); |
| if (err < 0) return err; |
| err = at_tok_nextint(&line, &response->sw1); |
| if (err < 0) return err; |
| err = at_tok_nextint(&line, &response->sw2); |
| if (err < 0) return err; |
| |
| if (at_tok_hasmore(&line)) { |
| err = at_tok_nextstr(&line, &response->simResponse); |
| if (err < 0) return err; |
| } |
| return 0; |
| } |
| |
| enum InterfaceState { |
| kInterfaceUp, |
| kInterfaceDown, |
| }; |
| |
| static RIL_Errno setInterfaceState(const char* interfaceName, |
| enum InterfaceState state) { |
| struct ifreq request; |
| int status = 0; |
| int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP); |
| if (sock == -1) { |
| RLOGE("Failed to open interface socket: %s (%d)", |
| strerror(errno), errno); |
| return RIL_E_GENERIC_FAILURE; |
| } |
| |
| memset(&request, 0, sizeof(request)); |
| strncpy(request.ifr_name, interfaceName, sizeof(request.ifr_name)); |
| request.ifr_name[sizeof(request.ifr_name) - 1] = '\0'; |
| status = ioctl(sock, SIOCGIFFLAGS, &request); |
| if (status != 0) { |
| RLOGE("Failed to get interface flags for %s: %s (%d)", |
| interfaceName, strerror(errno), errno); |
| close(sock); |
| return RIL_E_RADIO_NOT_AVAILABLE; |
| } |
| |
| bool isUp = (request.ifr_flags & IFF_UP); |
| if ((state == kInterfaceUp && isUp) || (state == kInterfaceDown && !isUp)) { |
| // Interface already in desired state |
| close(sock); |
| return RIL_E_SUCCESS; |
| } |
| |
| // Simply toggle the flag since we know it's the opposite of what we want |
| request.ifr_flags ^= IFF_UP; |
| |
| status = ioctl(sock, SIOCSIFFLAGS, &request); |
| if (status != 0) { |
| RLOGE("Failed to set interface flags for %s: %s (%d)", |
| interfaceName, strerror(errno), errno); |
| close(sock); |
| return RIL_E_GENERIC_FAILURE; |
| } |
| |
| close(sock); |
| return RIL_E_SUCCESS; |
| } |
| |
| /** do post-AT+CFUN=1 initialization */ |
| static void onRadioPowerOn() |
| { |
| #ifdef USE_TI_COMMANDS |
| /* Must be after CFUN=1 */ |
| /* TI specific -- notifications for CPHS things such */ |
| /* as CPHS message waiting indicator */ |
| |
| at_send_command("AT%CPHS=1", NULL); |
| |
| /* TI specific -- enable NITZ unsol notifs */ |
| at_send_command("AT%CTZV=1", NULL); |
| #endif |
| |
| pollSIMState(NULL); |
| } |
| |
| /** do post- SIM ready initialization */ |
| static void onSIMReady() |
| { |
| at_send_command_singleline("AT+CSMS=1", "+CSMS:", NULL); |
| /* |
| * Always send SMS messages directly to the TE |
| * |
| * mode = 1 // discard when link is reserved (link should never be |
| * reserved) |
| * mt = 2 // most messages routed to TE |
| * bm = 2 // new cell BM's routed to TE |
| * ds = 1 // Status reports routed to TE |
| * bfr = 1 // flush buffer |
| */ |
| at_send_command("AT+CNMI=1,2,2,1,1", NULL); |
| } |
| |
| static void requestRadioPower(void *data, size_t datalen __unused, RIL_Token t) |
| { |
| int onOff; |
| |
| int err; |
| ATResponse *p_response = NULL; |
| |
| assert (datalen >= sizeof(int *)); |
| onOff = ((int *)data)[0]; |
| |
| if (onOff == 0 && sState != RADIO_STATE_OFF) { |
| err = at_send_command("AT+CFUN=0", &p_response); |
| if (err < 0 || p_response->success == 0) goto error; |
| 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 (isRadioOn() != 1) { |
| goto error; |
| } |
| } |
| setRadioState(RADIO_STATE_ON); |
| } |
| |
| 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); |
| } |
| |
| static void requestShutdown(RIL_Token t) |
| { |
| int onOff; |
| |
| int err; |
| ATResponse *p_response = NULL; |
| |
| if (sState != RADIO_STATE_OFF) { |
| err = at_send_command("AT+CFUN=0", &p_response); |
| setRadioState(RADIO_STATE_UNAVAILABLE); |
| } |
| |
| at_response_free(p_response); |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| return; |
| } |
| |
| static void requestOrSendDataCallList(RIL_Token *t); |
| |
| static void onDataCallListChanged(void *param __unused) |
| { |
| requestOrSendDataCallList(NULL); |
| } |
| |
| static void requestDataCallList(void *data __unused, size_t datalen __unused, RIL_Token t) |
| { |
| requestOrSendDataCallList(&t); |
| } |
| |
| // Hang up, reject, conference, call waiting |
| static void requestCallSelection( |
| void *data __unused, size_t datalen __unused, RIL_Token t, int request) |
| { |
| // 3GPP 22.030 6.5.5 |
| static char hangupWaiting[] = "AT+CHLD=0"; |
| static char hangupForeground[] = "AT+CHLD=1"; |
| static char switchWaiting[] = "AT+CHLD=2"; |
| static char conference[] = "AT+CHLD=3"; |
| static char reject[] = "ATH"; |
| |
| char* atCommand; |
| |
| if (getSIMStatus() == SIM_ABSENT) { |
| RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); |
| return; |
| } |
| |
| switch(request) { |
| case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: |
| // "Releases all held calls or sets User Determined User Busy |
| // (UDUB) for a waiting call." |
| atCommand = hangupWaiting; |
| break; |
| case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: |
| // "Releases all active calls (if any exist) and accepts |
| // the other (held or waiting) call." |
| atCommand = hangupForeground; |
| break; |
| case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: |
| // "Places all active calls (if any exist) on hold and accepts |
| // the other (held or waiting) call." |
| atCommand = switchWaiting; |
| #ifdef WORKAROUND_ERRONEOUS_ANSWER |
| s_expectAnswer = 1; |
| #endif /* WORKAROUND_ERRONEOUS_ANSWER */ |
| break; |
| case RIL_REQUEST_CONFERENCE: |
| // "Adds a held call to the conversation" |
| atCommand = conference; |
| break; |
| case RIL_REQUEST_UDUB: |
| // User determined user busy (reject) |
| atCommand = reject; |
| break; |
| default: |
| assert(0); |
| } |
| at_send_command(atCommand, NULL); |
| // Success or failure is ignored by the upper layer here. |
| // It will call GET_CURRENT_CALLS and determine success that way. |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| } |
| |
| static bool hasWifiCapability() |
| { |
| char propValue[PROP_VALUE_MAX]; |
| return property_get("ro.boot.qemu.wifi", propValue, "") > 0 && |
| strcmp("1", propValue) == 0; |
| } |
| |
| static const char* getRadioInterfaceName(bool hasWifi) |
| { |
| return hasWifi ? PPP_TTY_PATH_RADIO0 : PPP_TTY_PATH_ETH0; |
| } |
| |
| static void requestOrSendDataCallList(RIL_Token *t) |
| { |
| ATResponse *p_response; |
| ATLine *p_cur; |
| int err; |
| int n = 0; |
| char *out; |
| char propValue[PROP_VALUE_MAX]; |
| bool hasWifi = hasWifiCapability(); |
| const char* radioInterfaceName = getRadioInterfaceName(hasWifi); |
| |
| err = at_send_command_multiline ("AT+CGACT?", "+CGACT:", &p_response); |
| if (err != 0 || p_response->success == 0) { |
| if (t != NULL) |
| RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| else |
| RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, |
| NULL, 0); |
| return; |
| } |
| |
| for (p_cur = p_response->p_intermediates; p_cur != NULL; |
| p_cur = p_cur->p_next) |
| n++; |
| |
| RIL_Data_Call_Response_v11 *responses = |
| alloca(n * sizeof(RIL_Data_Call_Response_v11)); |
| |
| int i; |
| for (i = 0; i < n; i++) { |
| responses[i].status = -1; |
| responses[i].suggestedRetryTime = -1; |
| responses[i].cid = -1; |
| responses[i].active = -1; |
| responses[i].type = ""; |
| responses[i].ifname = ""; |
| responses[i].addresses = ""; |
| responses[i].dnses = ""; |
| responses[i].gateways = ""; |
| responses[i].pcscf = ""; |
| responses[i].mtu = 0; |
| } |
| |
| RIL_Data_Call_Response_v11 *response = responses; |
| for (p_cur = p_response->p_intermediates; p_cur != NULL; |
| p_cur = p_cur->p_next) { |
| char *line = p_cur->line; |
| |
| err = at_tok_start(&line); |
| if (err < 0) |
| goto error; |
| |
| err = at_tok_nextint(&line, &response->cid); |
| if (err < 0) |
| goto error; |
| |
| err = at_tok_nextint(&line, &response->active); |
| if (err < 0) |
| goto error; |
| |
| response++; |
| } |
| |
| at_response_free(p_response); |
| |
| err = at_send_command_multiline ("AT+CGDCONT?", "+CGDCONT:", &p_response); |
| if (err != 0 || p_response->success == 0) { |
| if (t != NULL) |
| RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| else |
| RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, |
| NULL, 0); |
| return; |
| } |
| |
| for (p_cur = p_response->p_intermediates; p_cur != NULL; |
| p_cur = p_cur->p_next) { |
| char *line = p_cur->line; |
| int cid; |
| |
| err = at_tok_start(&line); |
| if (err < 0) |
| goto error; |
| |
| err = at_tok_nextint(&line, &cid); |
| if (err < 0) |
| goto error; |
| |
| for (i = 0; i < n; i++) { |
| if (responses[i].cid == cid) |
| break; |
| } |
| |
| if (i >= n) { |
| /* details for a context we didn't hear about in the last request */ |
| continue; |
| } |
| |
| // Assume no error |
| responses[i].status = 0; |
| |
| // type |
| err = at_tok_nextstr(&line, &out); |
| if (err < 0) |
| goto error; |
| |
| int type_size = strlen(out) + 1; |
| responses[i].type = alloca(type_size); |
| strlcpy(responses[i].type, out, type_size); |
| |
| // APN ignored for v5 |
| err = at_tok_nextstr(&line, &out); |
| if (err < 0) |
| goto error; |
| |
| int ifname_size = strlen(radioInterfaceName) + 1; |
| responses[i].ifname = alloca(ifname_size); |
| strlcpy(responses[i].ifname, radioInterfaceName, ifname_size); |
| |
| err = at_tok_nextstr(&line, &out); |
| if (err < 0) |
| goto error; |
| |
| int addresses_size = strlen(out) + 1; |
| responses[i].addresses = alloca(addresses_size); |
| strlcpy(responses[i].addresses, out, addresses_size); |
| |
| /* I don't know where we are, so use the public Google DNS |
| * servers by default and no gateway. |
| */ |
| responses[i].dnses = "8.8.8.8 8.8.4.4"; |
| responses[i].gateways = ""; |
| } |
| |
| at_response_free(p_response); |
| |
| if (t != NULL) |
| RIL_onRequestComplete(*t, RIL_E_SUCCESS, responses, |
| n * sizeof(RIL_Data_Call_Response_v11)); |
| else |
| RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, |
| responses, |
| n * sizeof(RIL_Data_Call_Response_v11)); |
| |
| return; |
| |
| error: |
| if (t != NULL) |
| RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| else |
| RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, |
| NULL, 0); |
| |
| at_response_free(p_response); |
| } |
| |
| static void requestQueryNetworkSelectionMode( |
| void *data __unused, size_t datalen __unused, RIL_Token t) |
| { |
| int err; |
| ATResponse *p_response = NULL; |
| int response = 0; |
| char *line; |
| |
| err = at_send_command_singleline("AT+COPS?", "+COPS:", &p_response); |
| |
| if (err < 0 || p_response->success == 0) { |
| goto error; |
| } |
| |
| line = p_response->p_intermediates->line; |
| |
| err = at_tok_start(&line); |
| |
| if (err < 0) { |
| goto error; |
| } |
| |
| err = at_tok_nextint(&line, &response); |
| |
| if (err < 0) { |
| goto error; |
| } |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(int)); |
| at_response_free(p_response); |
| return; |
| error: |
| at_response_free(p_response); |
| RLOGE("requestQueryNetworkSelectionMode must never return error when radio is on"); |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| } |
| |
| static void sendCallStateChanged(void *param __unused) |
| { |
| RIL_onUnsolicitedResponse ( |
| RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, |
| NULL, 0); |
| } |
| |
| static void requestGetCurrentCalls(void *data __unused, size_t datalen __unused, RIL_Token t) |
| { |
| int err; |
| ATResponse *p_response; |
| ATLine *p_cur; |
| int countCalls; |
| int countValidCalls; |
| RIL_Call *p_calls; |
| RIL_Call **pp_calls; |
| int i; |
| int needRepoll = 0; |
| |
| #ifdef WORKAROUND_ERRONEOUS_ANSWER |
| int prevIncomingOrWaitingLine; |
| |
| prevIncomingOrWaitingLine = s_incomingOrWaitingLine; |
| s_incomingOrWaitingLine = -1; |
| #endif /*WORKAROUND_ERRONEOUS_ANSWER*/ |
| |
| err = at_send_command_multiline ("AT+CLCC", "+CLCC:", &p_response); |
| |
| if (err != 0 || p_response->success == 0) { |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| return; |
| } |
| |
| /* count the calls */ |
| for (countCalls = 0, p_cur = p_response->p_intermediates |
| ; p_cur != NULL |
| ; p_cur = p_cur->p_next |
| ) { |
| countCalls++; |
| } |
| |
| /* yes, there's an array of pointers and then an array of structures */ |
| |
| pp_calls = (RIL_Call **)alloca(countCalls * sizeof(RIL_Call *)); |
| p_calls = (RIL_Call *)alloca(countCalls * sizeof(RIL_Call)); |
| memset (p_calls, 0, countCalls * sizeof(RIL_Call)); |
| |
| /* init the pointer array */ |
| for(i = 0; i < countCalls ; i++) { |
| pp_calls[i] = &(p_calls[i]); |
| } |
| |
| for (countValidCalls = 0, p_cur = p_response->p_intermediates |
| ; p_cur != NULL |
| ; p_cur = p_cur->p_next |
| ) { |
| err = callFromCLCCLine(p_cur->line, p_calls + countValidCalls); |
| |
| if (err != 0) { |
| continue; |
| } |
| |
| #ifdef WORKAROUND_ERRONEOUS_ANSWER |
| if (p_calls[countValidCalls].state == RIL_CALL_INCOMING |
| || p_calls[countValidCalls].state == RIL_CALL_WAITING |
| ) { |
| s_incomingOrWaitingLine = p_calls[countValidCalls].index; |
| } |
| #endif /*WORKAROUND_ERRONEOUS_ANSWER*/ |
| |
| if (p_calls[countValidCalls].state != RIL_CALL_ACTIVE |
| && p_calls[countValidCalls].state != RIL_CALL_HOLDING |
| ) { |
| needRepoll = 1; |
| } |
| |
| countValidCalls++; |
| } |
| |
| #ifdef WORKAROUND_ERRONEOUS_ANSWER |
| // Basically: |
| // A call was incoming or waiting |
| // Now it's marked as active |
| // But we never answered it |
| // |
| // This is probably a bug, and the call will probably |
| // disappear from the call list in the next poll |
| if (prevIncomingOrWaitingLine >= 0 |
| && s_incomingOrWaitingLine < 0 |
| && s_expectAnswer == 0 |
| ) { |
| for (i = 0; i < countValidCalls ; i++) { |
| |
| if (p_calls[i].index == prevIncomingOrWaitingLine |
| && p_calls[i].state == RIL_CALL_ACTIVE |
| && s_repollCallsCount < REPOLL_CALLS_COUNT_MAX |
| ) { |
| RLOGI( |
| "Hit WORKAROUND_ERRONOUS_ANSWER case." |
| " Repoll count: %d\n", s_repollCallsCount); |
| s_repollCallsCount++; |
| goto error; |
| } |
| } |
| } |
| |
| s_expectAnswer = 0; |
| s_repollCallsCount = 0; |
| #endif /*WORKAROUND_ERRONEOUS_ANSWER*/ |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, pp_calls, |
| countValidCalls * sizeof (RIL_Call *)); |
| |
| at_response_free(p_response); |
| |
| #ifdef POLL_CALL_STATE |
| if (countValidCalls) { // We don't seem to get a "NO CARRIER" message from |
| // smd, so we're forced to poll until the call ends. |
| #else |
| if (needRepoll) { |
| #endif |
| RIL_requestTimedCallback (sendCallStateChanged, NULL, &TIMEVAL_CALLSTATEPOLL); |
| } |
| |
| return; |
| #ifdef WORKAROUND_ERRONEOUS_ANSWER |
| error: |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| at_response_free(p_response); |
| #endif |
| } |
| |
| static void requestDial(void *data, size_t datalen __unused, RIL_Token t) |
| { |
| RIL_Dial *p_dial; |
| char *cmd; |
| const char *clir; |
| int ret; |
| |
| p_dial = (RIL_Dial *)data; |
| |
| switch (p_dial->clir) { |
| case 1: clir = "I"; break; /*invocation*/ |
| case 2: clir = "i"; break; /*suppression*/ |
| default: |
| case 0: clir = ""; break; /*subscription default*/ |
| } |
| |
| asprintf(&cmd, "ATD%s%s;", p_dial->address, clir); |
| |
| ret = at_send_command(cmd, NULL); |
| |
| free(cmd); |
| |
| /* success or failure is ignored by the upper layer here. |
| it will call GET_CURRENT_CALLS and determine success that way */ |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| } |
| |
| static void requestWriteSmsToSim(void *data, size_t datalen __unused, RIL_Token t) |
| { |
| RIL_SMS_WriteArgs *p_args; |
| char *cmd; |
| int length; |
| int err; |
| ATResponse *p_response = NULL; |
| |
| if (getSIMStatus() == SIM_ABSENT) { |
| RIL_onRequestComplete(t, RIL_E_SIM_ABSENT, NULL, 0); |
| return; |
| } |
| |
| p_args = (RIL_SMS_WriteArgs *)data; |
| |
| length = strlen(p_args->pdu)/2; |
| asprintf(&cmd, "AT+CMGW=%d,%d", length, p_args->status); |
| |
| err = at_send_command_sms(cmd, p_args->pdu, "+CMGW:", &p_response); |
| |
| if (err != 0 || p_response->success == 0) goto error; |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| at_response_free(p_response); |
| |
| return; |
| error: |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| at_response_free(p_response); |
| } |
| |
| static void requestHangup(void *data, size_t datalen __unused, RIL_Token t) |
| { |
| int *p_line; |
| |
| int ret; |
| char *cmd; |
| |
| if (getSIMStatus() == SIM_ABSENT) { |
| RIL_onRequestComplete(t, RIL_E_MODEM_ERR, NULL, 0); |
| return; |
| } |
| p_line = (int *)data; |
| |
| // 3GPP 22.030 6.5.5 |
| // "Releases a specific active call X" |
| asprintf(&cmd, "AT+CHLD=1%d", p_line[0]); |
| |
| ret = at_send_command(cmd, NULL); |
| |
| free(cmd); |
| |
| /* success or failure is ignored by the upper layer here. |
| it will call GET_CURRENT_CALLS and determine success that way */ |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| } |
| |
| static void requestSignalStrength(void *data __unused, size_t datalen __unused, RIL_Token t) |
| { |
| ATResponse *p_response = NULL; |
| int err; |
| char *line; |
| int count = 0; |
| // Accept a response that is at least v6, and up to v10 |
| int minNumOfElements=sizeof(RIL_SignalStrength_v6)/sizeof(int); |
| int maxNumOfElements=sizeof(RIL_SignalStrength_v10)/sizeof(int); |
| int response[maxNumOfElements]; |
| |
| memset(response, 0, sizeof(response)); |
| |
| err = at_send_command_singleline("AT+CSQ", "+CSQ:", &p_response); |
| |
| if (err < 0 || p_response->success == 0) { |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| goto error; |
| } |
| |
| line = p_response->p_intermediates->line; |
| |
| err = at_tok_start(&line); |
| if (err < 0) goto error; |
| |
| for (count = 0; count < maxNumOfElements; count++) { |
| err = at_tok_nextint(&line, &(response[count])); |
| if (err < 0 && count < minNumOfElements) goto error; |
| } |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response)); |
| |
| at_response_free(p_response); |
| return; |
| |
| error: |
| 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); |
| } |
| |
| /** |
| * 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 __unused, void *data, |
| size_t datalen __unused, 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 __unused, void *data __unused, |
| size_t datalen __unused, 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 __unused, void *data __unused, |
| size_t datalen __unused, 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 __unused, void *data __unused, |
| size_t datalen __unused, 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 requestDeviceIdentity(int request __unused, void *data __unused, |
| size_t datalen __unused, RIL_Token t) |
| { |
| int err; |
| int response[4]; |
| char * responseStr[4]; |
| 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[0] = "----"; |
| responseStr[1] = "----"; |
| responseStr[2] = "77777777"; |
| responseStr[3] = ""; // default empty for non-CDMA |
| |
| 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 { |
| if (TECH_BIT(sMdmInfo) == MDM_CDMA) { |
| responseStr[3] = p_response->p_intermediates->line; |
| } else { |
| responseStr[0] = p_response->p_intermediates->line; |
| } |
| } |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, count*sizeof(char*)); |
| at_response_free(p_response); |
| } |
| |
| static void requestCdmaGetSubscriptionSource(int request __unused, void *data, |
| size_t datalen __unused, 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 __unused, 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(cmd, &p_response); |
| if (err < 0 || !p_response->success) |
| goto error; |
| free(cmd); |
| cmd = NULL; |
| |
| 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 __unused, void *data __unused, |
| size_t datalen __unused, 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*)); |
| } |
| |
| static void requestCdmaGetRoamingPreference(int request __unused, void *data __unused, |
| size_t datalen __unused, 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 __unused, void *data, |
| size_t datalen __unused, 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; |
| |
| /* Ok you have to be careful here |
| * The solicited version of the CREG response is |
| * +CREG: n, stat, [lac, cid] |
| * and the unsolicited version is |
| * +CREG: stat, [lac, cid] |
| * The <n> parameter is basically "is unsolicited creg on?" |
| * which it should always be |
| * |
| * Now we should normally get the solicited version here, |
| * but the unsolicited version could have snuck in |
| * so we have to handle both |
| * |
| * Also since the LAC and CID are only reported when registered, |
| * we can have 1, 2, 3, or 4 arguments here |
| * |
| * finally, a +CGREG: answer may have a fifth value that corresponds |
| * to the network type, as in; |
| * |
| * +CGREG: n, stat [,lac, cid [,networkType]] |
| */ |
| |
| /* count number of commas */ |
| commas = 0; |
| for (p = line ; *p != '\0' ;p++) { |
| 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, &resp[0]); |
| if (err < 0) goto error; |
| 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, &resp[0]); |
| if (err < 0) goto error; |
| resp[1] = -1; |
| resp[2] = -1; |
| if (err < 0) goto error; |
| break; |
| |
| case 2: /* +CREG: <stat>, <lac>, <cid> */ |
| err = at_tok_nextint(&line, &resp[0]); |
| if (err < 0) goto error; |
| err = at_tok_nexthexint(&line, &resp[1]); |
| if (err < 0) goto error; |
| 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, &resp[0]); |
| if (err < 0) goto error; |
| err = at_tok_nexthexint(&line, &resp[1]); |
| if (err < 0) goto error; |
| err = at_tok_nexthexint(&line, &resp[2]); |
| if (err < 0) goto error; |
| break; |
| /* special case for CGREG, there is a fourth parameter |
| * that is the network type (unknown/gprs/edge/umts) |
| */ |
| case 4: /* +CGREG: <n>, <stat>, <lac>, <cid>, <networkType> */ |
| err = at_tok_nextint(&line, &skip); |
| if (err < 0) goto error; |
| err = at_tok_nextint(&line, &resp[0]); |
| if (err < 0) goto error; |
| err = at_tok_nexthexint(&line, &resp[1]); |
| if (err < 0) goto error; |
| err = at_tok_nexthexint(&line, &resp[2]); |
| if (err < 0) goto error; |
| 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; |
| } |
| |
| #define REG_STATE_LEN 15 |
| #define REG_DATA_STATE_LEN 6 |
| static void requestRegistrationState(int request, void *data __unused, |
| size_t datalen __unused, 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; |
| |
| 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; |
| } |
| |
| 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: |
| 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); |
| } |
| |
| static void requestOperator(void *data __unused, size_t datalen __unused, RIL_Token t) |
| { |
| int err; |
| int i; |
| int skip; |
| ATLine *p_cur; |
| char *response[3]; |
| |
| memset(response, 0, sizeof(response)); |
| |
| ATResponse *p_response = NULL; |
| |
| err = at_send_command_multiline( |
| "AT+COPS=3,0;+COPS?;+COPS=3,1;+COPS?;+COPS=3,2;+COPS?", |
| "+COPS:", &p_response); |
| |
| /* we expect 3 lines here: |
| * +COPS: 0,0,"T - Mobile" |
| * +COPS: 0,1,"TMO" |
| * +COPS: 0,2,"310170" |
| */ |
| |
| if (err != 0) goto error; |
| |
| for (i = 0, p_cur = p_response->p_intermediates |
| ; p_cur != NULL |
| ; p_cur = p_cur->p_next, i++ |
| ) { |
| char *line = p_cur->line; |
| |
| err = at_tok_start(&line); |
| if (err < 0) goto error; |
| |
| err = at_tok_nextint(&line, &skip); |
| if (err < 0) goto error; |
| |
| // If we're unregistered, we may just get |
| // a "+COPS: 0" response |
| if (!at_tok_hasmore(&line)) { |
| response[i] = NULL; |
| continue; |
| } |
| |
| err = at_tok_nextint(&line, &skip); |
| if (err < 0) goto error; |
| |
| // a "+COPS: 0, n" response is also possible |
| if (!at_tok_hasmore(&line)) { |
| response[i] = NULL; |
| continue; |
| } |
| |
| 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) { |
| /* expect 3 lines exactly */ |
| goto error; |
| } |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response)); |
| at_response_free(p_response); |
| |
| return; |
| error: |
| 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; |
| |
| if (getSIMStatus() == SIM_ABSENT) { |
| RIL_onRequestComplete(t, RIL_E_SIM_ABSENT, NULL, 0); |
| return; |
| } |
| |
| RLOGD("requestCdmaSendSMS datalen=%zu, sizeof(RIL_CDMA_SMS_Message)=%zu", |
| 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; |
| const char *smsc; |
| const char *pdu; |
| int tpLayerLength; |
| char *cmd1, *cmd2; |
| RIL_SMS_Response response; |
| ATResponse *p_response = NULL; |
| |
| if (getSIMStatus() == SIM_ABSENT) { |
| RIL_onRequestComplete(t, RIL_E_SIM_ABSENT, NULL, 0); |
| return; |
| } |
| |
| memset(&response, 0, sizeof(response)); |
| RLOGD("requestSendSMS datalen =%zu", 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]; |
| |
| tpLayerLength = strlen(pdu)/2; |
| |
| // "NULL for default SMSC" |
| if (smsc == NULL) { |
| smsc= "00"; |
| } |
| |
| asprintf(&cmd1, "AT+CMGS=%d", tpLayerLength); |
| asprintf(&cmd2, "%s%s", smsc, pdu); |
| |
| err = at_send_command_sms(cmd1, cmd2, "+CMGS:", &p_response); |
| |
| free(cmd1); |
| free(cmd2); |
| |
| if (err != 0 || p_response->success == 0) goto error; |
| |
| /* 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: |
| 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)); |
| |
| RLOGD("requestImsSendSMS: datalen=%zu, " |
| "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 { |
| RLOGE("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 requestSimOpenChannel(void *data, size_t datalen, RIL_Token t) |
| { |
| ATResponse *p_response = NULL; |
| int32_t session_id; |
| int err; |
| char cmd[32]; |
| char dummy; |
| char *line; |
| |
| // Max length is 16 bytes according to 3GPP spec 27.007 section 8.45 |
| if (data == NULL || datalen == 0 || datalen > 16) { |
| ALOGE("Invalid data passed to requestSimOpenChannel"); |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| return; |
| } |
| |
| snprintf(cmd, sizeof(cmd), "AT+CCHO=%s", (char*) data); |
| |
| err = at_send_command_numeric(cmd, &p_response); |
| if (err < 0 || p_response == NULL || p_response->success == 0) { |
| ALOGE("Error %d opening logical channel: %d", |
| err, p_response ? p_response->success : 0); |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| at_response_free(p_response); |
| return; |
| } |
| |
| // Ensure integer only by scanning for an extra char but expect one result |
| line = p_response->p_intermediates->line; |
| if (sscanf(line, "%" SCNd32 "%c", &session_id, &dummy) != 1) { |
| ALOGE("Invalid AT response, expected integer, was '%s'", line); |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| return; |
| } |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, &session_id, sizeof(&session_id)); |
| at_response_free(p_response); |
| } |
| |
| static void requestSimCloseChannel(void *data, size_t datalen, RIL_Token t) |
| { |
| ATResponse *p_response = NULL; |
| int32_t session_id; |
| int err; |
| char cmd[32]; |
| |
| if (data == NULL || datalen != sizeof(session_id)) { |
| ALOGE("Invalid data passed to requestSimCloseChannel"); |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| return; |
| } |
| session_id = ((int32_t *)data)[0]; |
| snprintf(cmd, sizeof(cmd), "AT+CCHC=%" PRId32, session_id); |
| err = at_send_command_singleline(cmd, "+CCHC", &p_response); |
| |
| if (err < 0 || p_response == NULL || p_response->success == 0) { |
| ALOGE("Error %d closing logical channel %d: %d", |
| err, session_id, p_response ? p_response->success : 0); |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| at_response_free(p_response); |
| return; |
| } |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| |
| at_response_free(p_response); |
| } |
| |
| static void requestSimTransmitApduChannel(void *data, |
| size_t datalen, |
| RIL_Token t) |
| { |
| ATResponse *p_response = NULL; |
| int err; |
| char *cmd; |
| char *line; |
| size_t cmd_size; |
| RIL_SIM_IO_Response sim_response; |
| RIL_SIM_APDU *apdu = (RIL_SIM_APDU *)data; |
| |
| if (apdu == NULL || datalen != sizeof(RIL_SIM_APDU)) { |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| return; |
| } |
| |
| cmd_size = 10 + (apdu->data ? strlen(apdu->data) : 0); |
| asprintf(&cmd, "AT+CGLA=%d,%zu,%02x%02x%02x%02x%02x%s", |
| apdu->sessionid, cmd_size, apdu->cla, apdu->instruction, |
| apdu->p1, apdu->p2, apdu->p3, apdu->data ? apdu->data : ""); |
| |
| err = at_send_command_singleline(cmd, "+CGLA", &p_response); |
| free(cmd); |
| if (err < 0 || p_response == NULL || p_response->success == 0) { |
| ALOGE("Error %d transmitting APDU: %d", |
| err, p_response ? p_response->success : 0); |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| at_response_free(p_response); |
| return; |
| } |
| |
| line = p_response->p_intermediates->line; |
| err = parseSimResponseLine(line, &sim_response); |
| |
| if (err == 0) { |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, |
| &sim_response, sizeof(sim_response)); |
| } else { |
| ALOGE("Error %d parsing SIM response line: %s", err, line); |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| } |
| at_response_free(p_response); |
| } |
| |
| static void requestSetupDataCall(void *data, size_t datalen, RIL_Token t) |
| { |
| const char *apn; |
| char *cmd; |
| int err; |
| ATResponse *p_response = NULL; |
| |
| apn = ((const char **)data)[2]; |
| |
| #ifdef USE_TI_COMMANDS |
| // Config for multislot class 10 (probably default anyway eh?) |
| err = at_send_command("AT%CPRIM=\"GMM\",\"CONFIG MULTISLOT_CLASS=<10>\"", |
| NULL); |
| |
| err = at_send_command("AT%DATA=2,\"UART\",1,,\"SER\",\"UART\",0", NULL); |
| #endif /* USE_TI_COMMANDS */ |
| |
| int fd, qmistatus; |
| size_t cur = 0; |
| size_t len; |
| ssize_t written, rlen; |
| char status[32] = {0}; |
| int retry = 10; |
| const char *pdp_type; |
| |
| 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 */ |
| |
| RLOGD("opened the qmi device\n"); |
| asprintf(&cmd, "up:%s", apn); |
| len = strlen(cmd); |
| |
| while (cur < len) { |
| do { |
| written = write (fd, cmd + cur, len - cur); |
| } while (written < 0 && errno == EINTR); |
| |
| if (written < 0) { |
| RLOGE("### ERROR writing to /dev/qmi"); |
| close(fd); |
| goto error; |
| } |
| |
| cur += written; |
| } |
| |
| // wait for interface to come online |
| |
| do { |
| sleep(1); |
| do { |
| rlen = read(fd, status, 31); |
| } while (rlen < 0 && errno == EINTR); |
| |
| if (rlen < 0) { |
| RLOGE("### ERROR reading from /dev/qmi"); |
| close(fd); |
| goto error; |
| } else { |
| status[rlen] = '\0'; |
| RLOGD("### status: %s", status); |
| } |
| } while (strncmp(status, "STATE=up", 8) && strcmp(status, "online") && --retry); |
| |
| close(fd); |
| |
| if (retry == 0) { |
| RLOGE("### Failed to get data connection up\n"); |
| goto error; |
| } |
| |
| qmistatus = system("netcfg rmnet0 dhcp"); |
| |
| RLOGD("netcfg rmnet0 dhcp: status %d\n", qmistatus); |
| |
| if (qmistatus < 0) goto error; |
| |
| } else { |
| bool hasWifi = hasWifiCapability(); |
| const char* radioInterfaceName = getRadioInterfaceName(hasWifi); |
| if (setInterfaceState(radioInterfaceName, kInterfaceUp) != RIL_E_SUCCESS) { |
| goto error; |
| } |
| |
| if (datalen > 6 * sizeof(char *)) { |
| pdp_type = ((const char **)data)[6]; |
| } else { |
| pdp_type = "IP"; |
| } |
| |
| asprintf(&cmd, "AT+CGDCONT=1,\"%s\",\"%s\",,0,0", pdp_type, apn); |
| //FIXME check for error here |
| err = at_send_command(cmd, NULL); |
| free(cmd); |
| |
| // Set required QoS params to default |
| err = at_send_command("AT+CGQREQ=1", NULL); |
| |
| // Set minimum QoS params to default |
| err = at_send_command("AT+CGQMIN=1", NULL); |
| |
| // packet-domain event reporting |
| err = at_send_command("AT+CGEREP=1,0", NULL); |
| |
| // Hangup anything that's happening there now |
| err = at_send_command("AT+CGACT=1,0", NULL); |
| |
| // Start data on PDP context 1 |
| err = at_send_command("ATD*99***1#", &p_response); |
| |
| if (err < 0 || p_response->success == 0) { |
| goto error; |
| } |
| } |
| |
| requestOrSendDataCallList(&t); |
| |
| at_response_free(p_response); |
| |
| return; |
| error: |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| at_response_free(p_response); |
| |
| } |
| |
| static void requestDeactivateDataCall(RIL_Token t) |
| { |
| bool hasWifi = hasWifiCapability(); |
| const char* radioInterfaceName = getRadioInterfaceName(hasWifi); |
| RIL_Errno rilErrno = setInterfaceState(radioInterfaceName, kInterfaceDown); |
| RIL_onRequestComplete(t, rilErrno, NULL, 0); |
| } |
| |
| static void requestSMSAcknowledge(void *data, size_t datalen __unused, RIL_Token t) |
| { |
| int ackSuccess; |
| int err; |
| |
| if (getSIMStatus() == SIM_ABSENT) { |
| RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); |
| return; |
| } |
| |
| ackSuccess = ((int *)data)[0]; |
| |
| if (ackSuccess == 1) { |
| err = at_send_command("AT+CNMA=1", NULL); |
| } else if (ackSuccess == 0) { |
| err = at_send_command("AT+CNMA=2", NULL); |
| } else { |
| RLOGE("unsupported arg to RIL_REQUEST_SMS_ACKNOWLEDGE\n"); |
| goto error; |
| } |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| error: |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| |
| } |
| |
| static void requestSIM_IO(void *data, size_t datalen __unused, RIL_Token t) |
| { |
| ATResponse *p_response = NULL; |
| RIL_SIM_IO_Response sr; |
| int err; |
| char *cmd = NULL; |
| RIL_SIM_IO_v6 *p_args; |
| char *line; |
| |
| memset(&sr, 0, sizeof(sr)); |
| |
| p_args = (RIL_SIM_IO_v6 *)data; |
| |
| /* FIXME handle pin2 */ |
| |
| if (p_args->data == NULL) { |
| asprintf(&cmd, "AT+CRSM=%d,%d,%d,%d,%d", |
| p_args->command, p_args->fileid, |
| p_args->p1, p_args->p2, p_args->p3); |
| } else { |
| asprintf(&cmd, "AT+CRSM=%d,%d,%d,%d,%d,%s", |
| p_args->command, p_args->fileid, |
| p_args->p1, p_args->p2, p_args->p3, p_args->data); |
| } |
| |
| err = at_send_command_singleline(cmd, "+CRSM:", &p_response); |
| |
| if (err < 0 || p_response->success == 0) { |
| goto error; |
| } |
| |
| line = p_response->p_intermediates->line; |
| |
| err = parseSimResponseLine(line, &sr); |
| if (err < 0) { |
| goto error; |
| } |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, &sr, sizeof(sr)); |
| at_response_free(p_response); |
| free(cmd); |
| |
| return; |
| error: |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| at_response_free(p_response); |
| free(cmd); |
| |
| } |
| |
| static void requestEnterSimPin(void* data, size_t datalen, RIL_Token t) |
| { |
| ATResponse *p_response = NULL; |
| int err; |
| char* cmd = NULL; |
| const char** strings = (const char**)data;; |
| |
| if ( datalen == sizeof(char*) ) { |
| asprintf(&cmd, "AT+CPIN=%s", strings[0]); |
| } else if ( datalen == 2*sizeof(char*) ) { |
| asprintf(&cmd, "AT+CPIN=%s,%s", strings[0], strings[1]); |
| } else |
| goto error; |
| |
| 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 __unused, 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 __unused, size_t datalen __unused, 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) { |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| return; |
| } |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| } |
| |
| // TODO: Use all radio types |
| static int techFromModemType(int mdmtype) |
| { |
| 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; |
| } |
| |
| static void requestGetCellInfoList(void *data __unused, size_t datalen __unused, RIL_Token t) |
| { |
| uint64_t curTime = ril_nano_time(); |
| RIL_CellInfo_v12 ci[1] = |
| { |
| { // ci[0] |
| 1, // cellInfoType |
| 1, // registered |
| RIL_TIMESTAMP_TYPE_MODEM, |
| 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, //arfcn unknown |
| 0xFF, // bsic unknown |
| }, |
| { // gsm.signalStrengthGsm |
| 10, // signalStrength |
| 0 // bitErrorRate |
| , INT_MAX // timingAdvance invalid value |
| } |
| } |
| } |
| } |
| }; |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, ci, sizeof(ci)); |
| } |
| |
| |
| static void requestSetCellInfoListRate(void *data, size_t datalen __unused, 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); |
| } |
| |
| static void requestGetHardwareConfig(void *data, size_t datalen, RIL_Token t) |
| { |
| // TODO - hook this up with real query/info from radio. |
| |
| RIL_HardwareConfig hwCfg; |
| |
| RIL_UNUSED_PARM(data); |
| RIL_UNUSED_PARM(datalen); |
| |
| hwCfg.type = -1; |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, &hwCfg, sizeof(hwCfg)); |
| } |
| |
| static void requestGetTtyMode(void *data, size_t datalen, RIL_Token t) |
| { |
| int ttyModeResponse; |
| |
| RIL_UNUSED_PARM(data); |
| RIL_UNUSED_PARM(datalen); |
| |
| ttyModeResponse = (getSIMStatus() == SIM_READY) ? 1 // TTY Full |
| : 0; // TTY Off |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, &ttyModeResponse, sizeof(ttyModeResponse)); |
| } |
| |
| static void requestGetRadioCapability(void *data, size_t datalen, RIL_Token t) |
| { |
| RIL_RadioCapability radioCapability; |
| |
| RIL_UNUSED_PARM(data); |
| RIL_UNUSED_PARM(datalen); |
| |
| radioCapability.version = RIL_RADIO_CAPABILITY_VERSION; |
| radioCapability.session = 0; |
| radioCapability.phase = 0; |
| radioCapability.rat = 0; |
| radioCapability.logicalModemUuid[0] = '\0'; |
| radioCapability.status = RC_STATUS_SUCCESS; |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, &radioCapability, sizeof(radioCapability)); |
| } |
| |
| static void requestGetMute(void *data, size_t datalen, RIL_Token t) |
| { |
| int muteResponse; |
| |
| RIL_UNUSED_PARM(data); |
| RIL_UNUSED_PARM(datalen); |
| |
| muteResponse = 0; // Mute disabled |
| |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, &muteResponse, sizeof(muteResponse)); |
| } |
| |
| /*** Callback methods from the RIL library to us ***/ |
| |
| /** |
| * Call from RIL to us to make a RIL_REQUEST |
| * |
| * Must be completed with a call to RIL_onRequestComplete() |
| * |
| * RIL_onRequestComplete() may be called from any thread, before or after |
| * this function returns. |
| * |
| * Because onRequest function could be called from multiple different thread, |
| * we must ensure that the underlying at_send_command_* function |
| * is atomic. |
| */ |
| static void |
| onRequest (int request, void *data, size_t datalen, RIL_Token t) |
| { |
| ATResponse *p_response; |
| int err; |
| |
| RLOGD("onRequest: %s", requestToString(request)); |
| |
| /* Ignore all requests except RIL_REQUEST_GET_SIM_STATUS |
| * when RADIO_STATE_UNAVAILABLE. |
| */ |
| if (sState == RADIO_STATE_UNAVAILABLE |
| && request != RIL_REQUEST_GET_SIM_STATUS |
| ) { |
| RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); |
| return; |
| } |
| |
| /* Ignore all non-power requests when RADIO_STATE_OFF |
| * (except RIL_REQUEST_GET_SIM_STATUS) |
| */ |
| if (sState == RADIO_STATE_OFF) { |
| switch(request) { |
| case RIL_REQUEST_BASEBAND_VERSION: |
| case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: |
| case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE: |
| case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE: |
| case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE: |
| case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE: |
| case RIL_REQUEST_CDMA_SUBSCRIPTION: |
| case RIL_REQUEST_DEVICE_IDENTITY: |
| case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: |
| case RIL_REQUEST_GET_ACTIVITY_INFO: |
| case RIL_REQUEST_GET_CARRIER_RESTRICTIONS: |
| case RIL_REQUEST_GET_CURRENT_CALLS: |
| case RIL_REQUEST_GET_IMEI: |
| case RIL_REQUEST_GET_MUTE: |
| case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: |
| case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: |
| case RIL_REQUEST_GET_RADIO_CAPABILITY: |
| case RIL_REQUEST_GET_SIM_STATUS: |
| case RIL_REQUEST_NV_RESET_CONFIG: |
| case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: |
| case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: |
| case RIL_REQUEST_QUERY_TTY_MODE: |
| case RIL_REQUEST_RADIO_POWER: |
| case RIL_REQUEST_SET_BAND_MODE: |
| case RIL_REQUEST_SET_CARRIER_RESTRICTIONS: |
| case RIL_REQUEST_SET_LOCATION_UPDATES: |
| case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: |
| case RIL_REQUEST_SET_TTY_MODE: |
| case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: |
| case RIL_REQUEST_STOP_LCE: |
| case RIL_REQUEST_VOICE_RADIO_TECH: |
| // Process all the above, even though the radio is off |
| break; |
| |
| default: |
| // For all others, say NOT_AVAILABLE because the radio is off |
| RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); |
| return; |
| } |
| } |
| |
| switch (request) { |
| case RIL_REQUEST_GET_SIM_STATUS: { |
| RIL_CardStatus_v6 *p_card_status; |
| char *p_buffer; |
| int buffer_size; |
| |
| int result = getCardStatus(&p_card_status); |
| if (result == RIL_E_SUCCESS) { |
| p_buffer = (char *)p_card_status; |
| buffer_size = sizeof(*p_card_status); |
| } else { |
| p_buffer = NULL; |
| buffer_size = 0; |
| } |
| RIL_onRequestComplete(t, result, p_buffer, buffer_size); |
| freeCardStatus(p_card_status); |
| break; |
| } |
| case RIL_REQUEST_GET_CURRENT_CALLS: |
| requestGetCurrentCalls(data, datalen, t); |
| break; |
| case RIL_REQUEST_DIAL: |
| requestDial(data, datalen, t); |
| break; |
| case RIL_REQUEST_HANGUP: |
| requestHangup(data, datalen, t); |
| break; |
| case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: |
| case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: |
| case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: |
| case RIL_REQUEST_CONFERENCE: |
| case RIL_REQUEST_UDUB: |
| requestCallSelection(data, datalen, t, request); |
| break; |
| case RIL_REQUEST_ANSWER: |
| at_send_command("ATA", NULL); |
| |
| #ifdef WORKAROUND_ERRONEOUS_ANSWER |
| s_expectAnswer = 1; |
| #endif /* WORKAROUND_ERRONEOUS_ANSWER */ |
| |
| if (getSIMStatus() != SIM_READY) { |
| RIL_onRequestComplete(t, RIL_E_MODEM_ERR, NULL, 0); |
| } else { |
| // Success or failure is ignored by the upper layer here. |
| // It will call GET_CURRENT_CALLS and determine success that way. |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| } |
| break; |
| |
| case RIL_REQUEST_SEPARATE_CONNECTION: |
| { |
| char cmd[12]; |
| int party = ((int*)data)[0]; |
| |
| if (getSIMStatus() == SIM_ABSENT) { |
| RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); |
| return; |
| } |
| // Make sure that party is in a valid range. |
| // (Note: The Telephony middle layer imposes a range of 1 to 7. |
| // It's sufficient for us to just make sure it's single digit.) |
| if (party > 0 && party < 10) { |
| sprintf(cmd, "AT+CHLD=2%d", party); |
| at_send_command(cmd, NULL); |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| } else { |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| } |
| } |
| break; |
| |
| case RIL_REQUEST_SIGNAL_STRENGTH: |
| requestSignalStrength(data, datalen, t); |
| break; |
| case RIL_REQUEST_VOICE_REGISTRATION_STATE: |
| case RIL_REQUEST_DATA_REGISTRATION_STATE: |
| requestRegistrationState(request, data, datalen, t); |
| break; |
| case RIL_REQUEST_OPERATOR: |
| requestOperator(data, datalen, t); |
| break; |
| case RIL_REQUEST_RADIO_POWER: |
| requestRadioPower(data, datalen, t); |
| break; |
| case RIL_REQUEST_DTMF: { |
| char c = ((char *)data)[0]; |
| char *cmd; |
| asprintf(&cmd, "AT+VTS=%c", (int)c); |
| at_send_command(cmd, NULL); |
| free(cmd); |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| break; |
| } |
| case RIL_REQUEST_SEND_SMS: |
| case RIL_REQUEST_SEND_SMS_EXPECT_MORE: |
| 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_SIM_OPEN_CHANNEL: |
| requestSimOpenChannel(data, datalen, t); |
| break; |
| case RIL_REQUEST_SIM_CLOSE_CHANNEL: |
| requestSimCloseChannel(data, datalen, t); |
| break; |
| case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: |
| requestSimTransmitApduChannel(data, datalen, t); |
| break; |
| case RIL_REQUEST_SETUP_DATA_CALL: |
| requestSetupDataCall(data, datalen, t); |
| break; |
| case RIL_REQUEST_DEACTIVATE_DATA_CALL: |
| requestDeactivateDataCall(t); |
| break; |
| case RIL_REQUEST_SMS_ACKNOWLEDGE: |
| requestSMSAcknowledge(data, datalen, t); |
| break; |
| |
| case RIL_REQUEST_GET_IMSI: |
| p_response = NULL; |
| err = at_send_command_numeric("AT+CIMI", &p_response); |
| |
| if (err < 0 || p_response->success == 0) { |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| } else { |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, |
| p_response->p_intermediates->line, sizeof(char *)); |
| } |
| at_response_free(p_response); |
| break; |
| |
| case RIL_REQUEST_GET_IMEI: |
| p_response = NULL; |
| 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); |
| } else { |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, |
| p_response->p_intermediates->line, sizeof(char *)); |
| } |
| at_response_free(p_response); |
| break; |
| |
| case RIL_REQUEST_SIM_IO: |
| requestSIM_IO(data,datalen,t); |
| break; |
| |
| case RIL_REQUEST_SEND_USSD: |
| requestSendUSSD(data, datalen, t); |
| break; |
| |
| case RIL_REQUEST_CANCEL_USSD: |
| if (getSIMStatus() == SIM_ABSENT) { |
| RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); |
| return; |
| } |
| p_response = NULL; |
| err = at_send_command_numeric("AT+CUSD=2", &p_response); |
| |
| if (err < 0 || p_response->success == 0) { |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| } else { |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, |
| p_response->p_intermediates->line, sizeof(char *)); |
| } |
| at_response_free(p_response); |
| break; |
| |
| case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: |
| if (getSIMStatus() == SIM_ABSENT) { |
| RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); |
| } else { |
| at_send_command("AT+COPS=0", NULL); |
| } |
| break; |
| |
| case RIL_REQUEST_DATA_CALL_LIST: |
| requestDataCallList(data, datalen, t); |
| break; |
| |
| case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: |
| requestQueryNetworkSelectionMode(data, datalen, t); |
| break; |
| |
| case RIL_REQUEST_OEM_HOOK_RAW: |
| // echo back data |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, data, datalen); |
| break; |
| |
| |
| case RIL_REQUEST_OEM_HOOK_STRINGS: { |
| int i; |
| const char ** cur; |
| |
| RLOGD("got OEM_HOOK_STRINGS: 0x%8p %lu", data, (long)datalen); |
| |
| |
| for (i = (datalen / sizeof (char *)), cur = (const char **)data ; |
| i > 0 ; cur++, i --) { |
| RLOGD("> '%s'", *cur); |
| } |
| |
| // echo back strings |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, data, datalen); |
| break; |
| } |
| |
| case RIL_REQUEST_WRITE_SMS_TO_SIM: |
| requestWriteSmsToSim(data, datalen, t); |
| break; |
| |
| case RIL_REQUEST_DELETE_SMS_ON_SIM: { |
| char * cmd; |
| p_response = NULL; |
| asprintf(&cmd, "AT+CMGD=%d", ((int *)data)[0]); |
| err = at_send_command(cmd, &p_response); |
| free(cmd); |
| if (err < 0 || p_response->success == 0) { |
| RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); |
| } else { |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| } |
| at_response_free(p_response); |
| break; |
| } |
| |
| case RIL_REQUEST_ENTER_SIM_PIN: |
| case RIL_REQUEST_ENTER_SIM_PUK: |
| case RIL_REQUEST_ENTER_SIM_PIN2: |
| case RIL_REQUEST_ENTER_SIM_PUK2: |
| case RIL_REQUEST_CHANGE_SIM_PIN: |
| case RIL_REQUEST_CHANGE_SIM_PIN2: |
| 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; |
| |
| RLOGD("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; |
| |
| case RIL_REQUEST_GET_HARDWARE_CONFIG: |
| requestGetHardwareConfig(data, datalen, t); |
| break; |
| |
| case RIL_REQUEST_SHUTDOWN: |
| requestShutdown(t); |
| break; |
| |
| case RIL_REQUEST_QUERY_TTY_MODE: |
| requestGetTtyMode(data, datalen, t); |
| break; |
| |
| case RIL_REQUEST_GET_RADIO_CAPABILITY: |
| requestGetRadioCapability(data, datalen, t); |
| break; |
| |
| case RIL_REQUEST_GET_MUTE: |
| requestGetMute(data, datalen, t); |
| break; |
| |
| case RIL_REQUEST_SET_INITIAL_ATTACH_APN: |
| case RIL_REQUEST_ALLOW_DATA: |
| case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: |
| case RIL_REQUEST_SET_CLIR: |
| case RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION: |
| case RIL_REQUEST_SET_BAND_MODE: |
| case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: |
| case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: |
| case RIL_REQUEST_SET_LOCATION_UPDATES: |
| case RIL_REQUEST_SET_TTY_MODE: |
| case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE: |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| break; |
| |
| case RIL_REQUEST_BASEBAND_VERSION: |
| requestCdmaBaseBandVersion(request, data, datalen, t); |
| break; |
| |
| case RIL_REQUEST_DEVICE_IDENTITY: |
| requestDeviceIdentity(request, data, datalen, t); |
| break; |
| |
| case RIL_REQUEST_CDMA_SUBSCRIPTION: |
| requestCdmaSubscription(request, data, datalen, t); |
| break; |
| |
| case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: |
| requestCdmaGetSubscriptionSource(request, data, datalen, t); |
| break; |
| |
| case RIL_REQUEST_START_LCE: |
| case RIL_REQUEST_STOP_LCE: |
| case RIL_REQUEST_PULL_LCEDATA: |
| if (getSIMStatus() == SIM_ABSENT) { |
| RIL_onRequestComplete(t, RIL_E_SIM_ABSENT, NULL, 0); |
| } else { |
| RIL_onRequestComplete(t, RIL_E_LCE_NOT_SUPPORTED, NULL, 0); |
| } |
| break; |
| |
| case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE: |
| if (TECH_BIT(sMdmInfo) == MDM_CDMA) { |
| requestCdmaGetRoamingPreference(request, data, datalen, t); |
| } else { |
| RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0); |
| } |
| break; |
| |
| case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE: |
| if (TECH_BIT(sMdmInfo) == MDM_CDMA) { |
| requestCdmaSetSubscriptionSource(request, data, datalen, t); |
| } else { |
| // VTS tests expect us to silently do nothing |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| } |
| break; |
| |
| case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE: |
| if (TECH_BIT(sMdmInfo) == MDM_CDMA) { |
| requestCdmaSetRoamingPreference(request, data, datalen, t); |
| } else { |
| // VTS tests expect us to silently do nothing |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| } |
| break; |
| |
| case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: |
| if (TECH_BIT(sMdmInfo) == MDM_CDMA) { |
| requestExitEmergencyMode(data, datalen, t); |
| } else { |
| // VTS tests expect us to silently do nothing |
| RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); |
| } |
| break; |
| |
| default: |
| RLOGD("Request not supported. Tech: %d",TECH(sMdmInfo)); |
| RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0); |
| break; |
| } |
| } |
| |
| /** |
| * Synchronous call from the RIL to us to return current radio state. |
| * RADIO_STATE_UNAVAILABLE should be the initial state. |
| */ |
| static RIL_RadioState |
| currentState() |
| { |
| return sState; |
| } |
| /** |
| * Call from RIL to us to find out whether a specific request code |
| * is supported by this implementation. |
| * |
| * Return 1 for "supported" and 0 for "unsupported" |
| */ |
| |
| static int |
| onSupports (int requestCode __unused) |
| { |
| //@@@ todo |
| |
| return 1; |
| } |
| |
| static void onCancel (RIL_Token t __unused) |
| { |
| //@@@todo |
| |
| } |
| |
| static const char * getVersion(void) |
| { |
| return "android reference-ril 1.0"; |
| } |
| |
| 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); |
| |
| oldState = sState; |
| |
| if (s_closed > 0) { |
| // If we're closed, the only reasonable state is |
| // RADIO_STATE_UNAVAILABLE |
| // This is here because things on the main thread |
| // may attempt to change the radio state after the closed |
| // event happened in another thread |
| newState = RADIO_STATE_UNAVAILABLE; |
| } |
| |
| if (sState != newState || s_closed > 0) { |
| sState = newState; |
| |
| pthread_cond_broadcast (&s_state_cond); |
| } |
| |
| pthread_mutex_unlock(&s_state_mutex); |
| |
| |
| /* do these outside of the mutex */ |
| if (sState != oldState) { |
| RIL_onUnsolicitedResponse (RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED, |
| NULL, 0); |
| // Sim state can change as result of radio state change |
| RIL_onUnsolicitedResponse (RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, |
| NULL, 0); |
| |
| /* FIXME onSimReady() and onRadioPowerOn() cannot be called |
| * from the AT reader thread |
| * Currently, this doesn't happen, but if that changes then these |
| * will need to be dispatched on the request thread |
| */ |
| 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() |
| { |
| ATResponse *p_response = NULL; |
| int err; |
| int ret; |
| char *cpinLine; |
| char *cpinResult; |
| |
| RLOGD("getSIMStatus(). sState: %d",sState); |
| 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 = (sState == RADIO_STATE_ON) ? SIM_READY : SIM_NOT_READY; |
| |
| done: |
| at_response_free(p_response); |
| return ret; |
| } |
| |
| |
| /** |
| * Get the current card status. |
| * |
| * This must be freed using freeCardStatus. |
| * @return: On success returns RIL_E_SUCCESS |
| */ |
| static int getCardStatus(RIL_CardStatus_v6 **pp_card_status) { |
| static RIL_AppStatus app_status_array[] = { |
| // SIM_ABSENT = 0 |
| { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN, |
| NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, |
| // SIM_NOT_READY = 1 |
| { RIL_APPTYPE_USIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN, |
| NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, |
| // SIM_READY = 2 |
| { RIL_APPTYPE_USIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY, |
| NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, |
| // SIM_PIN = 3 |
| { RIL_APPTYPE_USIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN, |
| NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, |
| // SIM_PUK = 4 |
| { RIL_APPTYPE_USIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN, |
| NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN }, |
| // SIM_NETWORK_PERSONALIZATION = 5 |
| { RIL_APPTYPE_USIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK, |
| 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 }, |
| // ISIM_ABSENT = 12 |
| { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN, |
| NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, |
| // ISIM_NOT_READY = 13 |
| { RIL_APPTYPE_ISIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN, |
| NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, |
| // ISIM_READY = 14 |
| { RIL_APPTYPE_ISIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY, |
| NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, |
| // ISIM_PIN = 15 |
| { RIL_APPTYPE_ISIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN, |
| NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, |
| // ISIM_PUK = 16 |
| { RIL_APPTYPE_ISIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN, |
| NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN }, |
| // ISIM_NETWORK_PERSONALIZATION = 17 |
| { RIL_APPTYPE_ISIM, 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; |
| |
| int sim_status = getSIMStatus(); |
| if (sim_status == SIM_ABSENT) { |
| card_state = RIL_CARDSTATE_ABSENT; |
| num_apps = 0; |
| } else { |
| card_state = RIL_CARDSTATE_PRESENT; |
| num_apps = 3; |
| } |
| |
| // Allocate and initialize base card status. |
| RIL_CardStatus_v6 *p_card_status = malloc(sizeof(RIL_CardStatus_v6)); |
| p_card_status->card_state = card_state; |
| p_card_status->universal_pin_state = RIL_PINSTATE_UNKNOWN; |
| p_card_status->gsm_umts_subscription_app_index = -1; |
| p_card_status->cdma_subscription_app_index = -1; |
| p_card_status->ims_subscription_app_index = -1; |
| p_card_status->num_applications = num_apps; |
| |
| // Initialize application status |
| int i; |
| for (i = 0; i < RIL_CARD_MAX_APPS; i++) { |
| p_card_status->applications[i] = app_status_array[SIM_ABSENT]; |
| } |
| |
| // Pickup the appropriate application status |
| // that reflects sim_status for gsm. |
| if (num_apps != 0) { |
| p_card_status->num_applications = 3; |
| p_card_status->gsm_umts_subscription_app_index = 0; |
| p_card_status->cdma_subscription_app_index = 1; |
| p_card_status->ims_subscription_app_index = 2; |
| |
| // 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]; |
| p_card_status->applications[2] = app_status_array[sim_status + ISIM_ABSENT]; |
| } |
| |
| *pp_card_status = p_card_status; |
| return RIL_E_SUCCESS; |
| } |
| |
| /** |
| * Free the card status returned by getCardStatus |
| */ |
| static void freeCardStatus(RIL_CardStatus_v6 *p_card_status) { |
| free(p_card_status); |
| } |
| |
| /** |
| * SIM ready means any commands that access the SIM will work, including: |
| * AT+CPIN, AT+CSMS, AT+CNMI, AT+CRSM |
| * (all SMS-related commands) |
| */ |
| |
| static void pollSIMState (void *param __unused) |
| { |
| ATResponse *p_response; |
| int ret; |
| |
| if (sState != RADIO_STATE_UNAVAILABLE) { |
| // no longer valid to poll |
| return; |
| } |
| |
| switch(getSIMStatus()) { |
| case SIM_ABSENT: |
| case SIM_PIN: |
| case SIM_PUK: |
| case SIM_NETWORK_PERSONALIZATION: |
| default: |
| RLOGI("SIM ABSENT or LOCKED"); |
| RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0); |
| return; |
| |
| case SIM_NOT_READY: |
| RIL_requestTimedCallback (pollSIMState, NULL, &TIMEVAL_SIMPOLL); |
| return; |
| |
| case SIM_READY: |
| RLOGI("SIM_READY"); |
| onSIMReady(); |
| RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0); |
| return; |
| } |
| } |
| |
| /** returns 1 if on, 0 if off, and -1 on error */ |
| static int isRadioOn() |
| { |
| ATResponse *p_response = NULL; |
| int err; |
| char *line; |
| char ret; |
| |
| err = at_send_command_singleline("AT+CFUN?", "+CFUN:", &p_response); |
| |
| if (err < 0 || p_response->success == 0) { |
| // assume radio is off |
| goto error; |
| } |
| |
| line = p_response->p_intermediates->line; |
| |
| err = at_tok_start(&line); |
| if (err < 0) goto error; |
| |
| err = at_tok_nextbool(&line, &ret); |
| if (err < 0) goto error; |
| |
| at_response_free(p_response); |
| |
| return (int)ret; |
| |
| error: |
| |
| at_response_free(p_response); |
| return -1; |
| } |
| |
| /** |
| * 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 __unused, 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 __unused, int *current, int32_t *preferred) |
| { |
| ATResponse *response = NULL; |
| int err; |
| int res; |
| |
| RLOGD("query_ctec. current: %p, preferred: %p", current, 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: %p. status: %d", err, 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 |
| */ |
| static void initializeCallback(void *param __unused) |
| { |
| ATResponse *p_response = NULL; |
| int err; |
| |
| setRadioState (RADIO_STATE_OFF); |
| |
| at_handshake(); |
| |
| probeForModemMode(sMdmInfo); |
| /* 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_ON); |
| } |
| } |
| |
| static void waitForClose() |
| { |
| pthread_mutex_lock(&s_state_mutex); |
| |
| while (s_closed == 0) { |
| pthread_cond_wait(&s_state_cond, &s_state_mutex); |
| } |
| |
| 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 |
| * not be issued here |
| */ |
| static void onUnsolicited (const char *s, const char *sms_pdu) |
| { |
| char *line = NULL, *p; |
| int err; |
| |
| /* Ignore unsolicited responses until we're initialized. |
| * This is OK because the RIL library will poll for initial state |
| */ |
| if (sState == RADIO_STATE_UNAVAILABLE) { |
| return; |
| } |
| |
| if (strStartsWith(s, "%CTZV:")) { |
| /* TI specific -- NITZ time */ |
| char *response; |
| |
| line = p = strdup(s); |
| at_tok_start(&p); |
| |
| err = at_tok_nextstr(&p, &response); |
| |
| if (err != 0) { |
| RLOGE("invalid NITZ line %s\n", s); |
| } else { |
| RIL_onUnsolicitedResponse ( |
| RIL_UNSOL_NITZ_TIME_RECEIVED, |
| response, strlen(response) + 1); |
| } |
| free(line); |
| } else if (strStartsWith(s,"+CRING:") |
| || strStartsWith(s,"RING") |
| || strStartsWith(s,"NO CARRIER") |
| || strStartsWith(s,"+CCWA") |
| ) { |
| RIL_onUnsolicitedResponse ( |
| RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, |
| NULL, 0); |
| #ifdef WORKAROUND_FAKE_CGEV |
| RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); //TODO use new function |
| #endif /* WORKAROUND_FAKE_CGEV */ |
| } else if (strStartsWith(s,"+CREG:") |
| || strStartsWith(s,"+CGREG:") |
| ) { |
| RIL_onUnsolicitedResponse ( |
| RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, |
| NULL, 0); |
| #ifdef WORKAROUND_FAKE_CGEV |
| RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); |
| #endif /* WORKAROUND_FAKE_CGEV */ |
| } else if (strStartsWith(s, "+CMT:")) { |
| RIL_onUnsolicitedResponse ( |
| RIL_UNSOL_RESPONSE_NEW_SMS, |
| sms_pdu, strlen(sms_pdu)); |
| } else if (strStartsWith(s, "+CDS:")) { |
| RIL_onUnsolicitedResponse ( |
| RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT, |
| sms_pdu, strlen(sms_pdu)); |
| } else if (strStartsWith(s, "+CGEV:")) { |
| /* Really, we can ignore NW CLASS and ME CLASS events here, |
| * but right now we don't since extranous |
| * RIL_UNSOL_DATA_CALL_LIST_CHANGED calls are tolerated |
| */ |
| /* can't issue AT commands here -- call on main thread */ |
| RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); |
| #ifdef WORKAROUND_FAKE_CGEV |
| } 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() |
| { |
| RLOGI("AT channel closed\n"); |
| at_close(); |
| s_closed = 1; |
| |
| setRadioState (RADIO_STATE_UNAVAILABLE); |
| } |
| |
| /* 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 to pass hardware configuration information to telephony |
| * framework. |
| */ |
| static void setHardwareConfiguration(int num, RIL_HardwareConfig *cfg) |
| { |
| RIL_onUnsolicitedResponse(RIL_UNSOL_HARDWARE_CONFIG_CHANGED, cfg, num*sizeof(*cfg)); |
| } |
| |
| static void usage(char *s __unused) |
| { |
| #ifdef RIL_SHLIB |
| fprintf(stderr, "reference-ril requires: -p <tcp port> or -d /dev/tty_device\n"); |
| #else |
| fprintf(stderr, "usage: %s [-p <tcp port>] [-d /dev/tty_device]\n", s); |
| exit(-1); |
| #endif |
| } |
| |
| static void * |
| mainLoop(void *param __unused) |
| { |
| int fd; |
| int ret; |
| |
| AT_DUMP("== ", "entering mainLoop()", -1 ); |
| at_set_on_reader_closed(onATReaderClosed); |
| at_set_on_timeout(onATTimeout); |
| |
| for (;;) { |
| fd = -1; |
| while (fd < 0) { |
| if (s_port > 0) { |
| fd = socket_network_client("localhost", s_port, SOCK_STREAM); |
| } else if (s_device_socket) { |
| fd = socket_local_client(s_device_path, |
| ANDROID_SOCKET_NAMESPACE_FILESYSTEM, |
| SOCK_STREAM); |
| } else if (s_device_path != NULL) { |
| fd = open (s_device_path, O_RDWR); |
| if ( fd >= 0 && !memcmp( s_device_path, "/dev/ttyS", 9 ) ) { |
| /* disable echo on serial ports */ |
| struct termios ios; |
| tcgetattr( fd, &ios ); |
| ios.c_lflag = 0; /* disable ECHO, ICANON, etc... */ |
| tcsetattr( fd, TCSANOW, &ios ); |
| } |
| } |
| |
| if (fd < 0) { |
| perror ("opening AT interface. retrying..."); |
| sleep(10); |
| /* never returns */ |
| } |
| } |
| |
| s_closed = 0; |
| ret = at_open(fd, onUnsolicited); |
| |
| if (ret < 0) { |
| RLOGE ("AT error %d on at_open\n", ret); |
| return 0; |
| } |
| |
| RIL_requestTimedCallback(initializeCallback, NULL, &TIMEVAL_0); |
| |
| // Give initializeCallback a chance to dispatched, since |
| // we don't presently have a cancellation mechanism |
| sleep(1); |
| |
| waitForClose(); |
| RLOGI("Re-opening after close"); |
| } |
| } |
| |
| #ifdef RIL_SHLIB |
| |
| pthread_t s_tid_mainloop; |
| |
| const RIL_RadioFunctions *RIL_Init(const struct RIL_Env *env, int argc, char **argv) |
| { |
| int ret; |
| int fd = -1; |
| int opt; |
| pthread_attr_t attr; |
| |
| s_rilenv = env; |
| |
| while ( -1 != (opt = getopt(argc, argv, "p:d:s:c:"))) { |
| switch (opt) { |
| case 'p': |
| s_port = atoi(optarg); |
| if (s_port == 0) { |
| usage(argv[0]); |
| return NULL; |
| } |
| RLOGI("Opening loopback port %d\n", s_port); |
| break; |
| |
| case 'd': |
| s_device_path = optarg; |
| RLOGI("Opening tty device %s\n", s_device_path); |
| break; |
| |
| case 's': |
| s_device_path = optarg; |
| s_device_socket = 1; |
| RLOGI("Opening socket %s\n", s_device_path); |
| break; |
| |
| case 'c': |
| RLOGI("Client id received %s\n", optarg); |
| break; |
| |
| default: |
| usage(argv[0]); |
| return NULL; |
| } |
| } |
| |
| if (s_port < 0 && s_device_path == NULL) { |
| usage(argv[0]); |
| 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); |
| |
| return &s_callbacks; |
| } |
| #else /* RIL_SHLIB */ |
| int main (int argc, char **argv) |
| { |
| int ret; |
| int fd = -1; |
| int opt; |
| |
| while ( -1 != (opt = getopt(argc, argv, "p:d:"))) { |
| switch (opt) { |
| case 'p': |
| s_port = atoi(optarg); |
| if (s_port == 0) { |
| usage(argv[0]); |
| } |
| RLOGI("Opening loopback port %d\n", s_port); |
| break; |
| |
| case 'd': |
| s_device_path = optarg; |
| RLOGI("Opening tty device %s\n", s_device_path); |
| break; |
| |
| case 's': |
| s_device_path = optarg; |
| s_device_socket = 1; |
| RLOGI("Opening socket %s\n", s_device_path); |
| break; |
| |
| default: |
| usage(argv[0]); |
| } |
| } |
| |
| if (s_port < 0 && s_device_path == NULL) { |
| usage(argv[0]); |
| } |
| |
| RIL_register(&s_callbacks); |
| |
| mainLoop(NULL); |
| |
| return 0; |
| } |
| |
| #endif /* RIL_SHLIB */ |
