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