1 /* //device/system/reference-ril/reference-ril.c 2 ** 3 ** Copyright 2006, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 #include <telephony/ril_cdma_sms.h> 19 #include <telephony/librilutils.h> 20 #include <stdio.h> 21 #include <assert.h> 22 #include <string.h> 23 #include <errno.h> 24 #include <unistd.h> 25 #include <sys/cdefs.h> 26 #include <sys/types.h> 27 #include <sys/stat.h> 28 #include <fcntl.h> 29 #include <pthread.h> 30 #include <alloca.h> 31 #include "atchannel.h" 32 #include "at_tok.h" 33 #include "misc.h" 34 #include <getopt.h> 35 #include <sys/socket.h> 36 #include <cutils/sockets.h> 37 #include <termios.h> 38 #include <sys/system_properties.h> 39 40 #include "ril.h" 41 #include "hardware/qemu_pipe.h" 42 43 #define LOG_TAG "RIL" 44 #include <utils/Log.h> 45 46 static void *noopRemoveWarning( void *a ) { return a; } 47 #define RIL_UNUSED_PARM(a) noopRemoveWarning((void *)&(a)); 48 49 #define MAX_AT_RESPONSE 0x1000 50 51 /* pathname returned from RIL_REQUEST_SETUP_DATA_CALL / RIL_REQUEST_SETUP_DEFAULT_PDP */ 52 #define PPP_TTY_PATH "eth0" 53 54 // Default MTU value 55 #define DEFAULT_MTU 1500 56 57 #ifdef USE_TI_COMMANDS 58 59 // Enable a workaround 60 // 1) Make incoming call, do not answer 61 // 2) Hangup remote end 62 // Expected: call should disappear from CLCC line 63 // Actual: Call shows as "ACTIVE" before disappearing 64 #define WORKAROUND_ERRONEOUS_ANSWER 1 65 66 // Some varients of the TI stack do not support the +CGEV unsolicited 67 // response. However, they seem to send an unsolicited +CME ERROR: 150 68 #define WORKAROUND_FAKE_CGEV 1 69 #endif 70 71 /* Modem Technology bits */ 72 #define MDM_GSM 0x01 73 #define MDM_WCDMA 0x02 74 #define MDM_CDMA 0x04 75 #define MDM_EVDO 0x08 76 #define MDM_LTE 0x10 77 78 typedef struct { 79 int supportedTechs; // Bitmask of supported Modem Technology bits 80 int currentTech; // Technology the modem is currently using (in the format used by modem) 81 int isMultimode; 82 83 // Preferred mode bitmask. This is actually 4 byte-sized bitmasks with different priority values, 84 // in which the byte number from LSB to MSB give the priority. 85 // 86 // |MSB| | |LSB 87 // value: |00 |00 |00 |00 88 // byte #: |3 |2 |1 |0 89 // 90 // Higher byte order give higher priority. Thus, a value of 0x0000000f represents 91 // a preferred mode of GSM, WCDMA, CDMA, and EvDo in which all are equally preferrable, whereas 92 // 0x00000201 represents a mode with GSM and WCDMA, in which WCDMA is preferred over GSM 93 int32_t preferredNetworkMode; 94 int subscription_source; 95 96 } ModemInfo; 97 98 static ModemInfo *sMdmInfo; 99 // TECH returns the current technology in the format used by the modem. 100 // It can be used as an l-value 101 #define TECH(mdminfo) ((mdminfo)->currentTech) 102 // TECH_BIT returns the bitmask equivalent of the current tech 103 #define TECH_BIT(mdminfo) (1 << ((mdminfo)->currentTech)) 104 #define IS_MULTIMODE(mdminfo) ((mdminfo)->isMultimode) 105 #define TECH_SUPPORTED(mdminfo, tech) ((mdminfo)->supportedTechs & (tech)) 106 #define PREFERRED_NETWORK(mdminfo) ((mdminfo)->preferredNetworkMode) 107 // CDMA Subscription Source 108 #define SSOURCE(mdminfo) ((mdminfo)->subscription_source) 109 110 static int net2modem[] = { 111 MDM_GSM | MDM_WCDMA, // 0 - GSM / WCDMA Pref 112 MDM_GSM, // 1 - GSM only 113 MDM_WCDMA, // 2 - WCDMA only 114 MDM_GSM | MDM_WCDMA, // 3 - GSM / WCDMA Auto 115 MDM_CDMA | MDM_EVDO, // 4 - CDMA / EvDo Auto 116 MDM_CDMA, // 5 - CDMA only 117 MDM_EVDO, // 6 - EvDo only 118 MDM_GSM | MDM_WCDMA | MDM_CDMA | MDM_EVDO, // 7 - GSM/WCDMA, CDMA, EvDo 119 MDM_LTE | MDM_CDMA | MDM_EVDO, // 8 - LTE, CDMA and EvDo 120 MDM_LTE | MDM_GSM | MDM_WCDMA, // 9 - LTE, GSM/WCDMA 121 MDM_LTE | MDM_CDMA | MDM_EVDO | MDM_GSM | MDM_WCDMA, // 10 - LTE, CDMA, EvDo, GSM/WCDMA 122 MDM_LTE, // 11 - LTE only 123 }; 124 125 static int32_t net2pmask[] = { 126 MDM_GSM | (MDM_WCDMA << 8), // 0 - GSM / WCDMA Pref 127 MDM_GSM, // 1 - GSM only 128 MDM_WCDMA, // 2 - WCDMA only 129 MDM_GSM | MDM_WCDMA, // 3 - GSM / WCDMA Auto 130 MDM_CDMA | MDM_EVDO, // 4 - CDMA / EvDo Auto 131 MDM_CDMA, // 5 - CDMA only 132 MDM_EVDO, // 6 - EvDo only 133 MDM_GSM | MDM_WCDMA | MDM_CDMA | MDM_EVDO, // 7 - GSM/WCDMA, CDMA, EvDo 134 MDM_LTE | MDM_CDMA | MDM_EVDO, // 8 - LTE, CDMA and EvDo 135 MDM_LTE | MDM_GSM | MDM_WCDMA, // 9 - LTE, GSM/WCDMA 136 MDM_LTE | MDM_CDMA | MDM_EVDO | MDM_GSM | MDM_WCDMA, // 10 - LTE, CDMA, EvDo, GSM/WCDMA 137 MDM_LTE, // 11 - LTE only 138 }; 139 140 static int is3gpp2(int radioTech) { 141 switch (radioTech) { 142 case RADIO_TECH_IS95A: 143 case RADIO_TECH_IS95B: 144 case RADIO_TECH_1xRTT: 145 case RADIO_TECH_EVDO_0: 146 case RADIO_TECH_EVDO_A: 147 case RADIO_TECH_EVDO_B: 148 case RADIO_TECH_EHRPD: 149 return 1; 150 default: 151 return 0; 152 } 153 } 154 155 typedef enum { 156 SIM_ABSENT = 0, 157 SIM_NOT_READY = 1, 158 SIM_READY = 2, /* SIM_READY means the radio state is RADIO_STATE_SIM_READY */ 159 SIM_PIN = 3, 160 SIM_PUK = 4, 161 SIM_NETWORK_PERSONALIZATION = 5, 162 RUIM_ABSENT = 6, 163 RUIM_NOT_READY = 7, 164 RUIM_READY = 8, 165 RUIM_PIN = 9, 166 RUIM_PUK = 10, 167 RUIM_NETWORK_PERSONALIZATION = 11 168 } SIM_Status; 169 170 static void onRequest (int request, void *data, size_t datalen, RIL_Token t); 171 static RIL_RadioState currentState(); 172 static int onSupports (int requestCode); 173 static void onCancel (RIL_Token t); 174 static const char *getVersion(); 175 static int isRadioOn(); 176 static SIM_Status getSIMStatus(); 177 static int getCardStatus(RIL_CardStatus_v6 **pp_card_status); 178 static void freeCardStatus(RIL_CardStatus_v6 *p_card_status); 179 static void onDataCallListChanged(void *param); 180 181 extern const char * requestToString(int request); 182 183 /*** Static Variables ***/ 184 static const RIL_RadioFunctions s_callbacks = { 185 RIL_VERSION, 186 onRequest, 187 currentState, 188 onSupports, 189 onCancel, 190 getVersion 191 }; 192 193 #ifdef RIL_SHLIB 194 static const struct RIL_Env *s_rilenv; 195 196 #define RIL_onRequestComplete(t, e, response, responselen) s_rilenv->OnRequestComplete(t,e, response, responselen) 197 #define RIL_onUnsolicitedResponse(a,b,c) s_rilenv->OnUnsolicitedResponse(a,b,c) 198 #define RIL_requestTimedCallback(a,b,c) s_rilenv->RequestTimedCallback(a,b,c) 199 #endif 200 201 static RIL_RadioState sState = RADIO_STATE_UNAVAILABLE; 202 203 static pthread_mutex_t s_state_mutex = PTHREAD_MUTEX_INITIALIZER; 204 static pthread_cond_t s_state_cond = PTHREAD_COND_INITIALIZER; 205 206 static int s_port = -1; 207 static const char * s_device_path = NULL; 208 static int s_device_socket = 0; 209 210 /* trigger change to this with s_state_cond */ 211 static int s_closed = 0; 212 213 static int sFD; /* file desc of AT channel */ 214 static char sATBuffer[MAX_AT_RESPONSE+1]; 215 static char *sATBufferCur = NULL; 216 217 static const struct timeval TIMEVAL_SIMPOLL = {1,0}; 218 static const struct timeval TIMEVAL_CALLSTATEPOLL = {0,500000}; 219 static const struct timeval TIMEVAL_0 = {0,0}; 220 221 static int s_ims_registered = 0; // 0==unregistered 222 static int s_ims_services = 1; // & 0x1 == sms over ims supported 223 static int s_ims_format = 1; // FORMAT_3GPP(1) vs FORMAT_3GPP2(2); 224 static int s_ims_cause_retry = 0; // 1==causes sms over ims to temp fail 225 static int s_ims_cause_perm_failure = 0; // 1==causes sms over ims to permanent fail 226 static int s_ims_gsm_retry = 0; // 1==causes sms over gsm to temp fail 227 static int s_ims_gsm_fail = 0; // 1==causes sms over gsm to permanent fail 228 229 #ifdef WORKAROUND_ERRONEOUS_ANSWER 230 // Max number of times we'll try to repoll when we think 231 // we have a AT+CLCC race condition 232 #define REPOLL_CALLS_COUNT_MAX 4 233 234 // Line index that was incoming or waiting at last poll, or -1 for none 235 static int s_incomingOrWaitingLine = -1; 236 // Number of times we've asked for a repoll of AT+CLCC 237 static int s_repollCallsCount = 0; 238 // Should we expect a call to be answered in the next CLCC? 239 static int s_expectAnswer = 0; 240 #endif /* WORKAROUND_ERRONEOUS_ANSWER */ 241 242 static int s_cell_info_rate_ms = INT_MAX; 243 static int s_mcc = 0; 244 static int s_mnc = 0; 245 static int s_lac = 0; 246 static int s_cid = 0; 247 248 static void pollSIMState (void *param); 249 static void setRadioState(RIL_RadioState newState); 250 static void setRadioTechnology(ModemInfo *mdm, int newtech); 251 static int query_ctec(ModemInfo *mdm, int *current, int32_t *preferred); 252 static int parse_technology_response(const char *response, int *current, int32_t *preferred); 253 static int techFromModemType(int mdmtype); 254 255 static int clccStateToRILState(int state, RIL_CallState *p_state) 256 257 { 258 switch(state) { 259 case 0: *p_state = RIL_CALL_ACTIVE; return 0; 260 case 1: *p_state = RIL_CALL_HOLDING; return 0; 261 case 2: *p_state = RIL_CALL_DIALING; return 0; 262 case 3: *p_state = RIL_CALL_ALERTING; return 0; 263 case 4: *p_state = RIL_CALL_INCOMING; return 0; 264 case 5: *p_state = RIL_CALL_WAITING; return 0; 265 default: return -1; 266 } 267 } 268 269 /** 270 * Note: directly modified line and has *p_call point directly into 271 * modified line 272 */ 273 static int callFromCLCCLine(char *line, RIL_Call *p_call) 274 { 275 //+CLCC: 1,0,2,0,0,\"+18005551212\",145 276 // index,isMT,state,mode,isMpty(,number,TOA)? 277 278 int err; 279 int state; 280 int mode; 281 282 err = at_tok_start(&line); 283 if (err < 0) goto error; 284 285 err = at_tok_nextint(&line, &(p_call->index)); 286 if (err < 0) goto error; 287 288 err = at_tok_nextbool(&line, &(p_call->isMT)); 289 if (err < 0) goto error; 290 291 err = at_tok_nextint(&line, &state); 292 if (err < 0) goto error; 293 294 err = clccStateToRILState(state, &(p_call->state)); 295 if (err < 0) goto error; 296 297 err = at_tok_nextint(&line, &mode); 298 if (err < 0) goto error; 299 300 p_call->isVoice = (mode == 0); 301 302 err = at_tok_nextbool(&line, &(p_call->isMpty)); 303 if (err < 0) goto error; 304 305 if (at_tok_hasmore(&line)) { 306 err = at_tok_nextstr(&line, &(p_call->number)); 307 308 /* tolerate null here */ 309 if (err < 0) return 0; 310 311 // Some lame implementations return strings 312 // like "NOT AVAILABLE" in the CLCC line 313 if (p_call->number != NULL 314 && 0 == strspn(p_call->number, "+0123456789") 315 ) { 316 p_call->number = NULL; 317 } 318 319 err = at_tok_nextint(&line, &p_call->toa); 320 if (err < 0) goto error; 321 } 322 323 p_call->uusInfo = NULL; 324 325 return 0; 326 327 error: 328 RLOGE("invalid CLCC line\n"); 329 return -1; 330 } 331 332 333 /** do post-AT+CFUN=1 initialization */ 334 static void onRadioPowerOn() 335 { 336 #ifdef USE_TI_COMMANDS 337 /* Must be after CFUN=1 */ 338 /* TI specific -- notifications for CPHS things such */ 339 /* as CPHS message waiting indicator */ 340 341 at_send_command("AT%CPHS=1", NULL); 342 343 /* TI specific -- enable NITZ unsol notifs */ 344 at_send_command("AT%CTZV=1", NULL); 345 #endif 346 347 pollSIMState(NULL); 348 } 349 350 /** do post- SIM ready initialization */ 351 static void onSIMReady() 352 { 353 at_send_command_singleline("AT+CSMS=1", "+CSMS:", NULL); 354 /* 355 * Always send SMS messages directly to the TE 356 * 357 * mode = 1 // discard when link is reserved (link should never be 358 * reserved) 359 * mt = 2 // most messages routed to TE 360 * bm = 2 // new cell BM's routed to TE 361 * ds = 1 // Status reports routed to TE 362 * bfr = 1 // flush buffer 363 */ 364 at_send_command("AT+CNMI=1,2,2,1,1", NULL); 365 } 366 367 static void requestRadioPower(void *data, size_t datalen, RIL_Token t) 368 { 369 int onOff; 370 371 int err; 372 ATResponse *p_response = NULL; 373 374 assert (datalen >= sizeof(int *)); 375 onOff = ((int *)data)[0]; 376 377 if (onOff == 0 && sState != RADIO_STATE_OFF) { 378 err = at_send_command("AT+CFUN=0", &p_response); 379 if (err < 0 || p_response->success == 0) goto error; 380 setRadioState(RADIO_STATE_OFF); 381 } else if (onOff > 0 && sState == RADIO_STATE_OFF) { 382 err = at_send_command("AT+CFUN=1", &p_response); 383 if (err < 0|| p_response->success == 0) { 384 // Some stacks return an error when there is no SIM, 385 // but they really turn the RF portion on 386 // So, if we get an error, let's check to see if it 387 // turned on anyway 388 389 if (isRadioOn() != 1) { 390 goto error; 391 } 392 } 393 setRadioState(RADIO_STATE_ON); 394 } 395 396 at_response_free(p_response); 397 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 398 return; 399 error: 400 at_response_free(p_response); 401 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 402 } 403 404 static void requestShutdown(RIL_Token t) 405 { 406 int onOff; 407 408 int err; 409 ATResponse *p_response = NULL; 410 411 if (sState != RADIO_STATE_OFF) { 412 err = at_send_command("AT+CFUN=0", &p_response); 413 setRadioState(RADIO_STATE_UNAVAILABLE); 414 } 415 416 at_response_free(p_response); 417 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 418 return; 419 } 420 421 static void requestOrSendDataCallList(RIL_Token *t); 422 423 static void onDataCallListChanged(void *param __unused) 424 { 425 requestOrSendDataCallList(NULL); 426 } 427 428 static void requestDataCallList(void *data __unused, size_t datalen __unused, RIL_Token t) 429 { 430 requestOrSendDataCallList(&t); 431 } 432 433 static void requestOrSendDataCallList(RIL_Token *t) 434 { 435 ATResponse *p_response; 436 ATLine *p_cur; 437 int err; 438 int n = 0; 439 char *out; 440 441 err = at_send_command_multiline ("AT+CGACT?", "+CGACT:", &p_response); 442 if (err != 0 || p_response->success == 0) { 443 if (t != NULL) 444 RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0); 445 else 446 RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, 447 NULL, 0); 448 return; 449 } 450 451 for (p_cur = p_response->p_intermediates; p_cur != NULL; 452 p_cur = p_cur->p_next) 453 n++; 454 455 RIL_Data_Call_Response_v11 *responses = 456 alloca(n * sizeof(RIL_Data_Call_Response_v11)); 457 458 int i; 459 for (i = 0; i < n; i++) { 460 responses[i].status = -1; 461 responses[i].suggestedRetryTime = -1; 462 responses[i].cid = -1; 463 responses[i].active = -1; 464 responses[i].type = ""; 465 responses[i].ifname = ""; 466 responses[i].addresses = ""; 467 responses[i].dnses = ""; 468 responses[i].gateways = ""; 469 responses[i].pcscf = ""; 470 responses[i].mtu = 0; 471 } 472 473 RIL_Data_Call_Response_v11 *response = responses; 474 for (p_cur = p_response->p_intermediates; p_cur != NULL; 475 p_cur = p_cur->p_next) { 476 char *line = p_cur->line; 477 478 err = at_tok_start(&line); 479 if (err < 0) 480 goto error; 481 482 err = at_tok_nextint(&line, &response->cid); 483 if (err < 0) 484 goto error; 485 486 err = at_tok_nextint(&line, &response->active); 487 if (err < 0) 488 goto error; 489 490 response++; 491 } 492 493 at_response_free(p_response); 494 495 err = at_send_command_multiline ("AT+CGDCONT?", "+CGDCONT:", &p_response); 496 if (err != 0 || p_response->success == 0) { 497 if (t != NULL) 498 RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0); 499 else 500 RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, 501 NULL, 0); 502 return; 503 } 504 505 for (p_cur = p_response->p_intermediates; p_cur != NULL; 506 p_cur = p_cur->p_next) { 507 char *line = p_cur->line; 508 int cid; 509 510 err = at_tok_start(&line); 511 if (err < 0) 512 goto error; 513 514 err = at_tok_nextint(&line, &cid); 515 if (err < 0) 516 goto error; 517 518 for (i = 0; i < n; i++) { 519 if (responses[i].cid == cid) 520 break; 521 } 522 523 if (i >= n) { 524 /* details for a context we didn't hear about in the last request */ 525 continue; 526 } 527 528 // Assume no error 529 responses[i].status = 0; 530 531 // type 532 err = at_tok_nextstr(&line, &out); 533 if (err < 0) 534 goto error; 535 responses[i].type = alloca(strlen(out) + 1); 536 strcpy(responses[i].type, out); 537 538 // APN ignored for v5 539 err = at_tok_nextstr(&line, &out); 540 if (err < 0) 541 goto error; 542 543 responses[i].ifname = alloca(strlen(PPP_TTY_PATH) + 1); 544 strcpy(responses[i].ifname, PPP_TTY_PATH); 545 546 err = at_tok_nextstr(&line, &out); 547 if (err < 0) 548 goto error; 549 550 responses[i].addresses = alloca(strlen(out) + 1); 551 strcpy(responses[i].addresses, out); 552 553 { 554 char propValue[PROP_VALUE_MAX]; 555 556 if (__system_property_get("ro.kernel.qemu", propValue) != 0) { 557 /* We are in the emulator - the dns servers are listed 558 * by the following system properties, setup in 559 * /system/etc/init.goldfish.sh: 560 * - net.eth0.dns1 561 * - net.eth0.dns2 562 * - net.eth0.dns3 563 * - net.eth0.dns4 564 */ 565 const int dnslist_sz = 128; 566 char* dnslist = alloca(dnslist_sz); 567 const char* separator = ""; 568 int nn; 569 570 dnslist[0] = 0; 571 for (nn = 1; nn <= 4; nn++) { 572 /* Probe net.eth0.dns<n> */ 573 char propName[PROP_NAME_MAX]; 574 snprintf(propName, sizeof propName, "net.eth0.dns%d", nn); 575 576 /* Ignore if undefined */ 577 if (__system_property_get(propName, propValue) == 0) { 578 continue; 579 } 580 581 /* Append the DNS IP address */ 582 strlcat(dnslist, separator, dnslist_sz); 583 strlcat(dnslist, propValue, dnslist_sz); 584 separator = " "; 585 } 586 responses[i].dnses = dnslist; 587 588 /* There is only on gateway in the emulator */ 589 responses[i].gateways = "10.0.2.2"; 590 responses[i].mtu = DEFAULT_MTU; 591 } 592 else { 593 /* I don't know where we are, so use the public Google DNS 594 * servers by default and no gateway. 595 */ 596 responses[i].dnses = "8.8.8.8 8.8.4.4"; 597 responses[i].gateways = ""; 598 } 599 } 600 } 601 602 at_response_free(p_response); 603 604 if (t != NULL) 605 RIL_onRequestComplete(*t, RIL_E_SUCCESS, responses, 606 n * sizeof(RIL_Data_Call_Response_v11)); 607 else 608 RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, 609 responses, 610 n * sizeof(RIL_Data_Call_Response_v11)); 611 612 return; 613 614 error: 615 if (t != NULL) 616 RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0); 617 else 618 RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, 619 NULL, 0); 620 621 at_response_free(p_response); 622 } 623 624 static void requestQueryNetworkSelectionMode( 625 void *data __unused, size_t datalen __unused, RIL_Token t) 626 { 627 int err; 628 ATResponse *p_response = NULL; 629 int response = 0; 630 char *line; 631 632 err = at_send_command_singleline("AT+COPS?", "+COPS:", &p_response); 633 634 if (err < 0 || p_response->success == 0) { 635 goto error; 636 } 637 638 line = p_response->p_intermediates->line; 639 640 err = at_tok_start(&line); 641 642 if (err < 0) { 643 goto error; 644 } 645 646 err = at_tok_nextint(&line, &response); 647 648 if (err < 0) { 649 goto error; 650 } 651 652 RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(int)); 653 at_response_free(p_response); 654 return; 655 error: 656 at_response_free(p_response); 657 RLOGE("requestQueryNetworkSelectionMode must never return error when radio is on"); 658 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 659 } 660 661 static void sendCallStateChanged(void *param __unused) 662 { 663 RIL_onUnsolicitedResponse ( 664 RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, 665 NULL, 0); 666 } 667 668 static void requestGetCurrentCalls(void *data __unused, size_t datalen __unused, RIL_Token t) 669 { 670 int err; 671 ATResponse *p_response; 672 ATLine *p_cur; 673 int countCalls; 674 int countValidCalls; 675 RIL_Call *p_calls; 676 RIL_Call **pp_calls; 677 int i; 678 int needRepoll = 0; 679 680 #ifdef WORKAROUND_ERRONEOUS_ANSWER 681 int prevIncomingOrWaitingLine; 682 683 prevIncomingOrWaitingLine = s_incomingOrWaitingLine; 684 s_incomingOrWaitingLine = -1; 685 #endif /*WORKAROUND_ERRONEOUS_ANSWER*/ 686 687 err = at_send_command_multiline ("AT+CLCC", "+CLCC:", &p_response); 688 689 if (err != 0 || p_response->success == 0) { 690 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 691 return; 692 } 693 694 /* count the calls */ 695 for (countCalls = 0, p_cur = p_response->p_intermediates 696 ; p_cur != NULL 697 ; p_cur = p_cur->p_next 698 ) { 699 countCalls++; 700 } 701 702 /* yes, there's an array of pointers and then an array of structures */ 703 704 pp_calls = (RIL_Call **)alloca(countCalls * sizeof(RIL_Call *)); 705 p_calls = (RIL_Call *)alloca(countCalls * sizeof(RIL_Call)); 706 memset (p_calls, 0, countCalls * sizeof(RIL_Call)); 707 708 /* init the pointer array */ 709 for(i = 0; i < countCalls ; i++) { 710 pp_calls[i] = &(p_calls[i]); 711 } 712 713 for (countValidCalls = 0, p_cur = p_response->p_intermediates 714 ; p_cur != NULL 715 ; p_cur = p_cur->p_next 716 ) { 717 err = callFromCLCCLine(p_cur->line, p_calls + countValidCalls); 718 719 if (err != 0) { 720 continue; 721 } 722 723 #ifdef WORKAROUND_ERRONEOUS_ANSWER 724 if (p_calls[countValidCalls].state == RIL_CALL_INCOMING 725 || p_calls[countValidCalls].state == RIL_CALL_WAITING 726 ) { 727 s_incomingOrWaitingLine = p_calls[countValidCalls].index; 728 } 729 #endif /*WORKAROUND_ERRONEOUS_ANSWER*/ 730 731 if (p_calls[countValidCalls].state != RIL_CALL_ACTIVE 732 && p_calls[countValidCalls].state != RIL_CALL_HOLDING 733 ) { 734 needRepoll = 1; 735 } 736 737 countValidCalls++; 738 } 739 740 #ifdef WORKAROUND_ERRONEOUS_ANSWER 741 // Basically: 742 // A call was incoming or waiting 743 // Now it's marked as active 744 // But we never answered it 745 // 746 // This is probably a bug, and the call will probably 747 // disappear from the call list in the next poll 748 if (prevIncomingOrWaitingLine >= 0 749 && s_incomingOrWaitingLine < 0 750 && s_expectAnswer == 0 751 ) { 752 for (i = 0; i < countValidCalls ; i++) { 753 754 if (p_calls[i].index == prevIncomingOrWaitingLine 755 && p_calls[i].state == RIL_CALL_ACTIVE 756 && s_repollCallsCount < REPOLL_CALLS_COUNT_MAX 757 ) { 758 RLOGI( 759 "Hit WORKAROUND_ERRONOUS_ANSWER case." 760 " Repoll count: %d\n", s_repollCallsCount); 761 s_repollCallsCount++; 762 goto error; 763 } 764 } 765 } 766 767 s_expectAnswer = 0; 768 s_repollCallsCount = 0; 769 #endif /*WORKAROUND_ERRONEOUS_ANSWER*/ 770 771 RIL_onRequestComplete(t, RIL_E_SUCCESS, pp_calls, 772 countValidCalls * sizeof (RIL_Call *)); 773 774 at_response_free(p_response); 775 776 #ifdef POLL_CALL_STATE 777 if (countValidCalls) { // We don't seem to get a "NO CARRIER" message from 778 // smd, so we're forced to poll until the call ends. 779 #else 780 if (needRepoll) { 781 #endif 782 RIL_requestTimedCallback (sendCallStateChanged, NULL, &TIMEVAL_CALLSTATEPOLL); 783 } 784 785 return; 786 error: 787 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 788 at_response_free(p_response); 789 } 790 791 static void requestDial(void *data, size_t datalen __unused, RIL_Token t) 792 { 793 RIL_Dial *p_dial; 794 char *cmd; 795 const char *clir; 796 int ret; 797 798 p_dial = (RIL_Dial *)data; 799 800 switch (p_dial->clir) { 801 case 1: clir = "I"; break; /*invocation*/ 802 case 2: clir = "i"; break; /*suppression*/ 803 default: 804 case 0: clir = ""; break; /*subscription default*/ 805 } 806 807 asprintf(&cmd, "ATD%s%s;", p_dial->address, clir); 808 809 ret = at_send_command(cmd, NULL); 810 811 free(cmd); 812 813 /* success or failure is ignored by the upper layer here. 814 it will call GET_CURRENT_CALLS and determine success that way */ 815 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 816 } 817 818 static void requestWriteSmsToSim(void *data, size_t datalen __unused, RIL_Token t) 819 { 820 RIL_SMS_WriteArgs *p_args; 821 char *cmd; 822 int length; 823 int err; 824 ATResponse *p_response = NULL; 825 826 p_args = (RIL_SMS_WriteArgs *)data; 827 828 length = strlen(p_args->pdu)/2; 829 asprintf(&cmd, "AT+CMGW=%d,%d", length, p_args->status); 830 831 err = at_send_command_sms(cmd, p_args->pdu, "+CMGW:", &p_response); 832 833 if (err != 0 || p_response->success == 0) goto error; 834 835 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 836 at_response_free(p_response); 837 838 return; 839 error: 840 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 841 at_response_free(p_response); 842 } 843 844 static void requestHangup(void *data, size_t datalen __unused, RIL_Token t) 845 { 846 int *p_line; 847 848 int ret; 849 char *cmd; 850 851 p_line = (int *)data; 852 853 // 3GPP 22.030 6.5.5 854 // "Releases a specific active call X" 855 asprintf(&cmd, "AT+CHLD=1%d", p_line[0]); 856 857 ret = at_send_command(cmd, NULL); 858 859 free(cmd); 860 861 /* success or failure is ignored by the upper layer here. 862 it will call GET_CURRENT_CALLS and determine success that way */ 863 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 864 } 865 866 static void requestSignalStrength(void *data __unused, size_t datalen __unused, RIL_Token t) 867 { 868 ATResponse *p_response = NULL; 869 int err; 870 char *line; 871 int count =0; 872 int numofElements=sizeof(RIL_SignalStrength_v6)/sizeof(int); 873 int response[numofElements]; 874 875 err = at_send_command_singleline("AT+CSQ", "+CSQ:", &p_response); 876 877 if (err < 0 || p_response->success == 0) { 878 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 879 goto error; 880 } 881 882 line = p_response->p_intermediates->line; 883 884 err = at_tok_start(&line); 885 if (err < 0) goto error; 886 887 for (count =0; count < numofElements; count ++) { 888 err = at_tok_nextint(&line, &(response[count])); 889 if (err < 0) goto error; 890 } 891 892 RIL_onRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response)); 893 894 at_response_free(p_response); 895 return; 896 897 error: 898 RLOGE("requestSignalStrength must never return an error when radio is on"); 899 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 900 at_response_free(p_response); 901 } 902 903 /** 904 * networkModePossible. Decides whether the network mode is appropriate for the 905 * specified modem 906 */ 907 static int networkModePossible(ModemInfo *mdm, int nm) 908 { 909 if ((net2modem[nm] & mdm->supportedTechs) == net2modem[nm]) { 910 return 1; 911 } 912 return 0; 913 } 914 static void requestSetPreferredNetworkType( int request __unused, void *data, 915 size_t datalen __unused, RIL_Token t ) 916 { 917 ATResponse *p_response = NULL; 918 char *cmd = NULL; 919 int value = *(int *)data; 920 int current, old; 921 int err; 922 int32_t preferred = net2pmask[value]; 923 924 RLOGD("requestSetPreferredNetworkType: current: %x. New: %x", PREFERRED_NETWORK(sMdmInfo), preferred); 925 if (!networkModePossible(sMdmInfo, value)) { 926 RIL_onRequestComplete(t, RIL_E_MODE_NOT_SUPPORTED, NULL, 0); 927 return; 928 } 929 if (query_ctec(sMdmInfo, ¤t, NULL) < 0) { 930 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 931 return; 932 } 933 old = PREFERRED_NETWORK(sMdmInfo); 934 RLOGD("old != preferred: %d", old != preferred); 935 if (old != preferred) { 936 asprintf(&cmd, "AT+CTEC=%d,\"%x\"", current, preferred); 937 RLOGD("Sending command: <%s>", cmd); 938 err = at_send_command_singleline(cmd, "+CTEC:", &p_response); 939 free(cmd); 940 if (err || !p_response->success) { 941 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 942 return; 943 } 944 PREFERRED_NETWORK(sMdmInfo) = value; 945 if (!strstr( p_response->p_intermediates->line, "DONE") ) { 946 int current; 947 int res = parse_technology_response(p_response->p_intermediates->line, ¤t, NULL); 948 switch (res) { 949 case -1: // Error or unable to parse 950 break; 951 case 1: // Only able to parse current 952 case 0: // Both current and preferred were parsed 953 setRadioTechnology(sMdmInfo, current); 954 break; 955 } 956 } 957 } 958 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 959 } 960 961 static void requestGetPreferredNetworkType(int request __unused, void *data __unused, 962 size_t datalen __unused, RIL_Token t) 963 { 964 int preferred; 965 unsigned i; 966 967 switch ( query_ctec(sMdmInfo, NULL, &preferred) ) { 968 case -1: // Error or unable to parse 969 case 1: // Only able to parse current 970 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 971 break; 972 case 0: // Both current and preferred were parsed 973 for ( i = 0 ; i < sizeof(net2pmask) / sizeof(int32_t) ; i++ ) { 974 if (preferred == net2pmask[i]) { 975 RIL_onRequestComplete(t, RIL_E_SUCCESS, &i, sizeof(int)); 976 return; 977 } 978 } 979 RLOGE("Unknown preferred mode received from modem: %d", preferred); 980 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 981 break; 982 } 983 984 } 985 986 static void requestCdmaPrlVersion(int request __unused, void *data __unused, 987 size_t datalen __unused, RIL_Token t) 988 { 989 int err; 990 char * responseStr; 991 ATResponse *p_response = NULL; 992 const char *cmd; 993 char *line; 994 995 err = at_send_command_singleline("AT+WPRL?", "+WPRL:", &p_response); 996 if (err < 0 || !p_response->success) goto error; 997 line = p_response->p_intermediates->line; 998 err = at_tok_start(&line); 999 if (err < 0) goto error; 1000 err = at_tok_nextstr(&line, &responseStr); 1001 if (err < 0 || !responseStr) goto error; 1002 RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, strlen(responseStr)); 1003 at_response_free(p_response); 1004 return; 1005 error: 1006 at_response_free(p_response); 1007 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1008 } 1009 1010 static void requestCdmaBaseBandVersion(int request __unused, void *data __unused, 1011 size_t datalen __unused, RIL_Token t) 1012 { 1013 int err; 1014 char * responseStr; 1015 ATResponse *p_response = NULL; 1016 const char *cmd; 1017 const char *prefix; 1018 char *line, *p; 1019 int commas; 1020 int skip; 1021 int count = 4; 1022 1023 // Fixed values. TODO: query modem 1024 responseStr = strdup("1.0.0.0"); 1025 RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, sizeof(responseStr)); 1026 free(responseStr); 1027 } 1028 1029 static void requestCdmaDeviceIdentity(int request __unused, void *data __unused, 1030 size_t datalen __unused, RIL_Token t) 1031 { 1032 int err; 1033 int response[4]; 1034 char * responseStr[4]; 1035 ATResponse *p_response = NULL; 1036 const char *cmd; 1037 const char *prefix; 1038 char *line, *p; 1039 int commas; 1040 int skip; 1041 int count = 4; 1042 1043 // Fixed values. TODO: Query modem 1044 responseStr[0] = "----"; 1045 responseStr[1] = "----"; 1046 responseStr[2] = "77777777"; 1047 1048 err = at_send_command_numeric("AT+CGSN", &p_response); 1049 if (err < 0 || p_response->success == 0) { 1050 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1051 return; 1052 } else { 1053 responseStr[3] = p_response->p_intermediates->line; 1054 } 1055 1056 RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, count*sizeof(char*)); 1057 at_response_free(p_response); 1058 1059 return; 1060 error: 1061 RLOGE("requestCdmaDeviceIdentity must never return an error when radio is on"); 1062 at_response_free(p_response); 1063 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1064 } 1065 1066 static void requestCdmaGetSubscriptionSource(int request __unused, void *data, 1067 size_t datalen __unused, RIL_Token t) 1068 { 1069 int err; 1070 int *ss = (int *)data; 1071 ATResponse *p_response = NULL; 1072 char *cmd = NULL; 1073 char *line = NULL; 1074 int response; 1075 1076 asprintf(&cmd, "AT+CCSS?"); 1077 if (!cmd) goto error; 1078 1079 err = at_send_command_singleline(cmd, "+CCSS:", &p_response); 1080 if (err < 0 || !p_response->success) 1081 goto error; 1082 1083 line = p_response->p_intermediates->line; 1084 err = at_tok_start(&line); 1085 if (err < 0) goto error; 1086 1087 err = at_tok_nextint(&line, &response); 1088 free(cmd); 1089 cmd = NULL; 1090 1091 RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response)); 1092 1093 return; 1094 error: 1095 free(cmd); 1096 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1097 } 1098 1099 static void requestCdmaSetSubscriptionSource(int request __unused, void *data, 1100 size_t datalen, RIL_Token t) 1101 { 1102 int err; 1103 int *ss = (int *)data; 1104 ATResponse *p_response = NULL; 1105 char *cmd = NULL; 1106 1107 if (!ss || !datalen) { 1108 RLOGE("RIL_REQUEST_CDMA_SET_SUBSCRIPTION without data!"); 1109 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1110 return; 1111 } 1112 asprintf(&cmd, "AT+CCSS=%d", ss[0]); 1113 if (!cmd) goto error; 1114 1115 err = at_send_command(cmd, &p_response); 1116 if (err < 0 || !p_response->success) 1117 goto error; 1118 free(cmd); 1119 cmd = NULL; 1120 1121 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1122 1123 RIL_onUnsolicitedResponse(RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED, ss, sizeof(ss[0])); 1124 1125 return; 1126 error: 1127 free(cmd); 1128 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1129 } 1130 1131 static void requestCdmaSubscription(int request __unused, void *data __unused, 1132 size_t datalen __unused, RIL_Token t) 1133 { 1134 int err; 1135 int response[5]; 1136 char * responseStr[5]; 1137 ATResponse *p_response = NULL; 1138 const char *cmd; 1139 const char *prefix; 1140 char *line, *p; 1141 int commas; 1142 int skip; 1143 int count = 5; 1144 1145 // Fixed values. TODO: Query modem 1146 responseStr[0] = "8587777777"; // MDN 1147 responseStr[1] = "1"; // SID 1148 responseStr[2] = "1"; // NID 1149 responseStr[3] = "8587777777"; // MIN 1150 responseStr[4] = "1"; // PRL Version 1151 RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, count*sizeof(char*)); 1152 1153 return; 1154 error: 1155 RLOGE("requestRegistrationState must never return an error when radio is on"); 1156 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1157 } 1158 1159 static void requestCdmaGetRoamingPreference(int request __unused, void *data __unused, 1160 size_t datalen __unused, RIL_Token t) 1161 { 1162 int roaming_pref = -1; 1163 ATResponse *p_response = NULL; 1164 char *line; 1165 int res; 1166 1167 res = at_send_command_singleline("AT+WRMP?", "+WRMP:", &p_response); 1168 if (res < 0 || !p_response->success) { 1169 goto error; 1170 } 1171 line = p_response->p_intermediates->line; 1172 1173 res = at_tok_start(&line); 1174 if (res < 0) goto error; 1175 1176 res = at_tok_nextint(&line, &roaming_pref); 1177 if (res < 0) goto error; 1178 1179 RIL_onRequestComplete(t, RIL_E_SUCCESS, &roaming_pref, sizeof(roaming_pref)); 1180 return; 1181 error: 1182 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1183 } 1184 1185 static void requestCdmaSetRoamingPreference(int request __unused, void *data, 1186 size_t datalen __unused, RIL_Token t) 1187 { 1188 int *pref = (int *)data; 1189 ATResponse *p_response = NULL; 1190 char *line; 1191 int res; 1192 char *cmd = NULL; 1193 1194 asprintf(&cmd, "AT+WRMP=%d", *pref); 1195 if (cmd == NULL) goto error; 1196 1197 res = at_send_command(cmd, &p_response); 1198 if (res < 0 || !p_response->success) 1199 goto error; 1200 1201 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1202 free(cmd); 1203 return; 1204 error: 1205 free(cmd); 1206 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1207 } 1208 1209 static int parseRegistrationState(char *str, int *type, int *items, int **response) 1210 { 1211 int err; 1212 char *line = str, *p; 1213 int *resp = NULL; 1214 int skip; 1215 int count = 3; 1216 int commas; 1217 1218 RLOGD("parseRegistrationState. Parsing: %s",str); 1219 err = at_tok_start(&line); 1220 if (err < 0) goto error; 1221 1222 /* Ok you have to be careful here 1223 * The solicited version of the CREG response is 1224 * +CREG: n, stat, [lac, cid] 1225 * and the unsolicited version is 1226 * +CREG: stat, [lac, cid] 1227 * The <n> parameter is basically "is unsolicited creg on?" 1228 * which it should always be 1229 * 1230 * Now we should normally get the solicited version here, 1231 * but the unsolicited version could have snuck in 1232 * so we have to handle both 1233 * 1234 * Also since the LAC and CID are only reported when registered, 1235 * we can have 1, 2, 3, or 4 arguments here 1236 * 1237 * finally, a +CGREG: answer may have a fifth value that corresponds 1238 * to the network type, as in; 1239 * 1240 * +CGREG: n, stat [,lac, cid [,networkType]] 1241 */ 1242 1243 /* count number of commas */ 1244 commas = 0; 1245 for (p = line ; *p != '\0' ;p++) { 1246 if (*p == ',') commas++; 1247 } 1248 1249 resp = (int *)calloc(commas + 1, sizeof(int)); 1250 if (!resp) goto error; 1251 switch (commas) { 1252 case 0: /* +CREG: <stat> */ 1253 err = at_tok_nextint(&line, &resp[0]); 1254 if (err < 0) goto error; 1255 resp[1] = -1; 1256 resp[2] = -1; 1257 break; 1258 1259 case 1: /* +CREG: <n>, <stat> */ 1260 err = at_tok_nextint(&line, &skip); 1261 if (err < 0) goto error; 1262 err = at_tok_nextint(&line, &resp[0]); 1263 if (err < 0) goto error; 1264 resp[1] = -1; 1265 resp[2] = -1; 1266 if (err < 0) goto error; 1267 break; 1268 1269 case 2: /* +CREG: <stat>, <lac>, <cid> */ 1270 err = at_tok_nextint(&line, &resp[0]); 1271 if (err < 0) goto error; 1272 err = at_tok_nexthexint(&line, &resp[1]); 1273 if (err < 0) goto error; 1274 err = at_tok_nexthexint(&line, &resp[2]); 1275 if (err < 0) goto error; 1276 break; 1277 case 3: /* +CREG: <n>, <stat>, <lac>, <cid> */ 1278 err = at_tok_nextint(&line, &skip); 1279 if (err < 0) goto error; 1280 err = at_tok_nextint(&line, &resp[0]); 1281 if (err < 0) goto error; 1282 err = at_tok_nexthexint(&line, &resp[1]); 1283 if (err < 0) goto error; 1284 err = at_tok_nexthexint(&line, &resp[2]); 1285 if (err < 0) goto error; 1286 break; 1287 /* special case for CGREG, there is a fourth parameter 1288 * that is the network type (unknown/gprs/edge/umts) 1289 */ 1290 case 4: /* +CGREG: <n>, <stat>, <lac>, <cid>, <networkType> */ 1291 err = at_tok_nextint(&line, &skip); 1292 if (err < 0) goto error; 1293 err = at_tok_nextint(&line, &resp[0]); 1294 if (err < 0) goto error; 1295 err = at_tok_nexthexint(&line, &resp[1]); 1296 if (err < 0) goto error; 1297 err = at_tok_nexthexint(&line, &resp[2]); 1298 if (err < 0) goto error; 1299 err = at_tok_nexthexint(&line, &resp[3]); 1300 if (err < 0) goto error; 1301 count = 4; 1302 break; 1303 default: 1304 goto error; 1305 } 1306 s_lac = resp[1]; 1307 s_cid = resp[2]; 1308 if (response) 1309 *response = resp; 1310 if (items) 1311 *items = commas + 1; 1312 if (type) 1313 *type = techFromModemType(TECH(sMdmInfo)); 1314 return 0; 1315 error: 1316 free(resp); 1317 return -1; 1318 } 1319 1320 #define REG_STATE_LEN 15 1321 #define REG_DATA_STATE_LEN 6 1322 static void requestRegistrationState(int request, void *data __unused, 1323 size_t datalen __unused, RIL_Token t) 1324 { 1325 int err; 1326 int *registration; 1327 char **responseStr = NULL; 1328 ATResponse *p_response = NULL; 1329 const char *cmd; 1330 const char *prefix; 1331 char *line; 1332 int i = 0, j, numElements = 0; 1333 int count = 3; 1334 int type, startfrom; 1335 1336 RLOGD("requestRegistrationState"); 1337 if (request == RIL_REQUEST_VOICE_REGISTRATION_STATE) { 1338 cmd = "AT+CREG?"; 1339 prefix = "+CREG:"; 1340 numElements = REG_STATE_LEN; 1341 } else if (request == RIL_REQUEST_DATA_REGISTRATION_STATE) { 1342 cmd = "AT+CGREG?"; 1343 prefix = "+CGREG:"; 1344 numElements = REG_DATA_STATE_LEN; 1345 } else { 1346 assert(0); 1347 goto error; 1348 } 1349 1350 err = at_send_command_singleline(cmd, prefix, &p_response); 1351 1352 if (err != 0) goto error; 1353 1354 line = p_response->p_intermediates->line; 1355 1356 if (parseRegistrationState(line, &type, &count, ®istration)) goto error; 1357 1358 responseStr = malloc(numElements * sizeof(char *)); 1359 if (!responseStr) goto error; 1360 memset(responseStr, 0, numElements * sizeof(char *)); 1361 /** 1362 * The first '4' bytes for both registration states remain the same. 1363 * But if the request is 'DATA_REGISTRATION_STATE', 1364 * the 5th and 6th byte(s) are optional. 1365 */ 1366 if (is3gpp2(type) == 1) { 1367 RLOGD("registration state type: 3GPP2"); 1368 // TODO: Query modem 1369 startfrom = 3; 1370 if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) { 1371 asprintf(&responseStr[3], "8"); // EvDo revA 1372 asprintf(&responseStr[4], "1"); // BSID 1373 asprintf(&responseStr[5], "123"); // Latitude 1374 asprintf(&responseStr[6], "222"); // Longitude 1375 asprintf(&responseStr[7], "0"); // CSS Indicator 1376 asprintf(&responseStr[8], "4"); // SID 1377 asprintf(&responseStr[9], "65535"); // NID 1378 asprintf(&responseStr[10], "0"); // Roaming indicator 1379 asprintf(&responseStr[11], "1"); // System is in PRL 1380 asprintf(&responseStr[12], "0"); // Default Roaming indicator 1381 asprintf(&responseStr[13], "0"); // Reason for denial 1382 asprintf(&responseStr[14], "0"); // Primary Scrambling Code of Current cell 1383 } else if (request == RIL_REQUEST_DATA_REGISTRATION_STATE) { 1384 asprintf(&responseStr[3], "8"); // Available data radio technology 1385 } 1386 } else { // type == RADIO_TECH_3GPP 1387 RLOGD("registration state type: 3GPP"); 1388 startfrom = 0; 1389 asprintf(&responseStr[1], "%x", registration[1]); 1390 asprintf(&responseStr[2], "%x", registration[2]); 1391 if (count > 3) 1392 asprintf(&responseStr[3], "%d", registration[3]); 1393 } 1394 asprintf(&responseStr[0], "%d", registration[0]); 1395 1396 /** 1397 * Optional bytes for DATA_REGISTRATION_STATE request 1398 * 4th byte : Registration denial code 1399 * 5th byte : The max. number of simultaneous Data Calls 1400 */ 1401 if(request == RIL_REQUEST_DATA_REGISTRATION_STATE) { 1402 // asprintf(&responseStr[4], "3"); 1403 // asprintf(&responseStr[5], "1"); 1404 } 1405 1406 for (j = startfrom; j < numElements; j++) { 1407 if (!responseStr[i]) goto error; 1408 } 1409 free(registration); 1410 registration = NULL; 1411 1412 RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, numElements*sizeof(responseStr)); 1413 for (j = 0; j < numElements; j++ ) { 1414 free(responseStr[j]); 1415 responseStr[j] = NULL; 1416 } 1417 free(responseStr); 1418 responseStr = NULL; 1419 at_response_free(p_response); 1420 1421 return; 1422 error: 1423 if (responseStr) { 1424 for (j = 0; j < numElements; j++) { 1425 free(responseStr[j]); 1426 responseStr[j] = NULL; 1427 } 1428 free(responseStr); 1429 responseStr = NULL; 1430 } 1431 RLOGE("requestRegistrationState must never return an error when radio is on"); 1432 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1433 at_response_free(p_response); 1434 } 1435 1436 static void requestOperator(void *data __unused, size_t datalen __unused, RIL_Token t) 1437 { 1438 int err; 1439 int i; 1440 int skip; 1441 ATLine *p_cur; 1442 char *response[3]; 1443 1444 memset(response, 0, sizeof(response)); 1445 1446 ATResponse *p_response = NULL; 1447 1448 err = at_send_command_multiline( 1449 "AT+COPS=3,0;+COPS?;+COPS=3,1;+COPS?;+COPS=3,2;+COPS?", 1450 "+COPS:", &p_response); 1451 1452 /* we expect 3 lines here: 1453 * +COPS: 0,0,"T - Mobile" 1454 * +COPS: 0,1,"TMO" 1455 * +COPS: 0,2,"310170" 1456 */ 1457 1458 if (err != 0) goto error; 1459 1460 for (i = 0, p_cur = p_response->p_intermediates 1461 ; p_cur != NULL 1462 ; p_cur = p_cur->p_next, i++ 1463 ) { 1464 char *line = p_cur->line; 1465 1466 err = at_tok_start(&line); 1467 if (err < 0) goto error; 1468 1469 err = at_tok_nextint(&line, &skip); 1470 if (err < 0) goto error; 1471 1472 // If we're unregistered, we may just get 1473 // a "+COPS: 0" response 1474 if (!at_tok_hasmore(&line)) { 1475 response[i] = NULL; 1476 continue; 1477 } 1478 1479 err = at_tok_nextint(&line, &skip); 1480 if (err < 0) goto error; 1481 1482 // a "+COPS: 0, n" response is also possible 1483 if (!at_tok_hasmore(&line)) { 1484 response[i] = NULL; 1485 continue; 1486 } 1487 1488 err = at_tok_nextstr(&line, &(response[i])); 1489 if (err < 0) goto error; 1490 // Simple assumption that mcc and mnc are 3 digits each 1491 if (strlen(response[i]) == 6) { 1492 if (sscanf(response[i], "%3d%3d", &s_mcc, &s_mnc) != 2) { 1493 RLOGE("requestOperator expected mccmnc to be 6 decimal digits"); 1494 } 1495 } 1496 } 1497 1498 if (i != 3) { 1499 /* expect 3 lines exactly */ 1500 goto error; 1501 } 1502 1503 RIL_onRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response)); 1504 at_response_free(p_response); 1505 1506 return; 1507 error: 1508 RLOGE("requestOperator must not return error when radio is on"); 1509 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1510 at_response_free(p_response); 1511 } 1512 1513 static void requestCdmaSendSMS(void *data, size_t datalen, RIL_Token t) 1514 { 1515 int err = 1; // Set to go to error: 1516 RIL_SMS_Response response; 1517 RIL_CDMA_SMS_Message* rcsm; 1518 1519 RLOGD("requestCdmaSendSMS datalen=%zu, sizeof(RIL_CDMA_SMS_Message)=%zu", 1520 datalen, sizeof(RIL_CDMA_SMS_Message)); 1521 1522 // verify data content to test marshalling/unmarshalling: 1523 rcsm = (RIL_CDMA_SMS_Message*)data; 1524 RLOGD("TeleserviceID=%d, bIsServicePresent=%d, \ 1525 uServicecategory=%d, sAddress.digit_mode=%d, \ 1526 sAddress.Number_mode=%d, sAddress.number_type=%d, ", 1527 rcsm->uTeleserviceID, rcsm->bIsServicePresent, 1528 rcsm->uServicecategory,rcsm->sAddress.digit_mode, 1529 rcsm->sAddress.number_mode,rcsm->sAddress.number_type); 1530 1531 if (err != 0) goto error; 1532 1533 // Cdma Send SMS implementation will go here: 1534 // But it is not implemented yet. 1535 1536 memset(&response, 0, sizeof(response)); 1537 response.messageRef = 1; 1538 RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response)); 1539 return; 1540 1541 error: 1542 // Cdma Send SMS will always cause send retry error. 1543 response.messageRef = -1; 1544 RIL_onRequestComplete(t, RIL_E_SMS_SEND_FAIL_RETRY, &response, sizeof(response)); 1545 } 1546 1547 static void requestSendSMS(void *data, size_t datalen, RIL_Token t) 1548 { 1549 int err; 1550 const char *smsc; 1551 const char *pdu; 1552 int tpLayerLength; 1553 char *cmd1, *cmd2; 1554 RIL_SMS_Response response; 1555 ATResponse *p_response = NULL; 1556 1557 memset(&response, 0, sizeof(response)); 1558 RLOGD("requestSendSMS datalen =%zu", datalen); 1559 1560 if (s_ims_gsm_fail != 0) goto error; 1561 if (s_ims_gsm_retry != 0) goto error2; 1562 1563 smsc = ((const char **)data)[0]; 1564 pdu = ((const char **)data)[1]; 1565 1566 tpLayerLength = strlen(pdu)/2; 1567 1568 // "NULL for default SMSC" 1569 if (smsc == NULL) { 1570 smsc= "00"; 1571 } 1572 1573 asprintf(&cmd1, "AT+CMGS=%d", tpLayerLength); 1574 asprintf(&cmd2, "%s%s", smsc, pdu); 1575 1576 err = at_send_command_sms(cmd1, cmd2, "+CMGS:", &p_response); 1577 1578 if (err != 0 || p_response->success == 0) goto error; 1579 1580 /* FIXME fill in messageRef and ackPDU */ 1581 response.messageRef = 1; 1582 RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response)); 1583 at_response_free(p_response); 1584 1585 return; 1586 error: 1587 response.messageRef = -2; 1588 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, &response, sizeof(response)); 1589 at_response_free(p_response); 1590 return; 1591 error2: 1592 // send retry error. 1593 response.messageRef = -1; 1594 RIL_onRequestComplete(t, RIL_E_SMS_SEND_FAIL_RETRY, &response, sizeof(response)); 1595 at_response_free(p_response); 1596 return; 1597 } 1598 1599 static void requestImsSendSMS(void *data, size_t datalen, RIL_Token t) 1600 { 1601 RIL_IMS_SMS_Message *p_args; 1602 RIL_SMS_Response response; 1603 1604 memset(&response, 0, sizeof(response)); 1605 1606 RLOGD("requestImsSendSMS: datalen=%zu, " 1607 "registered=%d, service=%d, format=%d, ims_perm_fail=%d, " 1608 "ims_retry=%d, gsm_fail=%d, gsm_retry=%d", 1609 datalen, s_ims_registered, s_ims_services, s_ims_format, 1610 s_ims_cause_perm_failure, s_ims_cause_retry, s_ims_gsm_fail, 1611 s_ims_gsm_retry); 1612 1613 // figure out if this is gsm/cdma format 1614 // then route it to requestSendSMS vs requestCdmaSendSMS respectively 1615 p_args = (RIL_IMS_SMS_Message *)data; 1616 1617 if (0 != s_ims_cause_perm_failure ) goto error; 1618 1619 // want to fail over ims and this is first request over ims 1620 if (0 != s_ims_cause_retry && 0 == p_args->retry) goto error2; 1621 1622 if (RADIO_TECH_3GPP == p_args->tech) { 1623 return requestSendSMS(p_args->message.gsmMessage, 1624 datalen - sizeof(RIL_RadioTechnologyFamily), 1625 t); 1626 } else if (RADIO_TECH_3GPP2 == p_args->tech) { 1627 return requestCdmaSendSMS(p_args->message.cdmaMessage, 1628 datalen - sizeof(RIL_RadioTechnologyFamily), 1629 t); 1630 } else { 1631 RLOGE("requestImsSendSMS invalid format value =%d", p_args->tech); 1632 } 1633 1634 error: 1635 response.messageRef = -2; 1636 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, &response, sizeof(response)); 1637 return; 1638 1639 error2: 1640 response.messageRef = -1; 1641 RIL_onRequestComplete(t, RIL_E_SMS_SEND_FAIL_RETRY, &response, sizeof(response)); 1642 } 1643 1644 static void requestSetupDataCall(void *data, size_t datalen, RIL_Token t) 1645 { 1646 const char *apn; 1647 char *cmd; 1648 int err; 1649 ATResponse *p_response = NULL; 1650 1651 apn = ((const char **)data)[2]; 1652 1653 #ifdef USE_TI_COMMANDS 1654 // Config for multislot class 10 (probably default anyway eh?) 1655 err = at_send_command("AT%CPRIM=\"GMM\",\"CONFIG MULTISLOT_CLASS=<10>\"", 1656 NULL); 1657 1658 err = at_send_command("AT%DATA=2,\"UART\",1,,\"SER\",\"UART\",0", NULL); 1659 #endif /* USE_TI_COMMANDS */ 1660 1661 int fd, qmistatus; 1662 size_t cur = 0; 1663 size_t len; 1664 ssize_t written, rlen; 1665 char status[32] = {0}; 1666 int retry = 10; 1667 const char *pdp_type; 1668 1669 RLOGD("requesting data connection to APN '%s'", apn); 1670 1671 fd = open ("/dev/qmi", O_RDWR); 1672 if (fd >= 0) { /* the device doesn't exist on the emulator */ 1673 1674 RLOGD("opened the qmi device\n"); 1675 asprintf(&cmd, "up:%s", apn); 1676 len = strlen(cmd); 1677 1678 while (cur < len) { 1679 do { 1680 written = write (fd, cmd + cur, len - cur); 1681 } while (written < 0 && errno == EINTR); 1682 1683 if (written < 0) { 1684 RLOGE("### ERROR writing to /dev/qmi"); 1685 close(fd); 1686 goto error; 1687 } 1688 1689 cur += written; 1690 } 1691 1692 // wait for interface to come online 1693 1694 do { 1695 sleep(1); 1696 do { 1697 rlen = read(fd, status, 31); 1698 } while (rlen < 0 && errno == EINTR); 1699 1700 if (rlen < 0) { 1701 RLOGE("### ERROR reading from /dev/qmi"); 1702 close(fd); 1703 goto error; 1704 } else { 1705 status[rlen] = '\0'; 1706 RLOGD("### status: %s", status); 1707 } 1708 } while (strncmp(status, "STATE=up", 8) && strcmp(status, "online") && --retry); 1709 1710 close(fd); 1711 1712 if (retry == 0) { 1713 RLOGE("### Failed to get data connection up\n"); 1714 goto error; 1715 } 1716 1717 qmistatus = system("netcfg rmnet0 dhcp"); 1718 1719 RLOGD("netcfg rmnet0 dhcp: status %d\n", qmistatus); 1720 1721 if (qmistatus < 0) goto error; 1722 1723 } else { 1724 1725 if (datalen > 6 * sizeof(char *)) { 1726 pdp_type = ((const char **)data)[6]; 1727 } else { 1728 pdp_type = "IP"; 1729 } 1730 1731 asprintf(&cmd, "AT+CGDCONT=1,\"%s\",\"%s\",,0,0", pdp_type, apn); 1732 //FIXME check for error here 1733 err = at_send_command(cmd, NULL); 1734 free(cmd); 1735 1736 // Set required QoS params to default 1737 err = at_send_command("AT+CGQREQ=1", NULL); 1738 1739 // Set minimum QoS params to default 1740 err = at_send_command("AT+CGQMIN=1", NULL); 1741 1742 // packet-domain event reporting 1743 err = at_send_command("AT+CGEREP=1,0", NULL); 1744 1745 // Hangup anything that's happening there now 1746 err = at_send_command("AT+CGACT=1,0", NULL); 1747 1748 // Start data on PDP context 1 1749 err = at_send_command("ATD*99***1#", &p_response); 1750 1751 if (err < 0 || p_response->success == 0) { 1752 goto error; 1753 } 1754 } 1755 1756 requestOrSendDataCallList(&t); 1757 1758 at_response_free(p_response); 1759 1760 return; 1761 error: 1762 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1763 at_response_free(p_response); 1764 1765 } 1766 1767 static void requestSMSAcknowledge(void *data, size_t datalen __unused, RIL_Token t) 1768 { 1769 int ackSuccess; 1770 int err; 1771 1772 ackSuccess = ((int *)data)[0]; 1773 1774 if (ackSuccess == 1) { 1775 err = at_send_command("AT+CNMA=1", NULL); 1776 } else if (ackSuccess == 0) { 1777 err = at_send_command("AT+CNMA=2", NULL); 1778 } else { 1779 RLOGE("unsupported arg to RIL_REQUEST_SMS_ACKNOWLEDGE\n"); 1780 goto error; 1781 } 1782 1783 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1784 error: 1785 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1786 1787 } 1788 1789 static void requestSIM_IO(void *data, size_t datalen __unused, RIL_Token t) 1790 { 1791 ATResponse *p_response = NULL; 1792 RIL_SIM_IO_Response sr; 1793 int err; 1794 char *cmd = NULL; 1795 RIL_SIM_IO_v6 *p_args; 1796 char *line; 1797 1798 memset(&sr, 0, sizeof(sr)); 1799 1800 p_args = (RIL_SIM_IO_v6 *)data; 1801 1802 /* FIXME handle pin2 */ 1803 1804 if (p_args->data == NULL) { 1805 asprintf(&cmd, "AT+CRSM=%d,%d,%d,%d,%d", 1806 p_args->command, p_args->fileid, 1807 p_args->p1, p_args->p2, p_args->p3); 1808 } else { 1809 asprintf(&cmd, "AT+CRSM=%d,%d,%d,%d,%d,%s", 1810 p_args->command, p_args->fileid, 1811 p_args->p1, p_args->p2, p_args->p3, p_args->data); 1812 } 1813 1814 err = at_send_command_singleline(cmd, "+CRSM:", &p_response); 1815 1816 if (err < 0 || p_response->success == 0) { 1817 goto error; 1818 } 1819 1820 line = p_response->p_intermediates->line; 1821 1822 err = at_tok_start(&line); 1823 if (err < 0) goto error; 1824 1825 err = at_tok_nextint(&line, &(sr.sw1)); 1826 if (err < 0) goto error; 1827 1828 err = at_tok_nextint(&line, &(sr.sw2)); 1829 if (err < 0) goto error; 1830 1831 if (at_tok_hasmore(&line)) { 1832 err = at_tok_nextstr(&line, &(sr.simResponse)); 1833 if (err < 0) goto error; 1834 } 1835 1836 RIL_onRequestComplete(t, RIL_E_SUCCESS, &sr, sizeof(sr)); 1837 at_response_free(p_response); 1838 free(cmd); 1839 1840 return; 1841 error: 1842 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1843 at_response_free(p_response); 1844 free(cmd); 1845 1846 } 1847 1848 static void requestEnterSimPin(void* data, size_t datalen, RIL_Token t) 1849 { 1850 ATResponse *p_response = NULL; 1851 int err; 1852 char* cmd = NULL; 1853 const char** strings = (const char**)data;; 1854 1855 if ( datalen == sizeof(char*) ) { 1856 asprintf(&cmd, "AT+CPIN=%s", strings[0]); 1857 } else if ( datalen == 2*sizeof(char*) ) { 1858 asprintf(&cmd, "AT+CPIN=%s,%s", strings[0], strings[1]); 1859 } else 1860 goto error; 1861 1862 err = at_send_command_singleline(cmd, "+CPIN:", &p_response); 1863 free(cmd); 1864 1865 if (err < 0 || p_response->success == 0) { 1866 error: 1867 RIL_onRequestComplete(t, RIL_E_PASSWORD_INCORRECT, NULL, 0); 1868 } else { 1869 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1870 } 1871 at_response_free(p_response); 1872 } 1873 1874 1875 static void requestSendUSSD(void *data, size_t datalen __unused, RIL_Token t) 1876 { 1877 const char *ussdRequest; 1878 1879 ussdRequest = (char *)(data); 1880 1881 1882 RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0); 1883 1884 // @@@ TODO 1885 1886 } 1887 1888 static void requestExitEmergencyMode(void *data __unused, size_t datalen __unused, RIL_Token t) 1889 { 1890 int err; 1891 ATResponse *p_response = NULL; 1892 1893 err = at_send_command("AT+WSOS=0", &p_response); 1894 1895 if (err < 0 || p_response->success == 0) { 1896 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1897 return; 1898 } 1899 1900 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1901 } 1902 1903 // TODO: Use all radio types 1904 static int techFromModemType(int mdmtype) 1905 { 1906 int ret = -1; 1907 switch (1 << mdmtype) { 1908 case MDM_CDMA: 1909 ret = RADIO_TECH_1xRTT; 1910 break; 1911 case MDM_EVDO: 1912 ret = RADIO_TECH_EVDO_A; 1913 break; 1914 case MDM_GSM: 1915 ret = RADIO_TECH_GPRS; 1916 break; 1917 case MDM_WCDMA: 1918 ret = RADIO_TECH_HSPA; 1919 break; 1920 case MDM_LTE: 1921 ret = RADIO_TECH_LTE; 1922 break; 1923 } 1924 return ret; 1925 } 1926 1927 static void requestGetCellInfoList(void *data __unused, size_t datalen __unused, RIL_Token t) 1928 { 1929 uint64_t curTime = ril_nano_time(); 1930 RIL_CellInfo ci[1] = 1931 { 1932 { // ci[0] 1933 1, // cellInfoType 1934 1, // registered 1935 curTime - 1000, // Fake some time in the past 1936 { // union CellInfo 1937 { // RIL_CellInfoGsm gsm 1938 { // gsm.cellIdneityGsm 1939 s_mcc, // mcc 1940 s_mnc, // mnc 1941 s_lac, // lac 1942 s_cid, // cid 1943 0 // psc 1944 }, 1945 { // gsm.signalStrengthGsm 1946 10, // signalStrength 1947 0 // bitErrorRate 1948 } 1949 } 1950 } 1951 } 1952 }; 1953 1954 RIL_onRequestComplete(t, RIL_E_SUCCESS, ci, sizeof(ci)); 1955 } 1956 1957 1958 static void requestSetCellInfoListRate(void *data, size_t datalen, RIL_Token t) 1959 { 1960 // For now we'll save the rate but no RIL_UNSOL_CELL_INFO_LIST messages 1961 // will be sent. 1962 assert (datalen == sizeof(int)); 1963 s_cell_info_rate_ms = ((int *)data)[0]; 1964 1965 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1966 } 1967 1968 static void requestGetHardwareConfig(void *data, size_t datalen, RIL_Token t) 1969 { 1970 // TODO - hook this up with real query/info from radio. 1971 1972 RIL_HardwareConfig hwCfg; 1973 1974 RIL_UNUSED_PARM(data); 1975 RIL_UNUSED_PARM(datalen); 1976 1977 hwCfg.type = -1; 1978 1979 RIL_onRequestComplete(t, RIL_E_SUCCESS, &hwCfg, sizeof(hwCfg)); 1980 } 1981 1982 1983 /*** Callback methods from the RIL library to us ***/ 1984 1985 /** 1986 * Call from RIL to us to make a RIL_REQUEST 1987 * 1988 * Must be completed with a call to RIL_onRequestComplete() 1989 * 1990 * RIL_onRequestComplete() may be called from any thread, before or after 1991 * this function returns. 1992 * 1993 * Will always be called from the same thread, so returning here implies 1994 * that the radio is ready to process another command (whether or not 1995 * the previous command has completed). 1996 */ 1997 static void 1998 onRequest (int request, void *data, size_t datalen, RIL_Token t) 1999 { 2000 ATResponse *p_response; 2001 int err; 2002 2003 RLOGD("onRequest: %s", requestToString(request)); 2004 2005 /* Ignore all requests except RIL_REQUEST_GET_SIM_STATUS 2006 * when RADIO_STATE_UNAVAILABLE. 2007 */ 2008 if (sState == RADIO_STATE_UNAVAILABLE 2009 && request != RIL_REQUEST_GET_SIM_STATUS 2010 ) { 2011 RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); 2012 return; 2013 } 2014 2015 /* Ignore all non-power requests when RADIO_STATE_OFF 2016 * (except RIL_REQUEST_GET_SIM_STATUS) 2017 */ 2018 if (sState == RADIO_STATE_OFF 2019 && !(request == RIL_REQUEST_RADIO_POWER 2020 || request == RIL_REQUEST_GET_SIM_STATUS) 2021 ) { 2022 RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); 2023 return; 2024 } 2025 2026 switch (request) { 2027 case RIL_REQUEST_GET_SIM_STATUS: { 2028 RIL_CardStatus_v6 *p_card_status; 2029 char *p_buffer; 2030 int buffer_size; 2031 2032 int result = getCardStatus(&p_card_status); 2033 if (result == RIL_E_SUCCESS) { 2034 p_buffer = (char *)p_card_status; 2035 buffer_size = sizeof(*p_card_status); 2036 } else { 2037 p_buffer = NULL; 2038 buffer_size = 0; 2039 } 2040 RIL_onRequestComplete(t, result, p_buffer, buffer_size); 2041 freeCardStatus(p_card_status); 2042 break; 2043 } 2044 case RIL_REQUEST_GET_CURRENT_CALLS: 2045 requestGetCurrentCalls(data, datalen, t); 2046 break; 2047 case RIL_REQUEST_DIAL: 2048 requestDial(data, datalen, t); 2049 break; 2050 case RIL_REQUEST_HANGUP: 2051 requestHangup(data, datalen, t); 2052 break; 2053 case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: 2054 // 3GPP 22.030 6.5.5 2055 // "Releases all held calls or sets User Determined User Busy 2056 // (UDUB) for a waiting call." 2057 at_send_command("AT+CHLD=0", NULL); 2058 2059 /* success or failure is ignored by the upper layer here. 2060 it will call GET_CURRENT_CALLS and determine success that way */ 2061 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 2062 break; 2063 case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: 2064 // 3GPP 22.030 6.5.5 2065 // "Releases all active calls (if any exist) and accepts 2066 // the other (held or waiting) call." 2067 at_send_command("AT+CHLD=1", NULL); 2068 2069 /* success or failure is ignored by the upper layer here. 2070 it will call GET_CURRENT_CALLS and determine success that way */ 2071 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 2072 break; 2073 case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: 2074 // 3GPP 22.030 6.5.5 2075 // "Places all active calls (if any exist) on hold and accepts 2076 // the other (held or waiting) call." 2077 at_send_command("AT+CHLD=2", NULL); 2078 2079 #ifdef WORKAROUND_ERRONEOUS_ANSWER 2080 s_expectAnswer = 1; 2081 #endif /* WORKAROUND_ERRONEOUS_ANSWER */ 2082 2083 /* success or failure is ignored by the upper layer here. 2084 it will call GET_CURRENT_CALLS and determine success that way */ 2085 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 2086 break; 2087 case RIL_REQUEST_ANSWER: 2088 at_send_command("ATA", NULL); 2089 2090 #ifdef WORKAROUND_ERRONEOUS_ANSWER 2091 s_expectAnswer = 1; 2092 #endif /* WORKAROUND_ERRONEOUS_ANSWER */ 2093 2094 /* success or failure is ignored by the upper layer here. 2095 it will call GET_CURRENT_CALLS and determine success that way */ 2096 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 2097 break; 2098 case RIL_REQUEST_CONFERENCE: 2099 // 3GPP 22.030 6.5.5 2100 // "Adds a held call to the conversation" 2101 at_send_command("AT+CHLD=3", NULL); 2102 2103 /* success or failure is ignored by the upper layer here. 2104 it will call GET_CURRENT_CALLS and determine success that way */ 2105 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 2106 break; 2107 case RIL_REQUEST_UDUB: 2108 /* user determined user busy */ 2109 /* sometimes used: ATH */ 2110 at_send_command("ATH", NULL); 2111 2112 /* success or failure is ignored by the upper layer here. 2113 it will call GET_CURRENT_CALLS and determine success that way */ 2114 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 2115 break; 2116 2117 case RIL_REQUEST_SEPARATE_CONNECTION: 2118 { 2119 char cmd[12]; 2120 int party = ((int*)data)[0]; 2121 2122 // Make sure that party is in a valid range. 2123 // (Note: The Telephony middle layer imposes a range of 1 to 7. 2124 // It's sufficient for us to just make sure it's single digit.) 2125 if (party > 0 && party < 10) { 2126 sprintf(cmd, "AT+CHLD=2%d", party); 2127 at_send_command(cmd, NULL); 2128 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 2129 } else { 2130 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 2131 } 2132 } 2133 break; 2134 2135 case RIL_REQUEST_SIGNAL_STRENGTH: 2136 requestSignalStrength(data, datalen, t); 2137 break; 2138 case RIL_REQUEST_VOICE_REGISTRATION_STATE: 2139 case RIL_REQUEST_DATA_REGISTRATION_STATE: 2140 requestRegistrationState(request, data, datalen, t); 2141 break; 2142 case RIL_REQUEST_OPERATOR: 2143 requestOperator(data, datalen, t); 2144 break; 2145 case RIL_REQUEST_RADIO_POWER: 2146 requestRadioPower(data, datalen, t); 2147 break; 2148 case RIL_REQUEST_DTMF: { 2149 char c = ((char *)data)[0]; 2150 char *cmd; 2151 asprintf(&cmd, "AT+VTS=%c", (int)c); 2152 at_send_command(cmd, NULL); 2153 free(cmd); 2154 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 2155 break; 2156 } 2157 case RIL_REQUEST_SEND_SMS: 2158 case RIL_REQUEST_SEND_SMS_EXPECT_MORE: 2159 requestSendSMS(data, datalen, t); 2160 break; 2161 case RIL_REQUEST_CDMA_SEND_SMS: 2162 requestCdmaSendSMS(data, datalen, t); 2163 break; 2164 case RIL_REQUEST_IMS_SEND_SMS: 2165 requestImsSendSMS(data, datalen, t); 2166 break; 2167 case RIL_REQUEST_SETUP_DATA_CALL: 2168 requestSetupDataCall(data, datalen, t); 2169 break; 2170 case RIL_REQUEST_SMS_ACKNOWLEDGE: 2171 requestSMSAcknowledge(data, datalen, t); 2172 break; 2173 2174 case RIL_REQUEST_GET_IMSI: 2175 p_response = NULL; 2176 err = at_send_command_numeric("AT+CIMI", &p_response); 2177 2178 if (err < 0 || p_response->success == 0) { 2179 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 2180 } else { 2181 RIL_onRequestComplete(t, RIL_E_SUCCESS, 2182 p_response->p_intermediates->line, sizeof(char *)); 2183 } 2184 at_response_free(p_response); 2185 break; 2186 2187 case RIL_REQUEST_GET_IMEI: 2188 p_response = NULL; 2189 err = at_send_command_numeric("AT+CGSN", &p_response); 2190 2191 if (err < 0 || p_response->success == 0) { 2192 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 2193 } else { 2194 RIL_onRequestComplete(t, RIL_E_SUCCESS, 2195 p_response->p_intermediates->line, sizeof(char *)); 2196 } 2197 at_response_free(p_response); 2198 break; 2199 2200 case RIL_REQUEST_SIM_IO: 2201 requestSIM_IO(data,datalen,t); 2202 break; 2203 2204 case RIL_REQUEST_SEND_USSD: 2205 requestSendUSSD(data, datalen, t); 2206 break; 2207 2208 case RIL_REQUEST_CANCEL_USSD: 2209 p_response = NULL; 2210 err = at_send_command_numeric("AT+CUSD=2", &p_response); 2211 2212 if (err < 0 || p_response->success == 0) { 2213 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 2214 } else { 2215 RIL_onRequestComplete(t, RIL_E_SUCCESS, 2216 p_response->p_intermediates->line, sizeof(char *)); 2217 } 2218 at_response_free(p_response); 2219 break; 2220 2221 case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: 2222 at_send_command("AT+COPS=0", NULL); 2223 break; 2224 2225 case RIL_REQUEST_DATA_CALL_LIST: 2226 requestDataCallList(data, datalen, t); 2227 break; 2228 2229 case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: 2230 requestQueryNetworkSelectionMode(data, datalen, t); 2231 break; 2232 2233 case RIL_REQUEST_OEM_HOOK_RAW: 2234 // echo back data 2235 RIL_onRequestComplete(t, RIL_E_SUCCESS, data, datalen); 2236 break; 2237 2238 2239 case RIL_REQUEST_OEM_HOOK_STRINGS: { 2240 int i; 2241 const char ** cur; 2242 2243 RLOGD("got OEM_HOOK_STRINGS: 0x%8p %lu", data, (long)datalen); 2244 2245 2246 for (i = (datalen / sizeof (char *)), cur = (const char **)data ; 2247 i > 0 ; cur++, i --) { 2248 RLOGD("> '%s'", *cur); 2249 } 2250 2251 // echo back strings 2252 RIL_onRequestComplete(t, RIL_E_SUCCESS, data, datalen); 2253 break; 2254 } 2255 2256 case RIL_REQUEST_WRITE_SMS_TO_SIM: 2257 requestWriteSmsToSim(data, datalen, t); 2258 break; 2259 2260 case RIL_REQUEST_DELETE_SMS_ON_SIM: { 2261 char * cmd; 2262 p_response = NULL; 2263 asprintf(&cmd, "AT+CMGD=%d", ((int *)data)[0]); 2264 err = at_send_command(cmd, &p_response); 2265 free(cmd); 2266 if (err < 0 || p_response->success == 0) { 2267 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 2268 } else { 2269 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 2270 } 2271 at_response_free(p_response); 2272 break; 2273 } 2274 2275 case RIL_REQUEST_ENTER_SIM_PIN: 2276 case RIL_REQUEST_ENTER_SIM_PUK: 2277 case RIL_REQUEST_ENTER_SIM_PIN2: 2278 case RIL_REQUEST_ENTER_SIM_PUK2: 2279 case RIL_REQUEST_CHANGE_SIM_PIN: 2280 case RIL_REQUEST_CHANGE_SIM_PIN2: 2281 requestEnterSimPin(data, datalen, t); 2282 break; 2283 2284 case RIL_REQUEST_IMS_REGISTRATION_STATE: { 2285 int reply[2]; 2286 //0==unregistered, 1==registered 2287 reply[0] = s_ims_registered; 2288 2289 //to be used when changed to include service supporated info 2290 //reply[1] = s_ims_services; 2291 2292 // FORMAT_3GPP(1) vs FORMAT_3GPP2(2); 2293 reply[1] = s_ims_format; 2294 2295 RLOGD("IMS_REGISTRATION=%d, format=%d ", 2296 reply[0], reply[1]); 2297 if (reply[1] != -1) { 2298 RIL_onRequestComplete(t, RIL_E_SUCCESS, reply, sizeof(reply)); 2299 } else { 2300 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 2301 } 2302 break; 2303 } 2304 2305 case RIL_REQUEST_VOICE_RADIO_TECH: 2306 { 2307 int tech = techFromModemType(TECH(sMdmInfo)); 2308 if (tech < 0 ) 2309 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 2310 else 2311 RIL_onRequestComplete(t, RIL_E_SUCCESS, &tech, sizeof(tech)); 2312 } 2313 break; 2314 case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: 2315 requestSetPreferredNetworkType(request, data, datalen, t); 2316 break; 2317 2318 case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: 2319 requestGetPreferredNetworkType(request, data, datalen, t); 2320 break; 2321 2322 case RIL_REQUEST_GET_CELL_INFO_LIST: 2323 requestGetCellInfoList(data, datalen, t); 2324 break; 2325 2326 case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: 2327 requestSetCellInfoListRate(data, datalen, t); 2328 break; 2329 2330 case RIL_REQUEST_GET_HARDWARE_CONFIG: 2331 requestGetHardwareConfig(data, datalen, t); 2332 break; 2333 2334 case RIL_REQUEST_SHUTDOWN: 2335 requestShutdown(t); 2336 break; 2337 2338 /* CDMA Specific Requests */ 2339 case RIL_REQUEST_BASEBAND_VERSION: 2340 if (TECH_BIT(sMdmInfo) == MDM_CDMA) { 2341 requestCdmaBaseBandVersion(request, data, datalen, t); 2342 break; 2343 } // Fall-through if tech is not cdma 2344 2345 case RIL_REQUEST_DEVICE_IDENTITY: 2346 if (TECH_BIT(sMdmInfo) == MDM_CDMA) { 2347 requestCdmaDeviceIdentity(request, data, datalen, t); 2348 break; 2349 } // Fall-through if tech is not cdma 2350 2351 case RIL_REQUEST_CDMA_SUBSCRIPTION: 2352 if (TECH_BIT(sMdmInfo) == MDM_CDMA) { 2353 requestCdmaSubscription(request, data, datalen, t); 2354 break; 2355 } // Fall-through if tech is not cdma 2356 2357 case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE: 2358 if (TECH_BIT(sMdmInfo) == MDM_CDMA) { 2359 requestCdmaSetSubscriptionSource(request, data, datalen, t); 2360 break; 2361 } // Fall-through if tech is not cdma 2362 2363 case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: 2364 if (TECH_BIT(sMdmInfo) == MDM_CDMA) { 2365 requestCdmaGetSubscriptionSource(request, data, datalen, t); 2366 break; 2367 } // Fall-through if tech is not cdma 2368 2369 case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE: 2370 if (TECH_BIT(sMdmInfo) == MDM_CDMA) { 2371 requestCdmaGetRoamingPreference(request, data, datalen, t); 2372 break; 2373 } // Fall-through if tech is not cdma 2374 2375 case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE: 2376 if (TECH_BIT(sMdmInfo) == MDM_CDMA) { 2377 requestCdmaSetRoamingPreference(request, data, datalen, t); 2378 break; 2379 } // Fall-through if tech is not cdma 2380 2381 case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: 2382 if (TECH_BIT(sMdmInfo) == MDM_CDMA) { 2383 requestExitEmergencyMode(data, datalen, t); 2384 break; 2385 } // Fall-through if tech is not cdma 2386 2387 default: 2388 RLOGD("Request not supported. Tech: %d",TECH(sMdmInfo)); 2389 RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0); 2390 break; 2391 } 2392 } 2393 2394 /** 2395 * Synchronous call from the RIL to us to return current radio state. 2396 * RADIO_STATE_UNAVAILABLE should be the initial state. 2397 */ 2398 static RIL_RadioState 2399 currentState() 2400 { 2401 return sState; 2402 } 2403 /** 2404 * Call from RIL to us to find out whether a specific request code 2405 * is supported by this implementation. 2406 * 2407 * Return 1 for "supported" and 0 for "unsupported" 2408 */ 2409 2410 static int 2411 onSupports (int requestCode __unused) 2412 { 2413 //@@@ todo 2414 2415 return 1; 2416 } 2417 2418 static void onCancel (RIL_Token t __unused) 2419 { 2420 //@@@todo 2421 2422 } 2423 2424 static const char * getVersion(void) 2425 { 2426 return "android reference-ril 1.0"; 2427 } 2428 2429 static void 2430 setRadioTechnology(ModemInfo *mdm, int newtech) 2431 { 2432 RLOGD("setRadioTechnology(%d)", newtech); 2433 2434 int oldtech = TECH(mdm); 2435 2436 if (newtech != oldtech) { 2437 RLOGD("Tech change (%d => %d)", oldtech, newtech); 2438 TECH(mdm) = newtech; 2439 if (techFromModemType(newtech) != techFromModemType(oldtech)) { 2440 int tech = techFromModemType(TECH(sMdmInfo)); 2441 if (tech > 0 ) { 2442 RIL_onUnsolicitedResponse(RIL_UNSOL_VOICE_RADIO_TECH_CHANGED, 2443 &tech, sizeof(tech)); 2444 } 2445 } 2446 } 2447 } 2448 2449 static void 2450 setRadioState(RIL_RadioState newState) 2451 { 2452 RLOGD("setRadioState(%d)", newState); 2453 RIL_RadioState oldState; 2454 2455 pthread_mutex_lock(&s_state_mutex); 2456 2457 oldState = sState; 2458 2459 if (s_closed > 0) { 2460 // If we're closed, the only reasonable state is 2461 // RADIO_STATE_UNAVAILABLE 2462 // This is here because things on the main thread 2463 // may attempt to change the radio state after the closed 2464 // event happened in another thread 2465 newState = RADIO_STATE_UNAVAILABLE; 2466 } 2467 2468 if (sState != newState || s_closed > 0) { 2469 sState = newState; 2470 2471 pthread_cond_broadcast (&s_state_cond); 2472 } 2473 2474 pthread_mutex_unlock(&s_state_mutex); 2475 2476 2477 /* do these outside of the mutex */ 2478 if (sState != oldState) { 2479 RIL_onUnsolicitedResponse (RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED, 2480 NULL, 0); 2481 // Sim state can change as result of radio state change 2482 RIL_onUnsolicitedResponse (RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, 2483 NULL, 0); 2484 2485 /* FIXME onSimReady() and onRadioPowerOn() cannot be called 2486 * from the AT reader thread 2487 * Currently, this doesn't happen, but if that changes then these 2488 * will need to be dispatched on the request thread 2489 */ 2490 if (sState == RADIO_STATE_ON) { 2491 onRadioPowerOn(); 2492 } 2493 } 2494 } 2495 2496 /** Returns RUIM_NOT_READY on error */ 2497 static SIM_Status 2498 getRUIMStatus() 2499 { 2500 ATResponse *p_response = NULL; 2501 int err; 2502 int ret; 2503 char *cpinLine; 2504 char *cpinResult; 2505 2506 if (sState == RADIO_STATE_OFF || sState == RADIO_STATE_UNAVAILABLE) { 2507 ret = SIM_NOT_READY; 2508 goto done; 2509 } 2510 2511 err = at_send_command_singleline("AT+CPIN?", "+CPIN:", &p_response); 2512 2513 if (err != 0) { 2514 ret = SIM_NOT_READY; 2515 goto done; 2516 } 2517 2518 switch (at_get_cme_error(p_response)) { 2519 case CME_SUCCESS: 2520 break; 2521 2522 case CME_SIM_NOT_INSERTED: 2523 ret = SIM_ABSENT; 2524 goto done; 2525 2526 default: 2527 ret = SIM_NOT_READY; 2528 goto done; 2529 } 2530 2531 /* CPIN? has succeeded, now look at the result */ 2532 2533 cpinLine = p_response->p_intermediates->line; 2534 err = at_tok_start (&cpinLine); 2535 2536 if (err < 0) { 2537 ret = SIM_NOT_READY; 2538 goto done; 2539 } 2540 2541 err = at_tok_nextstr(&cpinLine, &cpinResult); 2542 2543 if (err < 0) { 2544 ret = SIM_NOT_READY; 2545 goto done; 2546 } 2547 2548 if (0 == strcmp (cpinResult, "SIM PIN")) { 2549 ret = SIM_PIN; 2550 goto done; 2551 } else if (0 == strcmp (cpinResult, "SIM PUK")) { 2552 ret = SIM_PUK; 2553 goto done; 2554 } else if (0 == strcmp (cpinResult, "PH-NET PIN")) { 2555 return SIM_NETWORK_PERSONALIZATION; 2556 } else if (0 != strcmp (cpinResult, "READY")) { 2557 /* we're treating unsupported lock types as "sim absent" */ 2558 ret = SIM_ABSENT; 2559 goto done; 2560 } 2561 2562 at_response_free(p_response); 2563 p_response = NULL; 2564 cpinResult = NULL; 2565 2566 ret = SIM_READY; 2567 2568 done: 2569 at_response_free(p_response); 2570 return ret; 2571 } 2572 2573 /** Returns SIM_NOT_READY on error */ 2574 static SIM_Status 2575 getSIMStatus() 2576 { 2577 ATResponse *p_response = NULL; 2578 int err; 2579 int ret; 2580 char *cpinLine; 2581 char *cpinResult; 2582 2583 RLOGD("getSIMStatus(). sState: %d",sState); 2584 if (sState == RADIO_STATE_OFF || sState == RADIO_STATE_UNAVAILABLE) { 2585 ret = SIM_NOT_READY; 2586 goto done; 2587 } 2588 2589 err = at_send_command_singleline("AT+CPIN?", "+CPIN:", &p_response); 2590 2591 if (err != 0) { 2592 ret = SIM_NOT_READY; 2593 goto done; 2594 } 2595 2596 switch (at_get_cme_error(p_response)) { 2597 case CME_SUCCESS: 2598 break; 2599 2600 case CME_SIM_NOT_INSERTED: 2601 ret = SIM_ABSENT; 2602 goto done; 2603 2604 default: 2605 ret = SIM_NOT_READY; 2606 goto done; 2607 } 2608 2609 /* CPIN? has succeeded, now look at the result */ 2610 2611 cpinLine = p_response->p_intermediates->line; 2612 err = at_tok_start (&cpinLine); 2613 2614 if (err < 0) { 2615 ret = SIM_NOT_READY; 2616 goto done; 2617 } 2618 2619 err = at_tok_nextstr(&cpinLine, &cpinResult); 2620 2621 if (err < 0) { 2622 ret = SIM_NOT_READY; 2623 goto done; 2624 } 2625 2626 if (0 == strcmp (cpinResult, "SIM PIN")) { 2627 ret = SIM_PIN; 2628 goto done; 2629 } else if (0 == strcmp (cpinResult, "SIM PUK")) { 2630 ret = SIM_PUK; 2631 goto done; 2632 } else if (0 == strcmp (cpinResult, "PH-NET PIN")) { 2633 return SIM_NETWORK_PERSONALIZATION; 2634 } else if (0 != strcmp (cpinResult, "READY")) { 2635 /* we're treating unsupported lock types as "sim absent" */ 2636 ret = SIM_ABSENT; 2637 goto done; 2638 } 2639 2640 at_response_free(p_response); 2641 p_response = NULL; 2642 cpinResult = NULL; 2643 2644 ret = SIM_READY; 2645 2646 done: 2647 at_response_free(p_response); 2648 return ret; 2649 } 2650 2651 2652 /** 2653 * Get the current card status. 2654 * 2655 * This must be freed using freeCardStatus. 2656 * @return: On success returns RIL_E_SUCCESS 2657 */ 2658 static int getCardStatus(RIL_CardStatus_v6 **pp_card_status) { 2659 static RIL_AppStatus app_status_array[] = { 2660 // SIM_ABSENT = 0 2661 { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN, 2662 NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, 2663 // SIM_NOT_READY = 1 2664 { RIL_APPTYPE_SIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN, 2665 NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, 2666 // SIM_READY = 2 2667 { RIL_APPTYPE_SIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY, 2668 NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, 2669 // SIM_PIN = 3 2670 { RIL_APPTYPE_SIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN, 2671 NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, 2672 // SIM_PUK = 4 2673 { RIL_APPTYPE_SIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN, 2674 NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN }, 2675 // SIM_NETWORK_PERSONALIZATION = 5 2676 { RIL_APPTYPE_SIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK, 2677 NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, 2678 // RUIM_ABSENT = 6 2679 { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN, 2680 NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, 2681 // RUIM_NOT_READY = 7 2682 { RIL_APPTYPE_RUIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN, 2683 NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, 2684 // RUIM_READY = 8 2685 { RIL_APPTYPE_RUIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY, 2686 NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, 2687 // RUIM_PIN = 9 2688 { RIL_APPTYPE_RUIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN, 2689 NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, 2690 // RUIM_PUK = 10 2691 { RIL_APPTYPE_RUIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN, 2692 NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN }, 2693 // RUIM_NETWORK_PERSONALIZATION = 11 2694 { RIL_APPTYPE_RUIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK, 2695 NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN } 2696 }; 2697 RIL_CardState card_state; 2698 int num_apps; 2699 2700 int sim_status = getSIMStatus(); 2701 if (sim_status == SIM_ABSENT) { 2702 card_state = RIL_CARDSTATE_ABSENT; 2703 num_apps = 0; 2704 } else { 2705 card_state = RIL_CARDSTATE_PRESENT; 2706 num_apps = 2; 2707 } 2708 2709 // Allocate and initialize base card status. 2710 RIL_CardStatus_v6 *p_card_status = malloc(sizeof(RIL_CardStatus_v6)); 2711 p_card_status->card_state = card_state; 2712 p_card_status->universal_pin_state = RIL_PINSTATE_UNKNOWN; 2713 p_card_status->gsm_umts_subscription_app_index = RIL_CARD_MAX_APPS; 2714 p_card_status->cdma_subscription_app_index = RIL_CARD_MAX_APPS; 2715 p_card_status->ims_subscription_app_index = RIL_CARD_MAX_APPS; 2716 p_card_status->num_applications = num_apps; 2717 2718 // Initialize application status 2719 int i; 2720 for (i = 0; i < RIL_CARD_MAX_APPS; i++) { 2721 p_card_status->applications[i] = app_status_array[SIM_ABSENT]; 2722 } 2723 2724 // Pickup the appropriate application status 2725 // that reflects sim_status for gsm. 2726 if (num_apps != 0) { 2727 // Only support one app, gsm 2728 p_card_status->num_applications = 2; 2729 p_card_status->gsm_umts_subscription_app_index = 0; 2730 p_card_status->cdma_subscription_app_index = 1; 2731 2732 // Get the correct app status 2733 p_card_status->applications[0] = app_status_array[sim_status]; 2734 p_card_status->applications[1] = app_status_array[sim_status + RUIM_ABSENT]; 2735 } 2736 2737 *pp_card_status = p_card_status; 2738 return RIL_E_SUCCESS; 2739 } 2740 2741 /** 2742 * Free the card status returned by getCardStatus 2743 */ 2744 static void freeCardStatus(RIL_CardStatus_v6 *p_card_status) { 2745 free(p_card_status); 2746 } 2747 2748 /** 2749 * SIM ready means any commands that access the SIM will work, including: 2750 * AT+CPIN, AT+CSMS, AT+CNMI, AT+CRSM 2751 * (all SMS-related commands) 2752 */ 2753 2754 static void pollSIMState (void *param __unused) 2755 { 2756 ATResponse *p_response; 2757 int ret; 2758 2759 if (sState != RADIO_STATE_SIM_NOT_READY) { 2760 // no longer valid to poll 2761 return; 2762 } 2763 2764 switch(getSIMStatus()) { 2765 case SIM_ABSENT: 2766 case SIM_PIN: 2767 case SIM_PUK: 2768 case SIM_NETWORK_PERSONALIZATION: 2769 default: 2770 RLOGI("SIM ABSENT or LOCKED"); 2771 RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0); 2772 return; 2773 2774 case SIM_NOT_READY: 2775 RIL_requestTimedCallback (pollSIMState, NULL, &TIMEVAL_SIMPOLL); 2776 return; 2777 2778 case SIM_READY: 2779 RLOGI("SIM_READY"); 2780 onSIMReady(); 2781 RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0); 2782 return; 2783 } 2784 } 2785 2786 /** returns 1 if on, 0 if off, and -1 on error */ 2787 static int isRadioOn() 2788 { 2789 ATResponse *p_response = NULL; 2790 int err; 2791 char *line; 2792 char ret; 2793 2794 err = at_send_command_singleline("AT+CFUN?", "+CFUN:", &p_response); 2795 2796 if (err < 0 || p_response->success == 0) { 2797 // assume radio is off 2798 goto error; 2799 } 2800 2801 line = p_response->p_intermediates->line; 2802 2803 err = at_tok_start(&line); 2804 if (err < 0) goto error; 2805 2806 err = at_tok_nextbool(&line, &ret); 2807 if (err < 0) goto error; 2808 2809 at_response_free(p_response); 2810 2811 return (int)ret; 2812 2813 error: 2814 2815 at_response_free(p_response); 2816 return -1; 2817 } 2818 2819 /** 2820 * Parse the response generated by a +CTEC AT command 2821 * The values read from the response are stored in current and preferred. 2822 * Both current and preferred may be null. The corresponding value is ignored in that case. 2823 * 2824 * @return: -1 if some error occurs (or if the modem doesn't understand the +CTEC command) 2825 * 1 if the response includes the current technology only 2826 * 0 if the response includes both current technology and preferred mode 2827 */ 2828 int parse_technology_response( const char *response, int *current, int32_t *preferred ) 2829 { 2830 int err; 2831 char *line, *p; 2832 int ct; 2833 int32_t pt = 0; 2834 char *str_pt; 2835 2836 line = p = strdup(response); 2837 RLOGD("Response: %s", line); 2838 err = at_tok_start(&p); 2839 if (err || !at_tok_hasmore(&p)) { 2840 RLOGD("err: %d. p: %s", err, p); 2841 free(line); 2842 return -1; 2843 } 2844 2845 err = at_tok_nextint(&p, &ct); 2846 if (err) { 2847 free(line); 2848 return -1; 2849 } 2850 if (current) *current = ct; 2851 2852 RLOGD("line remaining after int: %s", p); 2853 2854 err = at_tok_nexthexint(&p, &pt); 2855 if (err) { 2856 free(line); 2857 return 1; 2858 } 2859 if (preferred) { 2860 *preferred = pt; 2861 } 2862 free(line); 2863 2864 return 0; 2865 } 2866 2867 int query_supported_techs( ModemInfo *mdm __unused, int *supported ) 2868 { 2869 ATResponse *p_response; 2870 int err, val, techs = 0; 2871 char *tok; 2872 char *line; 2873 2874 RLOGD("query_supported_techs"); 2875 err = at_send_command_singleline("AT+CTEC=?", "+CTEC:", &p_response); 2876 if (err || !p_response->success) 2877 goto error; 2878 line = p_response->p_intermediates->line; 2879 err = at_tok_start(&line); 2880 if (err || !at_tok_hasmore(&line)) 2881 goto error; 2882 while (!at_tok_nextint(&line, &val)) { 2883 techs |= ( 1 << val ); 2884 } 2885 if (supported) *supported = techs; 2886 return 0; 2887 error: 2888 at_response_free(p_response); 2889 return -1; 2890 } 2891 2892 /** 2893 * query_ctec. Send the +CTEC AT command to the modem to query the current 2894 * and preferred modes. It leaves values in the addresses pointed to by 2895 * current and preferred. If any of those pointers are NULL, the corresponding value 2896 * is ignored, but the return value will still reflect if retreiving and parsing of the 2897 * values suceeded. 2898 * 2899 * @mdm Currently unused 2900 * @current A pointer to store the current mode returned by the modem. May be null. 2901 * @preferred A pointer to store the preferred mode returned by the modem. May be null. 2902 * @return -1 on error (or failure to parse) 2903 * 1 if only the current mode was returned by modem (or failed to parse preferred) 2904 * 0 if both current and preferred were returned correctly 2905 */ 2906 int query_ctec(ModemInfo *mdm __unused, int *current, int32_t *preferred) 2907 { 2908 ATResponse *response = NULL; 2909 int err; 2910 int res; 2911 2912 RLOGD("query_ctec. current: %p, preferred: %p", current, preferred); 2913 err = at_send_command_singleline("AT+CTEC?", "+CTEC:", &response); 2914 if (!err && response->success) { 2915 res = parse_technology_response(response->p_intermediates->line, current, preferred); 2916 at_response_free(response); 2917 return res; 2918 } 2919 RLOGE("Error executing command: %d. response: %p. status: %d", err, response, response? response->success : -1); 2920 at_response_free(response); 2921 return -1; 2922 } 2923 2924 int is_multimode_modem(ModemInfo *mdm) 2925 { 2926 ATResponse *response; 2927 int err; 2928 char *line; 2929 int tech; 2930 int32_t preferred; 2931 2932 if (query_ctec(mdm, &tech, &preferred) == 0) { 2933 mdm->currentTech = tech; 2934 mdm->preferredNetworkMode = preferred; 2935 if (query_supported_techs(mdm, &mdm->supportedTechs)) { 2936 return 0; 2937 } 2938 return 1; 2939 } 2940 return 0; 2941 } 2942 2943 /** 2944 * Find out if our modem is GSM, CDMA or both (Multimode) 2945 */ 2946 static void probeForModemMode(ModemInfo *info) 2947 { 2948 ATResponse *response; 2949 int err; 2950 assert (info); 2951 // Currently, our only known multimode modem is qemu's android modem, 2952 // which implements the AT+CTEC command to query and set mode. 2953 // Try that first 2954 2955 if (is_multimode_modem(info)) { 2956 RLOGI("Found Multimode Modem. Supported techs mask: %8.8x. Current tech: %d", 2957 info->supportedTechs, info->currentTech); 2958 return; 2959 } 2960 2961 /* Being here means that our modem is not multimode */ 2962 info->isMultimode = 0; 2963 2964 /* CDMA Modems implement the AT+WNAM command */ 2965 err = at_send_command_singleline("AT+WNAM","+WNAM:", &response); 2966 if (!err && response->success) { 2967 at_response_free(response); 2968 // TODO: find out if we really support EvDo 2969 info->supportedTechs = MDM_CDMA | MDM_EVDO; 2970 info->currentTech = MDM_CDMA; 2971 RLOGI("Found CDMA Modem"); 2972 return; 2973 } 2974 if (!err) at_response_free(response); 2975 // TODO: find out if modem really supports WCDMA/LTE 2976 info->supportedTechs = MDM_GSM | MDM_WCDMA | MDM_LTE; 2977 info->currentTech = MDM_GSM; 2978 RLOGI("Found GSM Modem"); 2979 } 2980 2981 /** 2982 * Initialize everything that can be configured while we're still in 2983 * AT+CFUN=0 2984 */ 2985 static void initializeCallback(void *param __unused) 2986 { 2987 ATResponse *p_response = NULL; 2988 int err; 2989 2990 setRadioState (RADIO_STATE_OFF); 2991 2992 at_handshake(); 2993 2994 probeForModemMode(sMdmInfo); 2995 /* note: we don't check errors here. Everything important will 2996 be handled in onATTimeout and onATReaderClosed */ 2997 2998 /* atchannel is tolerant of echo but it must */ 2999 /* have verbose result codes */ 3000 at_send_command("ATE0Q0V1", NULL); 3001 3002 /* No auto-answer */ 3003 at_send_command("ATS0=0", NULL); 3004 3005 /* Extended errors */ 3006 at_send_command("AT+CMEE=1", NULL); 3007 3008 /* Network registration events */ 3009 err = at_send_command("AT+CREG=2", &p_response); 3010 3011 /* some handsets -- in tethered mode -- don't support CREG=2 */ 3012 if (err < 0 || p_response->success == 0) { 3013 at_send_command("AT+CREG=1", NULL); 3014 } 3015 3016 at_response_free(p_response); 3017 3018 /* GPRS registration events */ 3019 at_send_command("AT+CGREG=1", NULL); 3020 3021 /* Call Waiting notifications */ 3022 at_send_command("AT+CCWA=1", NULL); 3023 3024 /* Alternating voice/data off */ 3025 at_send_command("AT+CMOD=0", NULL); 3026 3027 /* Not muted */ 3028 at_send_command("AT+CMUT=0", NULL); 3029 3030 /* +CSSU unsolicited supp service notifications */ 3031 at_send_command("AT+CSSN=0,1", NULL); 3032 3033 /* no connected line identification */ 3034 at_send_command("AT+COLP=0", NULL); 3035 3036 /* HEX character set */ 3037 at_send_command("AT+CSCS=\"HEX\"", NULL); 3038 3039 /* USSD unsolicited */ 3040 at_send_command("AT+CUSD=1", NULL); 3041 3042 /* Enable +CGEV GPRS event notifications, but don't buffer */ 3043 at_send_command("AT+CGEREP=1,0", NULL); 3044 3045 /* SMS PDU mode */ 3046 at_send_command("AT+CMGF=0", NULL); 3047 3048 #ifdef USE_TI_COMMANDS 3049 3050 at_send_command("AT%CPI=3", NULL); 3051 3052 /* TI specific -- notifications when SMS is ready (currently ignored) */ 3053 at_send_command("AT%CSTAT=1", NULL); 3054 3055 #endif /* USE_TI_COMMANDS */ 3056 3057 3058 /* assume radio is off on error */ 3059 if (isRadioOn() > 0) { 3060 setRadioState (RADIO_STATE_ON); 3061 } 3062 } 3063 3064 static void waitForClose() 3065 { 3066 pthread_mutex_lock(&s_state_mutex); 3067 3068 while (s_closed == 0) { 3069 pthread_cond_wait(&s_state_cond, &s_state_mutex); 3070 } 3071 3072 pthread_mutex_unlock(&s_state_mutex); 3073 } 3074 3075 static void sendUnsolImsNetworkStateChanged() 3076 { 3077 #if 0 // to be used when unsol is changed to return data. 3078 int reply[2]; 3079 reply[0] = s_ims_registered; 3080 reply[1] = s_ims_services; 3081 reply[1] = s_ims_format; 3082 #endif 3083 RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED, 3084 NULL, 0); 3085 } 3086 3087 /** 3088 * Called by atchannel when an unsolicited line appears 3089 * This is called on atchannel's reader thread. AT commands may 3090 * not be issued here 3091 */ 3092 static void onUnsolicited (const char *s, const char *sms_pdu) 3093 { 3094 char *line = NULL, *p; 3095 int err; 3096 3097 /* Ignore unsolicited responses until we're initialized. 3098 * This is OK because the RIL library will poll for initial state 3099 */ 3100 if (sState == RADIO_STATE_UNAVAILABLE) { 3101 return; 3102 } 3103 3104 if (strStartsWith(s, "%CTZV:")) { 3105 /* TI specific -- NITZ time */ 3106 char *response; 3107 3108 line = p = strdup(s); 3109 at_tok_start(&p); 3110 3111 err = at_tok_nextstr(&p, &response); 3112 3113 free(line); 3114 if (err != 0) { 3115 RLOGE("invalid NITZ line %s\n", s); 3116 } else { 3117 RIL_onUnsolicitedResponse ( 3118 RIL_UNSOL_NITZ_TIME_RECEIVED, 3119 response, strlen(response)); 3120 } 3121 } else if (strStartsWith(s,"+CRING:") 3122 || strStartsWith(s,"RING") 3123 || strStartsWith(s,"NO CARRIER") 3124 || strStartsWith(s,"+CCWA") 3125 ) { 3126 RIL_onUnsolicitedResponse ( 3127 RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, 3128 NULL, 0); 3129 #ifdef WORKAROUND_FAKE_CGEV 3130 RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); //TODO use new function 3131 #endif /* WORKAROUND_FAKE_CGEV */ 3132 } else if (strStartsWith(s,"+CREG:") 3133 || strStartsWith(s,"+CGREG:") 3134 ) { 3135 RIL_onUnsolicitedResponse ( 3136 RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, 3137 NULL, 0); 3138 #ifdef WORKAROUND_FAKE_CGEV 3139 RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); 3140 #endif /* WORKAROUND_FAKE_CGEV */ 3141 } else if (strStartsWith(s, "+CMT:")) { 3142 RIL_onUnsolicitedResponse ( 3143 RIL_UNSOL_RESPONSE_NEW_SMS, 3144 sms_pdu, strlen(sms_pdu)); 3145 } else if (strStartsWith(s, "+CDS:")) { 3146 RIL_onUnsolicitedResponse ( 3147 RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT, 3148 sms_pdu, strlen(sms_pdu)); 3149 } else if (strStartsWith(s, "+CGEV:")) { 3150 /* Really, we can ignore NW CLASS and ME CLASS events here, 3151 * but right now we don't since extranous 3152 * RIL_UNSOL_DATA_CALL_LIST_CHANGED calls are tolerated 3153 */ 3154 /* can't issue AT commands here -- call on main thread */ 3155 RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); 3156 #ifdef WORKAROUND_FAKE_CGEV 3157 } else if (strStartsWith(s, "+CME ERROR: 150")) { 3158 RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); 3159 #endif /* WORKAROUND_FAKE_CGEV */ 3160 } else if (strStartsWith(s, "+CTEC: ")) { 3161 int tech, mask; 3162 switch (parse_technology_response(s, &tech, NULL)) 3163 { 3164 case -1: // no argument could be parsed. 3165 RLOGE("invalid CTEC line %s\n", s); 3166 break; 3167 case 1: // current mode correctly parsed 3168 case 0: // preferred mode correctly parsed 3169 mask = 1 << tech; 3170 if (mask != MDM_GSM && mask != MDM_CDMA && 3171 mask != MDM_WCDMA && mask != MDM_LTE) { 3172 RLOGE("Unknown technology %d\n", tech); 3173 } else { 3174 setRadioTechnology(sMdmInfo, tech); 3175 } 3176 break; 3177 } 3178 } else if (strStartsWith(s, "+CCSS: ")) { 3179 int source = 0; 3180 line = p = strdup(s); 3181 if (!line) { 3182 RLOGE("+CCSS: Unable to allocate memory"); 3183 return; 3184 } 3185 if (at_tok_start(&p) < 0) { 3186 free(line); 3187 return; 3188 } 3189 if (at_tok_nextint(&p, &source) < 0) { 3190 RLOGE("invalid +CCSS response: %s", line); 3191 free(line); 3192 return; 3193 } 3194 SSOURCE(sMdmInfo) = source; 3195 RIL_onUnsolicitedResponse(RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED, 3196 &source, sizeof(source)); 3197 } else if (strStartsWith(s, "+WSOS: ")) { 3198 char state = 0; 3199 int unsol; 3200 line = p = strdup(s); 3201 if (!line) { 3202 RLOGE("+WSOS: Unable to allocate memory"); 3203 return; 3204 } 3205 if (at_tok_start(&p) < 0) { 3206 free(line); 3207 return; 3208 } 3209 if (at_tok_nextbool(&p, &state) < 0) { 3210 RLOGE("invalid +WSOS response: %s", line); 3211 free(line); 3212 return; 3213 } 3214 free(line); 3215 3216 unsol = state ? 3217 RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE : RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE; 3218 3219 RIL_onUnsolicitedResponse(unsol, NULL, 0); 3220 3221 } else if (strStartsWith(s, "+WPRL: ")) { 3222 int version = -1; 3223 line = p = strdup(s); 3224 if (!line) { 3225 RLOGE("+WPRL: Unable to allocate memory"); 3226 return; 3227 } 3228 if (at_tok_start(&p) < 0) { 3229 RLOGE("invalid +WPRL response: %s", s); 3230 free(line); 3231 return; 3232 } 3233 if (at_tok_nextint(&p, &version) < 0) { 3234 RLOGE("invalid +WPRL response: %s", s); 3235 free(line); 3236 return; 3237 } 3238 free(line); 3239 RIL_onUnsolicitedResponse(RIL_UNSOL_CDMA_PRL_CHANGED, &version, sizeof(version)); 3240 } else if (strStartsWith(s, "+CFUN: 0")) { 3241 setRadioState(RADIO_STATE_OFF); 3242 } 3243 } 3244 3245 /* Called on command or reader thread */ 3246 static void onATReaderClosed() 3247 { 3248 RLOGI("AT channel closed\n"); 3249 at_close(); 3250 s_closed = 1; 3251 3252 setRadioState (RADIO_STATE_UNAVAILABLE); 3253 } 3254 3255 /* Called on command thread */ 3256 static void onATTimeout() 3257 { 3258 RLOGI("AT channel timeout; closing\n"); 3259 at_close(); 3260 3261 s_closed = 1; 3262 3263 /* FIXME cause a radio reset here */ 3264 3265 setRadioState (RADIO_STATE_UNAVAILABLE); 3266 } 3267 3268 /* Called to pass hardware configuration information to telephony 3269 * framework. 3270 */ 3271 static void setHardwareConfiguration(int num, RIL_HardwareConfig *cfg) 3272 { 3273 RIL_onUnsolicitedResponse(RIL_UNSOL_HARDWARE_CONFIG_CHANGED, cfg, num*sizeof(*cfg)); 3274 } 3275 3276 static void usage(char *s) 3277 { 3278 #ifdef RIL_SHLIB 3279 fprintf(stderr, "reference-ril requires: -p <tcp port> or -d /dev/tty_device\n"); 3280 #else 3281 fprintf(stderr, "usage: %s [-p <tcp port>] [-d /dev/tty_device]\n", s); 3282 exit(-1); 3283 #endif 3284 } 3285 3286 static void * 3287 mainLoop(void *param __unused) 3288 { 3289 int fd; 3290 int ret; 3291 3292 AT_DUMP("== ", "entering mainLoop()", -1 ); 3293 at_set_on_reader_closed(onATReaderClosed); 3294 at_set_on_timeout(onATTimeout); 3295 3296 for (;;) { 3297 fd = -1; 3298 while (fd < 0) { 3299 if (s_port > 0) { 3300 fd = socket_loopback_client(s_port, SOCK_STREAM); 3301 } else if (s_device_socket) { 3302 if (!strcmp(s_device_path, "/dev/socket/qemud")) { 3303 /* Before trying to connect to /dev/socket/qemud (which is 3304 * now another "legacy" way of communicating with the 3305 * emulator), we will try to connecto to gsm service via 3306 * qemu pipe. */ 3307 fd = qemu_pipe_open("qemud:gsm"); 3308 if (fd < 0) { 3309 /* Qemu-specific control socket */ 3310 fd = socket_local_client( "qemud", 3311 ANDROID_SOCKET_NAMESPACE_RESERVED, 3312 SOCK_STREAM ); 3313 if (fd >= 0 ) { 3314 char answer[2]; 3315 3316 if ( write(fd, "gsm", 3) != 3 || 3317 read(fd, answer, 2) != 2 || 3318 memcmp(answer, "OK", 2) != 0) 3319 { 3320 close(fd); 3321 fd = -1; 3322 } 3323 } 3324 } 3325 } 3326 else 3327 fd = socket_local_client( s_device_path, 3328 ANDROID_SOCKET_NAMESPACE_FILESYSTEM, 3329 SOCK_STREAM ); 3330 } else if (s_device_path != NULL) { 3331 fd = open (s_device_path, O_RDWR); 3332 if ( fd >= 0 && !memcmp( s_device_path, "/dev/ttyS", 9 ) ) { 3333 /* disable echo on serial ports */ 3334 struct termios ios; 3335 tcgetattr( fd, &ios ); 3336 ios.c_lflag = 0; /* disable ECHO, ICANON, etc... */ 3337 tcsetattr( fd, TCSANOW, &ios ); 3338 } 3339 } 3340 3341 if (fd < 0) { 3342 perror ("opening AT interface. retrying..."); 3343 sleep(10); 3344 /* never returns */ 3345 } 3346 } 3347 3348 s_closed = 0; 3349 ret = at_open(fd, onUnsolicited); 3350 3351 if (ret < 0) { 3352 RLOGE ("AT error %d on at_open\n", ret); 3353 return 0; 3354 } 3355 3356 RIL_requestTimedCallback(initializeCallback, NULL, &TIMEVAL_0); 3357 3358 // Give initializeCallback a chance to dispatched, since 3359 // we don't presently have a cancellation mechanism 3360 sleep(1); 3361 3362 waitForClose(); 3363 RLOGI("Re-opening after close"); 3364 } 3365 } 3366 3367 #ifdef RIL_SHLIB 3368 3369 pthread_t s_tid_mainloop; 3370 3371 const RIL_RadioFunctions *RIL_Init(const struct RIL_Env *env, int argc, char **argv) 3372 { 3373 int ret; 3374 int fd = -1; 3375 int opt; 3376 pthread_attr_t attr; 3377 3378 s_rilenv = env; 3379 3380 while ( -1 != (opt = getopt(argc, argv, "p:d:s:c:"))) { 3381 switch (opt) { 3382 case 'p': 3383 s_port = atoi(optarg); 3384 if (s_port == 0) { 3385 usage(argv[0]); 3386 return NULL; 3387 } 3388 RLOGI("Opening loopback port %d\n", s_port); 3389 break; 3390 3391 case 'd': 3392 s_device_path = optarg; 3393 RLOGI("Opening tty device %s\n", s_device_path); 3394 break; 3395 3396 case 's': 3397 s_device_path = optarg; 3398 s_device_socket = 1; 3399 RLOGI("Opening socket %s\n", s_device_path); 3400 break; 3401 3402 case 'c': 3403 RLOGI("Client id received %s\n", optarg); 3404 break; 3405 3406 default: 3407 usage(argv[0]); 3408 return NULL; 3409 } 3410 } 3411 3412 if (s_port < 0 && s_device_path == NULL) { 3413 usage(argv[0]); 3414 return NULL; 3415 } 3416 3417 sMdmInfo = calloc(1, sizeof(ModemInfo)); 3418 if (!sMdmInfo) { 3419 RLOGE("Unable to alloc memory for ModemInfo"); 3420 return NULL; 3421 } 3422 pthread_attr_init (&attr); 3423 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); 3424 ret = pthread_create(&s_tid_mainloop, &attr, mainLoop, NULL); 3425 3426 return &s_callbacks; 3427 } 3428 #else /* RIL_SHLIB */ 3429 int main (int argc, char **argv) 3430 { 3431 int ret; 3432 int fd = -1; 3433 int opt; 3434 3435 while ( -1 != (opt = getopt(argc, argv, "p:d:"))) { 3436 switch (opt) { 3437 case 'p': 3438 s_port = atoi(optarg); 3439 if (s_port == 0) { 3440 usage(argv[0]); 3441 } 3442 RLOGI("Opening loopback port %d\n", s_port); 3443 break; 3444 3445 case 'd': 3446 s_device_path = optarg; 3447 RLOGI("Opening tty device %s\n", s_device_path); 3448 break; 3449 3450 case 's': 3451 s_device_path = optarg; 3452 s_device_socket = 1; 3453 RLOGI("Opening socket %s\n", s_device_path); 3454 break; 3455 3456 default: 3457 usage(argv[0]); 3458 } 3459 } 3460 3461 if (s_port < 0 && s_device_path == NULL) { 3462 usage(argv[0]); 3463 } 3464 3465 RIL_register(&s_callbacks); 3466 3467 mainLoop(NULL); 3468 3469 return 0; 3470 } 3471 3472 #endif /* RIL_SHLIB */ 3473
