1263 lines
34 KiB
C
1263 lines
34 KiB
C
/****************************************************************************
|
|
* drivers/modem/alt1250/altcom_hdlr_net.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 <stdint.h>
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <errno.h>
|
|
#include <arpa/inet.h>
|
|
#include <nuttx/modem/alt1250.h>
|
|
#include <nuttx/wireless/lte/lte.h>
|
|
#include <nuttx/wireless/lte/lte_ioctl.h>
|
|
|
|
#include "altcom_cmd.h"
|
|
#include "alt1250.h"
|
|
|
|
/****************************************************************************
|
|
* Pre-processor Definitions
|
|
****************************************************************************/
|
|
|
|
#define ALTCOMBS_BASE_HEX 16
|
|
|
|
/****************************************************************************
|
|
* Private Data
|
|
****************************************************************************/
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV1
|
|
static uint16_t g_set_repevt = 0;
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Private Functions
|
|
****************************************************************************/
|
|
|
|
static bool altcombs_check_arrydigitnum(FAR uint8_t number[], uint8_t digit)
|
|
{
|
|
uint8_t cnt;
|
|
|
|
for (cnt = 0; cnt < digit; cnt++)
|
|
{
|
|
if (number[cnt] < APICMD_CELLINFO_DIGIT_NUM_MIN ||
|
|
APICMD_CELLINFO_DIGIT_NUM_MAX < number[cnt])
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static int32_t altcombs_set_quality(FAR lte_quality_t *data,
|
|
FAR struct apicmd_cmddat_quality_s *cmd_quality)
|
|
{
|
|
data->valid = APICMD_QUALITY_ENABLE == cmd_quality->enability ?
|
|
LTE_VALID : LTE_INVALID;
|
|
if (data->valid)
|
|
{
|
|
data->rsrp = ntohs(cmd_quality->rsrp);
|
|
data->rsrq = ntohs(cmd_quality->rsrq);
|
|
data->sinr = ntohs(cmd_quality->sinr);
|
|
data->rssi = ntohs(cmd_quality->rssi);
|
|
if (data->rsrp < APICMD_QUALITY_RSRP_MIN ||
|
|
APICMD_QUALITY_RSRP_MAX < data->rsrp)
|
|
{
|
|
m_err("data.rsrp error:%d\n", data->rsrp);
|
|
data->valid = LTE_INVALID;
|
|
}
|
|
else if (data->rsrq < APICMD_QUALITY_RSRQ_MIN ||
|
|
APICMD_QUALITY_RSRQ_MAX < data->rsrq)
|
|
{
|
|
m_err("data.rsrq error:%d\n", data->rsrq);
|
|
data->valid = LTE_INVALID;
|
|
}
|
|
else if (data->sinr < APICMD_QUALITY_SINR_MIN ||
|
|
APICMD_QUALITY_SINR_MAX < data->sinr)
|
|
{
|
|
m_err("data->sinr error:%d\n", data->sinr);
|
|
data->valid = LTE_INVALID;
|
|
}
|
|
else
|
|
{
|
|
/* Do nothing. */
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV1
|
|
static void altcombs_set_cellinfo(
|
|
FAR struct apicmd_cmddat_cellinfo_s *cmd_cellinfo,
|
|
FAR lte_cellinfo_t *api_cellinfo)
|
|
{
|
|
if (cmd_cellinfo->valid == LTE_VALID)
|
|
{
|
|
if (ntohl(cmd_cellinfo->cell_id) > APICMD_CELLINFO_CELLID_MAX)
|
|
{
|
|
m_err("cmd_cellinfo->cell_id error:%ld\n",
|
|
ntohl(cmd_cellinfo->cell_id));
|
|
api_cellinfo->valid = LTE_INVALID;
|
|
}
|
|
else if (ntohl(cmd_cellinfo->earfcn) > APICMD_CELLINFO_EARFCN_MAX)
|
|
{
|
|
m_err("cmd_cellinfo->earfcn error:%ld\n",
|
|
ntohl(cmd_cellinfo->earfcn));
|
|
api_cellinfo->valid = LTE_INVALID;
|
|
}
|
|
else if (!altcombs_check_arrydigitnum(cmd_cellinfo->mcc,
|
|
LTE_MCC_DIGIT))
|
|
{
|
|
m_err("cmd_cellinfo->mcc error\n");
|
|
api_cellinfo->valid = LTE_INVALID;
|
|
}
|
|
else if (
|
|
cmd_cellinfo->mnc_digit < APICMD_CELLINFO_MNC_DIGIT_MIN ||
|
|
cmd_cellinfo->mnc_digit > LTE_MNC_DIGIT_MAX)
|
|
{
|
|
m_err("cmd_cellinfo->mnc_digit error:%d\n",
|
|
cmd_cellinfo->mnc_digit);
|
|
api_cellinfo->valid = LTE_INVALID;
|
|
}
|
|
else if (!altcombs_check_arrydigitnum(cmd_cellinfo->mnc,
|
|
cmd_cellinfo->mnc_digit))
|
|
{
|
|
m_err("cmd_cellinfo->mnc error\n");
|
|
api_cellinfo->valid = LTE_INVALID;
|
|
}
|
|
else
|
|
{
|
|
api_cellinfo->valid = LTE_VALID;
|
|
api_cellinfo->phycell_id = ntohl(cmd_cellinfo->cell_id);
|
|
api_cellinfo->earfcn = ntohl(cmd_cellinfo->earfcn);
|
|
memcpy(api_cellinfo->mcc, cmd_cellinfo->mcc, LTE_MCC_DIGIT);
|
|
api_cellinfo->mnc_digit = cmd_cellinfo->mnc_digit;
|
|
memcpy(api_cellinfo->mnc, cmd_cellinfo->mnc,
|
|
cmd_cellinfo->mnc_digit);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
api_cellinfo->valid = LTE_INVALID;
|
|
}
|
|
|
|
api_cellinfo->option = 0;
|
|
}
|
|
#endif
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
static void altcombs_set_cellinfo_v4(
|
|
FAR struct apicmd_cmddat_cellinfo_v4_s *cmd_cellinfo,
|
|
FAR lte_cellinfo_t *api_cellinfo)
|
|
{
|
|
int i;
|
|
|
|
api_cellinfo->valid = LTE_INVALID;
|
|
api_cellinfo->option = 0;
|
|
|
|
if (cmd_cellinfo->enability != LTE_INVALID)
|
|
{
|
|
if (ntohl(cmd_cellinfo->cell_id) > APICMD_CELLINFO_CELLID_MAX)
|
|
{
|
|
m_err("cmd_cellinfo->cell_id error:%ld\n",
|
|
ntohl(cmd_cellinfo->cell_id));
|
|
}
|
|
else if (ntohl(cmd_cellinfo->earfcn) > APICMD_CELLINFO_EARFCN_MAX)
|
|
{
|
|
m_err("cmd_cellinfo->earfcn error:%ld\n",
|
|
ntohl(cmd_cellinfo->earfcn));
|
|
}
|
|
else if (!altcombs_check_arrydigitnum(cmd_cellinfo->mcc,
|
|
LTE_MCC_DIGIT))
|
|
{
|
|
m_err("cmd_cellinfo->mcc error\n");
|
|
}
|
|
else if (
|
|
cmd_cellinfo->mnc_digit < APICMD_CELLINFO_MNC_DIGIT_MIN ||
|
|
cmd_cellinfo->mnc_digit > LTE_MNC_DIGIT_MAX)
|
|
{
|
|
m_err("cmd_cellinfo->mnc_digit error:%d\n",
|
|
cmd_cellinfo->mnc_digit);
|
|
}
|
|
else if (!altcombs_check_arrydigitnum(cmd_cellinfo->mnc,
|
|
cmd_cellinfo->mnc_digit))
|
|
{
|
|
m_err("cmd_cellinfo->mnc error\n");
|
|
}
|
|
else if (strlen((FAR const char *)cmd_cellinfo->cgid) >
|
|
APICMD_CELLINFO_GCID_MAX)
|
|
{
|
|
m_err("cmd_cellinfo->cgid error\n");
|
|
}
|
|
else
|
|
{
|
|
api_cellinfo->valid = LTE_VALID;
|
|
api_cellinfo->phycell_id = ntohl(cmd_cellinfo->cell_id);
|
|
api_cellinfo->earfcn = ntohl(cmd_cellinfo->earfcn);
|
|
memcpy(api_cellinfo->mcc, cmd_cellinfo->mcc, LTE_MCC_DIGIT);
|
|
api_cellinfo->mnc_digit = cmd_cellinfo->mnc_digit;
|
|
memcpy(api_cellinfo->mnc, cmd_cellinfo->mnc,
|
|
cmd_cellinfo->mnc_digit);
|
|
|
|
api_cellinfo->option |= LTE_CELLINFO_OPT_GCID;
|
|
api_cellinfo->gcid = strtoul((FAR const char *)cmd_cellinfo->cgid,
|
|
NULL, ALTCOMBS_BASE_HEX);
|
|
|
|
api_cellinfo->option |= LTE_CELLINFO_OPT_AREACODE;
|
|
api_cellinfo->area_code = ntohs(cmd_cellinfo->tac);
|
|
|
|
if (cmd_cellinfo->enability & APICMD_CELLINFO_VALID_SFN)
|
|
{
|
|
api_cellinfo->option |= LTE_CELLINFO_OPT_SFN;
|
|
api_cellinfo->sfn = ntohs(cmd_cellinfo->sfn);
|
|
}
|
|
|
|
if (cmd_cellinfo->enability & APICMD_CELLINFO_VALID_RSRP)
|
|
{
|
|
api_cellinfo->option |= LTE_CELLINFO_OPT_RSRP;
|
|
api_cellinfo->rsrp = ntohs(cmd_cellinfo->rsrp);
|
|
}
|
|
|
|
if (cmd_cellinfo->enability & APICMD_CELLINFO_VALID_RSRQ)
|
|
{
|
|
api_cellinfo->option |= LTE_CELLINFO_OPT_RSRQ;
|
|
api_cellinfo->rsrq = ntohs(cmd_cellinfo->rsrq);
|
|
}
|
|
|
|
if (cmd_cellinfo->enability & APICMD_CELLINFO_VALID_TIMEDIFFIDX)
|
|
{
|
|
api_cellinfo->option |= LTE_CELLINFO_OPT_TIMEDIFFIDX;
|
|
api_cellinfo->time_diffidx = ntohs(cmd_cellinfo->time_diffidx);
|
|
}
|
|
|
|
if (cmd_cellinfo->enability & APICMD_CELLINFO_VALID_TA)
|
|
{
|
|
api_cellinfo->option |= LTE_CELLINFO_OPT_TA;
|
|
api_cellinfo->ta = ntohs(cmd_cellinfo->ta);
|
|
}
|
|
|
|
if (api_cellinfo->nr_neighbor > cmd_cellinfo->neighbor_num)
|
|
{
|
|
api_cellinfo->nr_neighbor = cmd_cellinfo->neighbor_num;
|
|
}
|
|
|
|
for (i = 0; i < api_cellinfo->nr_neighbor; i++)
|
|
{
|
|
api_cellinfo->option |= LTE_CELLINFO_OPT_NEIGHBOR;
|
|
api_cellinfo->neighbors[i].option = 0;
|
|
api_cellinfo->neighbors[i].phycell_id =
|
|
ntohl(cmd_cellinfo->neighbor_cell[i].cell_id);
|
|
api_cellinfo->neighbors[i].earfcn =
|
|
ntohl(cmd_cellinfo->neighbor_cell[i].earfcn);
|
|
if (cmd_cellinfo->neighbor_cell[i].valid &
|
|
APICMD_CELLINFO_VALID_SFN)
|
|
{
|
|
api_cellinfo->neighbors[i].option |= LTE_CELLINFO_OPT_SFN;
|
|
api_cellinfo->neighbors[i].sfn =
|
|
ntohs(cmd_cellinfo->neighbor_cell[i].sfn);
|
|
}
|
|
|
|
if (cmd_cellinfo->neighbor_cell[i].valid &
|
|
APICMD_CELLINFO_VALID_RSRP)
|
|
{
|
|
api_cellinfo->neighbors[i].option |= LTE_CELLINFO_OPT_RSRP;
|
|
api_cellinfo->neighbors[i].rsrp =
|
|
ntohs(cmd_cellinfo->neighbor_cell[i].rsrp);
|
|
}
|
|
|
|
if (cmd_cellinfo->neighbor_cell[i].valid &
|
|
APICMD_CELLINFO_VALID_RSRQ)
|
|
{
|
|
api_cellinfo->neighbors[i].option |= LTE_CELLINFO_OPT_RSRQ;
|
|
api_cellinfo->neighbors[i].rsrq =
|
|
ntohs(cmd_cellinfo->neighbor_cell[i].rsrq);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void getltime_parse_response(
|
|
FAR struct apicmd_cmddat_getltimeres_s *resp,
|
|
FAR lte_localtime_t *localtime)
|
|
{
|
|
localtime->year = resp->ltime.year;
|
|
localtime->mon = resp->ltime.month;
|
|
localtime->mday = resp->ltime.day;
|
|
localtime->hour = resp->ltime.hour;
|
|
localtime->min = resp->ltime.minutes;
|
|
localtime->sec = resp->ltime.seconds;
|
|
localtime->tz_sec = ntohl(resp->ltime.timezone);
|
|
}
|
|
|
|
static void parse_ltime(FAR struct apicmd_cmddat_ltime_s *from,
|
|
FAR lte_localtime_t *to)
|
|
{
|
|
to->year = from->year;
|
|
to->mon = from->month;
|
|
to->mday = from->day;
|
|
to->hour = from->hour;
|
|
to->min = from->minutes;
|
|
to->sec = from->seconds;
|
|
to->tz_sec = ntohl(from->timezone);
|
|
}
|
|
|
|
static int parse_simd(FAR struct apicmd_cmddat_repevt_simd_s *simd,
|
|
FAR uint32_t *simstat)
|
|
{
|
|
int ret = 0;
|
|
|
|
switch (simd->status)
|
|
{
|
|
case APICMD_REPORT_EVT_SIMD_REMOVAL:
|
|
{
|
|
*simstat = LTE_SIMSTAT_REMOVAL;
|
|
}
|
|
break;
|
|
|
|
case APICMD_REPORT_EVT_SIMD_INSERTION:
|
|
{
|
|
*simstat = LTE_SIMSTAT_INSERTION;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
m_err("Unsupport SIMD status. status:%d\n", simd->status);
|
|
return -EILSEQ;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int parse_simstate(
|
|
FAR struct apicmd_cmddat_repevt_simstate_s *simstate,
|
|
FAR uint32_t *simstat)
|
|
{
|
|
int ret = 0;
|
|
|
|
switch (simstate->state)
|
|
{
|
|
case APICMD_REPORT_EVT_SIMSTATE_SIM_INIT_WAIT_PIN_UNLOCK:
|
|
{
|
|
*simstat = LTE_SIMSTAT_WAIT_PIN_UNLOCK;
|
|
}
|
|
break;
|
|
|
|
case APICMD_REPORT_EVT_SIMSTATE_PERSONALIZATION_FAILED:
|
|
{
|
|
*simstat = LTE_SIMSTAT_PERSONAL_FAILED;
|
|
}
|
|
break;
|
|
|
|
case APICMD_REPORT_EVT_SIMSTATE_ACTIVATION_COMPLETED:
|
|
{
|
|
*simstat = LTE_SIMSTAT_ACTIVATE;
|
|
}
|
|
break;
|
|
|
|
case APICMD_REPORT_EVT_SIMSTATE_DEACTIVATED:
|
|
{
|
|
*simstat = LTE_SIMSTAT_DEACTIVATE;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
m_err("Unsupport SIM state. status:%d\n", simstate->state);
|
|
ret = -EILSEQ;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
int32_t altcom_getltime_pkt_compose(FAR void **arg, size_t arglen,
|
|
uint8_t altver, FAR uint8_t *pktbuf,
|
|
const size_t pktsz, FAR uint16_t *altcid)
|
|
{
|
|
int32_t size = 0;
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV1
|
|
if (altver == ALTCOM_VER1)
|
|
{
|
|
*altcid = APICMDID_GET_LTIME;
|
|
}
|
|
else
|
|
#endif
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
*altcid = APICMDID_GET_LTIME_V4;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
size = -ENOSYS;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
int32_t altcom_getoper_pkt_compose(FAR void **arg, size_t arglen,
|
|
uint8_t altver, FAR uint8_t *pktbuf,
|
|
const size_t pktsz, FAR uint16_t *altcid)
|
|
{
|
|
int32_t size = 0;
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV1
|
|
if (altver == ALTCOM_VER1)
|
|
{
|
|
*altcid = APICMDID_GET_OPERATOR;
|
|
}
|
|
else
|
|
#endif
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
*altcid = APICMDID_GET_OPERATOR_V4;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
size = -ENOSYS;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
int32_t altcom_getqual_pkt_compose(FAR void **arg, size_t arglen,
|
|
uint8_t altver, FAR uint8_t *pktbuf,
|
|
const size_t pktsz, FAR uint16_t *altcid)
|
|
{
|
|
int32_t size = 0;
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV1
|
|
if (altver == ALTCOM_VER1)
|
|
{
|
|
*altcid = APICMDID_GET_QUALITY;
|
|
}
|
|
else
|
|
#endif
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
*altcid = APICMDID_GET_QUALITY_V4;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
size = -ENOSYS;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
int32_t altcom_getcell_pkt_compose(FAR void **arg, size_t arglen,
|
|
uint8_t altver, FAR uint8_t *pktbuf,
|
|
const size_t pktsz, FAR uint16_t *altcid)
|
|
{
|
|
int32_t size = 0;
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
*altcid = APICMDID_GET_CELLINFO_V4;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
size = -ENOTSUP;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
int32_t altcom_getrat_pkt_compose(FAR void **arg, size_t arglen,
|
|
uint8_t altver, FAR uint8_t *pktbuf,
|
|
const size_t pktsz, FAR uint16_t *altcid)
|
|
{
|
|
int32_t size = 0;
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
*altcid = APICMDID_GET_RAT_V4;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
size = -ENOTSUP;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
int32_t altcom_setrat_pkt_compose(FAR void **arg, size_t arglen,
|
|
uint8_t altver, FAR uint8_t *pktbuf,
|
|
const size_t pktsz, FAR uint16_t *altcid)
|
|
{
|
|
int32_t size = 0;
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
FAR uint8_t *rat = (FAR uint8_t *)arg[0];
|
|
FAR bool *persistent = (FAR bool *)arg[1];
|
|
#endif
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
FAR struct apicmd_cmddat_setrat_s *out =
|
|
(FAR struct apicmd_cmddat_setrat_s *)pktbuf;
|
|
|
|
out->rat = *rat;
|
|
out->persistency = *persistent;
|
|
|
|
size = sizeof(struct apicmd_cmddat_setrat_s);
|
|
|
|
*altcid = APICMDID_SET_RAT_V4;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
size = -ENOTSUP;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
int32_t altcom_getimscap_pkt_compose(FAR void **arg, size_t arglen,
|
|
uint8_t altver, FAR uint8_t *pktbuf,
|
|
const size_t pktsz,
|
|
FAR uint16_t *altcid)
|
|
{
|
|
int32_t size = 0;
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV1
|
|
if (altver == ALTCOM_VER1)
|
|
{
|
|
*altcid = APICMDID_GET_IMS_CAP;
|
|
}
|
|
else
|
|
#endif
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
*altcid = APICMDID_GET_IMS_CAP_V4;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
size = -ENOSYS;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
int32_t altcom_setrepqual_pkt_compose(FAR void **arg, size_t arglen,
|
|
uint8_t altver, FAR uint8_t *pktbuf,
|
|
const size_t pktsz,
|
|
FAR uint16_t *altcid)
|
|
{
|
|
int32_t size = 0;
|
|
FAR cellinfo_report_cb_t *callback = (FAR cellinfo_report_cb_t *)arg[0];
|
|
FAR uint32_t *period = (FAR uint32_t *)arg[1];
|
|
|
|
FAR struct apicmd_cmddat_setrepquality_s *out =
|
|
(FAR struct apicmd_cmddat_setrepquality_s *)pktbuf;
|
|
|
|
if (callback == NULL)
|
|
{
|
|
out->enability = APICMD_SET_REPQUALITY_DISABLE;
|
|
}
|
|
else
|
|
{
|
|
out->enability = APICMD_SET_REPQUALITY_ENABLE;
|
|
}
|
|
|
|
out->interval = htonl(*period);
|
|
size = sizeof(struct apicmd_cmddat_setrepquality_s);
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV1
|
|
if (altver == ALTCOM_VER1)
|
|
{
|
|
*altcid = APICMDID_SET_REP_QUALITY;
|
|
}
|
|
else
|
|
#endif
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
*altcid = APICMDID_SET_REP_QUALITY_V4;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
size = -ENOSYS;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
int32_t altcom_setrepcell_pkt_compose(FAR void **arg, size_t arglen,
|
|
uint8_t altver, FAR uint8_t *pktbuf,
|
|
const size_t pktsz,
|
|
FAR uint16_t *altcid)
|
|
{
|
|
int32_t size = 0;
|
|
FAR cellinfo_report_cb_t *callback = (FAR cellinfo_report_cb_t *)arg[0];
|
|
FAR uint32_t *period = (FAR uint32_t *)arg[1];
|
|
|
|
FAR struct apicmd_cmddat_setrepcellinfo_s *out =
|
|
(FAR struct apicmd_cmddat_setrepcellinfo_s *)pktbuf;
|
|
|
|
if (callback == NULL)
|
|
{
|
|
out->enability = LTE_DISABLE;
|
|
}
|
|
else
|
|
{
|
|
out->enability = LTE_ENABLE;
|
|
}
|
|
|
|
out->interval = htonl(*period);
|
|
size = sizeof(struct apicmd_cmddat_setrepcellinfo_s);
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV1
|
|
if (altver == ALTCOM_VER1)
|
|
{
|
|
*altcid = APICMDID_SET_REP_CELLINFO;
|
|
}
|
|
else
|
|
#endif
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
*altcid = APICMDID_SET_REP_CELLINFO_V4;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
size = -ENOSYS;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
int32_t altcom_setrepevt_pkt_compose(FAR void **arg, size_t arglen,
|
|
uint8_t altver, FAR uint8_t *pktbuf,
|
|
const size_t pktsz,
|
|
FAR uint16_t *altcid)
|
|
{
|
|
int32_t size = 0;
|
|
FAR simstat_report_cb_t *callback = (FAR simstat_report_cb_t *)arg[0];
|
|
FAR int32_t *id = (FAR int32_t *)arg[1];
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV1
|
|
if (altver == ALTCOM_VER1)
|
|
{
|
|
FAR struct apicmd_cmddat_setrepevt_s *out =
|
|
(FAR struct apicmd_cmddat_setrepevt_s *)pktbuf;
|
|
|
|
if (*id == LTE_CMDID_REPSIMSTAT)
|
|
{
|
|
if (callback)
|
|
{
|
|
g_set_repevt |=
|
|
(APICMD_SET_REP_EVT_SIMD | APICMD_SET_REP_EVT_SIMSTATE);
|
|
}
|
|
else
|
|
{
|
|
g_set_repevt &=
|
|
~(APICMD_SET_REP_EVT_SIMD | APICMD_SET_REP_EVT_SIMSTATE);
|
|
}
|
|
}
|
|
else if(*id == LTE_CMDID_REPLTIME)
|
|
{
|
|
if (callback)
|
|
{
|
|
g_set_repevt |= APICMD_SET_REP_EVT_LTIME;
|
|
}
|
|
else
|
|
{
|
|
g_set_repevt &= ~APICMD_SET_REP_EVT_LTIME;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
out->event = g_set_repevt;
|
|
size = sizeof(struct apicmd_cmddat_setrepevt_s);
|
|
*altcid = APICMDID_SET_REP_EVT;
|
|
}
|
|
else
|
|
#endif
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
FAR struct apicmd_cmddat_setrepevt_v4_s *out =
|
|
(FAR struct apicmd_cmddat_setrepevt_v4_s *)pktbuf;
|
|
|
|
if (*id == LTE_CMDID_REPSIMSTAT)
|
|
{
|
|
out->event = htons(APICMD_SET_REP_EVT_SIMD |
|
|
APICMD_SET_REP_EVT_SIMSTATE);
|
|
}
|
|
else if(*id == LTE_CMDID_REPLTIME)
|
|
{
|
|
out->event = htons(APICMD_SET_REP_EVT_LTIME);
|
|
}
|
|
else
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
out->enability = callback ? APICMD_SET_REP_EVT_ENABLE :
|
|
APICMD_SET_REP_EVT_DISABLE;
|
|
size = sizeof(struct apicmd_cmddat_setrepevt_v4_s);
|
|
*altcid = APICMDID_SET_REP_EVT_V4;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
size = -ENOSYS;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
int32_t altcom_getltime_pkt_parse(FAR struct alt1250_dev_s *dev,
|
|
FAR uint8_t *pktbuf, size_t pktsz,
|
|
uint8_t altver, FAR void **arg,
|
|
size_t arglen, FAR uint64_t *bitmap)
|
|
{
|
|
FAR int *ret = (FAR int *)arg[0];
|
|
FAR lte_localtime_t *localtime = (FAR lte_localtime_t *)arg[1];
|
|
FAR struct apicmd_cmddat_getltimeres_s *in =
|
|
(FAR struct apicmd_cmddat_getltimeres_s *)pktbuf;
|
|
|
|
*ret = (LTE_RESULT_OK == in->result) ? 0 : -EPROTO;
|
|
if (0 == *ret)
|
|
{
|
|
/* Parse local time */
|
|
|
|
getltime_parse_response(in, localtime);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t altcom_getoper_pkt_parse(FAR struct alt1250_dev_s *dev,
|
|
FAR uint8_t *pktbuf, size_t pktsz,
|
|
uint8_t altver, FAR void **arg,
|
|
size_t arglen, FAR uint64_t *bitmap)
|
|
{
|
|
FAR int *ret = (FAR int *)arg[0];
|
|
FAR char *oper = (FAR char *)arg[1];
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV1
|
|
if (altver == ALTCOM_VER1)
|
|
{
|
|
FAR struct apicmd_cmddat_getoperatorres_s *in =
|
|
(FAR struct apicmd_cmddat_getoperatorres_s *)pktbuf;
|
|
|
|
*ret = (LTE_RESULT_OK == in->result) ? 0 : -EPROTO;
|
|
if (0 == *ret)
|
|
{
|
|
if (arglen > 2)
|
|
{
|
|
FAR size_t *len = (FAR size_t *)arg[2];
|
|
|
|
/* Is it enough length to include Null terminate?
|
|
* The length of LTE_OPERATOR_LEN includes the
|
|
* null terminator.
|
|
*/
|
|
|
|
if (*len < strnlen((FAR const char *)in->oper,
|
|
LTE_OPERATOR_LEN))
|
|
{
|
|
return -ENOBUFS;
|
|
}
|
|
}
|
|
|
|
strncpy(oper, (FAR const char *)in->oper, LTE_OPERATOR_LEN);
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
FAR struct apicmd_cmddat_getoperatorres_v4_s *in =
|
|
(FAR struct apicmd_cmddat_getoperatorres_v4_s *)pktbuf;
|
|
|
|
*ret = (LTE_RESULT_OK == in->result) ? 0 : -EPROTO;
|
|
if (0 == *ret)
|
|
{
|
|
if (arglen > 2)
|
|
{
|
|
FAR size_t *len = (FAR size_t *)arg[2];
|
|
|
|
/* Is it enough length to include Null terminate?
|
|
* The length of LTE_OPERATOR_LEN includes the
|
|
* null terminator.
|
|
*/
|
|
|
|
if (*len < strnlen((FAR const char *)in->oper,
|
|
LTE_OPERATOR_LEN))
|
|
{
|
|
return -ENOBUFS;
|
|
}
|
|
}
|
|
|
|
strncpy(oper, (FAR const char *)in->oper, LTE_OPERATOR_LEN);
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t altcom_getqual_pkt_parse(FAR struct alt1250_dev_s *dev,
|
|
FAR uint8_t *pktbuf, size_t pktsz,
|
|
uint8_t altver, FAR void **arg,
|
|
size_t arglen, FAR uint64_t *bitmap)
|
|
{
|
|
FAR int *ret = (FAR int *)arg[0];
|
|
FAR lte_quality_t *quality = (FAR lte_quality_t *)arg[1];
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV1
|
|
if (altver == ALTCOM_VER1)
|
|
{
|
|
FAR struct apicmd_cmddat_getqualityres_s *in =
|
|
(FAR struct apicmd_cmddat_getqualityres_s *)pktbuf;
|
|
|
|
*ret = (LTE_RESULT_OK == in->result) ? 0 : -EPROTO;
|
|
if (0 == *ret)
|
|
{
|
|
/* Parse quality information */
|
|
|
|
altcombs_set_quality(quality, &in->quality);
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
FAR struct apicmd_cmddat_getqualityres_v4_s *in =
|
|
(FAR struct apicmd_cmddat_getqualityres_v4_s *)pktbuf;
|
|
|
|
*ret = 0;
|
|
|
|
/* Parse quality information */
|
|
|
|
altcombs_set_quality(quality, &in->quality);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t altcom_getcell_pkt_parse(FAR struct alt1250_dev_s *dev,
|
|
FAR uint8_t *pktbuf, size_t pktsz,
|
|
uint8_t altver, FAR void **arg,
|
|
size_t arglen, FAR uint64_t *bitmap)
|
|
{
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
FAR int *ret = (FAR int *)arg[0];
|
|
FAR lte_cellinfo_t *cellinfo = (FAR lte_cellinfo_t *)arg[1];
|
|
#endif
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
FAR struct apicmd_cmddat_getcellinfores_v4_s *in =
|
|
(FAR struct apicmd_cmddat_getcellinfores_v4_s *)pktbuf;
|
|
|
|
/* Parse LTE network cell information */
|
|
|
|
altcombs_set_cellinfo_v4(&in->cellinfo, cellinfo);
|
|
|
|
*ret = 0;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t altcom_getrat_pkt_parse(FAR struct alt1250_dev_s *dev,
|
|
FAR uint8_t *pktbuf, size_t pktsz,
|
|
uint8_t altver, FAR void **arg,
|
|
size_t arglen, FAR uint64_t *bitmap)
|
|
{
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
FAR int *ret = (FAR int *)arg[0];
|
|
FAR lte_ratinfo_t *ratinfo = (FAR lte_ratinfo_t *)arg[1];
|
|
#endif
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
FAR struct apicmd_cmddat_getratres_s *in =
|
|
(FAR struct apicmd_cmddat_getratres_s *)pktbuf;
|
|
|
|
*ret = ntohl(in->result);
|
|
|
|
if (0 > *ret)
|
|
{
|
|
m_err("Modem returned an error [%ld].\n", *ret);
|
|
}
|
|
else
|
|
{
|
|
ratinfo->rat = in->rat;
|
|
ratinfo->multi_rat_support = (bool)in->rat_mode;
|
|
ratinfo->source = in->source;
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t altcom_setrat_pkt_parse(FAR struct alt1250_dev_s *dev,
|
|
FAR uint8_t *pktbuf, size_t pktsz,
|
|
uint8_t altver, FAR void **arg,
|
|
size_t arglen, FAR uint64_t *bitmap)
|
|
{
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
FAR int *ret = (FAR int *)arg[0];
|
|
#endif
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
FAR struct apicmd_cmddat_setratres_s *in =
|
|
(FAR struct apicmd_cmddat_setratres_s *)pktbuf;
|
|
|
|
*ret = ntohl(in->result);
|
|
|
|
if (0 > *ret)
|
|
{
|
|
m_err("Modem returned an error [%ld].\n", *ret);
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t altcom_getimscap_pkt_parse(FAR struct alt1250_dev_s *dev,
|
|
FAR uint8_t *pktbuf, size_t pktsz,
|
|
uint8_t altver, FAR void **arg,
|
|
size_t arglen, FAR uint64_t *bitmap)
|
|
{
|
|
FAR int *ret = (FAR int *)arg[0];
|
|
FAR bool *imscap = (FAR bool *)arg[1];
|
|
FAR struct apicmd_cmddat_getimscapres_s *in =
|
|
(FAR struct apicmd_cmddat_getimscapres_s *)pktbuf;
|
|
|
|
*ret = (LTE_RESULT_OK == in->result) ? 0 : -EPROTO;
|
|
if (0 == *ret)
|
|
{
|
|
*imscap = (in->ims_cap == APICMD_IMSCAP_ENABLE) ?
|
|
LTE_ENABLE : LTE_DISABLE;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t altcom_setrepqual_pkt_parse(FAR struct alt1250_dev_s *dev,
|
|
FAR uint8_t *pktbuf, size_t pktsz,
|
|
uint8_t altver, FAR void **arg,
|
|
size_t arglen, FAR uint64_t *bitmap)
|
|
{
|
|
FAR int *ret = (FAR int *)arg[0];
|
|
FAR struct apicmd_cmddat_setrepquality_res_s *in =
|
|
(FAR struct apicmd_cmddat_setrepquality_res_s *)pktbuf;
|
|
|
|
*ret = (LTE_RESULT_OK == in->result) ? 0 : -EIO;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t altcom_setrepcell_pkt_parse(FAR struct alt1250_dev_s *dev,
|
|
FAR uint8_t *pktbuf, size_t pktsz,
|
|
uint8_t altver, FAR void **arg,
|
|
size_t arglen, FAR uint64_t *bitmap)
|
|
{
|
|
FAR int *ret = (FAR int *)arg[0];
|
|
FAR struct apicmd_cmddat_setrepcellinfo_res_s *in =
|
|
(FAR struct apicmd_cmddat_setrepcellinfo_res_s *)pktbuf;
|
|
|
|
*ret = (LTE_RESULT_OK == in->result) ? 0 : -EIO;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t altcom_repqual_pkt_parse(FAR struct alt1250_dev_s *dev,
|
|
FAR uint8_t *pktbuf, size_t pktsz,
|
|
uint8_t altver, FAR void **arg,
|
|
size_t arglen, FAR uint64_t *bitmap)
|
|
{
|
|
FAR lte_quality_t *quality = (FAR lte_quality_t *)arg[0];
|
|
int ret = 0;
|
|
|
|
FAR struct apicmd_cmddat_quality_s *in =
|
|
(FAR struct apicmd_cmddat_quality_s *)pktbuf;
|
|
|
|
ret = altcombs_set_quality(quality, in);
|
|
if (0 > ret)
|
|
{
|
|
return -EFAULT;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t altcom_repcell_pkt_parse(FAR struct alt1250_dev_s *dev,
|
|
FAR uint8_t *pktbuf, size_t pktsz,
|
|
uint8_t altver, FAR void **arg,
|
|
size_t arglen, FAR uint64_t *bitmap)
|
|
{
|
|
struct cellinfo_helper_s
|
|
{
|
|
lte_cellinfo_t info;
|
|
lte_neighbor_cell_t neighbors[LTE_NEIGHBOR_CELL_MAX];
|
|
};
|
|
|
|
FAR lte_cellinfo_t *cellinfo = (FAR lte_cellinfo_t *)arg[0];
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV1
|
|
if (altver == ALTCOM_VER1)
|
|
{
|
|
FAR struct apicmd_cmddat_cellinfo_s *in =
|
|
(FAR struct apicmd_cmddat_cellinfo_s *)pktbuf;
|
|
|
|
cellinfo->nr_neighbor = 0;
|
|
|
|
altcombs_set_cellinfo(in, cellinfo);
|
|
}
|
|
else
|
|
#endif
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
FAR struct apicmd_cmddat_cellinfo_v4_s *in =
|
|
(FAR struct apicmd_cmddat_cellinfo_v4_s *)pktbuf;
|
|
|
|
cellinfo->nr_neighbor = LTE_NEIGHBOR_CELL_MAX;
|
|
|
|
altcombs_set_cellinfo_v4(in, cellinfo);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t altcom_setrepevt_pkt_parse(FAR struct alt1250_dev_s *dev,
|
|
FAR uint8_t *pktbuf, size_t pktsz,
|
|
uint8_t altver, FAR void **arg,
|
|
size_t arglen, FAR uint64_t *bitmap)
|
|
{
|
|
FAR int *ret = (FAR int *)arg[0];
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV1
|
|
if (altver == ALTCOM_VER1)
|
|
{
|
|
FAR struct apicmd_cmddat_setrepevtres_s *in =
|
|
(FAR struct apicmd_cmddat_setrepevtres_s *)pktbuf;
|
|
|
|
*ret = (APICMD_SET_REP_EVT_RES_OK == in->result) ? 0 : -EIO;
|
|
}
|
|
else
|
|
#endif
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
FAR struct apicmd_cmddat_setrepevtres_v4_s *in =
|
|
(FAR struct apicmd_cmddat_setrepevtres_v4_s *)pktbuf;
|
|
|
|
*ret = (APICMD_SET_REP_EVT_RES_OK == in->result) ? 0 : -EIO;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t altcom_repevt_pkt_parse(FAR struct alt1250_dev_s *dev,
|
|
FAR uint8_t *pktbuf, size_t pktsz,
|
|
uint8_t altver, FAR void **arg,
|
|
size_t arglen, FAR uint64_t *bitmap)
|
|
{
|
|
int32_t ret = -ENOTSUP;
|
|
alt_evtbuf_inst_t *inst;
|
|
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV1
|
|
if (altver == ALTCOM_VER1)
|
|
{
|
|
FAR struct apicmd_cmddat_repevt_s *in =
|
|
(FAR struct apicmd_cmddat_repevt_s *)pktbuf;
|
|
|
|
switch (in->type)
|
|
{
|
|
case APICMD_REPORT_EVT_TYPE_LTIME:
|
|
{
|
|
*bitmap = get_event_lapibuffer(dev, LTE_CMDID_REPLTIME, &inst);
|
|
if (*bitmap != 0ULL)
|
|
{
|
|
FAR lte_localtime_t *ltime = inst->outparam[0];
|
|
parse_ltime(&in->u.ltime, ltime);
|
|
ret = 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case APICMD_REPORT_EVT_TYPE_SIMD:
|
|
case APICMD_REPORT_EVT_TYPE_SIMSTATE:
|
|
{
|
|
*bitmap = get_event_lapibuffer(dev, LTE_CMDID_REPSIMSTAT,
|
|
&inst);
|
|
if (*bitmap != 0ULL)
|
|
{
|
|
FAR uint32_t *simstat = inst->outparam[0];
|
|
if (in->type == APICMD_REPORT_EVT_TYPE_SIMD)
|
|
{
|
|
ret = parse_simd(&in->u.simd, simstat);
|
|
}
|
|
else
|
|
{
|
|
ret = parse_simstate(&in->u.simstate, simstat);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
m_err("Unsupport event type. type:%d\n", in->type);
|
|
ret = -EILSEQ;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
#ifndef CONFIG_MODEM_ALT1250_DISABLE_PV4
|
|
if (altver == ALTCOM_VER4)
|
|
{
|
|
FAR struct apicmd_cmddat_repevt_v4_s *in =
|
|
(FAR struct apicmd_cmddat_repevt_v4_s *)pktbuf;
|
|
|
|
switch (ntohs(in->type))
|
|
{
|
|
case APICMD_REPORT_EVT_TYPE_LTIME:
|
|
{
|
|
*bitmap = get_event_lapibuffer(dev, LTE_CMDID_REPLTIME, &inst);
|
|
if (*bitmap != 0ULL)
|
|
{
|
|
FAR lte_localtime_t *ltime = inst->outparam[0];
|
|
parse_ltime(&in->u.ltime, ltime);
|
|
ret = 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case APICMD_REPORT_EVT_TYPE_SIMD:
|
|
case APICMD_REPORT_EVT_TYPE_SIMSTATE:
|
|
{
|
|
*bitmap = get_event_lapibuffer(dev, LTE_CMDID_REPSIMSTAT,
|
|
&inst);
|
|
if (*bitmap != 0ULL)
|
|
{
|
|
FAR uint32_t *simstat = inst->outparam[0];
|
|
if (ntohs(in->type) == APICMD_REPORT_EVT_TYPE_SIMD)
|
|
{
|
|
ret = parse_simd(&in->u.simd, simstat);
|
|
}
|
|
else
|
|
{
|
|
ret = parse_simstate(&in->u.simstate, simstat);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
m_err("Unsupport event type. type:%d\n",
|
|
ntohs(in->type));
|
|
ret = -EILSEQ;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
return ret;
|
|
}
|