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 <stdio.h> 19 #include <assert.h> 20 #include <string.h> 21 #include <errno.h> 22 #include <unistd.h> 23 #include <sys/types.h> 24 #include <sys/stat.h> 25 #include <fcntl.h> 26 #include <pthread.h> 27 #include <alloca.h> 28 #include "atchannel.h" 29 #include "at_tok.h" 30 #include "misc.h" 31 #include <getopt.h> 32 #include <sys/socket.h> 33 #include <cutils/sockets.h> 34 #include <termios.h> 35 #include <sys/system_properties.h> 36 37 #include "ril.h" 38 #include "hardware/qemu_pipe.h" 39 40 #define LOG_TAG "RIL" 41 #include <utils/Log.h> 42 43 #define MAX_AT_RESPONSE 0x1000 44 45 /* pathname returned from RIL_REQUEST_SETUP_DATA_CALL / RIL_REQUEST_SETUP_DEFAULT_PDP */ 46 #define PPP_TTY_PATH "eth0" 47 48 #ifdef USE_TI_COMMANDS 49 50 // Enable a workaround 51 // 1) Make incoming call, do not answer 52 // 2) Hangup remote end 53 // Expected: call should disappear from CLCC line 54 // Actual: Call shows as "ACTIVE" before disappearing 55 #define WORKAROUND_ERRONEOUS_ANSWER 1 56 57 // Some varients of the TI stack do not support the +CGEV unsolicited 58 // response. However, they seem to send an unsolicited +CME ERROR: 150 59 #define WORKAROUND_FAKE_CGEV 1 60 #endif 61 62 typedef enum { 63 SIM_ABSENT = 0, 64 SIM_NOT_READY = 1, 65 SIM_READY = 2, /* SIM_READY means the radio state is RADIO_STATE_SIM_READY */ 66 SIM_PIN = 3, 67 SIM_PUK = 4, 68 SIM_NETWORK_PERSONALIZATION = 5 69 } SIM_Status; 70 71 static void onRequest (int request, void *data, size_t datalen, RIL_Token t); 72 static RIL_RadioState currentState(); 73 static int onSupports (int requestCode); 74 static void onCancel (RIL_Token t); 75 static const char *getVersion(); 76 static int isRadioOn(); 77 static SIM_Status getSIMStatus(); 78 static int getCardStatus(RIL_CardStatus_v6 **pp_card_status); 79 static void freeCardStatus(RIL_CardStatus_v6 *p_card_status); 80 static void onDataCallListChanged(void *param); 81 82 extern const char * requestToString(int request); 83 84 /*** Static Variables ***/ 85 static const RIL_RadioFunctions s_callbacks = { 86 RIL_VERSION, 87 onRequest, 88 currentState, 89 onSupports, 90 onCancel, 91 getVersion 92 }; 93 94 #ifdef RIL_SHLIB 95 static const struct RIL_Env *s_rilenv; 96 97 #define RIL_onRequestComplete(t, e, response, responselen) s_rilenv->OnRequestComplete(t,e, response, responselen) 98 #define RIL_onUnsolicitedResponse(a,b,c) s_rilenv->OnUnsolicitedResponse(a,b,c) 99 #define RIL_requestTimedCallback(a,b,c) s_rilenv->RequestTimedCallback(a,b,c) 100 #endif 101 102 static RIL_RadioState sState = RADIO_STATE_UNAVAILABLE; 103 104 static pthread_mutex_t s_state_mutex = PTHREAD_MUTEX_INITIALIZER; 105 static pthread_cond_t s_state_cond = PTHREAD_COND_INITIALIZER; 106 107 static int s_port = -1; 108 static const char * s_device_path = NULL; 109 static int s_device_socket = 0; 110 111 /* trigger change to this with s_state_cond */ 112 static int s_closed = 0; 113 114 static int sFD; /* file desc of AT channel */ 115 static char sATBuffer[MAX_AT_RESPONSE+1]; 116 static char *sATBufferCur = NULL; 117 118 static const struct timeval TIMEVAL_SIMPOLL = {1,0}; 119 static const struct timeval TIMEVAL_CALLSTATEPOLL = {0,500000}; 120 static const struct timeval TIMEVAL_0 = {0,0}; 121 122 #ifdef WORKAROUND_ERRONEOUS_ANSWER 123 // Max number of times we'll try to repoll when we think 124 // we have a AT+CLCC race condition 125 #define REPOLL_CALLS_COUNT_MAX 4 126 127 // Line index that was incoming or waiting at last poll, or -1 for none 128 static int s_incomingOrWaitingLine = -1; 129 // Number of times we've asked for a repoll of AT+CLCC 130 static int s_repollCallsCount = 0; 131 // Should we expect a call to be answered in the next CLCC? 132 static int s_expectAnswer = 0; 133 #endif /* WORKAROUND_ERRONEOUS_ANSWER */ 134 135 static void pollSIMState (void *param); 136 static void setRadioState(RIL_RadioState newState); 137 138 static int clccStateToRILState(int state, RIL_CallState *p_state) 139 140 { 141 switch(state) { 142 case 0: *p_state = RIL_CALL_ACTIVE; return 0; 143 case 1: *p_state = RIL_CALL_HOLDING; return 0; 144 case 2: *p_state = RIL_CALL_DIALING; return 0; 145 case 3: *p_state = RIL_CALL_ALERTING; return 0; 146 case 4: *p_state = RIL_CALL_INCOMING; return 0; 147 case 5: *p_state = RIL_CALL_WAITING; return 0; 148 default: return -1; 149 } 150 } 151 152 /** 153 * Note: directly modified line and has *p_call point directly into 154 * modified line 155 */ 156 static int callFromCLCCLine(char *line, RIL_Call *p_call) 157 { 158 //+CLCC: 1,0,2,0,0,\"+18005551212\",145 159 // index,isMT,state,mode,isMpty(,number,TOA)? 160 161 int err; 162 int state; 163 int mode; 164 165 err = at_tok_start(&line); 166 if (err < 0) goto error; 167 168 err = at_tok_nextint(&line, &(p_call->index)); 169 if (err < 0) goto error; 170 171 err = at_tok_nextbool(&line, &(p_call->isMT)); 172 if (err < 0) goto error; 173 174 err = at_tok_nextint(&line, &state); 175 if (err < 0) goto error; 176 177 err = clccStateToRILState(state, &(p_call->state)); 178 if (err < 0) goto error; 179 180 err = at_tok_nextint(&line, &mode); 181 if (err < 0) goto error; 182 183 p_call->isVoice = (mode == 0); 184 185 err = at_tok_nextbool(&line, &(p_call->isMpty)); 186 if (err < 0) goto error; 187 188 if (at_tok_hasmore(&line)) { 189 err = at_tok_nextstr(&line, &(p_call->number)); 190 191 /* tolerate null here */ 192 if (err < 0) return 0; 193 194 // Some lame implementations return strings 195 // like "NOT AVAILABLE" in the CLCC line 196 if (p_call->number != NULL 197 && 0 == strspn(p_call->number, "+0123456789") 198 ) { 199 p_call->number = NULL; 200 } 201 202 err = at_tok_nextint(&line, &p_call->toa); 203 if (err < 0) goto error; 204 } 205 206 p_call->uusInfo = NULL; 207 208 return 0; 209 210 error: 211 ALOGE("invalid CLCC line\n"); 212 return -1; 213 } 214 215 216 /** do post-AT+CFUN=1 initialization */ 217 static void onRadioPowerOn() 218 { 219 #ifdef USE_TI_COMMANDS 220 /* Must be after CFUN=1 */ 221 /* TI specific -- notifications for CPHS things such */ 222 /* as CPHS message waiting indicator */ 223 224 at_send_command("AT%CPHS=1", NULL); 225 226 /* TI specific -- enable NITZ unsol notifs */ 227 at_send_command("AT%CTZV=1", NULL); 228 #endif 229 230 pollSIMState(NULL); 231 } 232 233 /** do post- SIM ready initialization */ 234 static void onSIMReady() 235 { 236 at_send_command_singleline("AT+CSMS=1", "+CSMS:", NULL); 237 /* 238 * Always send SMS messages directly to the TE 239 * 240 * mode = 1 // discard when link is reserved (link should never be 241 * reserved) 242 * mt = 2 // most messages routed to TE 243 * bm = 2 // new cell BM's routed to TE 244 * ds = 1 // Status reports routed to TE 245 * bfr = 1 // flush buffer 246 */ 247 at_send_command("AT+CNMI=1,2,2,1,1", NULL); 248 } 249 250 static void requestRadioPower(void *data, size_t datalen, RIL_Token t) 251 { 252 int onOff; 253 254 int err; 255 ATResponse *p_response = NULL; 256 257 assert (datalen >= sizeof(int *)); 258 onOff = ((int *)data)[0]; 259 260 if (onOff == 0 && sState != RADIO_STATE_OFF) { 261 err = at_send_command("AT+CFUN=0", &p_response); 262 if (err < 0 || p_response->success == 0) goto error; 263 setRadioState(RADIO_STATE_OFF); 264 } else if (onOff > 0 && sState == RADIO_STATE_OFF) { 265 err = at_send_command("AT+CFUN=1", &p_response); 266 if (err < 0|| p_response->success == 0) { 267 // Some stacks return an error when there is no SIM, 268 // but they really turn the RF portion on 269 // So, if we get an error, let's check to see if it 270 // turned on anyway 271 272 if (isRadioOn() != 1) { 273 goto error; 274 } 275 } 276 setRadioState(RADIO_STATE_SIM_NOT_READY); 277 } 278 279 at_response_free(p_response); 280 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 281 return; 282 error: 283 at_response_free(p_response); 284 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 285 } 286 287 static void requestOrSendDataCallList(RIL_Token *t); 288 289 static void onDataCallListChanged(void *param) 290 { 291 requestOrSendDataCallList(NULL); 292 } 293 294 static void requestDataCallList(void *data, size_t datalen, RIL_Token t) 295 { 296 requestOrSendDataCallList(&t); 297 } 298 299 static void requestOrSendDataCallList(RIL_Token *t) 300 { 301 ATResponse *p_response; 302 ATLine *p_cur; 303 int err; 304 int n = 0; 305 char *out; 306 307 err = at_send_command_multiline ("AT+CGACT?", "+CGACT:", &p_response); 308 if (err != 0 || p_response->success == 0) { 309 if (t != NULL) 310 RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0); 311 else 312 RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, 313 NULL, 0); 314 return; 315 } 316 317 for (p_cur = p_response->p_intermediates; p_cur != NULL; 318 p_cur = p_cur->p_next) 319 n++; 320 321 RIL_Data_Call_Response_v6 *responses = 322 alloca(n * sizeof(RIL_Data_Call_Response_v6)); 323 324 int i; 325 for (i = 0; i < n; i++) { 326 responses[i].status = -1; 327 responses[i].suggestedRetryTime = -1; 328 responses[i].cid = -1; 329 responses[i].active = -1; 330 responses[i].type = ""; 331 responses[i].ifname = ""; 332 responses[i].addresses = ""; 333 responses[i].dnses = ""; 334 responses[i].gateways = ""; 335 } 336 337 RIL_Data_Call_Response_v6 *response = responses; 338 for (p_cur = p_response->p_intermediates; p_cur != NULL; 339 p_cur = p_cur->p_next) { 340 char *line = p_cur->line; 341 342 err = at_tok_start(&line); 343 if (err < 0) 344 goto error; 345 346 err = at_tok_nextint(&line, &response->cid); 347 if (err < 0) 348 goto error; 349 350 err = at_tok_nextint(&line, &response->active); 351 if (err < 0) 352 goto error; 353 354 response++; 355 } 356 357 at_response_free(p_response); 358 359 err = at_send_command_multiline ("AT+CGDCONT?", "+CGDCONT:", &p_response); 360 if (err != 0 || p_response->success == 0) { 361 if (t != NULL) 362 RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0); 363 else 364 RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, 365 NULL, 0); 366 return; 367 } 368 369 for (p_cur = p_response->p_intermediates; p_cur != NULL; 370 p_cur = p_cur->p_next) { 371 char *line = p_cur->line; 372 int cid; 373 374 err = at_tok_start(&line); 375 if (err < 0) 376 goto error; 377 378 err = at_tok_nextint(&line, &cid); 379 if (err < 0) 380 goto error; 381 382 for (i = 0; i < n; i++) { 383 if (responses[i].cid == cid) 384 break; 385 } 386 387 if (i >= n) { 388 /* details for a context we didn't hear about in the last request */ 389 continue; 390 } 391 392 // Assume no error 393 responses[i].status = 0; 394 395 // type 396 err = at_tok_nextstr(&line, &out); 397 if (err < 0) 398 goto error; 399 responses[i].type = alloca(strlen(out) + 1); 400 strcpy(responses[i].type, out); 401 402 // APN ignored for v5 403 err = at_tok_nextstr(&line, &out); 404 if (err < 0) 405 goto error; 406 407 responses[i].ifname = alloca(strlen(PPP_TTY_PATH) + 1); 408 strcpy(responses[i].ifname, PPP_TTY_PATH); 409 410 err = at_tok_nextstr(&line, &out); 411 if (err < 0) 412 goto error; 413 414 responses[i].addresses = alloca(strlen(out) + 1); 415 strcpy(responses[i].addresses, out); 416 417 { 418 char propValue[PROP_VALUE_MAX]; 419 420 if (__system_property_get("ro.kernel.qemu", propValue) != 0) { 421 /* We are in the emulator - the dns servers are listed 422 * by the following system properties, setup in 423 * /system/etc/init.goldfish.sh: 424 * - net.eth0.dns1 425 * - net.eth0.dns2 426 * - net.eth0.dns3 427 * - net.eth0.dns4 428 */ 429 const int dnslist_sz = 128; 430 char* dnslist = alloca(dnslist_sz); 431 const char* separator = ""; 432 int nn; 433 434 dnslist[0] = 0; 435 for (nn = 1; nn <= 4; nn++) { 436 /* Probe net.eth0.dns<n> */ 437 char propName[PROP_NAME_MAX]; 438 snprintf(propName, sizeof propName, "net.eth0.dns%d", nn); 439 440 /* Ignore if undefined */ 441 if (__system_property_get(propName, propValue) == 0) { 442 continue; 443 } 444 445 /* Append the DNS IP address */ 446 strlcat(dnslist, separator, dnslist_sz); 447 strlcat(dnslist, propValue, dnslist_sz); 448 separator = " "; 449 } 450 responses[i].dnses = dnslist; 451 452 /* There is only on gateway in the emulator */ 453 responses[i].gateways = "10.0.2.2"; 454 } 455 else { 456 /* I don't know where we are, so use the public Google DNS 457 * servers by default and no gateway. 458 */ 459 responses[i].dnses = "8.8.8.8 8.8.4.4"; 460 responses[i].gateways = ""; 461 } 462 } 463 } 464 465 at_response_free(p_response); 466 467 if (t != NULL) 468 RIL_onRequestComplete(*t, RIL_E_SUCCESS, responses, 469 n * sizeof(RIL_Data_Call_Response_v6)); 470 else 471 RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, 472 responses, 473 n * sizeof(RIL_Data_Call_Response_v6)); 474 475 return; 476 477 error: 478 if (t != NULL) 479 RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0); 480 else 481 RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, 482 NULL, 0); 483 484 at_response_free(p_response); 485 } 486 487 static void requestQueryNetworkSelectionMode( 488 void *data, size_t datalen, RIL_Token t) 489 { 490 int err; 491 ATResponse *p_response = NULL; 492 int response = 0; 493 char *line; 494 495 err = at_send_command_singleline("AT+COPS?", "+COPS:", &p_response); 496 497 if (err < 0 || p_response->success == 0) { 498 goto error; 499 } 500 501 line = p_response->p_intermediates->line; 502 503 err = at_tok_start(&line); 504 505 if (err < 0) { 506 goto error; 507 } 508 509 err = at_tok_nextint(&line, &response); 510 511 if (err < 0) { 512 goto error; 513 } 514 515 RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(int)); 516 at_response_free(p_response); 517 return; 518 error: 519 at_response_free(p_response); 520 ALOGE("requestQueryNetworkSelectionMode must never return error when radio is on"); 521 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 522 } 523 524 static void sendCallStateChanged(void *param) 525 { 526 RIL_onUnsolicitedResponse ( 527 RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, 528 NULL, 0); 529 } 530 531 static void requestGetCurrentCalls(void *data, size_t datalen, RIL_Token t) 532 { 533 int err; 534 ATResponse *p_response; 535 ATLine *p_cur; 536 int countCalls; 537 int countValidCalls; 538 RIL_Call *p_calls; 539 RIL_Call **pp_calls; 540 int i; 541 int needRepoll = 0; 542 543 #ifdef WORKAROUND_ERRONEOUS_ANSWER 544 int prevIncomingOrWaitingLine; 545 546 prevIncomingOrWaitingLine = s_incomingOrWaitingLine; 547 s_incomingOrWaitingLine = -1; 548 #endif /*WORKAROUND_ERRONEOUS_ANSWER*/ 549 550 err = at_send_command_multiline ("AT+CLCC", "+CLCC:", &p_response); 551 552 if (err != 0 || p_response->success == 0) { 553 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 554 return; 555 } 556 557 /* count the calls */ 558 for (countCalls = 0, p_cur = p_response->p_intermediates 559 ; p_cur != NULL 560 ; p_cur = p_cur->p_next 561 ) { 562 countCalls++; 563 } 564 565 /* yes, there's an array of pointers and then an array of structures */ 566 567 pp_calls = (RIL_Call **)alloca(countCalls * sizeof(RIL_Call *)); 568 p_calls = (RIL_Call *)alloca(countCalls * sizeof(RIL_Call)); 569 memset (p_calls, 0, countCalls * sizeof(RIL_Call)); 570 571 /* init the pointer array */ 572 for(i = 0; i < countCalls ; i++) { 573 pp_calls[i] = &(p_calls[i]); 574 } 575 576 for (countValidCalls = 0, p_cur = p_response->p_intermediates 577 ; p_cur != NULL 578 ; p_cur = p_cur->p_next 579 ) { 580 err = callFromCLCCLine(p_cur->line, p_calls + countValidCalls); 581 582 if (err != 0) { 583 continue; 584 } 585 586 #ifdef WORKAROUND_ERRONEOUS_ANSWER 587 if (p_calls[countValidCalls].state == RIL_CALL_INCOMING 588 || p_calls[countValidCalls].state == RIL_CALL_WAITING 589 ) { 590 s_incomingOrWaitingLine = p_calls[countValidCalls].index; 591 } 592 #endif /*WORKAROUND_ERRONEOUS_ANSWER*/ 593 594 if (p_calls[countValidCalls].state != RIL_CALL_ACTIVE 595 && p_calls[countValidCalls].state != RIL_CALL_HOLDING 596 ) { 597 needRepoll = 1; 598 } 599 600 countValidCalls++; 601 } 602 603 #ifdef WORKAROUND_ERRONEOUS_ANSWER 604 // Basically: 605 // A call was incoming or waiting 606 // Now it's marked as active 607 // But we never answered it 608 // 609 // This is probably a bug, and the call will probably 610 // disappear from the call list in the next poll 611 if (prevIncomingOrWaitingLine >= 0 612 && s_incomingOrWaitingLine < 0 613 && s_expectAnswer == 0 614 ) { 615 for (i = 0; i < countValidCalls ; i++) { 616 617 if (p_calls[i].index == prevIncomingOrWaitingLine 618 && p_calls[i].state == RIL_CALL_ACTIVE 619 && s_repollCallsCount < REPOLL_CALLS_COUNT_MAX 620 ) { 621 ALOGI( 622 "Hit WORKAROUND_ERRONOUS_ANSWER case." 623 " Repoll count: %d\n", s_repollCallsCount); 624 s_repollCallsCount++; 625 goto error; 626 } 627 } 628 } 629 630 s_expectAnswer = 0; 631 s_repollCallsCount = 0; 632 #endif /*WORKAROUND_ERRONEOUS_ANSWER*/ 633 634 RIL_onRequestComplete(t, RIL_E_SUCCESS, pp_calls, 635 countValidCalls * sizeof (RIL_Call *)); 636 637 at_response_free(p_response); 638 639 #ifdef POLL_CALL_STATE 640 if (countValidCalls) { // We don't seem to get a "NO CARRIER" message from 641 // smd, so we're forced to poll until the call ends. 642 #else 643 if (needRepoll) { 644 #endif 645 RIL_requestTimedCallback (sendCallStateChanged, NULL, &TIMEVAL_CALLSTATEPOLL); 646 } 647 648 return; 649 error: 650 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 651 at_response_free(p_response); 652 } 653 654 static void requestDial(void *data, size_t datalen, RIL_Token t) 655 { 656 RIL_Dial *p_dial; 657 char *cmd; 658 const char *clir; 659 int ret; 660 661 p_dial = (RIL_Dial *)data; 662 663 switch (p_dial->clir) { 664 case 1: clir = "I"; break; /*invocation*/ 665 case 2: clir = "i"; break; /*suppression*/ 666 default: 667 case 0: clir = ""; break; /*subscription default*/ 668 } 669 670 asprintf(&cmd, "ATD%s%s;", p_dial->address, clir); 671 672 ret = at_send_command(cmd, NULL); 673 674 free(cmd); 675 676 /* success or failure is ignored by the upper layer here. 677 it will call GET_CURRENT_CALLS and determine success that way */ 678 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 679 } 680 681 static void requestWriteSmsToSim(void *data, size_t datalen, RIL_Token t) 682 { 683 RIL_SMS_WriteArgs *p_args; 684 char *cmd; 685 int length; 686 int err; 687 ATResponse *p_response = NULL; 688 689 p_args = (RIL_SMS_WriteArgs *)data; 690 691 length = strlen(p_args->pdu)/2; 692 asprintf(&cmd, "AT+CMGW=%d,%d", length, p_args->status); 693 694 err = at_send_command_sms(cmd, p_args->pdu, "+CMGW:", &p_response); 695 696 if (err != 0 || p_response->success == 0) goto error; 697 698 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 699 at_response_free(p_response); 700 701 return; 702 error: 703 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 704 at_response_free(p_response); 705 } 706 707 static void requestHangup(void *data, size_t datalen, RIL_Token t) 708 { 709 int *p_line; 710 711 int ret; 712 char *cmd; 713 714 p_line = (int *)data; 715 716 // 3GPP 22.030 6.5.5 717 // "Releases a specific active call X" 718 asprintf(&cmd, "AT+CHLD=1%d", p_line[0]); 719 720 ret = at_send_command(cmd, NULL); 721 722 free(cmd); 723 724 /* success or failure is ignored by the upper layer here. 725 it will call GET_CURRENT_CALLS and determine success that way */ 726 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 727 } 728 729 static void requestSignalStrength(void *data, size_t datalen, RIL_Token t) 730 { 731 ATResponse *p_response = NULL; 732 int err; 733 int response[2]; 734 char *line; 735 736 err = at_send_command_singleline("AT+CSQ", "+CSQ:", &p_response); 737 738 if (err < 0 || p_response->success == 0) { 739 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 740 goto error; 741 } 742 743 line = p_response->p_intermediates->line; 744 745 err = at_tok_start(&line); 746 if (err < 0) goto error; 747 748 err = at_tok_nextint(&line, &(response[0])); 749 if (err < 0) goto error; 750 751 err = at_tok_nextint(&line, &(response[1])); 752 if (err < 0) goto error; 753 754 RIL_onRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response)); 755 756 at_response_free(p_response); 757 return; 758 759 error: 760 ALOGE("requestSignalStrength must never return an error when radio is on"); 761 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 762 at_response_free(p_response); 763 } 764 765 static void requestRegistrationState(int request, void *data, 766 size_t datalen, RIL_Token t) 767 { 768 int err; 769 int response[4]; 770 char * responseStr[4]; 771 ATResponse *p_response = NULL; 772 const char *cmd; 773 const char *prefix; 774 char *line, *p; 775 int commas; 776 int skip; 777 int count = 3; 778 779 780 if (request == RIL_REQUEST_VOICE_REGISTRATION_STATE) { 781 cmd = "AT+CREG?"; 782 prefix = "+CREG:"; 783 } else if (request == RIL_REQUEST_DATA_REGISTRATION_STATE) { 784 cmd = "AT+CGREG?"; 785 prefix = "+CGREG:"; 786 } else { 787 assert(0); 788 goto error; 789 } 790 791 err = at_send_command_singleline(cmd, prefix, &p_response); 792 793 if (err != 0) goto error; 794 795 line = p_response->p_intermediates->line; 796 797 err = at_tok_start(&line); 798 if (err < 0) goto error; 799 800 /* Ok you have to be careful here 801 * The solicited version of the CREG response is 802 * +CREG: n, stat, [lac, cid] 803 * and the unsolicited version is 804 * +CREG: stat, [lac, cid] 805 * The <n> parameter is basically "is unsolicited creg on?" 806 * which it should always be 807 * 808 * Now we should normally get the solicited version here, 809 * but the unsolicited version could have snuck in 810 * so we have to handle both 811 * 812 * Also since the LAC and CID are only reported when registered, 813 * we can have 1, 2, 3, or 4 arguments here 814 * 815 * finally, a +CGREG: answer may have a fifth value that corresponds 816 * to the network type, as in; 817 * 818 * +CGREG: n, stat [,lac, cid [,networkType]] 819 */ 820 821 /* count number of commas */ 822 commas = 0; 823 for (p = line ; *p != '\0' ;p++) { 824 if (*p == ',') commas++; 825 } 826 827 switch (commas) { 828 case 0: /* +CREG: <stat> */ 829 err = at_tok_nextint(&line, &response[0]); 830 if (err < 0) goto error; 831 response[1] = -1; 832 response[2] = -1; 833 break; 834 835 case 1: /* +CREG: <n>, <stat> */ 836 err = at_tok_nextint(&line, &skip); 837 if (err < 0) goto error; 838 err = at_tok_nextint(&line, &response[0]); 839 if (err < 0) goto error; 840 response[1] = -1; 841 response[2] = -1; 842 if (err < 0) goto error; 843 break; 844 845 case 2: /* +CREG: <stat>, <lac>, <cid> */ 846 err = at_tok_nextint(&line, &response[0]); 847 if (err < 0) goto error; 848 err = at_tok_nexthexint(&line, &response[1]); 849 if (err < 0) goto error; 850 err = at_tok_nexthexint(&line, &response[2]); 851 if (err < 0) goto error; 852 break; 853 case 3: /* +CREG: <n>, <stat>, <lac>, <cid> */ 854 err = at_tok_nextint(&line, &skip); 855 if (err < 0) goto error; 856 err = at_tok_nextint(&line, &response[0]); 857 if (err < 0) goto error; 858 err = at_tok_nexthexint(&line, &response[1]); 859 if (err < 0) goto error; 860 err = at_tok_nexthexint(&line, &response[2]); 861 if (err < 0) goto error; 862 break; 863 /* special case for CGREG, there is a fourth parameter 864 * that is the network type (unknown/gprs/edge/umts) 865 */ 866 case 4: /* +CGREG: <n>, <stat>, <lac>, <cid>, <networkType> */ 867 err = at_tok_nextint(&line, &skip); 868 if (err < 0) goto error; 869 err = at_tok_nextint(&line, &response[0]); 870 if (err < 0) goto error; 871 err = at_tok_nexthexint(&line, &response[1]); 872 if (err < 0) goto error; 873 err = at_tok_nexthexint(&line, &response[2]); 874 if (err < 0) goto error; 875 err = at_tok_nexthexint(&line, &response[3]); 876 if (err < 0) goto error; 877 count = 4; 878 break; 879 default: 880 goto error; 881 } 882 883 asprintf(&responseStr[0], "%d", response[0]); 884 asprintf(&responseStr[1], "%x", response[1]); 885 asprintf(&responseStr[2], "%x", response[2]); 886 887 if (count > 3) 888 asprintf(&responseStr[3], "%d", response[3]); 889 890 RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, count*sizeof(char*)); 891 at_response_free(p_response); 892 893 return; 894 error: 895 ALOGE("requestRegistrationState must never return an error when radio is on"); 896 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 897 at_response_free(p_response); 898 } 899 900 static void requestOperator(void *data, size_t datalen, RIL_Token t) 901 { 902 int err; 903 int i; 904 int skip; 905 ATLine *p_cur; 906 char *response[3]; 907 908 memset(response, 0, sizeof(response)); 909 910 ATResponse *p_response = NULL; 911 912 err = at_send_command_multiline( 913 "AT+COPS=3,0;+COPS?;+COPS=3,1;+COPS?;+COPS=3,2;+COPS?", 914 "+COPS:", &p_response); 915 916 /* we expect 3 lines here: 917 * +COPS: 0,0,"T - Mobile" 918 * +COPS: 0,1,"TMO" 919 * +COPS: 0,2,"310170" 920 */ 921 922 if (err != 0) goto error; 923 924 for (i = 0, p_cur = p_response->p_intermediates 925 ; p_cur != NULL 926 ; p_cur = p_cur->p_next, i++ 927 ) { 928 char *line = p_cur->line; 929 930 err = at_tok_start(&line); 931 if (err < 0) goto error; 932 933 err = at_tok_nextint(&line, &skip); 934 if (err < 0) goto error; 935 936 // If we're unregistered, we may just get 937 // a "+COPS: 0" response 938 if (!at_tok_hasmore(&line)) { 939 response[i] = NULL; 940 continue; 941 } 942 943 err = at_tok_nextint(&line, &skip); 944 if (err < 0) goto error; 945 946 // a "+COPS: 0, n" response is also possible 947 if (!at_tok_hasmore(&line)) { 948 response[i] = NULL; 949 continue; 950 } 951 952 err = at_tok_nextstr(&line, &(response[i])); 953 if (err < 0) goto error; 954 } 955 956 if (i != 3) { 957 /* expect 3 lines exactly */ 958 goto error; 959 } 960 961 RIL_onRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response)); 962 at_response_free(p_response); 963 964 return; 965 error: 966 ALOGE("requestOperator must not return error when radio is on"); 967 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 968 at_response_free(p_response); 969 } 970 971 static void requestSendSMS(void *data, size_t datalen, RIL_Token t) 972 { 973 int err; 974 const char *smsc; 975 const char *pdu; 976 int tpLayerLength; 977 char *cmd1, *cmd2; 978 RIL_SMS_Response response; 979 ATResponse *p_response = NULL; 980 981 smsc = ((const char **)data)[0]; 982 pdu = ((const char **)data)[1]; 983 984 tpLayerLength = strlen(pdu)/2; 985 986 // "NULL for default SMSC" 987 if (smsc == NULL) { 988 smsc= "00"; 989 } 990 991 asprintf(&cmd1, "AT+CMGS=%d", tpLayerLength); 992 asprintf(&cmd2, "%s%s", smsc, pdu); 993 994 err = at_send_command_sms(cmd1, cmd2, "+CMGS:", &p_response); 995 996 if (err != 0 || p_response->success == 0) goto error; 997 998 memset(&response, 0, sizeof(response)); 999 1000 /* FIXME fill in messageRef and ackPDU */ 1001 1002 RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response)); 1003 at_response_free(p_response); 1004 1005 return; 1006 error: 1007 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1008 at_response_free(p_response); 1009 } 1010 1011 static void requestSetupDataCall(void *data, size_t datalen, RIL_Token t) 1012 { 1013 const char *apn; 1014 char *cmd; 1015 int err; 1016 ATResponse *p_response = NULL; 1017 1018 apn = ((const char **)data)[2]; 1019 1020 #ifdef USE_TI_COMMANDS 1021 // Config for multislot class 10 (probably default anyway eh?) 1022 err = at_send_command("AT%CPRIM=\"GMM\",\"CONFIG MULTISLOT_CLASS=<10>\"", 1023 NULL); 1024 1025 err = at_send_command("AT%DATA=2,\"UART\",1,,\"SER\",\"UART\",0", NULL); 1026 #endif /* USE_TI_COMMANDS */ 1027 1028 int fd, qmistatus; 1029 size_t cur = 0; 1030 size_t len; 1031 ssize_t written, rlen; 1032 char status[32] = {0}; 1033 int retry = 10; 1034 const char *pdp_type; 1035 1036 ALOGD("requesting data connection to APN '%s'", apn); 1037 1038 fd = open ("/dev/qmi", O_RDWR); 1039 if (fd >= 0) { /* the device doesn't exist on the emulator */ 1040 1041 ALOGD("opened the qmi device\n"); 1042 asprintf(&cmd, "up:%s", apn); 1043 len = strlen(cmd); 1044 1045 while (cur < len) { 1046 do { 1047 written = write (fd, cmd + cur, len - cur); 1048 } while (written < 0 && errno == EINTR); 1049 1050 if (written < 0) { 1051 ALOGE("### ERROR writing to /dev/qmi"); 1052 close(fd); 1053 goto error; 1054 } 1055 1056 cur += written; 1057 } 1058 1059 // wait for interface to come online 1060 1061 do { 1062 sleep(1); 1063 do { 1064 rlen = read(fd, status, 31); 1065 } while (rlen < 0 && errno == EINTR); 1066 1067 if (rlen < 0) { 1068 ALOGE("### ERROR reading from /dev/qmi"); 1069 close(fd); 1070 goto error; 1071 } else { 1072 status[rlen] = '\0'; 1073 ALOGD("### status: %s", status); 1074 } 1075 } while (strncmp(status, "STATE=up", 8) && strcmp(status, "online") && --retry); 1076 1077 close(fd); 1078 1079 if (retry == 0) { 1080 ALOGE("### Failed to get data connection up\n"); 1081 goto error; 1082 } 1083 1084 qmistatus = system("netcfg rmnet0 dhcp"); 1085 1086 ALOGD("netcfg rmnet0 dhcp: status %d\n", qmistatus); 1087 1088 if (qmistatus < 0) goto error; 1089 1090 } else { 1091 1092 if (datalen > 6 * sizeof(char *)) { 1093 pdp_type = ((const char **)data)[6]; 1094 } else { 1095 pdp_type = "IP"; 1096 } 1097 1098 asprintf(&cmd, "AT+CGDCONT=1,\"%s\",\"%s\",,0,0", pdp_type, apn); 1099 //FIXME check for error here 1100 err = at_send_command(cmd, NULL); 1101 free(cmd); 1102 1103 // Set required QoS params to default 1104 err = at_send_command("AT+CGQREQ=1", NULL); 1105 1106 // Set minimum QoS params to default 1107 err = at_send_command("AT+CGQMIN=1", NULL); 1108 1109 // packet-domain event reporting 1110 err = at_send_command("AT+CGEREP=1,0", NULL); 1111 1112 // Hangup anything that's happening there now 1113 err = at_send_command("AT+CGACT=1,0", NULL); 1114 1115 // Start data on PDP context 1 1116 err = at_send_command("ATD*99***1#", &p_response); 1117 1118 if (err < 0 || p_response->success == 0) { 1119 goto error; 1120 } 1121 } 1122 1123 requestOrSendDataCallList(&t); 1124 1125 at_response_free(p_response); 1126 1127 return; 1128 error: 1129 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1130 at_response_free(p_response); 1131 1132 } 1133 1134 static void requestSMSAcknowledge(void *data, size_t datalen, RIL_Token t) 1135 { 1136 int ackSuccess; 1137 int err; 1138 1139 ackSuccess = ((int *)data)[0]; 1140 1141 if (ackSuccess == 1) { 1142 err = at_send_command("AT+CNMA=1", NULL); 1143 } else if (ackSuccess == 0) { 1144 err = at_send_command("AT+CNMA=2", NULL); 1145 } else { 1146 ALOGE("unsupported arg to RIL_REQUEST_SMS_ACKNOWLEDGE\n"); 1147 goto error; 1148 } 1149 1150 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1151 error: 1152 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1153 1154 } 1155 1156 static void requestSIM_IO(void *data, size_t datalen, RIL_Token t) 1157 { 1158 ATResponse *p_response = NULL; 1159 RIL_SIM_IO_Response sr; 1160 int err; 1161 char *cmd = NULL; 1162 RIL_SIM_IO_v6 *p_args; 1163 char *line; 1164 1165 memset(&sr, 0, sizeof(sr)); 1166 1167 p_args = (RIL_SIM_IO_v6 *)data; 1168 1169 /* FIXME handle pin2 */ 1170 1171 if (p_args->data == NULL) { 1172 asprintf(&cmd, "AT+CRSM=%d,%d,%d,%d,%d", 1173 p_args->command, p_args->fileid, 1174 p_args->p1, p_args->p2, p_args->p3); 1175 } else { 1176 asprintf(&cmd, "AT+CRSM=%d,%d,%d,%d,%d,%s", 1177 p_args->command, p_args->fileid, 1178 p_args->p1, p_args->p2, p_args->p3, p_args->data); 1179 } 1180 1181 err = at_send_command_singleline(cmd, "+CRSM:", &p_response); 1182 1183 if (err < 0 || p_response->success == 0) { 1184 goto error; 1185 } 1186 1187 line = p_response->p_intermediates->line; 1188 1189 err = at_tok_start(&line); 1190 if (err < 0) goto error; 1191 1192 err = at_tok_nextint(&line, &(sr.sw1)); 1193 if (err < 0) goto error; 1194 1195 err = at_tok_nextint(&line, &(sr.sw2)); 1196 if (err < 0) goto error; 1197 1198 if (at_tok_hasmore(&line)) { 1199 err = at_tok_nextstr(&line, &(sr.simResponse)); 1200 if (err < 0) goto error; 1201 } 1202 1203 RIL_onRequestComplete(t, RIL_E_SUCCESS, &sr, sizeof(sr)); 1204 at_response_free(p_response); 1205 free(cmd); 1206 1207 return; 1208 error: 1209 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1210 at_response_free(p_response); 1211 free(cmd); 1212 1213 } 1214 1215 static void requestEnterSimPin(void* data, size_t datalen, RIL_Token t) 1216 { 1217 ATResponse *p_response = NULL; 1218 int err; 1219 char* cmd = NULL; 1220 const char** strings = (const char**)data;; 1221 1222 if ( datalen == sizeof(char*) ) { 1223 asprintf(&cmd, "AT+CPIN=%s", strings[0]); 1224 } else if ( datalen == 2*sizeof(char*) ) { 1225 asprintf(&cmd, "AT+CPIN=%s,%s", strings[0], strings[1]); 1226 } else 1227 goto error; 1228 1229 err = at_send_command_singleline(cmd, "+CPIN:", &p_response); 1230 free(cmd); 1231 1232 if (err < 0 || p_response->success == 0) { 1233 error: 1234 RIL_onRequestComplete(t, RIL_E_PASSWORD_INCORRECT, NULL, 0); 1235 } else { 1236 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1237 } 1238 at_response_free(p_response); 1239 } 1240 1241 1242 static void requestSendUSSD(void *data, size_t datalen, RIL_Token t) 1243 { 1244 const char *ussdRequest; 1245 1246 ussdRequest = (char *)(data); 1247 1248 1249 RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0); 1250 1251 // @@@ TODO 1252 1253 } 1254 1255 1256 /*** Callback methods from the RIL library to us ***/ 1257 1258 /** 1259 * Call from RIL to us to make a RIL_REQUEST 1260 * 1261 * Must be completed with a call to RIL_onRequestComplete() 1262 * 1263 * RIL_onRequestComplete() may be called from any thread, before or after 1264 * this function returns. 1265 * 1266 * Will always be called from the same thread, so returning here implies 1267 * that the radio is ready to process another command (whether or not 1268 * the previous command has completed). 1269 */ 1270 static void 1271 onRequest (int request, void *data, size_t datalen, RIL_Token t) 1272 { 1273 ATResponse *p_response; 1274 int err; 1275 1276 ALOGD("onRequest: %s", requestToString(request)); 1277 1278 /* Ignore all requests except RIL_REQUEST_GET_SIM_STATUS 1279 * when RADIO_STATE_UNAVAILABLE. 1280 */ 1281 if (sState == RADIO_STATE_UNAVAILABLE 1282 && request != RIL_REQUEST_GET_SIM_STATUS 1283 ) { 1284 RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); 1285 return; 1286 } 1287 1288 /* Ignore all non-power requests when RADIO_STATE_OFF 1289 * (except RIL_REQUEST_GET_SIM_STATUS) 1290 */ 1291 if (sState == RADIO_STATE_OFF 1292 && !(request == RIL_REQUEST_RADIO_POWER 1293 || request == RIL_REQUEST_GET_SIM_STATUS) 1294 ) { 1295 RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); 1296 return; 1297 } 1298 1299 switch (request) { 1300 case RIL_REQUEST_GET_SIM_STATUS: { 1301 RIL_CardStatus_v6 *p_card_status; 1302 char *p_buffer; 1303 int buffer_size; 1304 1305 int result = getCardStatus(&p_card_status); 1306 if (result == RIL_E_SUCCESS) { 1307 p_buffer = (char *)p_card_status; 1308 buffer_size = sizeof(*p_card_status); 1309 } else { 1310 p_buffer = NULL; 1311 buffer_size = 0; 1312 } 1313 RIL_onRequestComplete(t, result, p_buffer, buffer_size); 1314 freeCardStatus(p_card_status); 1315 break; 1316 } 1317 case RIL_REQUEST_GET_CURRENT_CALLS: 1318 requestGetCurrentCalls(data, datalen, t); 1319 break; 1320 case RIL_REQUEST_DIAL: 1321 requestDial(data, datalen, t); 1322 break; 1323 case RIL_REQUEST_HANGUP: 1324 requestHangup(data, datalen, t); 1325 break; 1326 case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: 1327 // 3GPP 22.030 6.5.5 1328 // "Releases all held calls or sets User Determined User Busy 1329 // (UDUB) for a waiting call." 1330 at_send_command("AT+CHLD=0", NULL); 1331 1332 /* success or failure is ignored by the upper layer here. 1333 it will call GET_CURRENT_CALLS and determine success that way */ 1334 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1335 break; 1336 case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: 1337 // 3GPP 22.030 6.5.5 1338 // "Releases all active calls (if any exist) and accepts 1339 // the other (held or waiting) call." 1340 at_send_command("AT+CHLD=1", NULL); 1341 1342 /* success or failure is ignored by the upper layer here. 1343 it will call GET_CURRENT_CALLS and determine success that way */ 1344 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1345 break; 1346 case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: 1347 // 3GPP 22.030 6.5.5 1348 // "Places all active calls (if any exist) on hold and accepts 1349 // the other (held or waiting) call." 1350 at_send_command("AT+CHLD=2", NULL); 1351 1352 #ifdef WORKAROUND_ERRONEOUS_ANSWER 1353 s_expectAnswer = 1; 1354 #endif /* WORKAROUND_ERRONEOUS_ANSWER */ 1355 1356 /* success or failure is ignored by the upper layer here. 1357 it will call GET_CURRENT_CALLS and determine success that way */ 1358 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1359 break; 1360 case RIL_REQUEST_ANSWER: 1361 at_send_command("ATA", NULL); 1362 1363 #ifdef WORKAROUND_ERRONEOUS_ANSWER 1364 s_expectAnswer = 1; 1365 #endif /* WORKAROUND_ERRONEOUS_ANSWER */ 1366 1367 /* success or failure is ignored by the upper layer here. 1368 it will call GET_CURRENT_CALLS and determine success that way */ 1369 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1370 break; 1371 case RIL_REQUEST_CONFERENCE: 1372 // 3GPP 22.030 6.5.5 1373 // "Adds a held call to the conversation" 1374 at_send_command("AT+CHLD=3", NULL); 1375 1376 /* success or failure is ignored by the upper layer here. 1377 it will call GET_CURRENT_CALLS and determine success that way */ 1378 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1379 break; 1380 case RIL_REQUEST_UDUB: 1381 /* user determined user busy */ 1382 /* sometimes used: ATH */ 1383 at_send_command("ATH", NULL); 1384 1385 /* success or failure is ignored by the upper layer here. 1386 it will call GET_CURRENT_CALLS and determine success that way */ 1387 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1388 break; 1389 1390 case RIL_REQUEST_SEPARATE_CONNECTION: 1391 { 1392 char cmd[12]; 1393 int party = ((int*)data)[0]; 1394 1395 // Make sure that party is in a valid range. 1396 // (Note: The Telephony middle layer imposes a range of 1 to 7. 1397 // It's sufficient for us to just make sure it's single digit.) 1398 if (party > 0 && party < 10) { 1399 sprintf(cmd, "AT+CHLD=2%d", party); 1400 at_send_command(cmd, NULL); 1401 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1402 } else { 1403 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1404 } 1405 } 1406 break; 1407 1408 case RIL_REQUEST_SIGNAL_STRENGTH: 1409 requestSignalStrength(data, datalen, t); 1410 break; 1411 case RIL_REQUEST_VOICE_REGISTRATION_STATE: 1412 case RIL_REQUEST_DATA_REGISTRATION_STATE: 1413 requestRegistrationState(request, data, datalen, t); 1414 break; 1415 case RIL_REQUEST_OPERATOR: 1416 requestOperator(data, datalen, t); 1417 break; 1418 case RIL_REQUEST_RADIO_POWER: 1419 requestRadioPower(data, datalen, t); 1420 break; 1421 case RIL_REQUEST_DTMF: { 1422 char c = ((char *)data)[0]; 1423 char *cmd; 1424 asprintf(&cmd, "AT+VTS=%c", (int)c); 1425 at_send_command(cmd, NULL); 1426 free(cmd); 1427 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1428 break; 1429 } 1430 case RIL_REQUEST_SEND_SMS: 1431 requestSendSMS(data, datalen, t); 1432 break; 1433 case RIL_REQUEST_SETUP_DATA_CALL: 1434 requestSetupDataCall(data, datalen, t); 1435 break; 1436 case RIL_REQUEST_SMS_ACKNOWLEDGE: 1437 requestSMSAcknowledge(data, datalen, t); 1438 break; 1439 1440 case RIL_REQUEST_GET_IMSI: 1441 p_response = NULL; 1442 err = at_send_command_numeric("AT+CIMI", &p_response); 1443 1444 if (err < 0 || p_response->success == 0) { 1445 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1446 } else { 1447 RIL_onRequestComplete(t, RIL_E_SUCCESS, 1448 p_response->p_intermediates->line, sizeof(char *)); 1449 } 1450 at_response_free(p_response); 1451 break; 1452 1453 case RIL_REQUEST_GET_IMEI: 1454 p_response = NULL; 1455 err = at_send_command_numeric("AT+CGSN", &p_response); 1456 1457 if (err < 0 || p_response->success == 0) { 1458 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1459 } else { 1460 RIL_onRequestComplete(t, RIL_E_SUCCESS, 1461 p_response->p_intermediates->line, sizeof(char *)); 1462 } 1463 at_response_free(p_response); 1464 break; 1465 1466 case RIL_REQUEST_SIM_IO: 1467 requestSIM_IO(data,datalen,t); 1468 break; 1469 1470 case RIL_REQUEST_SEND_USSD: 1471 requestSendUSSD(data, datalen, t); 1472 break; 1473 1474 case RIL_REQUEST_CANCEL_USSD: 1475 p_response = NULL; 1476 err = at_send_command_numeric("AT+CUSD=2", &p_response); 1477 1478 if (err < 0 || p_response->success == 0) { 1479 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1480 } else { 1481 RIL_onRequestComplete(t, RIL_E_SUCCESS, 1482 p_response->p_intermediates->line, sizeof(char *)); 1483 } 1484 at_response_free(p_response); 1485 break; 1486 1487 case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: 1488 at_send_command("AT+COPS=0", NULL); 1489 break; 1490 1491 case RIL_REQUEST_DATA_CALL_LIST: 1492 requestDataCallList(data, datalen, t); 1493 break; 1494 1495 case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: 1496 requestQueryNetworkSelectionMode(data, datalen, t); 1497 break; 1498 1499 case RIL_REQUEST_OEM_HOOK_RAW: 1500 // echo back data 1501 RIL_onRequestComplete(t, RIL_E_SUCCESS, data, datalen); 1502 break; 1503 1504 1505 case RIL_REQUEST_OEM_HOOK_STRINGS: { 1506 int i; 1507 const char ** cur; 1508 1509 ALOGD("got OEM_HOOK_STRINGS: 0x%8p %lu", data, (long)datalen); 1510 1511 1512 for (i = (datalen / sizeof (char *)), cur = (const char **)data ; 1513 i > 0 ; cur++, i --) { 1514 ALOGD("> '%s'", *cur); 1515 } 1516 1517 // echo back strings 1518 RIL_onRequestComplete(t, RIL_E_SUCCESS, data, datalen); 1519 break; 1520 } 1521 1522 case RIL_REQUEST_WRITE_SMS_TO_SIM: 1523 requestWriteSmsToSim(data, datalen, t); 1524 break; 1525 1526 case RIL_REQUEST_DELETE_SMS_ON_SIM: { 1527 char * cmd; 1528 p_response = NULL; 1529 asprintf(&cmd, "AT+CMGD=%d", ((int *)data)[0]); 1530 err = at_send_command(cmd, &p_response); 1531 free(cmd); 1532 if (err < 0 || p_response->success == 0) { 1533 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); 1534 } else { 1535 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); 1536 } 1537 at_response_free(p_response); 1538 break; 1539 } 1540 1541 case RIL_REQUEST_ENTER_SIM_PIN: 1542 case RIL_REQUEST_ENTER_SIM_PUK: 1543 case RIL_REQUEST_ENTER_SIM_PIN2: 1544 case RIL_REQUEST_ENTER_SIM_PUK2: 1545 case RIL_REQUEST_CHANGE_SIM_PIN: 1546 case RIL_REQUEST_CHANGE_SIM_PIN2: 1547 requestEnterSimPin(data, datalen, t); 1548 break; 1549 1550 default: 1551 RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0); 1552 break; 1553 } 1554 } 1555 1556 /** 1557 * Synchronous call from the RIL to us to return current radio state. 1558 * RADIO_STATE_UNAVAILABLE should be the initial state. 1559 */ 1560 static RIL_RadioState 1561 currentState() 1562 { 1563 return sState; 1564 } 1565 /** 1566 * Call from RIL to us to find out whether a specific request code 1567 * is supported by this implementation. 1568 * 1569 * Return 1 for "supported" and 0 for "unsupported" 1570 */ 1571 1572 static int 1573 onSupports (int requestCode) 1574 { 1575 //@@@ todo 1576 1577 return 1; 1578 } 1579 1580 static void onCancel (RIL_Token t) 1581 { 1582 //@@@todo 1583 1584 } 1585 1586 static const char * getVersion(void) 1587 { 1588 return "android reference-ril 1.0"; 1589 } 1590 1591 static void 1592 setRadioState(RIL_RadioState newState) 1593 { 1594 RIL_RadioState oldState; 1595 1596 pthread_mutex_lock(&s_state_mutex); 1597 1598 oldState = sState; 1599 1600 if (s_closed > 0) { 1601 // If we're closed, the only reasonable state is 1602 // RADIO_STATE_UNAVAILABLE 1603 // This is here because things on the main thread 1604 // may attempt to change the radio state after the closed 1605 // event happened in another thread 1606 newState = RADIO_STATE_UNAVAILABLE; 1607 } 1608 1609 if (sState != newState || s_closed > 0) { 1610 sState = newState; 1611 1612 pthread_cond_broadcast (&s_state_cond); 1613 } 1614 1615 pthread_mutex_unlock(&s_state_mutex); 1616 1617 1618 /* do these outside of the mutex */ 1619 if (sState != oldState) { 1620 RIL_onUnsolicitedResponse (RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED, 1621 NULL, 0); 1622 1623 /* FIXME onSimReady() and onRadioPowerOn() cannot be called 1624 * from the AT reader thread 1625 * Currently, this doesn't happen, but if that changes then these 1626 * will need to be dispatched on the request thread 1627 */ 1628 if (sState == RADIO_STATE_SIM_READY) { 1629 onSIMReady(); 1630 } else if (sState == RADIO_STATE_SIM_NOT_READY) { 1631 onRadioPowerOn(); 1632 } 1633 } 1634 } 1635 1636 /** Returns SIM_NOT_READY on error */ 1637 static SIM_Status 1638 getSIMStatus() 1639 { 1640 ATResponse *p_response = NULL; 1641 int err; 1642 int ret; 1643 char *cpinLine; 1644 char *cpinResult; 1645 1646 if (sState == RADIO_STATE_OFF || sState == RADIO_STATE_UNAVAILABLE) { 1647 ret = SIM_NOT_READY; 1648 goto done; 1649 } 1650 1651 err = at_send_command_singleline("AT+CPIN?", "+CPIN:", &p_response); 1652 1653 if (err != 0) { 1654 ret = SIM_NOT_READY; 1655 goto done; 1656 } 1657 1658 switch (at_get_cme_error(p_response)) { 1659 case CME_SUCCESS: 1660 break; 1661 1662 case CME_SIM_NOT_INSERTED: 1663 ret = SIM_ABSENT; 1664 goto done; 1665 1666 default: 1667 ret = SIM_NOT_READY; 1668 goto done; 1669 } 1670 1671 /* CPIN? has succeeded, now look at the result */ 1672 1673 cpinLine = p_response->p_intermediates->line; 1674 err = at_tok_start (&cpinLine); 1675 1676 if (err < 0) { 1677 ret = SIM_NOT_READY; 1678 goto done; 1679 } 1680 1681 err = at_tok_nextstr(&cpinLine, &cpinResult); 1682 1683 if (err < 0) { 1684 ret = SIM_NOT_READY; 1685 goto done; 1686 } 1687 1688 if (0 == strcmp (cpinResult, "SIM PIN")) { 1689 ret = SIM_PIN; 1690 goto done; 1691 } else if (0 == strcmp (cpinResult, "SIM PUK")) { 1692 ret = SIM_PUK; 1693 goto done; 1694 } else if (0 == strcmp (cpinResult, "PH-NET PIN")) { 1695 return SIM_NETWORK_PERSONALIZATION; 1696 } else if (0 != strcmp (cpinResult, "READY")) { 1697 /* we're treating unsupported lock types as "sim absent" */ 1698 ret = SIM_ABSENT; 1699 goto done; 1700 } 1701 1702 at_response_free(p_response); 1703 p_response = NULL; 1704 cpinResult = NULL; 1705 1706 ret = SIM_READY; 1707 1708 done: 1709 at_response_free(p_response); 1710 return ret; 1711 } 1712 1713 1714 /** 1715 * Get the current card status. 1716 * 1717 * This must be freed using freeCardStatus. 1718 * @return: On success returns RIL_E_SUCCESS 1719 */ 1720 static int getCardStatus(RIL_CardStatus_v6 **pp_card_status) { 1721 static RIL_AppStatus app_status_array[] = { 1722 // SIM_ABSENT = 0 1723 { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN, 1724 NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, 1725 // SIM_NOT_READY = 1 1726 { RIL_APPTYPE_SIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN, 1727 NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, 1728 // SIM_READY = 2 1729 { RIL_APPTYPE_SIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY, 1730 NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, 1731 // SIM_PIN = 3 1732 { RIL_APPTYPE_SIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN, 1733 NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, 1734 // SIM_PUK = 4 1735 { RIL_APPTYPE_SIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN, 1736 NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN }, 1737 // SIM_NETWORK_PERSONALIZATION = 5 1738 { RIL_APPTYPE_SIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK, 1739 NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN } 1740 }; 1741 RIL_CardState card_state; 1742 int num_apps; 1743 1744 int sim_status = getSIMStatus(); 1745 if (sim_status == SIM_ABSENT) { 1746 card_state = RIL_CARDSTATE_ABSENT; 1747 num_apps = 0; 1748 } else { 1749 card_state = RIL_CARDSTATE_PRESENT; 1750 num_apps = 1; 1751 } 1752 1753 // Allocate and initialize base card status. 1754 RIL_CardStatus_v6 *p_card_status = malloc(sizeof(RIL_CardStatus_v6)); 1755 p_card_status->card_state = card_state; 1756 p_card_status->universal_pin_state = RIL_PINSTATE_UNKNOWN; 1757 p_card_status->gsm_umts_subscription_app_index = RIL_CARD_MAX_APPS; 1758 p_card_status->cdma_subscription_app_index = RIL_CARD_MAX_APPS; 1759 p_card_status->ims_subscription_app_index = RIL_CARD_MAX_APPS; 1760 p_card_status->num_applications = num_apps; 1761 1762 // Initialize application status 1763 int i; 1764 for (i = 0; i < RIL_CARD_MAX_APPS; i++) { 1765 p_card_status->applications[i] = app_status_array[SIM_ABSENT]; 1766 } 1767 1768 // Pickup the appropriate application status 1769 // that reflects sim_status for gsm. 1770 if (num_apps != 0) { 1771 // Only support one app, gsm 1772 p_card_status->num_applications = 1; 1773 p_card_status->gsm_umts_subscription_app_index = 0; 1774 1775 // Get the correct app status 1776 p_card_status->applications[0] = app_status_array[sim_status]; 1777 } 1778 1779 *pp_card_status = p_card_status; 1780 return RIL_E_SUCCESS; 1781 } 1782 1783 /** 1784 * Free the card status returned by getCardStatus 1785 */ 1786 static void freeCardStatus(RIL_CardStatus_v6 *p_card_status) { 1787 free(p_card_status); 1788 } 1789 1790 /** 1791 * SIM ready means any commands that access the SIM will work, including: 1792 * AT+CPIN, AT+CSMS, AT+CNMI, AT+CRSM 1793 * (all SMS-related commands) 1794 */ 1795 1796 static void pollSIMState (void *param) 1797 { 1798 ATResponse *p_response; 1799 int ret; 1800 1801 if (sState != RADIO_STATE_SIM_NOT_READY) { 1802 // no longer valid to poll 1803 return; 1804 } 1805 1806 switch(getSIMStatus()) { 1807 case SIM_ABSENT: 1808 case SIM_PIN: 1809 case SIM_PUK: 1810 case SIM_NETWORK_PERSONALIZATION: 1811 default: 1812 setRadioState(RADIO_STATE_SIM_LOCKED_OR_ABSENT); 1813 return; 1814 1815 case SIM_NOT_READY: 1816 RIL_requestTimedCallback (pollSIMState, NULL, &TIMEVAL_SIMPOLL); 1817 return; 1818 1819 case SIM_READY: 1820 setRadioState(RADIO_STATE_SIM_READY); 1821 return; 1822 } 1823 } 1824 1825 /** returns 1 if on, 0 if off, and -1 on error */ 1826 static int isRadioOn() 1827 { 1828 ATResponse *p_response = NULL; 1829 int err; 1830 char *line; 1831 char ret; 1832 1833 err = at_send_command_singleline("AT+CFUN?", "+CFUN:", &p_response); 1834 1835 if (err < 0 || p_response->success == 0) { 1836 // assume radio is off 1837 goto error; 1838 } 1839 1840 line = p_response->p_intermediates->line; 1841 1842 err = at_tok_start(&line); 1843 if (err < 0) goto error; 1844 1845 err = at_tok_nextbool(&line, &ret); 1846 if (err < 0) goto error; 1847 1848 at_response_free(p_response); 1849 1850 return (int)ret; 1851 1852 error: 1853 1854 at_response_free(p_response); 1855 return -1; 1856 } 1857 1858 /** 1859 * Initialize everything that can be configured while we're still in 1860 * AT+CFUN=0 1861 */ 1862 static void initializeCallback(void *param) 1863 { 1864 ATResponse *p_response = NULL; 1865 int err; 1866 1867 setRadioState (RADIO_STATE_OFF); 1868 1869 at_handshake(); 1870 1871 /* note: we don't check errors here. Everything important will 1872 be handled in onATTimeout and onATReaderClosed */ 1873 1874 /* atchannel is tolerant of echo but it must */ 1875 /* have verbose result codes */ 1876 at_send_command("ATE0Q0V1", NULL); 1877 1878 /* No auto-answer */ 1879 at_send_command("ATS0=0", NULL); 1880 1881 /* Extended errors */ 1882 at_send_command("AT+CMEE=1", NULL); 1883 1884 /* Network registration events */ 1885 err = at_send_command("AT+CREG=2", &p_response); 1886 1887 /* some handsets -- in tethered mode -- don't support CREG=2 */ 1888 if (err < 0 || p_response->success == 0) { 1889 at_send_command("AT+CREG=1", NULL); 1890 } 1891 1892 at_response_free(p_response); 1893 1894 /* GPRS registration events */ 1895 at_send_command("AT+CGREG=1", NULL); 1896 1897 /* Call Waiting notifications */ 1898 at_send_command("AT+CCWA=1", NULL); 1899 1900 /* Alternating voice/data off */ 1901 at_send_command("AT+CMOD=0", NULL); 1902 1903 /* Not muted */ 1904 at_send_command("AT+CMUT=0", NULL); 1905 1906 /* +CSSU unsolicited supp service notifications */ 1907 at_send_command("AT+CSSN=0,1", NULL); 1908 1909 /* no connected line identification */ 1910 at_send_command("AT+COLP=0", NULL); 1911 1912 /* HEX character set */ 1913 at_send_command("AT+CSCS=\"HEX\"", NULL); 1914 1915 /* USSD unsolicited */ 1916 at_send_command("AT+CUSD=1", NULL); 1917 1918 /* Enable +CGEV GPRS event notifications, but don't buffer */ 1919 at_send_command("AT+CGEREP=1,0", NULL); 1920 1921 /* SMS PDU mode */ 1922 at_send_command("AT+CMGF=0", NULL); 1923 1924 #ifdef USE_TI_COMMANDS 1925 1926 at_send_command("AT%CPI=3", NULL); 1927 1928 /* TI specific -- notifications when SMS is ready (currently ignored) */ 1929 at_send_command("AT%CSTAT=1", NULL); 1930 1931 #endif /* USE_TI_COMMANDS */ 1932 1933 1934 /* assume radio is off on error */ 1935 if (isRadioOn() > 0) { 1936 setRadioState (RADIO_STATE_SIM_NOT_READY); 1937 } 1938 } 1939 1940 static void waitForClose() 1941 { 1942 pthread_mutex_lock(&s_state_mutex); 1943 1944 while (s_closed == 0) { 1945 pthread_cond_wait(&s_state_cond, &s_state_mutex); 1946 } 1947 1948 pthread_mutex_unlock(&s_state_mutex); 1949 } 1950 1951 /** 1952 * Called by atchannel when an unsolicited line appears 1953 * This is called on atchannel's reader thread. AT commands may 1954 * not be issued here 1955 */ 1956 static void onUnsolicited (const char *s, const char *sms_pdu) 1957 { 1958 char *line = NULL; 1959 int err; 1960 1961 /* Ignore unsolicited responses until we're initialized. 1962 * This is OK because the RIL library will poll for initial state 1963 */ 1964 if (sState == RADIO_STATE_UNAVAILABLE) { 1965 return; 1966 } 1967 1968 if (strStartsWith(s, "%CTZV:")) { 1969 /* TI specific -- NITZ time */ 1970 char *response; 1971 1972 line = strdup(s); 1973 at_tok_start(&line); 1974 1975 err = at_tok_nextstr(&line, &response); 1976 1977 if (err != 0) { 1978 ALOGE("invalid NITZ line %s\n", s); 1979 } else { 1980 RIL_onUnsolicitedResponse ( 1981 RIL_UNSOL_NITZ_TIME_RECEIVED, 1982 response, strlen(response)); 1983 } 1984 } else if (strStartsWith(s,"+CRING:") 1985 || strStartsWith(s,"RING") 1986 || strStartsWith(s,"NO CARRIER") 1987 || strStartsWith(s,"+CCWA") 1988 ) { 1989 RIL_onUnsolicitedResponse ( 1990 RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, 1991 NULL, 0); 1992 #ifdef WORKAROUND_FAKE_CGEV 1993 RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); //TODO use new function 1994 #endif /* WORKAROUND_FAKE_CGEV */ 1995 } else if (strStartsWith(s,"+CREG:") 1996 || strStartsWith(s,"+CGREG:") 1997 ) { 1998 RIL_onUnsolicitedResponse ( 1999 RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, 2000 NULL, 0); 2001 #ifdef WORKAROUND_FAKE_CGEV 2002 RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); 2003 #endif /* WORKAROUND_FAKE_CGEV */ 2004 } else if (strStartsWith(s, "+CMT:")) { 2005 RIL_onUnsolicitedResponse ( 2006 RIL_UNSOL_RESPONSE_NEW_SMS, 2007 sms_pdu, strlen(sms_pdu)); 2008 } else if (strStartsWith(s, "+CDS:")) { 2009 RIL_onUnsolicitedResponse ( 2010 RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT, 2011 sms_pdu, strlen(sms_pdu)); 2012 } else if (strStartsWith(s, "+CGEV:")) { 2013 /* Really, we can ignore NW CLASS and ME CLASS events here, 2014 * but right now we don't since extranous 2015 * RIL_UNSOL_DATA_CALL_LIST_CHANGED calls are tolerated 2016 */ 2017 /* can't issue AT commands here -- call on main thread */ 2018 RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); 2019 #ifdef WORKAROUND_FAKE_CGEV 2020 } else if (strStartsWith(s, "+CME ERROR: 150")) { 2021 RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); 2022 #endif /* WORKAROUND_FAKE_CGEV */ 2023 } 2024 } 2025 2026 /* Called on command or reader thread */ 2027 static void onATReaderClosed() 2028 { 2029 ALOGI("AT channel closed\n"); 2030 at_close(); 2031 s_closed = 1; 2032 2033 setRadioState (RADIO_STATE_UNAVAILABLE); 2034 } 2035 2036 /* Called on command thread */ 2037 static void onATTimeout() 2038 { 2039 ALOGI("AT channel timeout; closing\n"); 2040 at_close(); 2041 2042 s_closed = 1; 2043 2044 /* FIXME cause a radio reset here */ 2045 2046 setRadioState (RADIO_STATE_UNAVAILABLE); 2047 } 2048 2049 static void usage(char *s) 2050 { 2051 #ifdef RIL_SHLIB 2052 fprintf(stderr, "reference-ril requires: -p <tcp port> or -d /dev/tty_device\n"); 2053 #else 2054 fprintf(stderr, "usage: %s [-p <tcp port>] [-d /dev/tty_device]\n", s); 2055 exit(-1); 2056 #endif 2057 } 2058 2059 static void * 2060 mainLoop(void *param) 2061 { 2062 int fd; 2063 int ret; 2064 2065 AT_DUMP("== ", "entering mainLoop()", -1 ); 2066 at_set_on_reader_closed(onATReaderClosed); 2067 at_set_on_timeout(onATTimeout); 2068 2069 for (;;) { 2070 fd = -1; 2071 while (fd < 0) { 2072 if (s_port > 0) { 2073 fd = socket_loopback_client(s_port, SOCK_STREAM); 2074 } else if (s_device_socket) { 2075 if (!strcmp(s_device_path, "/dev/socket/qemud")) { 2076 /* Before trying to connect to /dev/socket/qemud (which is 2077 * now another "legacy" way of communicating with the 2078 * emulator), we will try to connecto to gsm service via 2079 * qemu pipe. */ 2080 fd = qemu_pipe_open("qemud:gsm"); 2081 if (fd < 0) { 2082 /* Qemu-specific control socket */ 2083 fd = socket_local_client( "qemud", 2084 ANDROID_SOCKET_NAMESPACE_RESERVED, 2085 SOCK_STREAM ); 2086 if (fd >= 0 ) { 2087 char answer[2]; 2088 2089 if ( write(fd, "gsm", 3) != 3 || 2090 read(fd, answer, 2) != 2 || 2091 memcmp(answer, "OK", 2) != 0) 2092 { 2093 close(fd); 2094 fd = -1; 2095 } 2096 } 2097 } 2098 } 2099 else 2100 fd = socket_local_client( s_device_path, 2101 ANDROID_SOCKET_NAMESPACE_FILESYSTEM, 2102 SOCK_STREAM ); 2103 } else if (s_device_path != NULL) { 2104 fd = open (s_device_path, O_RDWR); 2105 if ( fd >= 0 && !memcmp( s_device_path, "/dev/ttyS", 9 ) ) { 2106 /* disable echo on serial ports */ 2107 struct termios ios; 2108 tcgetattr( fd, &ios ); 2109 ios.c_lflag = 0; /* disable ECHO, ICANON, etc... */ 2110 tcsetattr( fd, TCSANOW, &ios ); 2111 } 2112 } 2113 2114 if (fd < 0) { 2115 perror ("opening AT interface. retrying..."); 2116 sleep(10); 2117 /* never returns */ 2118 } 2119 } 2120 2121 s_closed = 0; 2122 ret = at_open(fd, onUnsolicited); 2123 2124 if (ret < 0) { 2125 ALOGE ("AT error %d on at_open\n", ret); 2126 return 0; 2127 } 2128 2129 RIL_requestTimedCallback(initializeCallback, NULL, &TIMEVAL_0); 2130 2131 // Give initializeCallback a chance to dispatched, since 2132 // we don't presently have a cancellation mechanism 2133 sleep(1); 2134 2135 waitForClose(); 2136 ALOGI("Re-opening after close"); 2137 } 2138 } 2139 2140 #ifdef RIL_SHLIB 2141 2142 pthread_t s_tid_mainloop; 2143 2144 const RIL_RadioFunctions *RIL_Init(const struct RIL_Env *env, int argc, char **argv) 2145 { 2146 int ret; 2147 int fd = -1; 2148 int opt; 2149 pthread_attr_t attr; 2150 2151 s_rilenv = env; 2152 2153 while ( -1 != (opt = getopt(argc, argv, "p:d:s:"))) { 2154 switch (opt) { 2155 case 'p': 2156 s_port = atoi(optarg); 2157 if (s_port == 0) { 2158 usage(argv[0]); 2159 return NULL; 2160 } 2161 ALOGI("Opening loopback port %d\n", s_port); 2162 break; 2163 2164 case 'd': 2165 s_device_path = optarg; 2166 ALOGI("Opening tty device %s\n", s_device_path); 2167 break; 2168 2169 case 's': 2170 s_device_path = optarg; 2171 s_device_socket = 1; 2172 ALOGI("Opening socket %s\n", s_device_path); 2173 break; 2174 2175 default: 2176 usage(argv[0]); 2177 return NULL; 2178 } 2179 } 2180 2181 if (s_port < 0 && s_device_path == NULL) { 2182 usage(argv[0]); 2183 return NULL; 2184 } 2185 2186 pthread_attr_init (&attr); 2187 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); 2188 ret = pthread_create(&s_tid_mainloop, &attr, mainLoop, NULL); 2189 2190 return &s_callbacks; 2191 } 2192 #else /* RIL_SHLIB */ 2193 int main (int argc, char **argv) 2194 { 2195 int ret; 2196 int fd = -1; 2197 int opt; 2198 2199 while ( -1 != (opt = getopt(argc, argv, "p:d:"))) { 2200 switch (opt) { 2201 case 'p': 2202 s_port = atoi(optarg); 2203 if (s_port == 0) { 2204 usage(argv[0]); 2205 } 2206 ALOGI("Opening loopback port %d\n", s_port); 2207 break; 2208 2209 case 'd': 2210 s_device_path = optarg; 2211 ALOGI("Opening tty device %s\n", s_device_path); 2212 break; 2213 2214 case 's': 2215 s_device_path = optarg; 2216 s_device_socket = 1; 2217 ALOGI("Opening socket %s\n", s_device_path); 2218 break; 2219 2220 default: 2221 usage(argv[0]); 2222 } 2223 } 2224 2225 if (s_port < 0 && s_device_path == NULL) { 2226 usage(argv[0]); 2227 } 2228 2229 RIL_register(&s_callbacks); 2230 2231 mainLoop(NULL); 2232 2233 return 0; 2234 } 2235 2236 #endif /* RIL_SHLIB */ 2237
