sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ac11e3cba9
nuttx-apps/lte/alt1250/callback_handlers/alt1250_evt.c
SPRESENSE a16fb23dd7 lte/alt1250: Notice instance information 
Notice instance information of LwM2M server operation to application.
2024-01-24 22:21:56 +01:00

2197 lines
58 KiB
C
Raw Blame History

/****************************************************************************
* apps/lte/alt1250/callback_handlers/alt1250_evt.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <semaphore.h>
#include <nuttx/modem/alt1250.h>
#include <nuttx/wireless/lte/lte_ioctl.h>
#include <nuttx/net/sms.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <assert.h>
#include <nuttx/net/dns.h>
#include <lte/lte_lwm2m.h>
#include "alt1250_dbg.h"
#include "lte/lapi.h"
#include "lte/lte_api.h"
#include "alt1250_evt.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define TABLE_CONTENT(cid, acid, outp) \
{ .cmdid = LTE_CMDID_##cid, .altcid = APICMDID_##acid, \
.outparam = outp, .outparamlen = nitems(outp) }
#define TABLE_CONTENT_NOARG(cid, acid) \
{ .cmdid = LTE_CMDID_##cid, .altcid = APICMDID_##acid, \
.outparam = NULL, .outparamlen = 0 }
#define NCBTABLES (8 + ALTCOM_NSOCKET) /* 8 is the maximum number of events */
#define IS_REPORT_API(cmdid) \
( LTE_ISCMDGRP_EVENT(cmdid) || cmdid == LTE_CMDID_SETRESTART )
#define EVTTASK_NAME "lteevt_task"
#define LAPIEVT_QNAME "/lapievt"
#define clr_evtcb(info) reg_evtcb(info, 0, NULL)
#define search_free_evtcb() search_evtcb(0)
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static uint64_t lte_set_report_restart_exec_cb(FAR void *cb,
FAR void **cbarg,
FAR bool *set_writable);
#ifdef CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API
static uint64_t lte_radio_on_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_radio_off_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
#endif /* CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API */
static uint64_t lte_activate_pdn_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
#ifdef CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API
static uint64_t lte_deactivate_pdn_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_netinfo_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_imscap_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_version_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_phoneno_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_imsi_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_imei_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_pinset_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_set_pinenable_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_change_pin_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_enter_pin_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_localtime_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_operator_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_edrx_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_set_edrx_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_psm_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_set_psm_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_ce_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_set_ce_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_siminfo_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_current_edrx_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_current_psm_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_get_quality_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
#endif /* CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API */
static uint64_t lte_set_report_netinfo_exec_cb(FAR void *cb,
FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_set_report_simstat_exec_cb(FAR void *cb,
FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_set_report_localtime_exec_cb(FAR void *cb,
FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_set_report_quality_exec_cb(FAR void *cb,
FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lte_set_report_cellinfo_exec_cb(FAR void *cb,
FAR void **cbarg,
FAR bool *set_writable);
static uint64_t tls_config_verify_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lwm2m_read_evt_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lwm2m_write_evt_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lwm2m_exec_evt_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lwm2m_ovstart_evt_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lwm2m_ovstop_evt_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lwm2m_operation_evt_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static uint64_t lwm2m_fwupdate_evt_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
static FAR void *get_cbfunc(uint32_t cmdid);
static uint64_t alt1250_evt_search(uint32_t cmdid);
/****************************************************************************
* Private Data Types
****************************************************************************/
struct cbinfo_s
{
uint32_t cmdid;
CODE uint64_t (*cb)(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable);
};
/****************************************************************************
* Private Data
****************************************************************************/
#ifdef CONFIG_LTE_ALT1250_LAUNCH_EVENT_TASK
static int g_cbpid;
#endif
/* event argument for LTE_CMDID_SETRESTART */
static uint32_t g_reason;
static void *g_setrestartargs[] =
{
&g_reason
};
/* event argument for LTE_CMDID_GETVER */
static int g_getverret;
static lte_version_t g_ver;
static FAR void *g_getverargs[] =
{
&g_getverret, &g_ver
};
#ifdef CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API
/* event argument for LTE_CMDID_RADIOON */
static int g_radioonret;
static FAR void *g_radioonargs[] =
{
&g_radioonret
};
/* event argument for LTE_CMDID_RADIOOFF */
static int g_radiooffret;
static FAR void *g_radiooffargs[] =
{
&g_radiooffret
};
#endif /* CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API */
/* event argument for LTE_CMDID_ACTPDN */
static int g_actpdnret;
static lte_pdn_t g_pdn;
static FAR void *g_actpdnargs[] =
{
&g_actpdnret, &g_pdn
};
#ifdef CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API
/* event argument for LTE_CMDID_DEACTPDN */
static int g_deactpdnret;
static FAR void *g_deactpdnargs[] =
{
&g_deactpdnret
};
/* event argument for LTE_CMDID_GETNETINFO */
static int g_getnetinforet;
static lte_pdn_t g_pdninfo[LTE_SESSION_ID_MAX];
static lte_netinfo_t g_netinfo =
{
.pdn_stat = g_pdninfo
};
static uint8_t g_pdn_num = LTE_SESSION_ID_MAX;
static FAR void *g_netinfoargs[] =
{
&g_getnetinforet, &g_netinfo, &g_pdn_num
};
/* event argument for LTE_CMDID_IMSCAP */
static int g_imscapret;
static bool g_imscap;
static FAR void *g_imscapargs[] =
{
&g_imscapret, &g_imscap
};
/* event argument for LTE_CMDID_GETPHONE */
static int g_getphoneret;
static uint8_t g_getphoneerrcause;
static char g_phoneno[LTE_PHONENO_LEN];
#ifndef CONFIG_LTE_LAPI_KEEP_COMPATIBILITY
static size_t g_phonenolen = LTE_PHONENO_LEN;
#endif
static FAR void *g_getphoneargs[] =
{
#ifdef CONFIG_LTE_LAPI_KEEP_COMPATIBILITY
&g_getphoneret, &g_getphoneerrcause, g_phoneno
#else
&g_getphoneret, &g_getphoneerrcause, g_phoneno, &g_phonenolen
#endif
};
/* event argument for LTE_CMDID_GETIMSI */
static int g_getimsiret;
static uint8_t g_getimsierrcause;
static char g_imsi[LTE_SIMINFO_IMSI_LEN];
#ifndef CONFIG_LTE_LAPI_KEEP_COMPATIBILITY
static size_t g_imsilen = LTE_SIMINFO_IMSI_LEN;
#endif
static FAR void *g_getimsiargs[] =
{
#ifdef CONFIG_LTE_LAPI_KEEP_COMPATIBILITY
&g_getimsiret, &g_getimsierrcause, g_imsi
#else
&g_getimsiret, &g_getimsierrcause, g_imsi, &g_imsilen
#endif
};
/* event argument for LTE_CMDID_GETIMEI */
static int g_getimeiret;
static char g_imei[LTE_IMEI_LEN];
#ifndef CONFIG_LTE_LAPI_KEEP_COMPATIBILITY
static size_t g_imeilen = LTE_IMEI_LEN;
#endif
static FAR void *g_getimeiargs[] =
{
#ifdef CONFIG_LTE_LAPI_KEEP_COMPATIBILITY
&g_getimeiret, g_imei
#else
&g_getimeiret, g_imei, &g_imeilen
#endif
};
/* event argument for LTE_CMDID_GETPINSET */
static int g_getpinsetret;
static lte_getpin_t g_pinset;
static FAR void *g_getpinsetargs[] =
{
&g_getpinsetret, &g_pinset
};
/* event argument for LTE_CMDID_PINENABLE */
static int g_pinenableret;
static uint8_t g_pineattleft;
static FAR void *g_pinenableargs[] =
{
&g_pinenableret, &g_pineattleft
};
/* event argument for LTE_CMDID_CHANGEPIN */
static int g_changepinret;
static uint8_t g_chanattleft;
static FAR void *g_changepinargs[] =
{
&g_changepinret, &g_chanattleft
};
/* event argument for LTE_CMDID_ENTERPIN */
static int g_enterpinret;
static uint8_t g_entpinsimstat;
static uint8_t g_entpinattleft;
static FAR void *g_enterpinargs[] =
{
&g_enterpinret, &g_entpinsimstat, &g_entpinattleft
};
/* event argument for LTE_CMDID_GETLTIME */
static int g_getltimeret;
static lte_localtime_t g_ltime;
static FAR void *g_getltimeargs[] =
{
&g_getltimeret, &g_ltime
};
/* event argument for LTE_CMDID_GETOPER */
static int g_getoperret;
static char g_oper[LTE_OPERATOR_LEN];
#ifndef CONFIG_LTE_LAPI_KEEP_COMPATIBILITY
static size_t g_operlen = LTE_OPERATOR_LEN;
#endif
static FAR void *g_getoperargs[] =
{
#ifdef CONFIG_LTE_LAPI_KEEP_COMPATIBILITY
&g_getoperret, g_oper
#else
&g_getoperret, g_oper, &g_operlen
#endif
};
/* event argument for LTE_CMDID_GETEDRX */
static int g_getedrxret;
static lte_edrx_setting_t g_getedrx;
static bool g_is_getedrxevt;
static FAR void *g_getedrxargs[] =
{
&g_getedrxret, &g_getedrx, &g_is_getedrxevt
};
/* event argument for LTE_CMDID_SETEDRX */
static int g_setedrxret;
static FAR void *g_setedrxargs[] =
{
&g_setedrxret
};
/* event argument for LTE_CMDID_GETPSM */
static int g_getpsmret;
static lte_psm_setting_t g_getpsm;
static bool g_is_getpsmevt;
static FAR void *g_getpsmargs[] =
{
&g_getpsmret, &g_getpsm, &g_is_getpsmevt
};
/* event argument for LTE_CMDID_SETPSM */
static int g_setpsmret;
static FAR void *g_setpsmargs[] =
{
&g_setpsmret
};
/* event argument for LTE_CMDID_GETCE */
static int g_getceret;
static lte_ce_setting_t g_getce;
static FAR void *g_getceargs[] =
{
&g_getceret, &g_getce
};
/* event argument for LTE_CMDID_SETCE */
static int g_setceret;
static FAR void *g_setceargs[] =
{
&g_setceret
};
/* event argument for LTE_CMDID_GETSIMINFO */
static int g_setsiminforet;
static lte_siminfo_t g_siminfo;
static FAR void *g_getsiminfoargs[] =
{
&g_setsiminforet, &g_siminfo
};
/* event argument for LTE_CMDID_GETCEDRX */
static int g_getcedrxret;
static lte_edrx_setting_t g_getcedrx;
static bool g_is_getcedrxevt;
static FAR void *g_getcedrxargs[] =
{
&g_getcedrxret, &g_getcedrx, &g_is_getcedrxevt
};
/* event argument for LTE_CMDID_GETCPSM */
static int g_getcpsmret;
static lte_psm_setting_t g_getcpsm;
static bool g_is_getcpsmevt;
static FAR void *g_getcpsmargs[] =
{
&g_getcpsmret, &g_getcpsm, &g_is_getcpsmevt
};
/* event argument for LTE_CMDID_GETQUAL */
static int g_getqualret;
static lte_quality_t g_getqual;
static FAR void *g_getqualargs[] =
{
&g_getqualret, &g_getqual
};
/* event argument for LTE_CMDID_GETCELL */
static int g_getcellret;
static lte_neighbor_cell_t g_neighbors[LTE_NEIGHBOR_CELL_MAX];
static lte_cellinfo_t g_getcell =
{
.neighbors = g_neighbors
}
;
static FAR void *g_getcellargs[] =
{
&g_getcellret, &g_getcell
};
#endif /* CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API */
/* event argument for LTE_CMDID_GETRAT */
static int g_getratret;
static FAR void *g_getratargs[] =
{
&g_getratret
};
/* event argument for LTE_CMDID_SETRAT */
static int g_setratret;
static FAR void *g_setratargs[] =
{
&g_setratret
};
/* event argument for LTE_CMDID_GETRATINFO */
static int g_getratinforet;
static lte_ratinfo_t g_ratinfo;
static FAR void *g_getratinfoargs[] =
{
&g_getratinforet, &g_ratinfo
};
/* event argument for LTE_CMDID_REPNETINFO */
static lte_pdn_t g_reppdninfo[LTE_SESSION_ID_MAX];
static lte_netinfo_t g_repnetinfo =
{
.pdn_stat = g_reppdninfo
};
static uint8_t g_ndnsaddrs;
static struct sockaddr_storage g_dnsaddrs[ALTCOM_DNS_SERVERS];
static FAR void *g_repnetinfoargs[] =
{
&g_repnetinfo, &g_ndnsaddrs, g_dnsaddrs
};
/* event argument for LTE_CMDID_REPSIMSTAT */
static uint32_t g_repsimstat;
static FAR void *g_repsimstatargs[] =
{
&g_repsimstat
};
/* event argument for LTE_CMDID_REPLTIME */
static lte_localtime_t g_repltime;
static FAR void *g_repltimeargs[] =
{
&g_repltime
};
/* event argument for LTE_CMDID_REPQUAL */
static lte_quality_t g_repqual;
static FAR void *g_repqualargs[] =
{
&g_repqual
};
/* event argument for LTE_CMDID_REPCELL */
static lte_neighbor_cell_t g_repneighbors[LTE_NEIGHBOR_CELL_MAX];
static lte_cellinfo_t g_repcell =
{
.neighbors = g_repneighbors
};
static FAR void *g_repcellargs[] =
{
&g_repcell
};
/* event argument for LTE_CMDID_GETERRINFO */
static lte_errinfo_t g_geterrinfo;
static FAR void *g_geterrinfoargs[] =
{
&g_geterrinfo
};
/* event argument for LTE_CMDID_TLS_CONFIG_VERIFY_CALLBACK */
static uint32_t g_crt;
static int32_t g_depth;
static FAR void *g_vrfycbargs[] =
{
&g_crt, &g_depth
};
/* event argument for LTE_CMDID_SMS_REPORT_RECV */
static uint16_t g_smsmsg_index;
static uint16_t g_smsrecv_sz;
static uint8_t g_sms_maxnum;
static uint8_t g_sms_seqnum;
static struct sms_deliver_msg_max_s g_recvmsg;
static FAR void *g_smsreportargs[] =
{
&g_smsmsg_index, &g_smsrecv_sz, &g_sms_maxnum, &g_sms_seqnum, &g_recvmsg
};
/* event argument for LTE_CMDID_LWM2M_READ_EVT */
static struct lwm2mstub_instance_s g_lwm2mread_inst;
static FAR void *g_lwm2mreadargs[] =
{
NULL, NULL, &g_lwm2mread_inst
};
/* event argument for LTE_CMDID_LWM2M_WRITE_EVT */
static struct lwm2mstub_instance_s g_lwm2mwrite_inst;
static char g_lwm2mwrite_value[LWM2MSTUB_MAX_WRITE_SIZE];
static FAR void *g_lwm2mwriteargs[] =
{
NULL, NULL, &g_lwm2mwrite_inst, g_lwm2mwrite_value,
NULL, (FAR void *)LWM2MSTUB_MAX_WRITE_SIZE
};
/* event argument for LTE_CMDID_LWM2M_EXEC_EVT */
static struct lwm2mstub_instance_s g_lwm2mexec_inst;
static FAR void *g_lwm2mexecargs[] =
{
NULL, NULL, &g_lwm2mexec_inst, NULL
};
/* event argument for LTE_CMDID_LWM2M_OVSTART_EVT */
static struct lwm2mstub_instance_s g_lwm2movstart_inst;
static char g_lwm2movstart_token[LWM2MSTUB_MAX_TOKEN_SIZE];
static struct lwm2mstub_ovcondition_s g_lwm2movstart_cond;
static FAR void *g_lwm2movstartargs[] =
{
NULL, NULL, &g_lwm2movstart_inst, g_lwm2movstart_token,
(FAR void *)LWM2MSTUB_MAX_TOKEN_SIZE, &g_lwm2movstart_cond
};
/* event argument for LTE_CMDID_LWM2M_OVSTOP_EVT */
static struct lwm2mstub_instance_s g_lwm2movstop_inst;
static char g_lwm2movstop_token[LWM2MSTUB_MAX_TOKEN_SIZE];
static FAR void *g_lwm2movstopargs[] =
{
NULL, NULL, &g_lwm2movstop_inst, &g_lwm2movstop_token,
(FAR void *)LWM2MSTUB_MAX_TOKEN_SIZE
};
/* event argument for LTE_CMDID_LWM2M_SERVEROP_EVT */
static struct lwm2mstub_instance_s g_lwm2msrvop_inst;
static FAR void *g_lwm2moperationargs[] =
{
NULL, NULL, &g_lwm2msrvop_inst
};
/* event argument for LTE_CMDID_LWM2M_FWUP_EVT */
static FAR void *g_lwm2mfwupargs[] =
{
NULL
};
static struct alt_evtbuffer_s g_evtbuff;
static struct alt_evtbuf_inst_s g_evtbuffers[] =
{
TABLE_CONTENT(SETRESTART, POWER_ON, g_setrestartargs),
TABLE_CONTENT(GETVER, GET_VERSION, g_getverargs),
#ifdef CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API
TABLE_CONTENT(RADIOON, RADIO_ON, g_radioonargs),
TABLE_CONTENT(RADIOOFF, RADIO_OFF, g_radiooffargs),
#endif /* CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API */
TABLE_CONTENT(ACTPDN, ACTIVATE_PDN, g_actpdnargs),
#ifdef CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API
TABLE_CONTENT(DEACTPDN, DEACTIVATE_PDN, g_deactpdnargs),
TABLE_CONTENT(GETNETINFO, GET_NETINFO, g_netinfoargs),
TABLE_CONTENT(IMSCAP, GET_IMS_CAP, g_imscapargs),
TABLE_CONTENT(GETPHONE, GET_PHONENO, g_getphoneargs),
TABLE_CONTENT(GETIMSI, GET_IMSI, g_getimsiargs),
TABLE_CONTENT(GETIMEI, GET_IMEI, g_getimeiargs),
TABLE_CONTENT(GETPINSET, GET_PINSET, g_getpinsetargs),
TABLE_CONTENT(PINENABLE, SET_PIN_LOCK, g_pinenableargs),
TABLE_CONTENT(CHANGEPIN, SET_PIN_CODE, g_changepinargs),
TABLE_CONTENT(ENTERPIN, ENTER_PIN, g_enterpinargs),
TABLE_CONTENT(GETLTIME, GET_LTIME, g_getltimeargs),
TABLE_CONTENT(GETOPER, GET_OPERATOR, g_getoperargs),
TABLE_CONTENT(GETEDRX, GET_EDRX, g_getedrxargs),
TABLE_CONTENT(SETEDRX, SET_EDRX, g_setedrxargs),
TABLE_CONTENT(GETPSM, GET_PSM, g_getpsmargs),
TABLE_CONTENT(SETPSM, SET_PSM, g_setpsmargs),
TABLE_CONTENT(GETCE, GET_CE, g_getceargs),
TABLE_CONTENT(SETCE, SET_CE, g_setceargs),
TABLE_CONTENT(GETSIMINFO, GET_SIMINFO, g_getsiminfoargs),
TABLE_CONTENT(GETCEDRX, GET_DYNAMICEDRX, g_getcedrxargs),
TABLE_CONTENT(GETCPSM, GET_DYNAMICPSM, g_getcpsmargs),
TABLE_CONTENT(GETQUAL, GET_QUALITY, g_getqualargs),
TABLE_CONTENT(GETCELL, GET_CELLINFO, g_getcellargs),
#endif /* CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API */
TABLE_CONTENT(GETRAT, GET_RAT, g_getratargs),
TABLE_CONTENT(SETRAT, SET_RAT, g_setratargs),
TABLE_CONTENT(GETRATINFO, GET_RAT, g_getratinfoargs),
TABLE_CONTENT(REPNETINFO, REPORT_NETINFO, g_repnetinfoargs),
TABLE_CONTENT_NOARG(REPEVT_DUMMY, REPORT_EVT),
TABLE_CONTENT(REPSIMSTAT, UNKNOWN, g_repsimstatargs),
TABLE_CONTENT(REPLTIME, UNKNOWN, g_repltimeargs),
TABLE_CONTENT(REPQUAL, REPORT_QUALITY, g_repqualargs),
TABLE_CONTENT(REPCELL, REPORT_CELLINFO, g_repcellargs),
TABLE_CONTENT(GETERRINFO, ERRINFO, g_geterrinfoargs),
TABLE_CONTENT(TLS_CONFIG_VERIFY, TLS_CONFIG_VERIFY_CALLBACK,
g_vrfycbargs),
TABLE_CONTENT(SMS_REPORT_RECV, SMS_REPORT_RECV, g_smsreportargs),
/* For Unsolicited event */
TABLE_CONTENT_NOARG(LWM2M_URC_DUMMY, URC_EVENT),
TABLE_CONTENT(LWM2M_READ_EVT, UNKNOWN, g_lwm2mreadargs),
TABLE_CONTENT(LWM2M_WRITE_EVT, UNKNOWN, g_lwm2mwriteargs),
TABLE_CONTENT(LWM2M_EXEC_EVT, UNKNOWN, g_lwm2mexecargs),
TABLE_CONTENT(LWM2M_OVSTART_EVT, UNKNOWN, g_lwm2movstartargs),
TABLE_CONTENT(LWM2M_OVSTOP_EVT, UNKNOWN, g_lwm2movstopargs),
TABLE_CONTENT(LWM2M_SERVEROP_EVT, UNKNOWN, g_lwm2moperationargs),
TABLE_CONTENT(LWM2M_FWUP_EVT, UNKNOWN, g_lwm2mfwupargs),
/* Add the command ID of LTE_CMDID_SELECT to the table so that the driver
* can identify the bitmap of the select event.
* The output parameter is NULL since a container for select is used.
*/
TABLE_CONTENT_NOARG(SELECT, SOCK_SELECT)
};
static struct cbinfo_s g_execbtable[] =
{
{LTE_CMDID_SETRESTART, lte_set_report_restart_exec_cb},
#ifdef CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API
{LTE_CMDID_GETVER, lte_get_version_exec_cb},
{LTE_CMDID_RADIOON, lte_radio_on_exec_cb},
{LTE_CMDID_RADIOOFF, lte_radio_off_exec_cb},
#endif /* CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API */
{LTE_CMDID_ACTPDN, lte_activate_pdn_exec_cb},
#ifdef CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API
{LTE_CMDID_DEACTPDN, lte_deactivate_pdn_exec_cb},
{LTE_CMDID_GETNETINFO, lte_get_netinfo_exec_cb},
{LTE_CMDID_IMSCAP, lte_get_imscap_exec_cb},
{LTE_CMDID_GETPHONE, lte_get_phoneno_exec_cb},
{LTE_CMDID_GETIMSI, lte_get_imsi_exec_cb},
{LTE_CMDID_GETIMEI, lte_get_imei_exec_cb},
{LTE_CMDID_GETPINSET, lte_get_pinset_exec_cb},
{LTE_CMDID_PINENABLE, lte_set_pinenable_exec_cb},
{LTE_CMDID_CHANGEPIN, lte_change_pin_exec_cb},
{LTE_CMDID_ENTERPIN, lte_enter_pin_exec_cb},
{LTE_CMDID_GETLTIME, lte_get_localtime_exec_cb},
{LTE_CMDID_GETOPER, lte_get_operator_exec_cb},
{LTE_CMDID_GETEDRX, lte_get_edrx_exec_cb},
{LTE_CMDID_SETEDRX, lte_set_edrx_exec_cb},
{LTE_CMDID_GETPSM, lte_get_psm_exec_cb},
{LTE_CMDID_SETPSM, lte_set_psm_exec_cb},
{LTE_CMDID_GETCE, lte_get_ce_exec_cb},
{LTE_CMDID_SETCE, lte_set_ce_exec_cb},
{LTE_CMDID_GETSIMINFO, lte_get_siminfo_exec_cb},
{LTE_CMDID_GETCEDRX, lte_get_current_edrx_exec_cb},
{LTE_CMDID_GETCPSM, lte_get_current_psm_exec_cb},
{LTE_CMDID_GETQUAL, lte_get_quality_exec_cb},
#endif /* CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API */
{LTE_CMDID_REPNETINFO, lte_set_report_netinfo_exec_cb},
{LTE_CMDID_REPSIMSTAT, lte_set_report_simstat_exec_cb},
{LTE_CMDID_REPLTIME, lte_set_report_localtime_exec_cb},
{LTE_CMDID_REPQUAL, lte_set_report_quality_exec_cb},
{LTE_CMDID_REPCELL, lte_set_report_cellinfo_exec_cb},
{LTE_CMDID_TLS_CONFIG_VERIFY, tls_config_verify_exec_cb},
{LTE_CMDID_LWM2M_READ_EVT, lwm2m_read_evt_cb},
{LTE_CMDID_LWM2M_WRITE_EVT, lwm2m_write_evt_cb},
{LTE_CMDID_LWM2M_EXEC_EVT, lwm2m_exec_evt_cb},
{LTE_CMDID_LWM2M_OVSTART_EVT, lwm2m_ovstart_evt_cb},
{LTE_CMDID_LWM2M_OVSTOP_EVT, lwm2m_ovstop_evt_cb},
{LTE_CMDID_LWM2M_SERVEROP_EVT, lwm2m_operation_evt_cb},
{LTE_CMDID_LWM2M_FWUP_EVT, lwm2m_fwupdate_evt_cb},
};
static struct cbinfo_s g_cbtable[NCBTABLES];
static sem_t g_cbtablelock;
/****************************************************************************
* Private Functions
****************************************************************************/
static uint64_t lte_set_report_restart_exec_cb(FAR void *cb,
FAR void **cbarg,
FAR bool *set_writable)
{
restart_report_cb_t callback = (restart_report_cb_t)cb;
FAR uint32_t *param = (FAR uint32_t *)cbarg[0];
if (callback)
{
callback(*param);
}
return 0ULL;
}
#ifdef CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API
static uint64_t lte_radio_on_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
radio_on_cb_t callback = (radio_on_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
if (callback)
{
callback(*result);
}
return 0ULL;
}
static uint64_t lte_radio_off_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
radio_off_cb_t callback = (radio_off_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
if (callback)
{
callback(*result);
}
return 0ULL;
}
#endif /* CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API */
static uint64_t lte_activate_pdn_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
activate_pdn_cb_t callback = (activate_pdn_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR lte_pdn_t *pdn = (FAR lte_pdn_t *)cbarg[1];
if (callback)
{
callback(*result, pdn);
}
return 0ULL;
}
#ifdef CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API
static uint64_t lte_deactivate_pdn_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
deactivate_pdn_cb_t callback = (deactivate_pdn_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
if (callback)
{
callback(*result);
}
return 0ULL;
}
static uint64_t lte_get_netinfo_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_netinfo_cb_t callback = (get_netinfo_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR lte_netinfo_t *info = (FAR lte_netinfo_t *)cbarg[1];
if (callback)
{
callback(*result, info);
}
return 0ULL;
}
static uint64_t lte_get_imscap_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_imscap_cb_t callback = (get_imscap_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR bool *imscap = (FAR bool *)cbarg[1];
if (callback)
{
callback(*result, *imscap);
}
return 0ULL;
}
static uint64_t lte_get_version_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_ver_cb_t callback = (get_ver_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR lte_version_t *version = (FAR lte_version_t *)cbarg[1];
if (callback)
{
callback(*result, version);
}
return 0ULL;
}
static uint64_t lte_get_phoneno_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_phoneno_cb_t callback = (get_phoneno_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR uint8_t *errcause = (FAR uint8_t *)cbarg[1];
FAR char *phoneno = (FAR char *)cbarg[2];
if (callback)
{
callback(*result, *errcause, phoneno);
}
return 0ULL;
}
static uint64_t lte_get_imsi_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_imsi_cb_t callback = (get_imsi_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR uint8_t *errcause = (FAR uint8_t *)cbarg[1];
FAR char *imsi = (FAR char *)cbarg[2];
if (callback)
{
callback(*result, *errcause, imsi);
}
return 0ULL;
}
static uint64_t lte_get_imei_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_imei_cb_t callback = (get_imei_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR char *imei = (FAR char *)cbarg[1];
if (callback)
{
callback(*result, imei);
}
return 0ULL;
}
static uint64_t lte_get_pinset_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_pinset_cb_t callback = (get_pinset_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR lte_getpin_t *pinset = (FAR lte_getpin_t *)cbarg[1];
if (callback)
{
callback(*result, pinset);
}
return 0ULL;
}
static uint64_t lte_set_pinenable_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
set_pinenable_cb_t callback = (set_pinenable_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR uint8_t *attemptsleft = (FAR uint8_t *)cbarg[1];
if (callback)
{
callback(*result, *attemptsleft);
}
return 0ULL;
}
static uint64_t lte_change_pin_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
change_pin_cb_t callback = (change_pin_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR uint8_t *attemptsleft = (FAR uint8_t *)cbarg[1];
if (callback)
{
callback(*result, *attemptsleft);
}
return 0ULL;
}
static uint64_t lte_enter_pin_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
enter_pin_cb_t callback = (enter_pin_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR uint8_t *simstat = (FAR uint8_t *)cbarg[1];
FAR uint8_t *attemptsleft = (FAR uint8_t *)cbarg[2];
if (callback)
{
callback(*result, *simstat, *attemptsleft);
}
return 0ULL;
}
static uint64_t lte_get_localtime_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_localtime_cb_t callback = (get_localtime_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR lte_localtime_t *localtime = (FAR lte_localtime_t *)cbarg[1];
if (callback)
{
callback(*result, localtime);
}
return 0ULL;
}
static uint64_t lte_get_operator_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_operator_cb_t callback = (get_operator_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR char *oper = (FAR char *)cbarg[1];
if (callback)
{
callback(*result, oper);
}
return 0ULL;
}
static uint64_t lte_get_edrx_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_edrx_cb_t callback = (get_edrx_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR lte_edrx_setting_t *settings = (FAR lte_edrx_setting_t *)cbarg[1];
FAR bool *is_getedrxevt = (FAR bool *)cbarg[2];
if (!(*is_getedrxevt))
{
return alt1250_evt_search(LTE_CMDID_GETCEDRX);
}
if (callback)
{
callback(*result, settings);
*is_getedrxevt = false;
}
return 0ULL;
}
static uint64_t lte_set_edrx_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
set_edrx_cb_t callback = (set_edrx_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
if (callback)
{
callback(*result);
}
return 0ULL;
}
static uint64_t lte_get_psm_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_psm_cb_t callback = (get_psm_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR lte_psm_setting_t *settings = (FAR lte_psm_setting_t *)cbarg[1];
FAR bool *is_getpsmevt = (FAR bool *)cbarg[2];
if (!(*is_getpsmevt))
{
return alt1250_evt_search(LTE_CMDID_GETCPSM);
}
if (callback)
{
callback(*result, settings);
*is_getpsmevt = false;
}
return 0ULL;
}
static uint64_t lte_set_psm_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
set_psm_cb_t callback = (set_psm_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
if (callback)
{
callback(*result);
}
return 0ULL;
}
static uint64_t lte_get_ce_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_ce_cb_t callback = (get_ce_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR lte_ce_setting_t *settings = (FAR lte_ce_setting_t *)cbarg[1];
if (callback)
{
callback(*result, settings);
}
return 0ULL;
}
static uint64_t lte_set_ce_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
set_ce_cb_t callback = (set_ce_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
if (callback)
{
callback(*result);
}
return 0ULL;
}
static uint64_t lte_get_siminfo_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_siminfo_cb_t callback = (get_siminfo_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR lte_siminfo_t *siminfo = (FAR lte_siminfo_t *)cbarg[1];
if (callback)
{
callback(*result, siminfo);
}
return 0ULL;
}
static uint64_t lte_get_current_edrx_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_current_edrx_cb_t callback = (get_current_edrx_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR lte_edrx_setting_t *settings = (FAR lte_edrx_setting_t *)cbarg[1];
FAR bool *is_getcedrxevt = (FAR bool *)cbarg[2];
if (!(*is_getcedrxevt))
{
return alt1250_evt_search(LTE_CMDID_GETEDRX);
}
if (callback)
{
callback(*result, settings);
*is_getcedrxevt = false;
}
return 0ULL;
}
static uint64_t lte_get_current_psm_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_current_psm_cb_t callback = (get_current_psm_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR lte_psm_setting_t *settings = (FAR lte_psm_setting_t *)cbarg[1];
FAR bool *is_getcpsmevt = (FAR bool *)cbarg[2];
if (!(*is_getcpsmevt))
{
return alt1250_evt_search(LTE_CMDID_GETPSM);
}
if (callback)
{
callback(*result, settings);
*is_getcpsmevt = false;
}
return 0ULL;
}
static uint64_t lte_get_quality_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
get_quality_cb_t callback = (get_quality_cb_t)cb;
FAR uint32_t *result = (FAR uint32_t *)cbarg[0];
FAR lte_quality_t *quality = (FAR lte_quality_t *)cbarg[1];
if (callback)
{
callback(*result, quality);
}
return 0ULL;
}
#endif /* CONFIG_LTE_LAPI_ENABLE_DEPRECATED_API */
static uint64_t lte_set_report_netinfo_exec_cb(FAR void *cb,
FAR void **cbarg,
FAR bool *set_writable)
{
netinfo_report_cb_t callback = (netinfo_report_cb_t)cb;
FAR lte_netinfo_t *info = (FAR lte_netinfo_t *)cbarg[0];
uint8_t ndnsaddrs = *((FAR uint8_t *)cbarg[1]);
FAR struct sockaddr_storage *dnsaddr =
(FAR struct sockaddr_storage *)cbarg[2];
#if defined(CONFIG_NETDB_DNSCLIENT)
socklen_t addrlen;
uint8_t i;
#endif
#if defined(CONFIG_NETDB_DNSCLIENT)
DEBUGASSERT(ndnsaddrs <= ALTCOM_DNS_SERVERS);
ndnsaddrs = (ndnsaddrs > ALTCOM_DNS_SERVERS) ?
ALTCOM_DNS_SERVERS : ndnsaddrs;
for (i = 0; (i < ndnsaddrs) && (i < CONFIG_NETDB_DNSSERVER_NAMESERVERS);
i++)
{
addrlen = (dnsaddr[i].ss_family == AF_INET) ?
sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
dns_add_nameserver((FAR const struct sockaddr *)&dnsaddr[i], addrlen);
}
if (info->pdn_num > 0)
{
FAR lte_pdn_t *pdn = &info->pdn_stat[0];
FAR lte_ipaddr_t *ipaddr = &pdn->address[0];
/* ALT1250 can only connect one PDN, so check the first PDN. */
if ((pdn->ipaddr_num == 1) && (ipaddr->ip_type == LTE_IPTYPE_V4))
{
dns_set_queryfamily(AF_INET);
}
else if ((pdn->ipaddr_num == 1) && (ipaddr->ip_type == LTE_IPTYPE_V6))
{
dns_set_queryfamily(AF_INET6);
}
else
{
dns_set_queryfamily(AF_UNSPEC);
}
}
else
{
dns_set_queryfamily(AF_UNSPEC);
}
#endif
if (callback)
{
callback(info);
}
return 0ULL;
}
static uint64_t lte_set_report_simstat_exec_cb(FAR void *cb,
FAR void **cbarg,
FAR bool *set_writable)
{
simstat_report_cb_t callback = (simstat_report_cb_t)cb;
FAR uint32_t *simstat = (FAR uint32_t *)cbarg[0];
if (callback)
{
callback(*simstat);
}
return 0ULL;
}
static uint64_t lte_set_report_localtime_exec_cb(FAR void *cb,
FAR void **cbarg,
FAR bool *set_writable)
{
localtime_report_cb_t callback = (localtime_report_cb_t)cb;
FAR lte_localtime_t *localtime = (FAR lte_localtime_t *)cbarg[0];
if (callback)
{
callback(localtime);
}
return 0ULL;
}
static uint64_t lte_set_report_quality_exec_cb(FAR void *cb,
FAR void **cbarg,
FAR bool *set_writable)
{
quality_report_cb_t callback = (quality_report_cb_t)cb;
FAR lte_quality_t *quality = (FAR lte_quality_t *)cbarg[0];
if (callback)
{
callback(quality);
}
return 0ULL;
}
static uint64_t lte_set_report_cellinfo_exec_cb(FAR void *cb,
FAR void **cbarg,
FAR bool *set_writable)
{
cellinfo_report_cb_t callback = (cellinfo_report_cb_t)cb;
FAR lte_cellinfo_t *cellinfo = (FAR lte_cellinfo_t *)cbarg[0];
if (callback)
{
callback(cellinfo);
}
return 0ULL;
}
static uint64_t tls_config_verify_exec_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
CODE void (*callback)(FAR void **cbarg) = cb;
FAR void *arg[2];
uint32_t crt = *((FAR uint32_t *)cbarg[0]);
int32_t depth = *((FAR int32_t *)cbarg[1]);
arg[0] = &crt;
arg[1] = &depth;
/* Here, need to set the status of the event argument to "writable".
* The callback function below will send a response command to ALT1250
* for this event. After receiving the response command,
* ALT1250 may send this event again.
* If the status of the event argument is "not writable", the ALTCOM driver
* will discard this event.
*/
alt1250_setevtarg_writable(LTE_CMDID_TLS_CONFIG_VERIFY);
*set_writable = true;
/* Use a callback to pass event arguments. */
callback(arg);
return 0ULL;
}
static uint64_t lwm2m_read_evt_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
lwm2mstub_read_cb_t callback = (lwm2mstub_read_cb_t)cb;
if (callback)
{
callback((int)cbarg[0], (int)cbarg[1],
(FAR struct lwm2mstub_instance_s *)cbarg[2]);
}
return 0ULL;
}
static uint64_t lwm2m_write_evt_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
lwm2mstub_write_cb_t callback = (lwm2mstub_write_cb_t)cb;
if (callback)
{
callback((int)cbarg[0], (int)cbarg[1],
(FAR struct lwm2mstub_instance_s *)cbarg[2],
(FAR char *)cbarg[3], (int)cbarg[4]);
}
return 0ULL;
}
static uint64_t lwm2m_exec_evt_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
lwm2mstub_exec_cb_t callback = (lwm2mstub_exec_cb_t)cb;
if (callback)
{
callback((int)cbarg[0], (int)cbarg[1],
(FAR struct lwm2mstub_instance_s *)cbarg[2]);
}
return 0ULL;
}
static uint64_t lwm2m_ovstart_evt_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
lwm2mstub_ovstart_cb_t callback = (lwm2mstub_ovstart_cb_t)cb;
if (callback)
{
callback((int)cbarg[0], (int)cbarg[1],
(FAR struct lwm2mstub_instance_s *)cbarg[2],
(FAR char *)cbarg[3],
(FAR struct lwm2mstub_ovcondition_s *)cbarg[5]);
}
return 0ULL;
}
static uint64_t lwm2m_ovstop_evt_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
lwm2mstub_ovstop_cb_t callback = (lwm2mstub_ovstop_cb_t)cb;
if (callback)
{
callback((int)cbarg[0], (int)cbarg[1],
(FAR struct lwm2mstub_instance_s *)cbarg[2],
(FAR char *)cbarg[3]);
}
return 0ULL;
}
static uint64_t lwm2m_operation_evt_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
lwm2mstub_operation_cb_t callback = (lwm2mstub_operation_cb_t)cb;
if (callback)
{
callback((int)cbarg[0], (int)cbarg[1],
(FAR struct lwm2mstub_instance_s *)cbarg[2]);
}
return 0ULL;
}
static uint64_t lwm2m_fwupdate_evt_cb(FAR void *cb, FAR void **cbarg,
FAR bool *set_writable)
{
lwm2mstub_fwupstate_cb_t callback = (lwm2mstub_fwupstate_cb_t)cb;
if (callback)
{
callback((int)cbarg[0]);
}
return 0ULL;
}
/****************************************************************************
* Name: evtbuffer_init
****************************************************************************/
static FAR struct alt_evtbuffer_s *evtbuffer_init(void)
{
int i;
for (i = 0; i < nitems(g_evtbuffers); i++)
{
nxmutex_init(&g_evtbuffers[i].stat_lock);
g_evtbuffers[i].stat = ALTEVTBUF_ST_WRITABLE;
}
g_evtbuff.ninst = nitems(g_evtbuffers);
g_evtbuff.inst = g_evtbuffers;
return &g_evtbuff;
}
/****************************************************************************
* Name: clear_callback
****************************************************************************/
static void clear_callback(uint32_t cmdid)
{
int i;
sem_wait(&g_cbtablelock);
for (i = 0; i < nitems(g_cbtable); i++)
{
if (g_cbtable[i].cmdid == cmdid)
{
g_cbtable[i].cmdid = 0;
g_cbtable[i].cb = NULL;
break;
}
}
sem_post(&g_cbtablelock);
}
/****************************************************************************
* Name: errno2result
****************************************************************************/
static void errno2result(FAR int32_t *result_ptr)
{
if (result_ptr && *result_ptr < 0)
{
if (*result_ptr == -ECANCELED)
{
*result_ptr = LTE_RESULT_CANCEL;
}
else
{
*result_ptr = LTE_RESULT_ERROR;
}
}
}
/****************************************************************************
* Name: exec_callback
****************************************************************************/
static uint64_t exec_callback(uint32_t cmdid,
CODE uint64_t (*func)(FAR void *cb,
FAR void **arg,
FAR bool *set_writable),
FAR void **arg, FAR bool *set_writable)
{
uint64_t evtbitmap = 0ULL;
FAR int32_t *result = NULL;
FAR void *callback = NULL;
callback = get_cbfunc(cmdid);
if (callback)
{
if (!IS_REPORT_API(cmdid))
{
/* APIs that have result as a callback argument
* change the value before execution.
*/
result = (int32_t *)arg[0];
errno2result(result);
}
evtbitmap = func(callback, arg, set_writable);
return evtbitmap;
}
/* When callback is not found,
* GETPSM and GETEDRX, REPNETINFO, REPSIMSTAT, REPLTIME will
* execute func() and update the evtbitmap
*/
if (cmdid == LTE_CMDID_GETPSM ||
cmdid == LTE_CMDID_GETEDRX ||
cmdid == LTE_CMDID_REPNETINFO ||
cmdid == LTE_CMDID_REPSIMSTAT ||
cmdid == LTE_CMDID_REPLTIME)
{
evtbitmap = func(NULL, arg, set_writable);
}
return evtbitmap;
}
/****************************************************************************
* Name: get_evtarg
****************************************************************************/
static FAR void **get_evtarg(int idx)
{
FAR alt_evtbuf_inst_t *inst = &g_evtbuffers[idx];
return inst->outparam;
}
/****************************************************************************
* Name: get_cmdid_byidx
****************************************************************************/
static uint32_t get_cmdid_byidx(int idx)
{
FAR alt_evtbuf_inst_t *inst = &g_evtbuffers[idx];
return inst->cmdid;
}
/****************************************************************************
* Name: update_evtarg_writable
****************************************************************************/
static void update_evtarg_writable(int idx)
{
FAR alt_evtbuf_inst_t *inst = &g_evtbuffers[idx];
nxmutex_lock(&inst->stat_lock);
inst->stat = ALTEVTBUF_ST_WRITABLE;
nxmutex_unlock(&inst->stat_lock);
}
/****************************************************************************
* Name: update_evtarg_writableall
****************************************************************************/
static void update_evtarg_writableall(void)
{
int idx;
for (idx = 0; idx < nitems(g_evtbuffers); idx++)
{
FAR alt_evtbuf_inst_t *inst = &g_evtbuffers[idx];
nxmutex_lock(&inst->stat_lock);
inst->stat = ALTEVTBUF_ST_WRITABLE;
nxmutex_unlock(&inst->stat_lock);
}
}
/****************************************************************************
* Name: get_execfunc
****************************************************************************/
static FAR void *get_execfunc(int idx)
{
int i;
uint32_t cmdid;
cmdid = get_cmdid_byidx(idx);
for (i = 0; i < nitems(g_execbtable); i++)
{
if (g_execbtable[i].cmdid == cmdid)
{
return g_execbtable[i].cb;
}
}
return NULL;
}
/****************************************************************************
* Name: get_cbfunc
****************************************************************************/
static FAR void *get_cbfunc(uint32_t cmdid)
{
int i;
FAR void *ret = NULL;
sem_wait(&g_cbtablelock);
for (i = 0; i < nitems(g_cbtable); i++)
{
if (g_cbtable[i].cmdid == cmdid)
{
ret = g_cbtable[i].cb;
break;
}
}
sem_post(&g_cbtablelock);
return ret;
}
/****************************************************************************
* Name: alt1250_search_execcb
****************************************************************************/
static uint64_t alt1250_search_execcb(uint64_t evtbitmap)
{
int idx;
uint64_t ret = 0ULL;
uint64_t l_evtbitmap = 0ULL;
CODE uint64_t (*func)(FAR void *cb, FAR void **arg,
FAR bool *set_writable);
bool set_writable;
for (idx = 0; idx < nitems(g_evtbuffers); idx++)
{
if (evtbitmap & (1ULL << idx))
{
dbg_alt1250("idx=%d\n", idx);
set_writable = false;
func = get_execfunc(idx);
l_evtbitmap = exec_callback(g_evtbuffers[idx].cmdid, func,
get_evtarg(idx), &set_writable);
ret |= l_evtbitmap;
if (l_evtbitmap == 0ULL)
{
if (LTE_ISCMDGRP_NORMAL(g_evtbuffers[idx].cmdid))
{
clear_callback(g_evtbuffers[idx].cmdid);
}
}
if (l_evtbitmap == 0ULL)
{
if (!set_writable)
{
update_evtarg_writable(idx);
}
}
}
}
dbg_alt1250("evtbitmap=0x%llx\n", ret);
return ret;
}
/****************************************************************************
* Name: alt1250_evt_search
****************************************************************************/
static uint64_t alt1250_evt_search(uint32_t cmdid)
{
int idx;
uint64_t evtbitmap = 0ULL;
for (idx = 0; idx < nitems(g_evtbuffers); idx++)
{
if (g_evtbuffers[idx].cmdid == cmdid)
{
evtbitmap = (1ULL << idx);
}
}
return evtbitmap;
}
/****************************************************************************
* Name: reg_evtcb
****************************************************************************/
static int reg_evtcb(struct cbinfo_s *info, uint32_t cmdid, FAR void *cb)
{
if (info == NULL)
{
return ERROR;
}
info->cmdid = cmdid;
info->cb = cb;
return OK;
}
/****************************************************************************
* Name: search_evtcb
****************************************************************************/
static FAR struct cbinfo_s *search_evtcb(uint32_t cmdid)
{
int i;
for (i = 0; i < nitems(g_cbtable); i++)
{
if (g_cbtable[i].cmdid == cmdid)
{
return &g_cbtable[i];
}
}
return NULL;
}
/****************************************************************************
* Name: register_evtcb
****************************************************************************/
static int register_evtcb(uint32_t cmdid, FAR void *cb)
{
if (search_evtcb(cmdid) == NULL)
{
if (reg_evtcb(search_free_evtcb(), cmdid, cb) == ERROR)
{
return -EBUSY;
}
return OK;
}
else
{
return IS_REPORT_API(cmdid) ? -EALREADY : -EINPROGRESS;
}
}
/****************************************************************************
* Name: clear_evtcb
****************************************************************************/
static int clear_evtcb(uint32_t cmdid)
{
clr_evtcb(search_evtcb(cmdid));
return OK;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: alt1250_setevtbuff
****************************************************************************/
FAR struct alt_evtbuffer_s *init_event_buffer(void)
{
sem_init(&g_cbtablelock, 0, 1);
return evtbuffer_init();
}
/****************************************************************************
* Name: alt1250_evtdatadestroy
****************************************************************************/
int alt1250_evtdatadestroy(void)
{
sem_destroy(&g_cbtablelock);
return 0;
}
/****************************************************************************
* Name: alt1250_regevtcb
****************************************************************************/
int alt1250_regevtcb(uint32_t cmdid, FAR void *cb)
{
int ret;
sem_wait(&g_cbtablelock);
if (cb == NULL)
{
ret = clear_evtcb(cmdid);
}
else
{
ret = register_evtcb(cmdid, cb);
}
sem_post(&g_cbtablelock);
return ret;
}
/****************************************************************************
* Name: alt1250_execcb
****************************************************************************/
void alt1250_execcb(uint64_t evtbitmap)
{
uint64_t l_evtbitmap = 0ULL;
if (evtbitmap & ALT1250_EVTBIT_RESET)
{
/* call LTE_CMDID_SETRESTART */
alt1250_search_execcb(alt1250_evt_search(LTE_CMDID_SETRESTART));
update_evtarg_writableall();
}
else
{
l_evtbitmap = alt1250_search_execcb(evtbitmap);
if (l_evtbitmap != 0ULL)
{
alt1250_search_execcb(l_evtbitmap);
}
}
}
/****************************************************************************
* Name: alt1250_getevtarg
****************************************************************************/
FAR void **alt1250_getevtarg(uint32_t cmdid)
{
int i;
for (i = 0; i < nitems(g_evtbuffers); i++)
{
if (g_evtbuffers[i].cmdid == cmdid)
{
return g_evtbuffers[i].outparam;
}
}
return NULL;
}
/****************************************************************************
* Name: alt1250_checkcmdid
****************************************************************************/
bool alt1250_checkcmdid(uint32_t cmdid, uint64_t evtbitmap,
FAR uint64_t *bit)
{
int idx;
bool ret = false;
for (idx = 0; idx < nitems(g_evtbuffers); idx++)
{
if (evtbitmap & (1ULL << idx))
{
dbg_alt1250("idx=%d\n", idx);
if (g_evtbuffers[idx].cmdid == cmdid)
{
ret = true;
*bit = 1ULL << idx;
break;
}
}
}
return ret;
}
/****************************************************************************
* Name: alt1250_setevtarg_writable
****************************************************************************/
void alt1250_setevtarg_writable(uint32_t cmdid)
{
int idx;
FAR alt_evtbuf_inst_t *inst = NULL;
for (idx = 0; idx < nitems(g_evtbuffers); idx++)
{
if (g_evtbuffers[idx].cmdid == cmdid)
{
inst = &g_evtbuffers[idx];
nxmutex_lock(&inst->stat_lock);
inst->stat = ALTEVTBUF_ST_WRITABLE;
nxmutex_unlock(&inst->stat_lock);
break;
}
}
}
/****************************************************************************
* Name: alt1250_clrevtcb
****************************************************************************/
int alt1250_clrevtcb(uint8_t mode)
{
int ret = OK;
int i;
sem_wait(&g_cbtablelock);
if (mode == ALT1250_CLRMODE_WO_RESTART)
{
for (i = 0; i < nitems(g_cbtable); i++)
{
if (g_cbtable[i].cmdid != LTE_CMDID_SETRESTART)
{
g_cbtable[i].cb = NULL;
g_cbtable[i].cmdid = 0;
}
}
}
else if (mode == ALT1250_CLRMODE_ALL)
{
memset(g_cbtable, 0, sizeof(struct cbinfo_s) * NCBTABLES);
}
else
{
ret = -EINVAL;
}
sem_post(&g_cbtablelock);
return ret;
}
#ifdef CONFIG_LTE_ALT1250_LAUNCH_EVENT_TASK
static int internal_evttask(int argc, FAR char *argv[])
{
int ret;
bool is_running = true;
ret = lapi_evtinit(LAPIEVT_QNAME);
if (ret < 0)
{
dbg_alt1250("lapi_evtinit() failed: %d\n", ret);
goto errout;
}
while (is_running)
{
ret = lapi_evtyield(-1);
if (ret == 0)
{
dbg_alt1250("lapi_evtyield() finish normaly\n");
is_running = false;
}
else if (ret < 0)
{
dbg_alt1250("lapi_evtyield() failed: %d\n", ret);
}
}
errout:
lapi_evtdestoy();
return 0;
}
#endif
static int evt_qsend(FAR mqd_t *mqd, uint64_t evtbitmap)
{
int ret = ERROR;
if (*mqd != (mqd_t)-1)
{
ret = mq_send(*mqd, (FAR const char *)&evtbitmap, sizeof(evtbitmap),
0);
if (ret < 0)
{
ret = -errno;
dbg_alt1250("failed to send mq: %d\n", errno);
}
}
return ret;
}
int alt1250_evttask_sendmsg(FAR struct alt1250_s *dev, uint64_t msg)
{
return evt_qsend(&dev->evtq, msg);
}
int alt1250_evttask_start(void)
{
#ifdef CONFIG_LTE_ALT1250_LAUNCH_EVENT_TASK
g_cbpid = task_create(EVTTASK_NAME, CONFIG_LTE_ALT1250_EVENT_TASK_PRIORITY,
CONFIG_LTE_ALT1250_EVENT_TASK_STACKSIZE,
internal_evttask, NULL);
return g_cbpid;
#else
return 1; /* Always success */
#endif
}
void alt1250_evttask_stop(FAR struct alt1250_s *dev)
{
if (alt1250_evttask_sendmsg(dev, 0ULL) == OK)
{
#ifdef CONFIG_LTE_ALT1250_LAUNCH_EVENT_TASK
int stat;
waitpid(g_cbpid, &stat, WEXITED);
#endif
}
alt1250_evttask_msgclose(dev);
}
void alt1250_evttask_msgclose(FAR struct alt1250_s *dev)
{
if (dev->evtq != (mqd_t)-1)
{
/* FIXME: In case of the event callback task is not launched yet,
* this message may be dropped.
* Now, above behavior is not rescued..
*/
mq_close(dev->evtq);
mq_unlink(LAPIEVT_QNAME);
}
}
int alt1250_evttask_msgconnect(FAR const char *qname,
FAR struct alt1250_s *dev)
{
int ret = OK;
alt1250_evttask_msgclose(dev);
dev->evtq = mq_open(qname, O_WRONLY);
if (dev->evtq == (mqd_t)-1)
{
ret = -errno;
dbg_alt1250("failed to open mq(%s): %d\n", qname, errno);
}
return ret;
}
uint32_t alt1250_search_registered_callback(FAR int *index)
{
uint32_t ret = 0x00;
int i;
for (i = *index; i < NCBTABLES; i++)
{
if (g_cbtable[i].cb != NULL && IS_LTE_REPORT_EVENT(g_cbtable[i].cmdid))
{
ret = g_cbtable[i].cmdid;
*index = i;
break;
}
}
return ret;
}
int alt1250_get_report_ltecmd(FAR struct alt1250_s *dev, uint32_t cmdid,
FAR struct lte_ioctl_data_s *ltecmd)
{
int ret = OK;
static int result;
static int32_t param;
static FAR void *inparam[2];
static FAR void *outparam[1];
/* Generate ltecmd:
* cmdid : LAPI command ID
* inparam : Array of input arguments
* (First argument is callback pointer.)
* inparamlen : Size of inparam array
* outparam : Array of output arguments
* (The result parameter only.)
* outparamlen: Size of outparam array
*/
ltecmd->cmdid = cmdid;
ltecmd->inparam = inparam;
ltecmd->outparam = outparam;
ltecmd->outparamlen = 1;
inparam[0] = get_cbfunc(cmdid);
outparam[0] = (FAR void *)&result;
switch (cmdid)
{
case LTE_CMDID_REPNETINFO:
ltecmd->inparamlen = 1;
break;
case LTE_CMDID_REPSIMSTAT:
param = cmdid;
inparam[1] = (FAR void *)&param;
ltecmd->inparamlen = 2;
break;
case LTE_CMDID_REPLTIME:
param = cmdid;
inparam[1] = (FAR void *)&param;
ltecmd->inparamlen = 2;
break;
case LTE_CMDID_REPQUAL:
param = dev->quality_report_period;
inparam[1] = (FAR void *)&param;
ltecmd->inparamlen = 2;
break;
case LTE_CMDID_REPCELL:
param = dev->cellinfo_report_period;
inparam[1] = (FAR void *)&param;
ltecmd->inparamlen = 2;
break;
default:
ret = -EINVAL;
break;
}
return ret;
}
Reference in New Issue View Git Blame Copy Permalink