rilmodem: driver for Android modems

Driver for modems that are accessed through the Android Radio Interface
Layer (RIL) for telephony, using the gril library. The driver is almost
feature complete with some exceptions, being CBS and SAT the most
prominent.

Co-authored-by: Tony Espy <espy@canonical.com>
Co-authored-by: Ricardo Salveti de Araujo <ricardo.salveti@canonical.com>
Co-authored-by: Alfonso Sanchez-Beato <alfonso.sanchez-beato@canonical.com>
Co-authored-by: Islam Amer <islam.amer@jollamobile.com>
Co-authored-by: Jussi Kangas <jussi.kangas@tieto.com>
Co-authored-by: Juho Hämäläinen <juho.hamalainen@tieto.com>
Co-authored-by: Petri Takalokastari <petri.takalokastari@oss.tieto.com>
Co-authored-by: Jarko Poutiainen <Jarko.Poutiainen@oss.tieto.com>
Co-authored-by: Tommi Kenakkala <tommi.kenakkala@oss.tieto.com>
Co-authored-by: Miia Leinonen <miia.leinonen@oss.tieto.com>
Co-authored-by: Martti Piirainen <martti.piirainen@canonical.com>
Co-authored-by: You-Sheng Yang <vicamo.yang@canonical.com>

1 files changed, 327 insertions, 0 deletions

