blob: 9f96f4427e9e25de2cadb5cdf0bdd6e69ad4c5d1 [file] [log] [blame]
lhb07f4e12022-02-17 22:08:54 -08001// SPDX-License-Identifier: MediaTekProprietary
2/*
lh7b0674a2022-01-10 00:34:35 -08003 * Copyright (C) 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#include <string.h>
18#include <stddef.h>
19#include <stdlib.h>
20#include <stdio.h>
21#include <stdbool.h>
22#include<fcntl.h>
23#include<sys/stat.h>
24#include<sys/types.h>
25#include<unistd.h>
26#include <assert.h>
27#include <log/log.h>
28#include <vendor-ril/telephony/ril.h>
29#include <string>
30#include <mutex>
31#include <vector>
32#include <cutils/properties.h>
33
34#include "Radio_capability_switch_util.h"
35#include "common.h"
36#include "Phone_utils.h"
37#include "utils.h"
38#include "data.h"
39#include "cc.h"
ritafebcbfa2022-04-28 16:30:25 +080040#include "include/lynq_systime.h"
41#include <include/lynq_uci.h>
q.huang036b6cf2023-01-10 14:29:20 +080042#ifdef LED_SUPPORT
43#include "led.h"
44#endif
45#include "lynq_shm.h"
lh7b0674a2022-01-10 00:34:35 -080046static pthread_mutex_t s_DataMutex = PTHREAD_MUTEX_INITIALIZER;
47static pthread_cond_t s_DataCond = PTHREAD_COND_INITIALIZER;
48
49#undef LOG_TAG
50#define LOG_TAG "DEMO_COMMON"
51
llaaca09b2022-03-14 16:14:28 +080052#define UNKOWN_VALUE (-1)
53
54/*Warren add for FAW 2021/11/1 start*/
55extern int ttyGS3_fd = -1;
56/*Warren add for FAW 2021/11/1 end*/
57
58
lh7b0674a2022-01-10 00:34:35 -080059typedef enum {
60 STATE_IN_SERVICE =0,
61 STATE_OUT_OF_SERVICE =1,
62 STATE_EMERGENCY_ONLY =2,
63 STATE_POWER_OFF =3
64} Service_State;
65
66RfDesenseTxTest* m_RfDesense;
67static RIL_CardStatus_v6* cur_CardS_Status[2] = {NULL, NULL};
68static RIL_RadioCapability radio_capability[2];
69
70static int cur_voice_radio_tech[2] = {RADIO_TECH_UNKNOWN, RADIO_TECH_UNKNOWN};
71
72static int reg_voice_service_state[2] = {0, 0};
73static int reg_data_service_state[2] = {0, 0};
74static int reg_data_radio_tech[2] = {RADIO_TECH_UNKNOWN, RADIO_TECH_UNKNOWN};
75static int reg_voice_radio_tech[2] = {RADIO_TECH_UNKNOWN, RADIO_TECH_UNKNOWN};
76static int preferred_network_type[2] = {Phone_utils::PREFERRED_NETWORK_MODE, Phone_utils::PREFERRED_NETWORK_MODE};
77static int radio_status[2] = {RADIO_STATE_UNAVAILABLE, RADIO_STATE_UNAVAILABLE};
78static std::vector<int> call_state[2];
79
80static int default_sim_all = RIL_SOCKET_1;
81static int default_sim_all_except_data = RIL_SOCKET_1;
82static int default_sim_voice = RIL_SOCKET_1;
83static int default_sim_data = RIL_SOCKET_1;
84static int default_sim_sms = RIL_SOCKET_1;
85static bool isNeedReconnect = false;
86
87static std::int32_t token = 0;
88static std::mutex g_mutex;
ll112f8b82023-01-14 11:48:23 +080089
90pthread_mutex_t s_state_change_mutex = PTHREAD_MUTEX_INITIALIZER;
91pthread_cond_t s_state_change_cond = PTHREAD_COND_INITIALIZER;
92
llaaca09b2022-03-14 16:14:28 +080093/*Warren add for SZZT 2021/11/14 start*
94** record data registration
95*/
96extern int current_data_reg = -1;
97extern int modemStatus = 0;
98
99/*Warren add for SZZT 2021/11/14 end*/
100
101
102/*hq add for key information output start 2022/03/01*/
103// extern int lynq_output_LINFO_enable =0;
104
105// typedef enum {
106// RADIO_NW_2G = 0,
107// RADIO_NW_3G = 1,
108// RADIO_NW_4G = 2,
109// #ifdef TELEMATIC_5G_SUPPORT
110// RADIO_NW_5G = 3,
111// #endif
112// } RIL_RadioNW;
113
114// const char * cardStateToString(int cardStatus)
115// {
116// switch(cardStatus) {
117// case RIL_CARDSTATE_ABSENT:
118// return "absent";
119// case RIL_CARDSTATE_PRESENT:
120// return "present";
121// case RIL_CARDSTATE_ERROR:
122// return "error";
123// default:
124// return "unknown";
125// }
126// }
127// const char * serviceStateToString(int service_state)
128// {
129// switch(service_state) {
130// case STATE_IN_SERVICE:
131// return "IN SERVICE";
132// case STATE_OUT_OF_SERVICE:
133// return "OUT OF SERVICE";
134// case STATE_POWER_OFF:
135// return "POWER_OFF";
136// case STATE_EMERGENCY_ONLY:
137// return "EMERGENCY_ONLY";
138// case UNKOWN_VALUE:
139// return "unDefined";
140// default:
141// return "unDefined";
142// }
143// }
144// const char * RadioNwToString(int radio_nw)
145// {
146// switch(radio_nw) {
147// case RADIO_NW_2G:
148// return "2G";
149// case RADIO_NW_3G:
150// return "3G";
151// case RADIO_NW_4G:
152// return "4G";
153// #ifdef TELEMATIC_5G_SUPPORT
154// case RADIO_NW_5G:
155// return "5G";
156// #endif
157// case UNKOWN_VALUE:
158// return "unknown";
159// default:
160// return "unknown";
161// }
162// }
163// const char * preferredNetworkTypeToString(int preferred_network_type)
164// {
165// switch(preferred_network_type) {
166// case PREF_NET_TYPE_GSM_WCDMA /*0*/ : return " GSM/WCDMA (WCDMA case PREFerred)";
167// case PREF_NET_TYPE_GSM_ONLY : return " GSM only";
168// case PREF_NET_TYPE_WCDMA : return " WCDMA ";
169// case PREF_NET_TYPE_GSM_WCDMA_AUTO : return " GSM/WCDMA (auto mode, according to PRL)";
170// case PREF_NET_TYPE_CDMA_EVDO_AUTO : return " CDMA and EvDo (auto mode, according to PRL)";
171// case PREF_NET_TYPE_CDMA_ONLY : return " CDMA only";
172// case PREF_NET_TYPE_EVDO_ONLY : return " EvDo only";
173// case PREF_NET_TYPE_GSM_WCDMA_CDMA_EVDO_AUTO : return " GSM/WCDMA, CDMA, and EvDo (auto mode, according to PRL)";
174// case PREF_NET_TYPE_LTE_CDMA_EVDO : return " LTE, CDMA and EvDo";
175// case PREF_NET_TYPE_LTE_GSM_WCDMA : return " LTE, GSM/WCDMA";
176// case PREF_NET_TYPE_LTE_CMDA_EVDO_GSM_WCDMA : return " LTE, CDMA, EvDo, GSM/WCDMA";
177// case PREF_NET_TYPE_LTE_ONLY : return " LTE only";
178// case PREF_NET_TYPE_LTE_WCDMA /*12*/ : return " LTE/WCDMA";
179// case PREF_NET_TYPE_LTE_GSM /*30*/ : return " LTE/GSM";
180// case PREF_NET_TYPE_LTE_TDD_ONLY /*31*/ : return " LTE only";
181// case 13: return "TD-SCDMA only";
182// case 14: return "TD-SCDMA and WCDMA";
183// case 15: return "TD-SCDMA and LTE";
184// case 16: return "TD-SCDMA and GSM";
185// case 17: return "TD-SCDMA,GSM and LTE";
186// case 18: return "TD-SCDMA, GSM/WCDMA";
187// case 19: return "TD-SCDMA, WCDMA and LTE";
188// case 20: return "TD-SCDMA, GSM/WCDMA and LTE";
189// case 21: return "TD-SCDMA,EvDo,CDMA,GSM/WCDMA";
190// case 22: return "TD-SCDMA/LTE/GSM/WCDMA, CDMA, and EvDo";
191// //case 30: return "LTE/GSM";
192// //case 31: return "LTE TDD Only mode";
193// case 32: return "CDMA,GSM(2G Global)";
194// case 33: return "CDMA,EVDO,GSM";
195// case 34: return "LTE,CDMA,EVDO,GSM(4G Global, 4M)";
196// default:
197// return "unDefined";
198// }
199// }
200/*hq add for key information output end*/
lh7b0674a2022-01-10 00:34:35 -0800201
202static int regCodeToRadioTechnology(int request, int code, int slot);
203
llf7bc4182022-11-03 10:21:52 +0800204void lynq_output_info(const char* format,...)
205{
206 if(ttyGS3_fd < 0)
207 {
208 return;
209 }
210 char buf[1024] = {0};
211 int n;
212 va_list args;
213 va_start(args, format);
214 vsnprintf(buf, sizeof(buf), format, args);
215 va_end(args);
216 n=write(ttyGS3_fd, buf, strlen(buf));
217 if(n < 0)
218 {
219 perror("lynq resp write:");
220 }
221 return;
222}
223
lh7b0674a2022-01-10 00:34:35 -0800224void update_call_state(void *response, size_t responselen, int slot) {
225 int num = responselen / sizeof(RIL_Call *);
226 if(num == 0) {
227 call_state[slot].clear();
228 RLOGD("[SIM%d]clear call state", slot);
229 } else {
230 call_state[slot].clear();
231 for (int i = 0 ; i < num ; i++) {
232 RIL_Call *p_cur = ((RIL_Call **) response)[i];
233 /* each call info */
234 call_state[slot].push_back(p_cur->state);
q.huang1e9cdc92022-05-11 19:01:41 +0800235 RLOGD("[SIM%d][id:%d]update_call_state: %d", slot,p_cur->index, p_cur->state);
lh7b0674a2022-01-10 00:34:35 -0800236 }
237 }
238}
239
240int is_call_state_idle(int slot) {
241 bool is_idle = true;
242 if(!call_state[slot].empty()) {
243 is_idle = false;
244 }
245 RLOGD("[SIM%d]is_call_state_idle: %d", slot, is_idle);
246 return is_idle;
247}
248
249void update_preferred_network_type(int type, int slot) {
250 RLOGD("[SIM%d]update_preferred_network_type: %d", slot, type);
251 preferred_network_type[slot] = type;
252}
253
254int get_preferred_network_type(int slot) {
255 return preferred_network_type[slot];
256}
257
258static int needBlockReq(int request)
259{
260#ifdef ENABLE_BLOCK_FEATURE
261 return 1;
262#endif
263
264 switch (request){
265 case RIL_REQUEST_RADIO_POWER: return 1;
266 case RIL_REQUEST_SET_IMS_ENABLE: return 1;
267 //case RIL_REQUEST_DATA_REGISTRATION_STATE: return 1;
268 default: return 0;
269 }
270 return 0;
271}
272
273static int setupToken(int token, int mode, int block)
274{
275 switch (mode){
276 case INIT:
277 token |= INIT_TOKEN_MARK;
278 break;
279 case UDP:
280 token |= RIL_TOKEN_MARK;
281 break;
282 case ATCI:
283 token |= ATCI_TOKEN_MARK;
284 break;
285 case RSPD:
286 token |= RSP_DISP_TOKEN_MARK;
287 break;
288 case OTHER:
289 token |= OTHER_TOKEN_MARK;
290 break;
291 default:
292 break;
293 }
294
295 if(block)
296 token |= BLOCK_MARK;
297
298 return token;
299}
300
301bool isDataConnectEnable(int slot) {
302 char value[PROPERTY_VALUE_MAX] = {0};
303 utils::getMSimProperty(slot,PROP_DEFAULT_DATA_SIM_STATUS, value);
304 if(atoi(value) == 1) {
305 return true;
306 }
307 return false;
308}
309
310void updataDataConnectState(int slot, bool state) {
311 utils::setMSimProperty(slot,PROP_DEFAULT_DATA_SIM_STATUS, const_cast<char*>(state ? "1":"0"));
312}
313
314std::int32_t GenerateToken(int mode, int request) {
315 g_mutex.lock();
316 if (token +1 == TOKEN_MODE) {
317 token = 1;
318 } else {
319 token++;
320 }
321 std::int32_t t= 0;
322 t = setupToken(token,mode,needBlockReq(request));
323 g_mutex.unlock();
324 return t;
325}
326
327RequestInfo* creatRILInfoAndInit(int request, int mode, RIL_SOCKET_ID soc_id)
328{
329 RequestInfo *pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
330 if(pRI ==NULL){
331 RLOGE("%s,memory alloc error!",__func__);
332 return NULL;
333 }
334 android::initRequestInfo(pRI,request,mode, soc_id);
335 return pRI;
336}
337
338void set_default_sim_all_except_data(int slot_id) {
339 RLOGD("set_default_sim_all excpet data: %d", slot_id);
340 default_sim_all_except_data = slot_id;
341 set_default_sim_voice(slot_id);
342 set_default_sim_sms(slot_id);
343}
344
345int get_default_sim_all_except_data() {
346 return default_sim_all_except_data;
347}
348
349void set_default_sim_all(int slot_id){
350 RLOGD("set_default_sim_all: %d", slot_id);
351 default_sim_all = slot_id;
352 set_default_sim_all_except_data(slot_id);
353 set_default_sim_data(slot_id);
354}
355
356int get_default_sim_all(){
357 return default_sim_all;
358}
359
360void set_default_sim_voice(int slot_id){
361 RLOGD("set_default_sim_voice: %d", slot_id);
362 default_sim_voice = slot_id;
363}
364
ll112f8b82023-01-14 11:48:23 +0800365void lynq_send_result_already(void)
366{
367 RLOGD("send_imei_state_change");
368 pthread_mutex_lock(&s_state_change_mutex);
369 pthread_cond_signal(&s_state_change_cond);
370 pthread_mutex_unlock(&s_state_change_mutex);
371}
372
373void lynq_wait_result_comeback(void)
374{
375 RLOGD("wait_call_state");
376 pthread_mutex_lock(&s_state_change_mutex);
377 pthread_cond_wait(&s_state_change_cond,&s_state_change_mutex);
378 pthread_mutex_unlock(&s_state_change_mutex);
379}
380
lh7b0674a2022-01-10 00:34:35 -0800381int get_default_sim_voice(){
382 return default_sim_voice;
383}
384
385void set_default_sim_data(int slot) {
386 RLOGD("set_default_sim_data: %d", slot);
387 pthread_mutex_lock(&s_DataMutex);
388 if(get_default_sim_data() != slot) {
389 if(isDataConnectEnable(get_default_sim_data())) {
390 isNeedReconnect = true;
391 deactivateDataCall(0,NULL,(RIL_SOCKET_ID)0,NULL);
392 RLOGD("set_default_sim_data, wait deactive data call done");
393 pthread_cond_wait(&s_DataCond, &s_DataMutex);
394 RLOGD("set_default_sim_data, deactive data call done");
395 }
396 RLOGD("set_default_sim_data, set prop");
397 default_sim_data = slot;
398 utils::mtk_property_set(PROP_DEFAULT_DATA_SIM, std::to_string(default_sim_data + 1).c_str());
399 while(!isRadioAvailable(RIL_SOCKET_ID(slot))) {
400 sleep(1);
401 RLOGD("[SIM%d]set_default_sim_data(RIL_REQUEST_SET_RADIO_CAPABILITY): wait radio available", slot);
402 }
403 syncDataSettings(RIL_SOCKET_ID(slot));
404 if(utils::is_support_dsds()) {
405 Radio_capability_switch_util::sendRadioCapabilityRequest(slot);
406 }
407 }
408 pthread_mutex_unlock(&s_DataMutex);
409}
410
411bool isNeedConnect() {
412 return isNeedReconnect;
413}
414
415void resetConnect() {
416 isNeedReconnect = false;
417}
418int get_default_sim_data_for_switch() {
419 return default_sim_data;
420}
421
422int get_default_sim_data(){
423 default_sim_data = utils::mtk_property_get_int32(PROP_DEFAULT_DATA_SIM, 1) -1;
424 return default_sim_data;
425}
426
427void set_default_sim_sms(int slot_id){
428 RLOGD("set_default_sim_sms: %d", slot_id);
429 default_sim_sms = slot_id;
430}
431
432int get_default_sim_sms() {
433 return default_sim_sms;
434}
435
436static int regCodeToServiceState(int request,int code, int slot);
437
438const char * radioStateToString(RIL_RadioState s) {
439 switch (s) {
440 case RADIO_STATE_OFF:
441 return "RADIO_OFF";
442 case RADIO_STATE_UNAVAILABLE:
443 return "RADIO_UNAVAILABLE";
444 case RADIO_STATE_SIM_NOT_READY:
445 return "RADIO_SIM_NOT_READY";
446 case RADIO_STATE_SIM_LOCKED_OR_ABSENT:
447 return "RADIO_SIM_LOCKED_OR_ABSENT";
448 case RADIO_STATE_SIM_READY:
449 return "RADIO_SIM_READY";
450 case RADIO_STATE_RUIM_NOT_READY:
451 return "RADIO_RUIM_NOT_READY";
452 case RADIO_STATE_RUIM_READY:
453 return "RADIO_RUIM_READY";
454 case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:
455 return "RADIO_RUIM_LOCKED_OR_ABSENT";
456 case RADIO_STATE_NV_NOT_READY:
457 return "RADIO_NV_NOT_READY";
458 case RADIO_STATE_NV_READY:
459 return "RADIO_NV_READY";
460 case RADIO_STATE_ON:
461 return "RADIO_ON";
462 default:
463 return "<unknown state>";
464 }
465}
466
467const char *rilSocketIdToString(RIL_SOCKET_ID socket_id) {
468 switch (socket_id) {
469 case RIL_SOCKET_1:
470 return "RIL_SOCKET_1";
471#if (SIM_COUNT >= 2)
472 case RIL_SOCKET_2:
473 return "RIL_SOCKET_2";
474#endif
475#if (SIM_COUNT >= 3)
476 case RIL_SOCKET_3:
477 return "RIL_SOCKET_3";
478#endif
479#if (SIM_COUNT >= 4)
480 case RIL_SOCKET_4:
481 return "RIL_SOCKET_4";
482#endif
483 default:
484 return "not a valid RIL";
485 }
486}
487
488void update_radio_capa(RIL_RadioCapability* cap, int slot) {
489 memset(&radio_capability[slot], 0, sizeof(RIL_RadioCapability));
490 if(cap != NULL) {
491 strcpy(radio_capability[slot].logicalModemUuid,cap->logicalModemUuid);
492 radio_capability[slot].phase = cap->phase;
493 radio_capability[slot].rat = cap->rat;
494 radio_capability[slot].session = cap->session;
495 radio_capability[slot].status = cap->status;
496 radio_capability[slot].version = cap->version;
497 }
498}
499
500RIL_RadioCapability get_radio_capa(int slot) {
501 return radio_capability[slot];
502}
503
504void update_voice_radio_tech(int code, int slot) {
505 cur_voice_radio_tech[slot] = code;
506}
507
508int get_voice_radio_tech(int slot){
509 return cur_voice_radio_tech[slot];
510}
511
512void updateCardStatusV6(RIL_CardStatus_v6 *card_status,int slot)
513{
514 if(cur_CardS_Status[slot] != NULL) {
515 RLOGD("[slot%d]updateCardStatusV6", slot);
516 for(int i = 0; i < cur_CardS_Status[slot]->num_applications; i++) {
517 free(cur_CardS_Status[slot]->applications[i].aid_ptr);
518 cur_CardS_Status[slot]->applications[i].aid_ptr = NULL;
519 free(cur_CardS_Status[slot]->applications[i].app_label_ptr);
520 cur_CardS_Status[slot]->applications[i].app_label_ptr = NULL;
521 }
522 free(cur_CardS_Status[slot]);
523 cur_CardS_Status[slot] = NULL;
524 }
525 cur_CardS_Status[slot] = (RIL_CardStatus_v6 *)calloc(1, sizeof(RIL_CardStatus_v6));
526 memset(cur_CardS_Status[slot], 0, sizeof(RIL_CardStatus_v6));
527 cur_CardS_Status[slot]->card_state = card_status->card_state;
528 cur_CardS_Status[slot]->cdma_subscription_app_index = card_status->cdma_subscription_app_index;
529 cur_CardS_Status[slot]->gsm_umts_subscription_app_index = card_status->gsm_umts_subscription_app_index;
530 cur_CardS_Status[slot]->ims_subscription_app_index = card_status->ims_subscription_app_index;
531 cur_CardS_Status[slot]->num_applications = card_status->num_applications;
532 cur_CardS_Status[slot]->universal_pin_state = card_status->universal_pin_state;
533 RLOGD("[slot%d]updateCardStatusV6 card_state: %d, cdma_index: %d, gsm_index: %d, "
534 "ims_index: %d, num_applications: %d, universal_pin_state: %d",
535 slot,
536 cur_CardS_Status[slot]->card_state,
537 cur_CardS_Status[slot]->cdma_subscription_app_index,
538 cur_CardS_Status[slot]->gsm_umts_subscription_app_index,
539 cur_CardS_Status[slot]->ims_subscription_app_index,
540 cur_CardS_Status[slot]->num_applications,
541 cur_CardS_Status[slot]->universal_pin_state);
542 if(card_status)
543 {
544 for(int i = 0; i < card_status->num_applications; i++) {
545 cur_CardS_Status[slot]->applications[i].app_state = card_status->applications[i].app_state;
546 cur_CardS_Status[slot]->applications[i].app_type = card_status->applications[i].app_type;
547 cur_CardS_Status[slot]->applications[i].perso_substate = card_status->applications[i].perso_substate;
548 cur_CardS_Status[slot]->applications[i].pin1 = card_status->applications[i].pin1;
549 cur_CardS_Status[slot]->applications[i].pin1_replaced = card_status->applications[i].pin1_replaced;
550 cur_CardS_Status[slot]->applications[i].pin2 = card_status->applications[i].pin2;
551 cur_CardS_Status[slot]->applications[i].aid_ptr = strdup(card_status->applications[i].aid_ptr);
552 cur_CardS_Status[slot]->applications[i].app_label_ptr = strdup(card_status->applications[i].app_label_ptr);
553 }
554 } else {
555 RLOGD("[slot%d]updateCardStatusV6: sim card message is null", slot);
556 }
557}
558
559char* getAid(int slot)
560{
561 char* aid = "";
562 int index = -1;
563 if(cur_CardS_Status[slot] != NULL){
564 if(Phone_utils::get_phone_type(slot) == Phone_utils::PHONE_TYPE_CDMA) {
565 index = cur_CardS_Status[slot]->cdma_subscription_app_index;
566 } else {
567 index = cur_CardS_Status[slot]->gsm_umts_subscription_app_index;
568 }
569 if(index >= 0 && index < cur_CardS_Status[slot]->num_applications) {
570 aid = cur_CardS_Status[slot]->applications[index].aid_ptr;
571 }
572 }
573 RLOGD("[slot%d] index: %d, getAid: %s", slot, index, aid);
574 return aid;
575}
576
577void update_reg_voice_service_state(int request, char *code, int slot, int32_t token)
578{
579 if((reg_voice_service_state[slot] != atoi(code)) || ((token&RIL_TOKEN_MARK) == RIL_TOKEN_MARK)) {
580 reg_voice_service_state[slot] = atoi(code);
581 regCodeToServiceState(request, atoi(code), slot);
582 }
583}
584
585void update_reg_voice_radio_tech(int request, int code, int slot, int32_t token) {
586 if((reg_voice_radio_tech[slot] != code) || ((token&RIL_TOKEN_MARK) == RIL_TOKEN_MARK)){
587 reg_voice_radio_tech[slot] = code;
588 regCodeToRadioTechnology(request, code, slot);
589 }
590}
591
592void update_reg_data_service_state(int request, char *code,int slot, int32_t token)
593{
594 if((reg_data_service_state[slot] != atoi(code)) || ((token&RIL_TOKEN_MARK) == RIL_TOKEN_MARK)) {
595 reg_data_service_state[slot] = atoi(code);
596 regCodeToServiceState(request, atoi(code), slot);
llaaca09b2022-03-14 16:14:28 +0800597 /*Warren change for SZZT 2021//11/14 start*/
598 int status = regCodeToServiceState(request, atoi(code), slot);
599 current_data_reg = status;
600 /*Warren change for SZZT 2021//11/14 end*/
lh7b0674a2022-01-10 00:34:35 -0800601 }
602}
603
604void update_reg_data_radio_tech(int request, int code, int slot, int32_t token){
605 if((reg_data_radio_tech[slot] != code) || ((token&RIL_TOKEN_MARK) == RIL_TOKEN_MARK)) {
606 reg_data_radio_tech[slot] = code;
607 regCodeToRadioTechnology(request, code, slot);
608 }
609}
610
611void registerRadioOn(RfDesenseTxTest* rf){
612 if(!m_RfDesense) {
613 m_RfDesense = rf;
614 }
615}
616
617void unregisterRadioOn() {
618 if(m_RfDesense) {
619 m_RfDesense == NULL;
620 }
621}
622
623void registerRadioOffOrNotAvailable(RfDesenseTxTest* rf){
624 if(!m_RfDesense) {
625 m_RfDesense = rf;
626 }
627}
628
629void unregisterRadioOffOrNotAvailable() {
630 if(m_RfDesense) {
631 m_RfDesense == NULL;
632 }
633}
634
635void registerOnUnsolOemHookRaw(RfDesenseTxTest* rf){
636 if(!m_RfDesense) {
637 m_RfDesense = rf;
638 }
639}
640
641void unregisterOnUnsolOemHookRaw(){
642 if(m_RfDesense) {
643 m_RfDesense == NULL;
644 }
645}
646
647void register_response_oem_hook_raw(RfDesenseTxTest* rf){
648 if(!m_RfDesense) {
649 m_RfDesense = rf;
650 }
651}
652
653void unregister_response_oem_hook_raw(){
654 if(m_RfDesense) {
655 m_RfDesense == NULL;
656 }
657}
658
659void updateRadioStatus(int newValue ,RIL_SOCKET_ID soc_id)
660{
661 RLOGD("updateRadioStatus oldState: %d, newState: %d", radio_status[soc_id], newValue);
662 bool newOn = (newValue == RADIO_STATE_ON);
663 bool oldOn = (radio_status[soc_id] == RADIO_STATE_ON);
664 bool newAvaiable = (newValue != RADIO_STATE_UNAVAILABLE);
665 bool oldAvaiable = (radio_status[soc_id] != RADIO_STATE_UNAVAILABLE);
666 if (newOn && !oldOn) {
667 RLOGD("RadioStateOn");
668 //printf("[SIM%d] radio on\n",soc_id +1);
669 if(m_RfDesense){
670 m_RfDesense->emRadioStateOn();
671 }
672 }
673
674 if ((!newOn || !newAvaiable) && !((!oldOn || !oldAvaiable))) {
675 RLOGD("RadioStateOfforNotAvailable");
676 //printf("[SIM%d] radio off or not available\n",soc_id +1);
677 if(m_RfDesense){
678 m_RfDesense->emRadioStateOfforNotAvailable();
679 }
680 }
681 if(newValue != radio_status[soc_id]) {
682 radio_status[soc_id] = newValue;
683 }
684}
685
686bool isRadioOn(RIL_SOCKET_ID soc_id)
687{
688 return radio_status[soc_id] == RADIO_STATE_ON;
689}
690
691bool isRadioAvailable(RIL_SOCKET_ID soc_id)
692{
693 return radio_status[soc_id] != RADIO_STATE_UNAVAILABLE;
694}
695
696static int regCodeToServiceState(int request,int code, int slot)
697{
698 RLOGD("[slot%d]regCodeToServiceState %d, request: %s",slot, code, android::requestToString(request));
699 switch (code)
700 {
701 case 0:
702 case 2: // 2 is "searching"
703 case 3: // 3 is "registration denied"
704 case 4: // 4 is "unknown" no vaild in current baseband
705 case 10:// same as 0, but indicates that emergency call is possible.
706 case 12:// same as 2, but indicates that emergency call is possible.
707 case 13:// same as 3, but indicates that emergency call is possible.
708 case 14:// same as 4, but indicates that emergency call is possible.
709 {
710 if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
711 printf("[QUERY][VOICE REG_STATUS][SIM%d] The current service state is OUT OF SERVICE\n", slot);
712 } else {
713 printf("[QUERY][DATA REG_STATUS][SIM%d] The current service state is OUT OF SERVICE\n", slot);
714 }
715 return STATE_OUT_OF_SERVICE;
716 }
717
718 case 1:
719 case 5:
720 {
721 if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
722 printf("[QUERY][VOICE REG_STATUS][SIM%d] The current service state is IN SERVICE\n", slot);
723 } else {
724 printf("[QUERY][DATA REG_STATUS][SIM%d] The current service state is IN SERVICE\n", slot);
725 }
726 return STATE_IN_SERVICE;
727 }
728
729 default:
730 {
731 if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
732 printf("[QUERY][VOICE REG_STATUS][SIM%d] Unexpected service state %d\n", slot, code);
733 } else {
734 printf("[QUERY][DATA REG_STATUS][SIM%d] Unexpected service state %d\n", slot, code);
735 }
736 RLOGW("[SIM%d]regCodeToServiceState: unexpected service state %d", slot, code);
737 return STATE_OUT_OF_SERVICE;
738 }
739 }
740}
741
742static int regCodeToRadioTechnology(int request, int code, int slot) {
743 RLOGD("[slot%d]regCodeToRadioTechnology %d, request: %s",slot, code, android::requestToString(request));
744 switch(code) {
745 case RADIO_TECH_LTE:
746 {
747 if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
748 printf("[QUERY][VOICE REG_STATUS][SIM%d] The registered radio technology is 4G\n", slot);
749 } else {
750 printf("[QUERY][DATA REG_STATUS][SIM%d] The registered radio technology is 4G\n", slot);
751 }
752 break;
753 }
754 case RADIO_TECH_GSM:
755 case RADIO_TECH_GPRS:
756 case RADIO_TECH_EDGE:
757 case RADIO_TECH_IS95A:
758 case RADIO_TECH_IS95B:
759 case RADIO_TECH_1xRTT:
760 {
761 if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
762 printf("[QUERY][VOICE REG_STATUS][SIM%d] The registered radio technology is 2G\n", slot);
763 } else {
764 printf("[QUERY][DATA REG_STATUS][SIM%d] The registered radio technology is 2G\n", slot);
765 }
766 break;
767 }
768 case RADIO_TECH_UMTS:
769 case RADIO_TECH_HSDPA:
770 case RADIO_TECH_HSUPA:
771 case RADIO_TECH_HSPA:
772 case RADIO_TECH_EHRPD:
773 case RADIO_TECH_HSPAP:
774 case RADIO_TECH_TD_SCDMA:
775 case RADIO_TECH_EVDO_0:
776 case RADIO_TECH_EVDO_A:
777 case RADIO_TECH_EVDO_B:
778 {
779 if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
780 printf("[QUERY][VOICE REG_STATUS][SIM%d] The registered radio technology is 3G\n", slot);
781 } else {
782 printf("[QUERY][DATA REG_STATUS][SIM%d] The registered radio technology is 3G\n", slot);
783 }
784 break;
785 }
786#ifdef TELEMATIC_5G_SUPPORT
787 case RADIO_TECH_NR://5G
788 {
789 if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
790 printf("[QUERY][VOICE REG_STATUS][SIM%d] The registered radio technology is 5G\n", slot);
791 } else {
792 printf("[QUERY][DATA REG_STATUS][SIM%d] The registered radio technology is 5G\n", slot);
793 }
794 break;
795 }
796#endif
797 case RADIO_TECH_UNKNOWN:
798 {
799 if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
800 printf("[QUERY][VOICE REG_STATUS][SIM%d] The registered radio technology is unknown\n", slot);
801 } else {
802 printf("[QUERY][DATA REG_STATUS][SIM%d] The registered radio technology is unknown\n", slot);
803 }
804 break;
805 }
806 default:
807 {
808 if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
809 printf("[QUERY][VOICE REG_STATUS][SIM%d] %d is unexpected value\n",slot, code);
810 } else {
811 printf("[QUERY][DATA REG_STATUS][SIM%d] %d is unexpected value\n",slot, code);
812 }
813 }
814 }
815 return 0;
816}
817
818int get_reg_data_radio_tech(int slot) {
819 return reg_data_radio_tech[slot];
820}
821
822int get_reg_voice_radio_tech(int slot) {
823 return reg_voice_radio_tech[slot];
824}
825
826#ifdef ECALL_SUPPORT
827void ConvertMsd(const char *msdChar, unsigned char *msd) {
828 unsigned int n, x;
829
830 for (n = 0; n < MSD_MAX_LENGTH; n++) {
831 if (sscanf(&msdChar[n<<1], "%2x", &x) == 1) {
832 msd[n] = x;
833 } else {
834 RLOGE("invalid MSD characters");
835 break;
836 }
837 }
838}
839#endif /*ECALL_SUPPORT*/
840
841bool isFinalResponseErrorEx(char* str) {
842 AtLine atline(str, NULL);
843 return (atline.isFinalResponseErrorEx(0) == 1 ? true : false);
844}
845
846int get_atci_sim(){
847 return utils::mtk_property_get_int32(ATCI_SIM, 0);
848}
849
850static char *findNextChar(char *p, char c, int length)
851{
852 char *ptr = p;
853 int i = 0;
854 while (i++ < length)
855 {
856 if (*ptr++ == c)
857 return ptr;
858 }
859 return NULL;
860}
861
862static int getGMTval(char *pdata)
863{
864 char *ptr;
865 ptr = findNextChar(pdata, '+', strlen(pdata));
866 if (ptr == NULL)
867 {
868 ptr = findNextChar(pdata, '-', strlen(pdata));
869 if (ptr == NULL)
870 {
871 return 0;
872 }
873 }
874 return atoi(ptr);
875}
876
877static void adjustGMT2LocalTime(struct tm *src, int dGMTval)
878{
879 time_t t1, t2;
880 struct tm * ptm;
881 char buf[255];
882 int dShiftSec;
883
884 dShiftSec = dGMTval * 15 * 60;
885 t1 = mktime(src);
rita217de532022-05-31 17:15:48 +0800886
lh7b0674a2022-01-10 00:34:35 -0800887 t2 = (time_t)(t1 + dShiftSec);
888 ptm = gmtime(&t2);
889
890 memcpy(src, ptm, sizeof(struct tm));
891}
892
893void updateSystemTime(const void *data, int datalen)
894{
895 char strTime[32];
896 struct tm tm;
897 time_t t;
898 int dGMTval;
ritafebcbfa2022-04-28 16:30:25 +0800899 char modem_sync_enable[24] = "";
lh7b0674a2022-01-10 00:34:35 -0800900
901 if (data == NULL || datalen <= 0)
902 return;
903
904 memset(strTime, 0, sizeof(strTime));
905 strcat(strTime, "20");
906 strcat(strTime, (const char *)data);
907
908 dGMTval = getGMTval(strTime);
909 memset(&tm, 0, sizeof(struct tm));
910 strptime(strTime, "%Y/%m/%d,%H:%M:%S", &tm);
911
rita217de532022-05-31 17:15:48 +0800912 //adjustGMT2LocalTime(&tm, dGMTval);
lh7b0674a2022-01-10 00:34:35 -0800913
914 t = mktime(&tm);
ritafebcbfa2022-04-28 16:30:25 +0800915
916 lynq_get_value("lynq_uci", "lynq_sync_time", "lynq_modem_sync_time_enable" , modem_sync_enable);
917 if(!atoi(modem_sync_enable))
918 return ;
919
lh7b0674a2022-01-10 00:34:35 -0800920 stime(&t);
rjwa9991ce2023-01-05 14:52:28 +0800921 system("hwclock -w -f /dev/rtc0");
lh7b0674a2022-01-10 00:34:35 -0800922 return;
923}
924void notifyDataSignal() {
925 RLOGE("notifyDataSignal()");
926 pthread_mutex_lock(&s_DataMutex);
927 pthread_cond_broadcast(&s_DataCond);
928 pthread_mutex_unlock(&s_DataMutex);
929}
930
931bool mtkItTest(const char* data) {
932 std::string str("");
933 str.append(data);
934 RLOGD("%s, data: %s", __FUNCTION__, str.c_str());
935 std::vector<std::string> all;
936 RequestInfo* pRI = NULL;
937 utils::tokenize(str, ',', all);
938 if(all[0] != std::string("TEST")) {
939 return false;
940 }
941 android::Parcel p;
942 size_t pos = p.dataPosition();
943 for(int i = 1 ; i < all.size(); i++) {
944 std::string str = all[i];
945 RLOGD("%s, all[%d]: %s", __FUNCTION__, i, str.c_str());
946 std::vector<std::string> items;
947 utils::tokenize(str, '=', items);
948 if(items.size() == 2) {
949 if(items[0] == std::string("INT")) {
950 int para = std::stoi(items[1]);
951 p.writeInt32(para);
952 } else if(items[0] == std::string("STR")) {
953 writeStringToParcel(p, items[1].c_str());
954 } else if(items[0] == std::string("REQ")) {
955 int request = std::stoi(items[1]);
lhb07f4e12022-02-17 22:08:54 -0800956
957 // For loop, free before reassign to avoid memory leak
958 if (pRI != NULL) {
959 free(pRI);
960 }
lh7b0674a2022-01-10 00:34:35 -0800961 pRI = creatRILInfoAndInit(request, UDP, (RIL_SOCKET_ID) ((0)));
962 }
963 } else {
964 RLOGD("%s, too many \"=\"");
965 }
966 }
lhb07f4e12022-02-17 22:08:54 -0800967
lh7b0674a2022-01-10 00:34:35 -0800968 if(pRI && pRI->pCI) {
969 p.setDataPosition(pos);
970 pRI->pCI->dispatchFunction(p, pRI);
lh7b0674a2022-01-10 00:34:35 -0800971 }
lhb07f4e12022-02-17 22:08:54 -0800972
973 // Free to avoid memory leak
974 if(pRI != NULL) {
975 free(pRI);
976 pRI = NULL;
977 }
978
lh7b0674a2022-01-10 00:34:35 -0800979 return true;
980}
981int lynqSocketSendto(int fd,struct sockaddr *dest_addr,int addr_len,char msg[])
982{
983 int ret = 0;
984 ret = sendto(fd,msg,strlen(msg),0,dest_addr,addr_len);
985 if(ret>0)
986 {
987 RLOGD("[lynqSocketSendto] send msg success!!!");
988 return 0;
989 }
990 else
991 {
992 RLOGD("[lynqSocketSendto] send msg fail!!!");
993 return -1;
994 }
llaaca09b2022-03-14 16:14:28 +0800995}
q.huang4e08e4d2022-12-28 10:58:48 +0800996
q.huang036b6cf2023-01-10 14:29:20 +0800997void lynq_exit()
998{
999 ril_deinit_mem();
1000 mbtk_netled_deinit();
1001}
1002
q.huang4e08e4d2022-12-28 10:58:48 +08001003#ifdef LED_SUPPORT
1004bool ril_get_if_insert_simcard()
1005{
1006 int slot_id=get_default_sim_voice();
1007
1008 if(slot_id==0 || slot_id ==1)
1009 {
1010 if(cur_CardS_Status[slot_id]!=NULL)
1011 {
1012 return cur_CardS_Status[slot_id]->card_state == RIL_CARDSTATE_PRESENT;
1013 }
1014
1015 }
1016 return false;
1017}
1018
1019bool ril_get_if_3gpp_reg_success()
1020{
1021 int slot_id=get_default_sim_voice();
1022
1023 if(slot_id==0 || slot_id ==1)
1024 {
1025 return reg_voice_service_state[slot_id] ==1;
1026 }
1027 return false;
1028}
1029#endif
llaaca09b2022-03-14 16:14:28 +08001030/*hq add for key info output 2022/03/01 begin*/
1031// void lynq_output_LINFO_all()
1032// {
1033// int slot,startSlot=0,slotNum=SIM_COUNT;
1034
1035// if(default_sim_voice==default_sim_data && default_sim_voice==default_sim_sms){
1036// startSlot=default_sim_voice;
1037// slotNum=1;
1038// }
1039
1040// lynq_output_info("+LINFO: Report switch when key information changed is set: %d\n",lynq_output_LINFO_enable);
1041// lynq_output_info("+LINFO: Default voice SIM card is set : [SIM%d]\n", default_sim_voice+1);
1042// lynq_output_info("+LINFO: Default data SIM card is set : [SIM%d]\n", default_sim_data+1);
1043// lynq_output_info("+LINFO: Default sms SIM card is set : [SIM%d]\n", default_sim_sms+1);
1044
1045// for(slot=startSlot;slot<startSlot+slotNum;slot++){
1046// lynq_output_info("+LINFO: [SIM%d] Card State is %s\n",slot+1,cardStateToString((cur_CardS_Status[slot]!=NULL ? cur_CardS_Status[slot]->card_state:UNKOWN_VALUE)));
1047// lynq_output_info("+LINFO: [SIM%d] Preferred network_type: is %s\n", slot+1, preferredNetworkTypeToString(preferred_network_type[slot]));
1048// lynq_output_info("+LINFO: [SIM%d] Voice Registration State is %s\n",slot+1,serviceStateToString(regCodeToServiceState(reg_voice_service_state[slot])));
1049// lynq_output_info("+LINFO: [SIM%d] Voice Radio Access Network is %s\n",slot+1,RadioNwToString(regCodeToRadioTechnology(reg_voice_radio_tech[slot])));
1050// lynq_output_info("+LINFO: [SIM%d] Data Registration State is %s\n",slot+1,serviceStateToString(regCodeToServiceState(reg_data_service_state[slot])));
1051// lynq_output_info("+LINFO: [SIM%d] Data Radio Access Network is %s\n",slot+1,RadioNwToString(regCodeToRadioTechnology(reg_data_radio_tech[slot])));
1052// }
1053// return;
1054// }
1055// void lynq_output_LINFO(const char* format,...)
1056// {
1057// char buf[1024] = {0};
1058// int n;
1059// char ebuf[1024] = {0};
1060
1061// if(lynq_output_LINFO_enable)
1062// {
1063// va_list args;
1064// va_start(args, format);
1065// vsnprintf(buf, sizeof(buf), format, args);
1066// va_end(args);
1067
1068// printf("hq %s",buf);
1069// n=snprintf(ebuf,sizeof(ebuf),"+LINFO: %s", buf);
1070
1071// n=write(ttyGS3_fd, ebuf, strlen(ebuf));
1072// if(n < 0)
1073// {
1074// perror("lynq resp write:");
1075// }
1076// }
1077// return;
1078// }
1079// void lynq_output_info(const char* format,...)
1080// {
1081// char buf[1024] = {0};
1082// int n;
1083
1084// va_list args;
1085// va_start(args, format);
1086// vsnprintf(buf, sizeof(buf), format, args);
1087// va_end(args);
1088
1089// n=write(ttyGS3_fd, buf, strlen(buf));
1090// if(n < 0)
1091// {
1092// perror("lynq resp write:");
1093// }
1094
1095// return;
1096// }
1097/*hq add for key info output 2022/03/01 end*/