mirror of git://git.sysmocom.de/ofono
606 lines
16 KiB
C
606 lines
16 KiB
C
/*
|
|
*
|
|
* oFono - Open Source Telephony
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
#include <glib.h>
|
|
|
|
#include <ofono/log.h>
|
|
#include <ofono/modem.h>
|
|
#include <ofono/netreg.h>
|
|
#include <ofono/netmon.h>
|
|
|
|
#include "gatchat.h"
|
|
#include "gatresult.h"
|
|
|
|
#include "common.h"
|
|
#include "gemaltomodem.h"
|
|
#include "drivers/atmodem/vendor.h"
|
|
|
|
static const char *smoni_prefix[] = { "^SMONI:", NULL };
|
|
static const char *csq_prefix[] = { "+CSQ:", NULL };
|
|
|
|
struct netmon_driver_data {
|
|
GAtChat *chat;
|
|
};
|
|
|
|
struct req_cb_data {
|
|
gint ref_count; /* Ref count */
|
|
|
|
struct ofono_netmon *netmon;
|
|
ofono_netmon_cb_t cb;
|
|
void *data;
|
|
|
|
struct ofono_network_operator op;
|
|
|
|
int rssi; /* CSQ: received signal strength indicator (RSSI) */
|
|
|
|
union {
|
|
struct {
|
|
int arfcn; /* SMONI: Absolute Radio Frequency Channel Number */
|
|
int bcch; /* SMONI: Receiving level of the BCCH carrier in dBm */
|
|
int lac; /* SMONI: Location Area Code */
|
|
int ci; /* SMONI: Cell ID */
|
|
} gsm;
|
|
struct {
|
|
int uarfcn; /* SMONI: UTRAN Absolute Radio Frequency Channel Number */
|
|
int psc; /* SMONI: Primary Scrambling Code */
|
|
int ecno; /* SMONI: Carrier to noise ratio in dB */
|
|
int rscp; /* SMONI: Received Signal Code Power in dBm */
|
|
int lac; /* SMONI: Location Area Code */
|
|
int ci; /* SMONI: Cell ID */
|
|
} umts;
|
|
struct {
|
|
int euarfcn; /* SMONI: E-UTRA Absolute Radio Frequency Channel Number */
|
|
int rsrp; /* SMONI: Reference Signal Received Power */
|
|
int rsrq; /* SMONI: Reference Signal Received Quality */
|
|
} lte;
|
|
} t;
|
|
};
|
|
|
|
static inline struct req_cb_data *req_cb_data_new0(void *cb, void *data,
|
|
void *user)
|
|
{
|
|
struct req_cb_data *ret = g_new0(struct req_cb_data, 1);
|
|
|
|
ret->ref_count = 1;
|
|
ret->netmon = user;
|
|
ret->data = data;
|
|
ret->cb = cb;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static inline struct req_cb_data *req_cb_data_ref(struct req_cb_data *cbd)
|
|
{
|
|
if (cbd == NULL)
|
|
return NULL;
|
|
|
|
g_atomic_int_inc(&cbd->ref_count);
|
|
|
|
return cbd;
|
|
}
|
|
|
|
static void req_cb_data_unref(gpointer user_data)
|
|
{
|
|
struct req_cb_data *cbd = user_data;
|
|
gboolean is_zero;
|
|
|
|
if (cbd == NULL)
|
|
return;
|
|
|
|
is_zero = g_atomic_int_dec_and_test(&cbd->ref_count);
|
|
|
|
if (is_zero == TRUE)
|
|
g_free(cbd);
|
|
}
|
|
|
|
static gboolean gemalto_delayed_register(gpointer user_data)
|
|
{
|
|
struct ofono_netmon *netmon = user_data;
|
|
|
|
ofono_netmon_register(netmon);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static int gemalto_parse_smoni_gsm(GAtResultIter *iter,
|
|
struct req_cb_data *cbd)
|
|
{
|
|
/*
|
|
* ME is camping on a GSM (2G) cell:
|
|
* ^SMONI: ACT,ARFCN,BCCH,MCC,MNC,LAC,cell,C1,C2,NCC,BCC,GPRS,Conn_state
|
|
* ^SMONI: 2G,71,-61,262,02,0143,83BA,33,33,3,6,G,NOCONN
|
|
*
|
|
* ME is searching and could not (yet) find a suitable GSM (2G) cell:
|
|
* ^SMONI: ACT,ARFCN,BCCH,MCC,MNC,LAC,cell,C1,C2,NCC,BCC,GPRS,ARFCN,TS,timAdv,dBm,Q,ChMod
|
|
* ^SMONI: 2G,SEARCH,SEARCH
|
|
*
|
|
* ME is camping on a GSM cell but not registered to the network (only emergency call allowed):
|
|
* ^SMONI: ACT,ARFCN,BCCH,MCC,MNC,LAC,cell,C1,C2,NCC,BCC,GPRS,PWR,RXLev,ARFCN,TS,timAdv,dBm,Q,ChMod
|
|
* ^SMONI: 2G,673,-89,262,07,4EED,A500,16,16,7,4,G,5,-107,LIMSRV
|
|
*
|
|
* ME has a dedicated channel (for example call in progress):
|
|
* ^SMONI: ACT,ARFCN,BCCH,MCC,MNC,LAC,cell,C1,C2,NCC,BCC,GPRS,ARFCN,TS,timAdv,dBm,Q,ChMod
|
|
* ^SMONI: 2G,673,-80,262,07,4EED,A500,35,35,7,4,G,643,4,0,-80,0,S_FR
|
|
*/
|
|
|
|
enum smoni_gsm_field {
|
|
SMONI_GSM_ARFCN,
|
|
SMONI_GSM_BCCH,
|
|
SMONI_GSM_MCC,
|
|
SMONI_GSM_MNC,
|
|
SMONI_GSM_LAC,
|
|
SMONI_GSM_CI,
|
|
SMONI_GSM_MAX,
|
|
};
|
|
|
|
const char *str;
|
|
int number;
|
|
int idx;
|
|
|
|
cbd->t.gsm.arfcn = -1;
|
|
cbd->t.gsm.bcch = -1;
|
|
cbd->t.gsm.lac = -1;
|
|
cbd->t.gsm.ci = -1;
|
|
|
|
for (idx = 0; idx < SMONI_GSM_MAX; idx++) {
|
|
switch (idx) {
|
|
case SMONI_GSM_ARFCN:
|
|
if (g_at_result_iter_next_number(iter, &number))
|
|
cbd->t.gsm.arfcn = number;
|
|
break;
|
|
case SMONI_GSM_BCCH:
|
|
if (g_at_result_iter_next_unquoted_string(iter, &str)) {
|
|
if (sscanf(str, "%d", &number) == 1)
|
|
cbd->t.gsm.bcch = number;
|
|
}
|
|
break;
|
|
case SMONI_GSM_MCC:
|
|
if (g_at_result_iter_next_number(iter, &number))
|
|
snprintf(cbd->op.mcc, 4, "%d", number);
|
|
break;
|
|
case SMONI_GSM_MNC:
|
|
if (g_at_result_iter_next_number(iter, &number))
|
|
snprintf(cbd->op.mnc, 4, "%d", number);
|
|
break;
|
|
case SMONI_GSM_LAC:
|
|
if (g_at_result_iter_next_unquoted_string(iter, &str)) {
|
|
if (sscanf(str, "%x", &number) == 1)
|
|
cbd->t.gsm.lac = number;
|
|
}
|
|
break;
|
|
case SMONI_GSM_CI:
|
|
if (g_at_result_iter_next_unquoted_string(iter, &str)) {
|
|
if (sscanf(str, "%x", &number) == 1)
|
|
cbd->t.gsm.ci = number;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
DBG(" %-15s %s", "GSM.MCC", cbd->op.mcc);
|
|
DBG(" %-15s %s", "GSM.MNC", cbd->op.mnc);
|
|
DBG(" %-15s %d", "GSM.ARFCN", cbd->t.gsm.arfcn);
|
|
DBG(" %-15s %d", "GSM.BCCH", cbd->t.gsm.bcch);
|
|
DBG(" %-15s %d", "GSM.LAC", cbd->t.gsm.lac);
|
|
DBG(" %-15s %d", "GSM.CELL", cbd->t.gsm.ci);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int gemalto_parse_smoni_umts(GAtResultIter *iter,
|
|
struct req_cb_data *cbd)
|
|
{
|
|
/*
|
|
* ME is camping on a UMTS (3G) cell:
|
|
* ^SMONI: ACT,UARFCN,PSC,EC/n0,RSCP,MCC,MNC,LAC,cell,SQual,SRxLev,,Conn_state
|
|
* ^SMONI: 3G,10564,296,-7.5,-79,262,02,0143,00228FF,-92,-78,NOCONN
|
|
*
|
|
* ME is searching and could not (yet) find a suitable UMTS (3G) cell:
|
|
* ^SMONI: ACT,UARFCN,PSC,EC/n0,RSCP,MCC,MNC,LAC,cell,SQual,SRxLev,PhysCh, SF,Slot,EC/n0,RSCP,ComMod,HSUPA,HSDPA
|
|
* ^SMONI: 3G,SEARCH,SEARCH
|
|
*
|
|
* ME is camping on a UMTS cell but not registered to the network (only emergency call allowed):
|
|
* ^SMONI: ACT,UARFCN,PSC,EC/n0,RSCP,MCC,MNC,LAC,cell,SQual,SRxLev,PhysCh, SF,Slot,EC/n0,RSCP,ComMod,HSUPA,HSDPA
|
|
* ^SMONI: 3G,10564,96,-7.5,-79,262,02,0143,00228FF,-92,-78,LIMSRV
|
|
*
|
|
* ME has a dedicated channel (for example call in progress):
|
|
* ^SMONI: ACT,UARFCN,PSC,EC/n0,RSCP,MCC,MNC,LAC,cell,SQual,SRxLev,PhysCh, SF,Slot,EC/n0,RSCP,ComMod,HSUPA,HSDPA
|
|
* ^SMONI: 3G,10737,131,-5,-93,260,01,7D3D,C80BC9A,--,--,----,---,-,-5,-93,0,01,06
|
|
*/
|
|
|
|
enum smoni_umts_field {
|
|
SMONI_UMTS_UARFCN,
|
|
SMONI_UMTS_PSC,
|
|
SMONI_UMTS_ECN0,
|
|
SMONI_UMTS_RSCP,
|
|
SMONI_UMTS_MCC,
|
|
SMONI_UMTS_MNC,
|
|
SMONI_UMTS_LAC,
|
|
SMONI_UMTS_CI,
|
|
SMONI_UMTS_MAX,
|
|
};
|
|
|
|
const char *str;
|
|
float fnumber;
|
|
int number;
|
|
int idx;
|
|
|
|
cbd->t.umts.uarfcn = -1;
|
|
cbd->t.umts.psc = -1;
|
|
cbd->t.umts.ecno = -1;
|
|
cbd->t.umts.rscp = -1;
|
|
cbd->t.umts.lac = -1;
|
|
cbd->t.umts.ci = -1;
|
|
|
|
for (idx = 0; idx < SMONI_UMTS_MAX; idx++) {
|
|
switch (idx) {
|
|
case SMONI_UMTS_UARFCN:
|
|
if (g_at_result_iter_next_number(iter, &number))
|
|
cbd->t.umts.uarfcn = number;
|
|
break;
|
|
case SMONI_UMTS_PSC:
|
|
if (g_at_result_iter_next_number(iter, &number))
|
|
cbd->t.umts.psc = number;
|
|
break;
|
|
case SMONI_UMTS_ECN0:
|
|
if (g_at_result_iter_next_unquoted_string(iter, &str)) {
|
|
if (sscanf(str, "%f", &fnumber) == 1)
|
|
cbd->t.umts.ecno = (int)fnumber;
|
|
}
|
|
break;
|
|
case SMONI_UMTS_RSCP:
|
|
if (g_at_result_iter_next_unquoted_string(iter, &str)) {
|
|
if (sscanf(str, "%d", &number) == 1)
|
|
cbd->t.umts.rscp = number;
|
|
}
|
|
break;
|
|
case SMONI_UMTS_MCC:
|
|
if (g_at_result_iter_next_number(iter, &number))
|
|
snprintf(cbd->op.mcc, 4, "%d", number);
|
|
break;
|
|
case SMONI_UMTS_MNC:
|
|
if (g_at_result_iter_next_number(iter, &number))
|
|
snprintf(cbd->op.mnc, 4, "%d", number);
|
|
break;
|
|
case SMONI_UMTS_LAC:
|
|
if (g_at_result_iter_next_unquoted_string(iter, &str)) {
|
|
if (sscanf(str, "%x", &number) == 1)
|
|
cbd->t.umts.lac = number;
|
|
}
|
|
break;
|
|
case SMONI_UMTS_CI:
|
|
if (g_at_result_iter_next_unquoted_string(iter, &str)) {
|
|
if (sscanf(str, "%x", &number) == 1)
|
|
cbd->t.umts.ci = number;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
DBG(" %-15s %s", "UMTS.MCC", cbd->op.mcc);
|
|
DBG(" %-15s %s", "UMTS.MNC", cbd->op.mnc);
|
|
DBG(" %-15s %d", "UMTS.UARFCN", cbd->t.umts.uarfcn);
|
|
DBG(" %-15s %d", "UMTS.PSC", cbd->t.umts.psc);
|
|
DBG(" %-15s %d", "UMTS.ECN0", cbd->t.umts.ecno);
|
|
DBG(" %-15s %d", "UMTS.RSCP", cbd->t.umts.rscp);
|
|
DBG(" %-15s %d", "UMTS.LAC", cbd->t.umts.lac);
|
|
DBG(" %-15s %d", "UMTS.CELL", cbd->t.umts.ci);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int gemalto_parse_smoni_lte(GAtResultIter *iter,
|
|
struct req_cb_data *cbd)
|
|
{
|
|
/*
|
|
* ME is camping on a LTE (4G) cell:
|
|
* ^SMONI: ACT,EARFCN,Band,DL bandwidth,UL bandwidth,Mode,MCC,MNC,TAC,Global Cell ID,Phys-ical Cell ID,Srxlev,RSRP,RSRQ,Conn_state
|
|
* ^SMONI: 4G,6300,20,10,10,FDD,262,02,BF75,0345103,350,33,-94,-7,NOCONN
|
|
*
|
|
* ME is searching and could not (yet) find a suitable LTE (4G) cell:
|
|
* ^SMONI: ACT,EARFCN,Band,DL bandwidth,UL bandwidth,Mode,MCC,MNC,TAC,Global Cell ID,Phys-ical Cell ID,Srxlev,RSRP,RSRQ,Conn_state
|
|
* ^SMONI: 4G,SEARCH
|
|
*
|
|
* ME is camping on a LTE (4G) cell but not registered to the network (only emergency call allowed):
|
|
* ^SMONI: ACT,EARFCN,Band,DL bandwidth,UL bandwidth,Mode,MCC,MNC,TAC,Global Cell ID,Phys-ical Cell ID,Srxlev,RSRP,RSRQ,Conn_state
|
|
* ^SMONI: 4G,6300,20,10,10,FDD,262,02,BF75,0345103,350,33,-94,-7,LIMSRV
|
|
*
|
|
* ME has a dedicated channel (for example call in progress):
|
|
* ^SMONI: ACT,EARFCN,Band,DL bandwidth,UL bandwidth,Mode,MCC,MNC,TAC,Global Cell ID,Phys-ical Cell ID,TX_power,RSRP,RSRQ,Conn_state
|
|
* ^SMONI: 4G,6300,20,10,10,FDD,262,02,BF75,0345103,350,90,-94,-7,CONN
|
|
*/
|
|
|
|
const char *str;
|
|
int number;
|
|
|
|
cbd->t.lte.euarfcn = -1;
|
|
cbd->t.lte.rsrp = -1;
|
|
cbd->t.lte.rsrq = -1;
|
|
|
|
if (g_at_result_iter_next_number(iter, &number))
|
|
cbd->t.lte.euarfcn = number;
|
|
|
|
g_at_result_iter_skip_next(iter);
|
|
g_at_result_iter_skip_next(iter);
|
|
g_at_result_iter_skip_next(iter);
|
|
g_at_result_iter_skip_next(iter);
|
|
|
|
if (g_at_result_iter_next_number(iter, &number))
|
|
snprintf(cbd->op.mcc, 4, "%d", number);
|
|
|
|
if (g_at_result_iter_next_number(iter, &number))
|
|
snprintf(cbd->op.mnc, 4, "%d", number);
|
|
|
|
g_at_result_iter_skip_next(iter);
|
|
g_at_result_iter_skip_next(iter);
|
|
g_at_result_iter_skip_next(iter);
|
|
g_at_result_iter_skip_next(iter);
|
|
|
|
if (g_at_result_iter_next_unquoted_string(iter, &str)) {
|
|
if (sscanf(str, "%d", &number) == 1)
|
|
cbd->t.lte.rsrp = number;
|
|
}
|
|
|
|
if (g_at_result_iter_next_unquoted_string(iter, &str)) {
|
|
if (sscanf(str, "%d", &number) == 1)
|
|
cbd->t.lte.rsrq = number;
|
|
}
|
|
|
|
DBG(" %-15s %s", "LTE.MCC", cbd->op.mcc);
|
|
DBG(" %-15s %s", "LTE.MNC", cbd->op.mnc);
|
|
DBG(" %-15s %d", "LTE.EUARFCN", cbd->t.lte.euarfcn);
|
|
DBG(" %-15s %d", "LTE.RSRP", cbd->t.lte.rsrp);
|
|
DBG(" %-15s %d", "LTE.RSRQ", cbd->t.lte.rsrq);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void gemalto_netmon_finish_success(struct req_cb_data *cbd)
|
|
{
|
|
struct ofono_netmon *nm = cbd->netmon;
|
|
|
|
switch (cbd->op.tech) {
|
|
case OFONO_NETMON_CELL_TYPE_LTE:
|
|
ofono_netmon_serving_cell_notify(nm, cbd->op.tech,
|
|
OFONO_NETMON_INFO_MCC, cbd->op.mcc,
|
|
OFONO_NETMON_INFO_MNC, cbd->op.mnc,
|
|
OFONO_NETMON_INFO_RSSI, cbd->rssi,
|
|
OFONO_NETMON_INFO_EARFCN, cbd->t.lte.euarfcn,
|
|
OFONO_NETMON_INFO_RSRP, cbd->t.lte.rsrp,
|
|
OFONO_NETMON_INFO_RSRQ, cbd->t.lte.rsrq,
|
|
OFONO_NETMON_INFO_INVALID);
|
|
break;
|
|
case OFONO_NETMON_CELL_TYPE_UMTS:
|
|
ofono_netmon_serving_cell_notify(nm, cbd->op.tech,
|
|
OFONO_NETMON_INFO_MCC, cbd->op.mcc,
|
|
OFONO_NETMON_INFO_MNC, cbd->op.mnc,
|
|
OFONO_NETMON_INFO_RSSI, cbd->rssi,
|
|
OFONO_NETMON_INFO_ARFCN, cbd->t.umts.uarfcn,
|
|
OFONO_NETMON_INFO_PSC, cbd->t.umts.psc,
|
|
OFONO_NETMON_INFO_ECN0, cbd->t.umts.ecno,
|
|
OFONO_NETMON_INFO_RSCP, cbd->t.umts.rscp,
|
|
OFONO_NETMON_INFO_LAC, cbd->t.umts.lac,
|
|
OFONO_NETMON_INFO_CI, cbd->t.umts.ci,
|
|
OFONO_NETMON_INFO_INVALID);
|
|
break;
|
|
case OFONO_NETMON_CELL_TYPE_GSM:
|
|
ofono_netmon_serving_cell_notify(nm, cbd->op.tech,
|
|
OFONO_NETMON_INFO_MCC, cbd->op.mcc,
|
|
OFONO_NETMON_INFO_MNC, cbd->op.mnc,
|
|
OFONO_NETMON_INFO_RSSI, cbd->rssi,
|
|
OFONO_NETMON_INFO_ARFCN, cbd->t.gsm.arfcn,
|
|
OFONO_NETMON_INFO_LAC, cbd->t.gsm.lac,
|
|
OFONO_NETMON_INFO_CI, cbd->t.gsm.ci,
|
|
OFONO_NETMON_INFO_INVALID);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
CALLBACK_WITH_SUCCESS(cbd->cb, cbd->data);
|
|
}
|
|
|
|
static void csq_cb(gboolean ok, GAtResult *result, gpointer user_data)
|
|
{
|
|
struct req_cb_data *cbd = user_data;
|
|
struct ofono_error error;
|
|
GAtResultIter iter;
|
|
int rssi;
|
|
|
|
DBG("ok %d", ok);
|
|
|
|
decode_at_error(&error, g_at_result_final_response(result));
|
|
|
|
if (!ok) {
|
|
CALLBACK_WITH_FAILURE(cbd->cb, cbd->data);
|
|
return;
|
|
}
|
|
|
|
g_at_result_iter_init(&iter, result);
|
|
|
|
if (!g_at_result_iter_next(&iter, "+CSQ: ")) {
|
|
cbd->rssi = -1;
|
|
goto out;
|
|
}
|
|
|
|
if (!g_at_result_iter_next_number(&iter, &rssi) || rssi == 99)
|
|
cbd->rssi = -1;
|
|
else
|
|
cbd->rssi = rssi;
|
|
|
|
DBG(" RSSI %d ", cbd->rssi);
|
|
|
|
out:
|
|
gemalto_netmon_finish_success(cbd);
|
|
}
|
|
|
|
static void smoni_cb(gboolean ok, GAtResult *result, gpointer user_data)
|
|
{
|
|
struct req_cb_data *cbd = user_data;
|
|
struct ofono_netmon *nm = cbd->netmon;
|
|
struct netmon_driver_data *nmd = ofono_netmon_get_data(nm);
|
|
struct ofono_error error;
|
|
const char *technology;
|
|
GAtResultIter iter;
|
|
int ret;
|
|
|
|
DBG("ok %d", ok);
|
|
|
|
decode_at_error(&error, g_at_result_final_response(result));
|
|
|
|
if (!ok) {
|
|
CALLBACK_WITH_FAILURE(cbd->cb, cbd->data);
|
|
return;
|
|
}
|
|
|
|
g_at_result_iter_init(&iter, result);
|
|
|
|
/* do not fail */
|
|
|
|
if (!g_at_result_iter_next(&iter, "^SMONI: ")) {
|
|
CALLBACK_WITH_SUCCESS(cbd->cb, cbd->data);
|
|
return;
|
|
}
|
|
|
|
if (!g_at_result_iter_next_unquoted_string(&iter, &technology)) {
|
|
DBG("^SMONI: failed to parse technology");
|
|
CALLBACK_WITH_SUCCESS(cbd->cb, cbd->data);
|
|
return;
|
|
}
|
|
|
|
if (strcmp(technology, "2G") == 0) {
|
|
cbd->op.tech = OFONO_NETMON_CELL_TYPE_GSM;
|
|
} else if (strcmp(technology, "3G") == 0) {
|
|
cbd->op.tech = OFONO_NETMON_CELL_TYPE_UMTS;
|
|
} else if (strcmp(technology, "4G") == 0) {
|
|
cbd->op.tech = OFONO_NETMON_CELL_TYPE_LTE;
|
|
} else {
|
|
/* fall-back to GSM by default */
|
|
DBG("^SMONI: unexpected technology: %s", technology);
|
|
cbd->op.tech = OFONO_NETMON_CELL_TYPE_GSM;
|
|
}
|
|
|
|
switch (cbd->op.tech) {
|
|
case OFONO_NETMON_CELL_TYPE_LTE:
|
|
ret = gemalto_parse_smoni_lte(&iter, cbd);
|
|
break;
|
|
case OFONO_NETMON_CELL_TYPE_UMTS:
|
|
ret = gemalto_parse_smoni_umts(&iter, cbd);
|
|
break;
|
|
case OFONO_NETMON_CELL_TYPE_GSM:
|
|
ret = gemalto_parse_smoni_gsm(&iter, cbd);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (ret) {
|
|
CALLBACK_WITH_SUCCESS(cbd->cb, cbd->data);
|
|
return;
|
|
}
|
|
|
|
cbd = req_cb_data_ref(cbd);
|
|
if (g_at_chat_send(nmd->chat, "AT+CSQ", csq_prefix,
|
|
csq_cb, cbd, req_cb_data_unref))
|
|
return;
|
|
|
|
req_cb_data_unref(cbd);
|
|
CALLBACK_WITH_FAILURE(cbd->cb, cbd->data);
|
|
}
|
|
|
|
static void gemalto_netmon_request_update(struct ofono_netmon *netmon,
|
|
ofono_netmon_cb_t cb,
|
|
void *data)
|
|
{
|
|
struct netmon_driver_data *nmd = ofono_netmon_get_data(netmon);
|
|
struct req_cb_data *cbd;
|
|
|
|
DBG("gemalto netmon request update");
|
|
|
|
cbd = req_cb_data_new0(cb, data, netmon);
|
|
|
|
if (g_at_chat_send(nmd->chat, "AT^SMONI", smoni_prefix,
|
|
smoni_cb, cbd, req_cb_data_unref))
|
|
return;
|
|
|
|
req_cb_data_unref(cbd);
|
|
CALLBACK_WITH_FAILURE(cbd->cb, cbd->data);
|
|
}
|
|
|
|
static int gemalto_netmon_probe(struct ofono_netmon *netmon,
|
|
unsigned int vendor, void *user)
|
|
{
|
|
struct netmon_driver_data *nmd = g_new0(struct netmon_driver_data, 1);
|
|
GAtChat *chat = user;
|
|
|
|
DBG("gemalto netmon probe");
|
|
|
|
nmd->chat = g_at_chat_clone(chat);
|
|
|
|
ofono_netmon_set_data(netmon, nmd);
|
|
|
|
g_idle_add(gemalto_delayed_register, netmon);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void gemalto_netmon_remove(struct ofono_netmon *netmon)
|
|
{
|
|
struct netmon_driver_data *nmd = ofono_netmon_get_data(netmon);
|
|
|
|
DBG("gemalto netmon remove");
|
|
|
|
g_at_chat_unref(nmd->chat);
|
|
|
|
ofono_netmon_set_data(netmon, NULL);
|
|
|
|
g_free(nmd);
|
|
}
|
|
|
|
static const struct ofono_netmon_driver driver = {
|
|
.name = "gemaltomodem",
|
|
.probe = gemalto_netmon_probe,
|
|
.remove = gemalto_netmon_remove,
|
|
.request_update = gemalto_netmon_request_update,
|
|
};
|
|
|
|
void gemalto_netmon_init(void)
|
|
{
|
|
ofono_netmon_driver_register(&driver);
|
|
}
|
|
|
|
void gemalto_netmon_exit(void)
|
|
{
|
|
ofono_netmon_driver_unregister(&driver);
|
|
}
|