diff --git a/drivers/rilmodem/call-forwarding.c b/drivers/rilmodem/call-forwarding.c
new file mode 100644
index 00000000..7965e7d5
--- /dev/null
+++ b/drivers/rilmodem/call-forwarding.c
@@ -0,0 +1,327 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2013 Jolla Ltd
+ *  Contact: Jussi Kangas <jussi.kangas@tieto.com>
+ *  Copyright (C) 2014 Canonical Ltd.
+ *
+ *  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
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <glib.h>
+
+#include <ofono/log.h>
+#include <ofono/modem.h>
+#include <ofono/call-forwarding.h>
+
+#include "gril.h"
+#include "grilrequest.h"
+#include "grilreply.h"
+#include "grilunsol.h"
+
+#include "rilmodem.h"
+
+#include "common.h"
+
+enum cf_action {
+	CF_ACTION_DISABLE,
+	CF_ACTION_ENABLE,
+	CF_ACTION_INTERROGATE,
+	CF_ACTION_REGISTRATION,
+	CF_ACTION_ERASURE,
+};
+
+struct forw_data {
+	GRil *ril;
+	enum cf_action last_action;
+	int last_cls;
+};
+
+static const char *cf_action_to_string(enum cf_action action)
+{
+	switch (action) {
+	case CF_ACTION_DISABLE:
+		return "DISABLE";
+	case CF_ACTION_ENABLE:
+		return "ENABLE";
+	case CF_ACTION_INTERROGATE:
+		return "INTERROGATE";
+	case CF_ACTION_REGISTRATION:
+		return "REGISTRATION";
+	case CF_ACTION_ERASURE:
+		return "ERASURE";
+	}
+
+	return NULL;
+}
+
+static void ril_query_call_fwd_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	struct forw_data *fd = ofono_call_forwarding_get_data(cbd->user);
+	ofono_call_forwarding_query_cb_t cb = cbd->cb;
+	struct ofono_call_forwarding_condition *list;
+	unsigned int list_size;
+
+	if (message->error != RIL_E_SUCCESS) {
+		ofono_error("%s: rild error: %s", __func__,
+				ril_error_to_string(message->error));
+		goto error;
+	}
+
+	list = g_ril_reply_parse_query_call_fwd(fd->ril, message, &list_size);
+	/*
+	 * From atmodem:
+	 *
+	 * Specification is really unclear about this
+	 * generate status=0 for all classes just in case
+	 */
+	if (list_size == 0) {
+		list = g_new0(struct ofono_call_forwarding_condition, 1);
+		list_size = 1;
+
+		list->status = 0;
+		list->cls = fd->last_cls;
+	} else if (list == NULL) {
+		goto error;
+	}
+
+	CALLBACK_WITH_SUCCESS(cb, (int) list_size, list, cbd->data);
+	g_free(list);
+	return;
+
+error:
+	CALLBACK_WITH_FAILURE(cb, 0, NULL, cbd->data);
+}
+
+static void ril_set_forward_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_call_forwarding_set_cb_t cb = cbd->cb;
+	struct forw_data *fd = ofono_call_forwarding_get_data(cbd->user);
+
+	if (message->error == RIL_E_SUCCESS) {
+		g_ril_print_response_no_args(fd->ril, message);
+		CALLBACK_WITH_SUCCESS(cb, cbd->data);
+	} else {
+		ofono_error("%s: CF %s failed; rild error: %s", __func__,
+				cf_action_to_string(fd->last_action),
+				ril_error_to_string(message->error));
+		CALLBACK_WITH_FAILURE(cb, cbd->data);
+	}
+}
+
+static int ril_send_forward_cmd(int type, int cls,
+				const struct ofono_phone_number *number,
+				int time,
+				struct cb_data *cbd,
+				enum cf_action action)
+{
+	struct ofono_call_forwarding *cf = cbd->user;
+	struct forw_data *fd = ofono_call_forwarding_get_data(cf);
+	struct parcel rilp;
+	struct req_call_fwd fwd_req;
+	int ret = 0, request;
+	GRilResponseFunc response_func;
+
+	if (action == CF_ACTION_INTERROGATE) {
+		request = RIL_REQUEST_QUERY_CALL_FORWARD_STATUS;
+		response_func = ril_query_call_fwd_cb;
+	} else {
+		request = RIL_REQUEST_SET_CALL_FORWARD;
+		response_func = ril_set_forward_cb;
+	}
+
+	DBG("%s - %s", ril_request_id_to_string(request),
+		cf_action_to_string(action));
+
+	/*
+	 * Modem seems to respond with error to all queries
+	 * or settings made with bearer class
+	 * BEARER_CLASS_DEFAULT. Design decision: If given
+	 * class is BEARER_CLASS_DEFAULT let's map it to
+	 * SERVICE_CLASS_NONE as with it e.g. ./send-ussd '*21*<phone_number>#'
+	 * returns cls:53 i.e. 1+4+16+32 as service class.
+	*/
+	if (cls == BEARER_CLASS_DEFAULT)
+		cls = SERVICE_CLASS_NONE;
+
+	fd->last_action = action;
+	fd->last_cls = cls;
+
+	fwd_req.action = (int) action;
+	fwd_req.type = type;
+	fwd_req.cls = cls;
+	fwd_req.number = number;
+
+	/*
+	 * time has no real meaing for action commands other
+	 * then registration, so if not needed, set arbitrary
+	 * 60s time so rild doesn't return an error.
+	 */
+	if (time == -1)
+		fwd_req.time = 60;
+	else
+		fwd_req.time = time;
+
+	g_ril_request_call_fwd(fd->ril, &fwd_req, &rilp);
+
+	ret = g_ril_send(fd->ril, request, &rilp, response_func, cbd, g_free);
+	if (ret == 0)
+		ofono_error("%s: CF action %s failed", __func__,
+				cf_action_to_string(action));
+	return ret;
+}
+
+static void ril_activate(struct ofono_call_forwarding *cf,
+				int type, int cls,
+				ofono_call_forwarding_set_cb_t cb, void *data)
+{
+	struct cb_data *cbd = cb_data_new(cb, data, cf);
+
+	if (ril_send_forward_cmd(type, cls, NULL, -1, cbd,
+					CF_ACTION_ENABLE) == 0) {
+		CALLBACK_WITH_FAILURE(cb, cbd->data);
+		g_free(cbd);
+	}
+}
+
+static void ril_erasure(struct ofono_call_forwarding *cf,
+				int type, int cls,
+				ofono_call_forwarding_set_cb_t cb, void *data)
+{
+	struct cb_data *cbd = cb_data_new(cb, data, cf);
+
+	if (ril_send_forward_cmd(type, cls, NULL, -1, cbd,
+					CF_ACTION_ERASURE) == 0) {
+		CALLBACK_WITH_FAILURE(cb, cbd->data);
+		g_free(cbd);
+	}
+}
+
+static void ril_deactivate(struct ofono_call_forwarding *cf,
+				int type, int cls,
+				ofono_call_forwarding_set_cb_t cb, void *data)
+{
+	struct cb_data *cbd = cb_data_new(cb, data, cf);
+
+	if (ril_send_forward_cmd(type, cls, NULL, -1, cbd,
+					CF_ACTION_DISABLE) == 0) {
+		CALLBACK_WITH_FAILURE(cb, cbd->data);
+		g_free(cbd);
+	}
+}
+
+static void ril_registration(struct ofono_call_forwarding *cf, int type,
+				int cls,
+				const struct ofono_phone_number *number,
+				int time, ofono_call_forwarding_set_cb_t cb,
+				void *data)
+{
+	struct cb_data *cbd = cb_data_new(cb, data, cf);
+
+	if (ril_send_forward_cmd(type, cls, number, time, cbd,
+					CF_ACTION_REGISTRATION) == 0) {
+		CALLBACK_WITH_FAILURE(cb, cbd->data);
+		g_free(cbd);
+	}
+}
+
+static void ril_query(struct ofono_call_forwarding *cf, int type, int cls,
+				ofono_call_forwarding_query_cb_t cb,
+				void *data)
+{
+	struct cb_data *cbd = cb_data_new(cb, data, cf);
+
+	if (ril_send_forward_cmd(type, cls, NULL, -1, cbd,
+					CF_ACTION_INTERROGATE) == 0) {
+		CALLBACK_WITH_FAILURE(cb, 0, NULL, cbd->data);
+		g_free(cbd);
+	}
+}
+
+static gboolean ril_delayed_register(gpointer user_data)
+{
+	struct ofono_call_forwarding *cf = user_data;
+
+	ofono_call_forwarding_register(cf);
+	return FALSE;
+}
+
+static int ril_call_forwarding_probe(struct ofono_call_forwarding *cf,
+					unsigned int vendor, void *user)
+{
+	GRil *ril = user;
+	struct forw_data *fd;
+
+	fd = g_try_new0(struct forw_data, 1);
+	if (fd == NULL)
+		return -ENOMEM;
+
+	fd->ril = g_ril_clone(ril);
+	ofono_call_forwarding_set_data(cf, fd);
+
+	/*
+	 * ofono_call_forwarding_register() needs to be called after
+	 * the driver has been set in ofono_call_forwarding_create(),
+	 * which calls this function.  Most other drivers make
+	 * some kind of capabilities query to the modem, and then
+	 * call register in the callback; we use an idle event instead.
+	 */
+	g_idle_add(ril_delayed_register, cf);
+
+	return 0;
+}
+
+static void ril_call_forwarding_remove(struct ofono_call_forwarding *cf)
+{
+	struct forw_data *data = ofono_call_forwarding_get_data(cf);
+	ofono_call_forwarding_set_data(cf, NULL);
+
+	g_ril_unref(data->ril);
+	g_free(data);
+}
+
+static struct ofono_call_forwarding_driver driver = {
+	.name			= RILMODEM,
+	.probe			= ril_call_forwarding_probe,
+	.remove			= ril_call_forwarding_remove,
+	.erasure		= ril_erasure,
+	.deactivation		= ril_deactivate,
+	.query			= ril_query,
+	.registration		= ril_registration,
+	.activation		= ril_activate
+};
+
+void ril_call_forwarding_init(void)
+{
+	ofono_call_forwarding_driver_register(&driver);
+}
+
+void ril_call_forwarding_exit(void)
+{
+	ofono_call_forwarding_driver_unregister(&driver);
+}