2012-06-22 03:46:04 +00:00
|
|
|
/*
|
|
|
|
*
|
|
|
|
* oFono - Open Source Telephony
|
|
|
|
*
|
|
|
|
* Copyright (C) 2011-2012 Intel Corporation. All rights reserved.
|
|
|
|
*
|
|
|
|
* 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 <ofono/log.h>
|
|
|
|
#include <ofono/modem.h>
|
|
|
|
#include <ofono/gprs.h>
|
|
|
|
|
|
|
|
#include "qmi.h"
|
|
|
|
#include "nas.h"
|
2018-03-05 12:31:03 +00:00
|
|
|
#include "wds.h"
|
2012-06-22 03:46:04 +00:00
|
|
|
|
2017-04-29 12:46:42 +00:00
|
|
|
#include "src/common.h"
|
2012-06-22 03:46:04 +00:00
|
|
|
#include "qmimodem.h"
|
|
|
|
|
|
|
|
struct gprs_data {
|
2018-03-05 12:31:03 +00:00
|
|
|
struct qmi_device *dev;
|
2012-06-22 03:46:04 +00:00
|
|
|
struct qmi_service *nas;
|
2018-03-05 12:31:03 +00:00
|
|
|
struct qmi_service *wds;
|
|
|
|
unsigned int last_auto_context_id;
|
2012-06-22 03:46:04 +00:00
|
|
|
};
|
|
|
|
|
2017-04-29 12:46:43 +00:00
|
|
|
static bool extract_ss_info(struct qmi_result *result, int *status, int *tech)
|
2012-06-22 03:46:04 +00:00
|
|
|
{
|
|
|
|
const struct qmi_nas_serving_system *ss;
|
|
|
|
uint16_t len;
|
2017-04-29 12:46:43 +00:00
|
|
|
int i;
|
2012-06-22 03:46:04 +00:00
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
|
|
|
ss = qmi_result_get(result, QMI_NAS_RESULT_SERVING_SYSTEM, &len);
|
|
|
|
if (!ss)
|
|
|
|
return false;
|
|
|
|
|
2017-04-11 08:18:11 +00:00
|
|
|
if (ss->ps_state == QMI_NAS_ATTACH_STATE_ATTACHED)
|
2017-04-29 12:46:42 +00:00
|
|
|
*status = NETWORK_REGISTRATION_STATUS_REGISTERED;
|
2012-06-22 03:46:04 +00:00
|
|
|
else
|
2017-04-29 12:46:42 +00:00
|
|
|
*status = NETWORK_REGISTRATION_STATUS_NOT_REGISTERED;
|
2012-06-22 03:46:04 +00:00
|
|
|
|
2017-04-29 12:46:43 +00:00
|
|
|
*tech = -1;
|
|
|
|
for (i = 0; i < ss->radio_if_count; i++) {
|
|
|
|
DBG("radio in use %d", ss->radio_if[i]);
|
|
|
|
|
|
|
|
*tech = qmi_nas_rat_to_tech(ss->radio_if[i]);
|
|
|
|
}
|
|
|
|
|
2012-06-22 03:46:04 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-06-10 13:44:18 +00:00
|
|
|
static bool extract_dc_info(struct qmi_result *result, int *bearer_tech)
|
|
|
|
{
|
|
|
|
const struct qmi_nas_data_capability *dc;
|
|
|
|
uint16_t len;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
|
|
|
dc = qmi_result_get(result, QMI_NAS_RESULT_DATA_CAPABILITY_STATUS, &len);
|
|
|
|
if (!dc)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*bearer_tech = -1;
|
|
|
|
for (i = 0; i < dc->cap_count; i++) {
|
|
|
|
DBG("radio tech in use %d", dc->cap[i]);
|
|
|
|
|
|
|
|
*bearer_tech = qmi_nas_cap_to_bearer_tech(dc->cap[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-03-05 12:31:03 +00:00
|
|
|
static void get_lte_attach_param_cb(struct qmi_result *result, void *user_data)
|
|
|
|
{
|
|
|
|
struct ofono_gprs *gprs = user_data;
|
|
|
|
struct gprs_data *data = ofono_gprs_get_data(gprs);
|
|
|
|
char *apn = NULL;
|
|
|
|
uint16_t error;
|
|
|
|
uint8_t iptype;
|
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
|
|
|
if (qmi_result_set_error(result, &error)) {
|
|
|
|
ofono_error("Failed to query LTE attach params: %hd", error);
|
|
|
|
goto noapn;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* APN */
|
|
|
|
apn = qmi_result_get_string(result, 0x10);
|
|
|
|
if (!apn) {
|
|
|
|
DBG("Default profile has no APN setting");
|
|
|
|
goto noapn;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (qmi_result_get_uint8(result, 0x11, &iptype))
|
|
|
|
ofono_info("LTE attach IP type: %hhd", iptype);
|
|
|
|
|
|
|
|
ofono_gprs_cid_activated(gprs, data->last_auto_context_id, apn);
|
|
|
|
g_free(apn);
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
noapn:
|
|
|
|
data->last_auto_context_id = 0;
|
|
|
|
ofono_error("LTE bearer established but APN not set");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void get_default_profile_cb(struct qmi_result *result, void *user_data)
|
|
|
|
{
|
|
|
|
struct ofono_gprs* gprs = user_data;
|
|
|
|
struct gprs_data *data = ofono_gprs_get_data(gprs);
|
|
|
|
uint16_t error;
|
|
|
|
uint8_t index;
|
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
|
|
|
if (qmi_result_set_error(result, &error)) {
|
|
|
|
ofono_error("Get default profile error: %hd", error);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Profile index */
|
|
|
|
if (!qmi_result_get_uint8(result, 0x01, &index)) {
|
|
|
|
ofono_error("Failed query default profile");
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
DBG("Default profile index: %hhd", index);
|
|
|
|
|
|
|
|
data->last_auto_context_id = index;
|
|
|
|
|
|
|
|
/* Get LTE Attach Parameters */
|
|
|
|
if (qmi_service_send(data->wds, 0x85, NULL,
|
|
|
|
get_lte_attach_param_cb, gprs, NULL) > 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
error:
|
|
|
|
data->last_auto_context_id = 0;
|
|
|
|
ofono_error("LTE bearer established but APN not set");
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Query the settings in effect on the default bearer. These may be
|
|
|
|
* implicit or may even be something other than requested as the gateway
|
|
|
|
* is allowed to override whatever was requested by the user.
|
|
|
|
*/
|
|
|
|
static void get_lte_attach_params(struct ofono_gprs* gprs)
|
|
|
|
{
|
|
|
|
struct gprs_data *data = ofono_gprs_get_data(gprs);
|
|
|
|
struct {
|
|
|
|
uint8_t type;
|
|
|
|
uint8_t family;
|
|
|
|
} __attribute((packed)) p = {
|
|
|
|
.type = 0, /* 3GPP */
|
|
|
|
.family = 0, /* embedded */
|
|
|
|
};
|
|
|
|
struct qmi_param *param;
|
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
|
|
|
if (data->last_auto_context_id != 0)
|
|
|
|
return; /* Established or in progress */
|
|
|
|
|
|
|
|
/* Set query in progress */
|
|
|
|
data->last_auto_context_id = -1;
|
|
|
|
|
|
|
|
/* First we query the default profile in order to find out which
|
|
|
|
* context the modem has activated.
|
|
|
|
*/
|
|
|
|
param = qmi_param_new();
|
|
|
|
if (!param)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
/* Profile type */
|
|
|
|
qmi_param_append(param, 0x1, sizeof(p), &p);
|
|
|
|
|
|
|
|
/* Get default profile */
|
|
|
|
if (qmi_service_send(data->wds, 0x49, param,
|
|
|
|
get_default_profile_cb, gprs, NULL) > 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
qmi_param_free(param);
|
|
|
|
|
|
|
|
error:
|
|
|
|
ofono_warn("Unable to query LTE APN... will not activate context");
|
|
|
|
}
|
|
|
|
|
2017-04-29 12:46:43 +00:00
|
|
|
static int handle_ss_info(struct qmi_result *result, struct ofono_gprs *gprs)
|
|
|
|
{
|
2018-03-05 12:31:03 +00:00
|
|
|
struct gprs_data *data = ofono_gprs_get_data(gprs);
|
2017-04-29 12:46:43 +00:00
|
|
|
int status;
|
|
|
|
int tech;
|
2020-06-10 13:44:18 +00:00
|
|
|
int bearer_tech;
|
2017-04-29 12:46:43 +00:00
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
|
|
|
if (!extract_ss_info(result, &status, &tech))
|
|
|
|
return -1;
|
|
|
|
|
2018-03-05 12:31:03 +00:00
|
|
|
if (status == NETWORK_REGISTRATION_STATUS_REGISTERED) {
|
2017-04-29 12:46:43 +00:00
|
|
|
if (tech == ACCESS_TECHNOLOGY_EUTRAN) {
|
|
|
|
/* On LTE we are effectively always attached; and
|
|
|
|
* the default bearer is established as soon as the
|
2018-03-05 12:31:03 +00:00
|
|
|
* network is joined. We just need to query the
|
|
|
|
* parameters in effect on the default bearer and
|
|
|
|
* let the ofono core know about the activated
|
|
|
|
* context.
|
2017-04-29 12:46:43 +00:00
|
|
|
*/
|
2018-03-05 12:31:03 +00:00
|
|
|
get_lte_attach_params(gprs);
|
2017-04-29 12:46:43 +00:00
|
|
|
}
|
2018-03-05 12:31:03 +00:00
|
|
|
} else {
|
|
|
|
data->last_auto_context_id = 0;
|
|
|
|
}
|
2017-04-29 12:46:43 +00:00
|
|
|
|
2020-06-10 13:44:18 +00:00
|
|
|
/* DC is optional so only notify on successful extraction */
|
|
|
|
if (extract_dc_info(result, &bearer_tech))
|
|
|
|
ofono_gprs_bearer_notify(gprs, bearer_tech);
|
|
|
|
|
2017-04-29 12:46:43 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2012-06-22 03:46:04 +00:00
|
|
|
static void ss_info_notify(struct qmi_result *result, void *user_data)
|
|
|
|
{
|
|
|
|
struct ofono_gprs *gprs = user_data;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
2017-04-29 12:46:43 +00:00
|
|
|
status = handle_ss_info(result, gprs);
|
2012-06-22 03:46:04 +00:00
|
|
|
|
2017-04-29 12:46:43 +00:00
|
|
|
if (status >= 0)
|
|
|
|
ofono_gprs_status_notify(gprs, status);
|
2012-06-22 03:46:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void attach_detach_cb(struct qmi_result *result, void *user_data)
|
|
|
|
{
|
|
|
|
struct cb_data *cbd = user_data;
|
|
|
|
ofono_gprs_cb_t cb = cbd->cb;
|
|
|
|
uint16_t error;
|
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
|
|
|
if (qmi_result_set_error(result, &error)) {
|
|
|
|
if (error == 26) {
|
|
|
|
/* no effect */
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
CALLBACK_WITH_FAILURE(cb, cbd->data);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
|
|
|
CALLBACK_WITH_SUCCESS(cb, cbd->data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qmi_set_attached(struct ofono_gprs *gprs, int attached,
|
|
|
|
ofono_gprs_cb_t cb, void *user_data)
|
|
|
|
{
|
|
|
|
struct gprs_data *data = ofono_gprs_get_data(gprs);
|
|
|
|
struct cb_data *cbd = cb_data_new(cb, user_data);
|
|
|
|
struct qmi_param *param;
|
|
|
|
uint8_t action;
|
|
|
|
|
|
|
|
DBG("attached %d", attached);
|
|
|
|
|
|
|
|
if (attached)
|
|
|
|
action = QMI_NAS_ATTACH_ACTION_ATTACH;
|
|
|
|
else
|
|
|
|
action = QMI_NAS_ATTACH_ACTION_DETACH;
|
|
|
|
|
|
|
|
param = qmi_param_new_uint8(QMI_NAS_PARAM_ATTACH_ACTION, action);
|
|
|
|
if (!param)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
if (qmi_service_send(data->nas, QMI_NAS_ATTACH_DETACH, param,
|
|
|
|
attach_detach_cb, cbd, g_free) > 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
qmi_param_free(param);
|
|
|
|
|
|
|
|
error:
|
|
|
|
CALLBACK_WITH_FAILURE(cb, cbd->data);
|
|
|
|
|
|
|
|
g_free(cbd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void get_ss_info_cb(struct qmi_result *result, void *user_data)
|
|
|
|
{
|
|
|
|
struct cb_data *cbd = user_data;
|
2017-04-29 12:46:43 +00:00
|
|
|
struct ofono_gprs *gprs = cbd->user;
|
2012-06-22 03:46:04 +00:00
|
|
|
ofono_gprs_status_cb_t cb = cbd->cb;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
2017-04-29 12:46:43 +00:00
|
|
|
if (qmi_result_set_error(result, NULL))
|
|
|
|
goto error;
|
2012-06-22 03:46:04 +00:00
|
|
|
|
2017-04-29 12:46:43 +00:00
|
|
|
status = handle_ss_info(result, gprs);
|
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
goto error;
|
2012-06-22 03:46:04 +00:00
|
|
|
|
|
|
|
CALLBACK_WITH_SUCCESS(cb, status, cbd->data);
|
2017-04-29 12:46:43 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
error:
|
|
|
|
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
|
2012-06-22 03:46:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void qmi_attached_status(struct ofono_gprs *gprs,
|
|
|
|
ofono_gprs_status_cb_t cb, void *user_data)
|
|
|
|
{
|
|
|
|
struct gprs_data *data = ofono_gprs_get_data(gprs);
|
|
|
|
struct cb_data *cbd = cb_data_new(cb, user_data);
|
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
2017-04-29 12:46:43 +00:00
|
|
|
cbd->user = gprs;
|
2012-06-22 03:46:04 +00:00
|
|
|
if (qmi_service_send(data->nas, QMI_NAS_GET_SS_INFO, NULL,
|
|
|
|
get_ss_info_cb, cbd, g_free) > 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
|
|
|
|
|
|
|
|
g_free(cbd);
|
|
|
|
}
|
|
|
|
|
2018-03-05 12:31:03 +00:00
|
|
|
static void create_wds_cb(struct qmi_service *service, void *user_data)
|
2012-06-22 03:46:04 +00:00
|
|
|
{
|
|
|
|
struct ofono_gprs *gprs = user_data;
|
|
|
|
struct gprs_data *data = ofono_gprs_get_data(gprs);
|
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
|
|
|
if (!service) {
|
2018-03-05 12:31:03 +00:00
|
|
|
ofono_error("Failed to request WDS service");
|
2012-06-22 03:46:04 +00:00
|
|
|
ofono_gprs_remove(gprs);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-03-05 12:31:03 +00:00
|
|
|
data->wds = qmi_service_ref(service);
|
2012-06-22 03:46:04 +00:00
|
|
|
|
2017-03-22 18:14:50 +00:00
|
|
|
/*
|
|
|
|
* First get the SS info - the modem may already be connected,
|
|
|
|
* and the state-change notification may never arrive
|
|
|
|
*/
|
|
|
|
qmi_service_send(data->nas, QMI_NAS_GET_SS_INFO, NULL,
|
|
|
|
ss_info_notify, gprs, NULL);
|
|
|
|
|
2012-06-22 03:46:04 +00:00
|
|
|
qmi_service_register(data->nas, QMI_NAS_SS_INFO_IND,
|
|
|
|
ss_info_notify, gprs, NULL);
|
|
|
|
|
|
|
|
ofono_gprs_set_cid_range(gprs, 1, 1);
|
|
|
|
|
|
|
|
ofono_gprs_register(gprs);
|
|
|
|
}
|
|
|
|
|
2018-03-05 12:31:03 +00:00
|
|
|
static void create_nas_cb(struct qmi_service *service, void *user_data)
|
|
|
|
{
|
|
|
|
struct ofono_gprs *gprs = user_data;
|
|
|
|
struct gprs_data *data = ofono_gprs_get_data(gprs);
|
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
|
|
|
if (!service) {
|
|
|
|
ofono_error("Failed to request NAS service");
|
|
|
|
ofono_gprs_remove(gprs);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
data->nas = qmi_service_ref(service);
|
|
|
|
|
|
|
|
qmi_service_create_shared(data->dev, QMI_SERVICE_WDS,
|
|
|
|
create_wds_cb, gprs, NULL);
|
|
|
|
}
|
|
|
|
|
2012-06-22 03:46:04 +00:00
|
|
|
static int qmi_gprs_probe(struct ofono_gprs *gprs,
|
|
|
|
unsigned int vendor, void *user_data)
|
|
|
|
{
|
|
|
|
struct qmi_device *device = user_data;
|
|
|
|
struct gprs_data *data;
|
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
|
|
|
data = g_new0(struct gprs_data, 1);
|
|
|
|
|
|
|
|
ofono_gprs_set_data(gprs, data);
|
|
|
|
|
2018-03-05 12:31:03 +00:00
|
|
|
data->dev = device;
|
|
|
|
|
2017-04-29 12:46:41 +00:00
|
|
|
qmi_service_create_shared(device, QMI_SERVICE_NAS,
|
|
|
|
create_nas_cb, gprs, NULL);
|
2012-06-22 03:46:04 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qmi_gprs_remove(struct ofono_gprs *gprs)
|
|
|
|
{
|
|
|
|
struct gprs_data *data = ofono_gprs_get_data(gprs);
|
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
|
|
|
ofono_gprs_set_data(gprs, NULL);
|
|
|
|
|
2018-03-07 14:55:09 +00:00
|
|
|
qmi_service_unregister_all(data->wds);
|
|
|
|
qmi_service_unref(data->wds);
|
|
|
|
|
2012-06-22 03:46:04 +00:00
|
|
|
qmi_service_unregister_all(data->nas);
|
|
|
|
|
|
|
|
qmi_service_unref(data->nas);
|
|
|
|
|
|
|
|
g_free(data);
|
|
|
|
}
|
|
|
|
|
2018-10-17 13:36:10 +00:00
|
|
|
static const struct ofono_gprs_driver driver = {
|
2012-06-22 03:46:04 +00:00
|
|
|
.name = "qmimodem",
|
|
|
|
.probe = qmi_gprs_probe,
|
|
|
|
.remove = qmi_gprs_remove,
|
|
|
|
.set_attached = qmi_set_attached,
|
|
|
|
.attached_status = qmi_attached_status,
|
|
|
|
};
|
|
|
|
|
|
|
|
void qmi_gprs_init(void)
|
|
|
|
{
|
|
|
|
ofono_gprs_driver_register(&driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
void qmi_gprs_exit(void)
|
|
|
|
{
|
|
|
|
ofono_gprs_driver_unregister(&driver);
|
|
|
|
}
|