[PATCH_v4 0/5] Private network request to ConnMan
by Guillaume Zajac
Hi,
Changelog from v3 is:
- Add private-network source/include
- ConnMan plugin is independant from emulator
- Each application that need VPN will pass a callback as argument
when private network is requested. This callback will contain the
private network settings.
Guillaume Zajac (5):
gatppp: Add new contructor to use external fd
private-network: add callback typedef drivers and settings
private-network: add request/release functions and new feature to
Makefile.am
emulator: add request/release private network calls
connman: add plugin in oFono to request request/release private
network
Makefile.am | 10 +-
gatchat/gatppp.c | 33 +++++-
gatchat/gatppp.h | 1 +
gatchat/ppp.h | 2 +-
gatchat/ppp_net.c | 40 ++++---
include/private-network.h | 59 +++++++++
plugins/connman.c | 297 +++++++++++++++++++++++++++++++++++++++++++++
src/emulator.c | 49 ++++++--
src/ofono.h | 6 +
src/private-network.c | 89 ++++++++++++++
10 files changed, 556 insertions(+), 30 deletions(-)
create mode 100644 include/private-network.h
create mode 100644 plugins/connman.c
create mode 100644 src/private-network.c
1 day, 7 hours
Read/Write EFcfis/EFcphs-cff files
by Jeevaka Badrappan
Hi,
This patch reads and writes the call forwarding unconditional status
from and to the SIM depending on the SIM file availability.
New property needs to be added due to the fact that number won't be
available from the cphs-cff file.
Incase of SIM, EFcphs-cff file holds call forwarding status and it
is represented as a flag. In case of USIM(EFcfis), we have the status
flag and also number.So, adding new property for status and using the
existing VoiceUnconditional with number will work for both SIM and USIM cases.
Other option is to have 2 properties, "VoiceUnconditional" and "Number".
"VoiceUnconditional" will have the status of the call forwarding( "enabled",
"disabled") whereas the "Number" property will have the call forwared number.
offline-online state transitions results in caching the call forwaring status
every time. To avoid this, call forwarding atom is moved to the post sim and
its moved also due to the fact that call forwarding status doesn't change in
roaming.
Regards,
Jeevaka
Jeevaka Badrappan (7):
call-forwarding: Read/Write cfis/cphs-cff
ifx: Move call forwarding to post sim
isigen: Move call forwarding to post sim
plugins/n900: Move call forwarding to post sim
phonesim: Move call forwarding to post sim
doc: Add new property to call forwarding
TODO: Marking the Read/Write EFcfis task as done
TODO | 9 --
doc/call-forwarding-api.txt | 5 +
doc/features.txt | 5 +
plugins/ifx.c | 2 +-
plugins/isigen.c | 2 +-
plugins/n900.c | 2 +-
plugins/phonesim.c | 3 +-
src/call-forwarding.c | 242 ++++++++++++++++++++++++++++++++++++++++++-
8 files changed, 256 insertions(+), 14 deletions(-)
1 day, 11 hours
[PATCH] Simcom support
by Anthony Viallard
Add SIMCOM support.
I developped this with the SIM5216E chipset and ofono 1.12.
- SMS and GPRS work (in the same time) ;
- SIM card presence check ;
- No voice part because I can't test it ;
- Use default characters set instead GSM because it works like that
for what I'm doing (SMS+GPRS) (by default, the set is IRA for SIM5216E).
Also, the SIMCOM doc affraids me about problems when using GSM
(this setting causes easily software flow control (XON /XOFF) problems.).
Signed-off-by: Anthony Viallard <homer242 at gmail.com>
--- ofono-1.12.orig/Makefile.am 2012-04-20 21:06:29.000000000 +0200
+++ ofono-1.12/Makefile.am 2013-01-21 17:17:48.089627277 +0100
@@ -371,6 +371,9 @@ builtin_sources += plugins/samsung.c
builtin_modules += sim900
builtin_sources += plugins/sim900.c
+builtin_modules += simcom
+builtin_sources += plugins/simcom.c
+
if BLUETOOTH
builtin_modules += bluetooth
builtin_sources += plugins/bluetooth.c plugins/bluetooth.h
--- ofono-1.12.orig/drivers/atmodem/sms.c 2012-04-20 21:06:29.000000000 +0200
+++ ofono-1.12/drivers/atmodem/sms.c 2013-01-21 16:48:44.460627485 +0100
@@ -805,6 +807,7 @@ static gboolean build_cnmi_string(char *
case OFONO_VENDOR_NOVATEL:
case OFONO_VENDOR_HUAWEI:
case OFONO_VENDOR_ZTE:
+ case OFONO_VENDOR_SIMCOM:
/* MSM devices advertise support for mode 2, but return an
* error if we attempt to actually use it. */
mode = "1";
diff -pruN ofono-1.12.orig/drivers/atmodem/sim.c ofono-1.12/drivers/atmodem/sim.c
--- ofono-1.12.orig/drivers/atmodem/sim.c 2013-01-23 11:38:22.959609087 +0100
+++ ofono-1.12/drivers/atmodem/sim.c 2013-01-23 11:57:52.602608948 +0100
@@ -1023,12 +1023,18 @@ static void at_pin_send_cb(gboolean ok,
FALSE, cbd, g_free);
return;
case OFONO_VENDOR_ZTE:
case OFONO_VENDOR_ALCATEL:
case OFONO_VENDOR_HUAWEI:
+ case OFONO_VENDOR_SIMCOM:
/*
* On ZTE modems, after pin is entered, SIM state is checked
* by polling CPIN as their modem doesn't provide unsolicited
* notification of SIM readiness.
+ *
+ * On SIMCOM modems, SIM is busy after pin is entered (we've
+ * got an "+CME ERROR: 14" at "AT+CPIN?" request) and ofono
+ * don't catch the "+CPIN: READY" message sent by the modem
+ * when SIM is ready. So, use extra CPIN to check the state.
*/
sd->sim_state_query = at_util_sim_state_query_new(sd->chat,
2, 20, sim_state_cb, cbd,
diff -purN ofono-1.12/drivers/atmodem/network-registration.c ofono-patched/drivers/atmodem/network-registration.c
--- ofono-1.12/drivers/atmodem/network-registration.c 2013-01-18 15:04:03.598659165 +0100
+++ ofono-patched/drivers/atmodem/network-registration.c 2013-01-18 14:54:03.256659236 +0100
@@ -1411,6 +1411,14 @@ static void at_creg_set_cb(gboolean ok,
}
switch (nd->vendor) {
+ case OFONO_VENDOR_SIMCOM:
+ /* Register for CSQ changes */
+ g_at_chat_send(nd->chat, "AT+AUTOCSQ=1,1", none_prefix,
+ NULL, NULL, NULL);
+
+ g_at_chat_register(nd->chat, "+CSQ:",
+ csq_notify, FALSE, netreg, NULL);
+ break;
case OFONO_VENDOR_PHONESIM:
g_at_chat_register(nd->chat, "+CSQ:",
csq_notify, FALSE, netreg, NULL);
@@ -1534,7 +1537,6 @@ static void at_creg_set_cb(gboolean ok,
break;
case OFONO_VENDOR_NOKIA:
case OFONO_VENDOR_SAMSUNG:
- case OFONO_VENDOR_SIMCOM:
/* Signal strength reporting via CIND is not supported */
break;
default:
--- /dev/null 2013-01-28 10:34:59.843091650 +0100
+++ ofono-1.12/plugins/simcom.c 2013-02-15 16:16:38.058552544 +0100
@@ -0,0 +1,401 @@
+/*
+ *
+ * oFono - Open Source Telephony
+ *
+ * Copyright (C) 2008-2011 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 <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <glib.h>
+#include <gatchat.h>
+#include <gattty.h>
+
+#define OFONO_API_SUBJECT_TO_CHANGE
+#include <ofono/plugin.h>
+#include <ofono/modem.h>
+#include <ofono/devinfo.h>
+#include <ofono/netreg.h>
+#include <ofono/sim.h>
+#include <ofono/cbs.h>
+#include <ofono/sms.h>
+#include <ofono/ussd.h>
+#include <ofono/gprs.h>
+#include <ofono/gprs-context.h>
+#include <ofono/radio-settings.h>
+#include <ofono/phonebook.h>
+#include <ofono/log.h>
+
+#include <drivers/atmodem/atutil.h>
+#include <drivers/atmodem/vendor.h>
+
+#define MAX_IGNITION_POOL_CALL 7
+
+#define CMEERR_SIMBUSY 14
+
+static const char *none_prefix[] = { NULL };
+
+struct simcom_data {
+ GAtChat *modem;
+ GAtChat *data;
+ guint ignition_pool;
+ unsigned int ignition_pool_call;
+ unsigned int at_ignition_pending;
+ ofono_bool_t have_sim;
+};
+
+/* Callback and helpers functions */
+static void simcom_debug(const char *str, void *user_data)
+{
+ const char *prefix = user_data;
+
+ ofono_info("%s%s", prefix, str);
+}
+
+static gboolean simcom_ignition(gpointer user_data)
+{
+ struct ofono_modem *modem = user_data;
+ struct simcom_data *data = ofono_modem_get_data(modem);
+
+ ++data->ignition_pool_call;
+
+ if(data->at_ignition_pending > 0)
+ {
+ if(data->ignition_pool_call > MAX_IGNITION_POOL_CALL)
+ {
+ ofono_error("Ignition timeout");
+ return FALSE;
+ }
+
+ /* Waiting reply of AT commands */
+ DBG("Waiting AT reply...");
+ return TRUE;
+ }
+
+ ofono_modem_set_powered(modem, TRUE);
+
+ return FALSE;
+}
+
+static void simcom_sim_status(gboolean ok, GAtResult *result, gpointer user_data)
+{
+ struct ofono_modem *modem = user_data;
+ struct ofono_error error;
+ struct simcom_data *data = ofono_modem_get_data(modem);
+
+ --data->at_ignition_pending;
+
+ if(!ok)
+ {
+ decode_at_error(&error, g_at_result_final_response(result));
+ if(error.type == OFONO_ERROR_TYPE_CME)
+ {
+ if(error.error == CMEERR_SIMBUSY)
+ {
+ DBG("System is busy. Retry...");
+ g_at_chat_send(data->data, "AT+CPIN?",
+ none_prefix,
+ simcom_sim_status, modem,
+ NULL);
+ ++data->at_ignition_pending;
+ return;
+ }
+ }
+
+ data->have_sim = FALSE;
+ return;
+ }
+
+ /* If doesn't have an "fatal" error on AT+CPIN request,
+ * we can guess there a SIM card ...
+ */
+ data->have_sim = TRUE;
+}
+
+static void cfun_enable(gboolean ok, GAtResult *result, gpointer user_data)
+{
+ struct ofono_modem *modem = user_data;
+ struct simcom_data *data = ofono_modem_get_data(modem);
+
+ DBG("");
+
+ if (!ok) {
+ g_at_chat_unref(data->modem);
+ data->modem = NULL;
+
+ g_at_chat_unref(data->data);
+ data->data = NULL;
+
+ ofono_modem_set_powered(modem, FALSE);
+ return;
+ }
+
+ /* Get model and sim card status */
+ data->at_ignition_pending = 0;
+
+ g_at_chat_send(data->data, "AT+CPIN?", none_prefix,
+ simcom_sim_status, modem, NULL);
+ ++data->at_ignition_pending;
+
+ data->ignition_pool = g_timeout_add_seconds(1,
+ simcom_ignition,
+ modem);
+}
+
+static void cfun_disable(gboolean ok, GAtResult *result, gpointer user_data)
+{
+ struct ofono_modem *modem = user_data;
+ struct simcom_data *data = ofono_modem_get_data(modem);
+
+ DBG("");
+
+ g_at_chat_unref(data->data);
+ data->data = NULL;
+
+ if (ok)
+ ofono_modem_set_powered(modem, FALSE);
+}
+
+static GAtChat *open_device(struct ofono_modem *modem,
+ const char *key,
+ char *debug)
+{
+ const char *device;
+ GIOChannel *channel;
+ GAtSyntax *syntax;
+ GAtChat *chat;
+ /* GHashTable *options; */
+
+ device = ofono_modem_get_string(modem, key);
+ if (device == NULL)
+ {
+ ofono_error("Failed to get modem '%s'", key);
+ return NULL;
+ }
+
+ DBG("%s %s", key, device);
+
+ /* options = g_hash_table_new(g_str_hash, g_str_equal); */
+ /* if (options == NULL) */
+ /* return NULL; */
+
+ /* g_hash_table_insert(options, "Baud", "115200"); */
+ /* g_hash_table_insert(options, "Parity", "none"); */
+ /* g_hash_table_insert(options, "StopBits", "1"); */
+ /* g_hash_table_insert(options, "DataBits", "8"); */
+ /* g_hash_table_insert(options, "XonXoff", "off"); */
+ /* g_hash_table_insert(options, "RtsCts", "on"); */
+ /* g_hash_table_insert(options, "Local", "on"); */
+ /* g_hash_table_insert(options, "Read", "on"); */
+
+ channel = g_at_tty_open(device, NULL);
+
+ /* g_hash_table_destroy(options); */
+
+ if (channel == NULL)
+ {
+ ofono_error("Failed to get tty for '%s'", key);
+ return NULL;
+ }
+
+ syntax = g_at_syntax_new_gsm_permissive();
+ chat = g_at_chat_new(channel, syntax);
+ g_at_syntax_unref(syntax);
+
+ g_io_channel_unref(channel);
+
+ if (chat == NULL)
+ {
+ ofono_error("Failed to get chat for '%s'", key);
+ return NULL;
+ }
+
+ //if (getenv("OFONO_AT_DEBUG"))
+ g_at_chat_set_debug(chat, simcom_debug, debug);
+
+ return chat;
+}
+
+/* Modem interface function */
+static int simcom_probe(struct ofono_modem *modem)
+{
+ struct simcom_data *data;
+
+ DBG("%p", modem);
+
+ data = g_try_new0(struct simcom_data, 1);
+ if (data == NULL)
+ return -ENOMEM;
+
+ ofono_modem_set_data(modem, data);
+
+ return 0;
+}
+
+static void simcom_remove(struct ofono_modem *modem)
+{
+ struct simcom_data *data = ofono_modem_get_data(modem);
+
+ DBG("%p", modem);
+
+ if(data->ignition_pool > 0)
+ {
+ g_source_remove(data->ignition_pool);
+ data->ignition_pool = 0;
+ }
+
+ ofono_modem_set_data(modem, NULL);
+
+ /* Cleanup after hot-unplug */
+ g_at_chat_unref(data->data);
+
+ g_free(data);
+}
+
+static int simcom_enable(struct ofono_modem *modem)
+{
+ struct simcom_data *data = ofono_modem_get_data(modem);
+
+ DBG("%p", modem);
+
+ data->modem = open_device(modem, "Modem", "Modem: ");
+ if (data->modem == NULL)
+ return -EINVAL;
+
+ data->data = open_device(modem, "Data", "Data: ");
+ if (data->data == NULL) {
+ g_at_chat_unref(data->modem);
+ data->modem = NULL;
+ return -EIO;
+ }
+
+ g_at_chat_set_slave(data->modem, data->data);
+
+ g_at_chat_blacklist_terminator(data->data,
+ G_AT_CHAT_TERMINATOR_NO_CARRIER);
+
+ /* init modem */
+ g_at_chat_send(data->modem, "ATE0 +CMEE=1", NULL, NULL, NULL, NULL);
+ g_at_chat_send(data->data, "ATE0 +CMEE=1", NULL, NULL, NULL, NULL);
+
+ g_at_chat_send(data->data, "AT+CFUN=1", none_prefix,
+ cfun_enable, modem, NULL);
+
+ return -EINPROGRESS;
+}
+
+static int simcom_disable(struct ofono_modem *modem)
+{
+ struct simcom_data *data = ofono_modem_get_data(modem);
+
+ DBG("%p", modem);
+
+ g_at_chat_cancel_all(data->modem);
+ g_at_chat_unregister_all(data->modem);
+
+ g_at_chat_unref(data->modem);
+ data->modem = NULL;
+
+ g_at_chat_cancel_all(data->data);
+ g_at_chat_unregister_all(data->data);
+
+ g_at_chat_send(data->data, "AT+CFUN=4", none_prefix,
+ cfun_disable, modem, NULL);
+
+ return -EINPROGRESS;
+}
+
+static void simcom_pre_sim(struct ofono_modem *modem)
+{
+ struct simcom_data *data = ofono_modem_get_data(modem);
+ struct ofono_sim *sim;
+
+ DBG("%p", modem);
+
+ ofono_devinfo_create(modem, 0, "atmodem", data->data);
+ sim = ofono_sim_create(modem, OFONO_VENDOR_SIMCOM, "atmodem",
+ data->data);
+
+ if (sim)
+ ofono_sim_inserted_notify(sim, data->have_sim);
+}
+
+static void simcom_post_sim(struct ofono_modem *modem)
+{
+ struct simcom_data *data = ofono_modem_get_data(modem);
+ struct ofono_message_waiting *mw;
+ struct ofono_gprs *gprs;
+ struct ofono_gprs_context *gc;
+
+ DBG("%p", modem);
+
+ ofono_phonebook_create(modem, 0, "atmodem", data->data);
+
+ ofono_sms_create(modem, OFONO_VENDOR_SIMCOM, "atmodem",
+ data->data);
+
+ /* gprs things */
+ gprs = ofono_gprs_create(modem, 0, "atmodem", data->data);
+ gc = ofono_gprs_context_create(modem, 0, "atmodem", data->modem);
+
+ if(gprs && gc)
+ {
+ ofono_gprs_add_context(gprs, gc);
+ }
+}
+
+static void simcom_post_online(struct ofono_modem *modem)
+{
+ struct simcom_data *data = ofono_modem_get_data(modem);
+
+ DBG("%p", modem);
+
+ ofono_netreg_create(modem, OFONO_VENDOR_SIMCOM, "atmodem", data->data);
+ ofono_cbs_create(modem, 0, "atmodem", data->data);
+ ofono_ussd_create(modem, 0, "atmodem", data->data);
+}
+
+static struct ofono_modem_driver simcom_driver = {
+ .name = "simcom",
+ .probe = simcom_probe,
+ .remove = simcom_remove,
+ .enable = simcom_enable,
+ .disable = simcom_disable,
+ .pre_sim = simcom_pre_sim,
+ .post_sim = simcom_post_sim,
+ .post_online = simcom_post_online,
+};
+
+static int simcom_init(void)
+{
+ return ofono_modem_driver_register(&simcom_driver);
+}
+
+static void simcom_exit(void)
+{
+ ofono_modem_driver_unregister(&simcom_driver);
+}
+
+OFONO_PLUGIN_DEFINE(simcom, "SIMCOM modem driver", VERSION,
+ OFONO_PLUGIN_PRIORITY_DEFAULT,
+ simcom_init, simcom_exit)
1 day, 11 hours
IPV6 question
by Enrico Sau
Hi all,
As far as I understand, ofono doen't support IPV6 over ppp due to the fact
that IPV6 compression protocol implementation is missing.
Is that right?
Thank you,
Enrico
3 weeks, 2 days
Re: AW: AW: AW: connmand[186]: Online check failed but running dhclient manually fixes this issue
by Daniel Wagner
Hi Vinothkumar,
[sorry for the last mails where I got your last name mixed up...]
On 08/10/2017 07:03 AM, Eswaran Vinothkumar (BEG/PJ-IOT-EL) wrote:
> Could you send me the exact modem description you are using? So that we can write quirk?
>
> Hi,
>
> I am using TELIT 910 EUG Modem.
Okay, maybe that is already enough. I saw that in drivers/telit.c there
is already some code to handle variants of the modem. The matching is
done on these strings.
Are there any vid/pid available fot his modem?
Thanks,
Daniel
1 month, 2 weeks
Business
by Daser Jnr.
Hi all
>From a business point of view, can some one tell me what i can do with ofono
Cheers
Daser S.
3 months, 4 weeks
ofono fails to compile on gcc-6.3
by Pavel Machek
Hi!
I'm getting this:
CC drivers/rilmodem/network-registration.o
drivers/rilmodem/network-registration.c:40:32: error: unknown option
after ‘#pragma GCC diagnostic’ kind [-Werror=pragmas]
#pragma GCC diagnostic ignored "-Wrestrict"
cc1: error: unrecognized command line option ‘-Wno-format-truncation’
[-Werror]
cc1: all warnings being treated as errors
I commented out #pragma, and this allows compilation to
continue... until I hit same issue in
drivers/rilmodem/call-forwarding.c:41:32:
Best regards,
Pavel
--
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
3 years, 4 months
[PATCH 3/3] coex: modified ofono.conf for coex agent
by Antara Borwankar
From: Antara <antara.borwankar(a)intel.com>
Added coex agent interface to ofono.conf
---
src/ofono.conf | 1 +
1 file changed, 1 insertion(+)
diff --git a/src/ofono.conf b/src/ofono.conf
index 61e0bde..5a3afaa 100644
--- a/src/ofono.conf
+++ b/src/ofono.conf
@@ -16,6 +16,7 @@
<allow send_interface="org.ofono.PositioningRequestAgent"/>
<allow send_interface="org.ofono.HandsfreeAudioAgent"/>
<allow send_interface="org.ofono.NetworkMonitorAgent"/>
+ <allow send_interface="org.ofono.LTECoexAgent"/>
</policy>
<policy at_console="true">
--
1.9.1
3 years, 6 months
[PATCH 1/3] coex: Adding documetation for coex interface
by Antara Borwankar
From: Antara <antara.borwankar(a)intel.com>
Added coex-api.txt which defines coex interface for intel modems
---
doc/coex-api.txt | 126 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 126 insertions(+)
create mode 100644 doc/coex-api.txt
diff --git a/doc/coex-api.txt b/doc/coex-api.txt
new file mode 100644
index 0000000..8f5da47
--- /dev/null
+++ b/doc/coex-api.txt
@@ -0,0 +1,126 @@
+LTE Coexistence hierarchy
+===============
+
+Service org.ofono
+Interface org.ofono.org.ofono.intel.LteCoexistence
+Object path [variable prefix]/{modem0,modem1,...}
+
+Methods dict GetProperties()
+ Returns all coexistence configuration properties.
+
+ void SetProperty(string property, variant value)
+ Changes the value of the specified property. Only properties that
+ are listed as Read-write are changeable.
+ On success a PropertyChanged signal will be emitted.
+
+ Possible Errors: [service].Error.InProgress
+ [service].Error.InvalidArguments
+ [service].Error.Failed
+
+
+ void RegisterAgent(object path)
+
+ Registers an agent which will be called whenever the
+ modem initiates LTE Coexistence information.
+
+ Possible Errors: [service].Error.InProgress
+ [service].Error.InvalidArguments
+ [service].Error.InvalidFormat
+ [service].Error.Failed
+
+ void UnregisterAgent(object path)
+
+ Unregisters an agent.
+
+ Possible Errors: [service].Error.InvalidArguments
+ [service].Error.Failed
+
+ a(a{sv}) GetPlmnHistory()
+ Requests for LTE Plmn history list stored in NVM to
+ retrieve geo location history like MobileNetworkCode,
+ MobileCountryCode, LteBandsFDD, LteBandsTDD, ChannelBandwidth.
+
+ Refer to the sections below for which property types
+ are available, their valid value ranges and
+ applicability to different cell types.
+
+Signals PropertyChanged(string property, variant value)
+ This signal indicates a changed value of the given property.
+
+
+LTECoexistenceAgent Hierarchy [experimental]
+===============
+
+Service unique name
+Interface org.ofono.intel.LteCoexistenceAgent
+Object path freely definable
+
+Methods void ReceiveBluetoothNotification
+ (array{byte} notification, dict info) [noreply]
+
+ Requests the agent to process BT related LTE Coexistence
+ information. The dictionary info contains vector table with modem
+ recommended Safe Tx/Rx band and range information.The properties
+ involved are 'SafeTxMin', 'SafeRxMin', 'SafeTxMax', 'SafeRxMax' and
+ 'SafeVector'.
+
+ Possible Errors: None
+
+ void ReceiveWiFiNotification
+ (array{byte} notification, dict info) [noreply]
+
+ Requests the agent to process WiFi related LTE Coexistence
+ information. The dictionary info contains vector table with modem
+ recommended SafeTx/Rx band and range information. The properties
+ involved are'SafeTxMin', 'SafeRxMin', 'SafeTxMax', 'SafeRxMax' and
+ 'SafeVector'.
+
+ Possible Errors: None
+
+ void Release() [noreply]
+
+ Agent is being released, possibly because of oFono
+ terminating, Coex interface is being torn down or modem
+ off. No UnregisterAgent call is needed.
+
+
+Properties string Band [readwrite]
+ Frequency band in which the modem is operating when using "lte"
+ mode.
+
+ boolean BTActive [readwrite]
+ Maintains whether BT Coex is activated or not.
+
+ boolean WLANActive [readwrite]
+ Maintains whether WLAN Coex is activated or not.
+
+ string WLANBandwidth [readwrite]
+ Maintains at what frequency WLAN Coex is activated, when
+ "CoexWLANActive"
+ is active.
+ The possible values are:
+ - "20MHz"
+ - "40MHz"
+ - "80MHz"
+
+LTE Plmn history params
+=================================
+string
+ uint16 MobileNetworkCode [readonly, optional]
+ Contains the MNC of the cell.
+
+string
+ uint16 MobileCountryCode [readonly, optional]
+ Contains the MCC of the cell.
+
+ uint32 LteBandsFDD [readonly, optional]
+ Contains the Lte FDD band. Valid range
+ of values is 1 to 32 as per 3GPP 36.101 Section 5.5.
+
+ uint32 LteBandsTDD [readonly, optional]
+ Contains the Lte TDD band. Valid range
+ of values is 33 to 64 as per 3GPP 36.101 Section 5.5.
+
+ uint8 ChannelBandwidth [readonly, optional]
+ Contains the Channel bandwidth. Valid range
+ of values is 0 to 6 as per 3GPP 36.101 Section 5.6.
--
1.9.1
3 years, 6 months
[PATCH 2/3] coex: coex agent implementation
by Antara Borwankar
From: Antara <antara.borwankar(a)intel.com>
Added implementation for coex agent
---
plugins/xmm7xxx.c | 995 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 995 insertions(+)
diff --git a/plugins/xmm7xxx.c b/plugins/xmm7xxx.c
index 195f96b..c1a5d75 100644
--- a/plugins/xmm7xxx.c
+++ b/plugins/xmm7xxx.c
@@ -57,16 +57,979 @@
#include <drivers/atmodem/atutil.h>
#include <drivers/atmodem/vendor.h>
+#include "ofono.h"
+#include "gdbus.h"
+
+#define OFONO_COEX_INTERFACE OFONO_SERVICE ".intel.LteCoexistence"
+#define OFONO_COEX_AGENT_INTERFACE OFONO_SERVICE ".intel.LteCoexistenceAgent"
+
+#define NET_BAND_LTE_INVALID 0
+#define NET_BAND_LTE_1 101
+#define NET_BAND_LTE_43 143
+#define BAND_LEN 20
+#define MAX_BT_SAFE_VECTOR 15
+#define MAX_WL_SAFE_VECTOR 13
+
static const char *none_prefix[] = { NULL };
static const char *xsimstate_prefix[] = { "+XSIMSTATE:", NULL };
+static const char *xnvmplmn_prefix[] = { "+XNVMPLMN:", NULL };
+
+enum coex_agent_result {
+ COEX_AGENT_RESULT_OK,
+ COEX_AGENT_RESULT_BACK,
+ COEX_AGENT_RESULT_TERMINATE,
+ COEX_AGENT_RESULT_TIMEOUT,
+ COEX_AGENT_RESULT_BUSY,};
+
+struct bt_coex_info {
+ int safe_tx_min;
+ int safe_tx_max;
+ int safe_rx_min;
+ int safe_rx_max;
+ int safe_vector[MAX_BT_SAFE_VECTOR];
+ int num_safe_vector;
+};
+
+struct wl_coex_info {
+ int safe_tx_min;
+ int safe_tx_max;
+ int safe_rx_min;
+ int safe_rx_max;
+ int safe_vector[MAX_BT_SAFE_VECTOR];
+ int num_safe_vector;
+};
+
+struct coex_agent {
+ char *path;
+ char *bus;
+ guint disconnect_watch;
+ ofono_bool_t remove_on_terminate;
+ ofono_destroy_func removed_cb;
+ void *removed_data;
+ DBusMessage *msg;
+ int min_length;
+ int max_length;
+ ofono_bool_t hidden_entry;
+};
struct xmm7xxx_data {
GAtChat *chat; /* AT chat */
struct ofono_sim *sim;
ofono_bool_t have_sim;
ofono_bool_t sms_phonebook_added;
+ unsigned int netreg_watch;
+};
+
+/* Coex Implementation */
+enum wlan_bw {
+ OFONO_WLAN_BW_UNSUPPORTED = -1,
+ OFONO_WLAN_BW_20MHZ = 0,
+ OFONO_WLAN_BW_40MHZ = 1,
+ OFONO_WLAN_BW_80MHZ = 2,
+};
+
+struct Plmnhist {
+ unsigned short mnc;
+ unsigned short mcc;
+ unsigned long tdd;
+ unsigned long fdd;
+ unsigned char bw;
};
+struct ofono_coex {
+ GAtChat *chat;
+ struct ofono_modem *modem;
+
+ DBusMessage *pending;
+ ofono_bool_t bt_active;
+ ofono_bool_t wlan_active;
+ enum wlan_bw wlan_bw;
+ char *lte_band;
+
+ ofono_bool_t pending_bt_active;
+ ofono_bool_t pending_wlan_active;
+ enum wlan_bw pending_wlan_bw;
+ ofono_bool_t lte_active;
+
+ struct coex_agent *session_agent;
+};
+
+ofono_bool_t coex_agent_matches(struct coex_agent *agent,
+ const char *path, const char *sender)
+{
+ return !strcmp(agent->path, path) && !strcmp(agent->bus, sender);
+}
+
+void coex_agent_set_removed_notify(struct coex_agent *agent,
+ ofono_destroy_func destroy,
+ void *user_data)
+{
+ agent->removed_cb = destroy;
+ agent->removed_data = user_data;
+}
+
+static void coex_agent_send_noreply(struct coex_agent *agent, const char *method)
+{
+ DBusConnection *conn = ofono_dbus_get_connection();
+ DBusMessage *message;
+
+ message = dbus_message_new_method_call(agent->bus, agent->path,
+ OFONO_COEX_INTERFACE,
+ method);
+ if (message == NULL)
+ return;
+
+ dbus_message_set_no_reply(message, TRUE);
+
+ g_dbus_send_message(conn, message);
+}
+
+void coex_agent_send_release(struct coex_agent *agent)
+{
+ coex_agent_send_noreply(agent, "Release");
+}
+
+void coex_agent_free(struct coex_agent *agent)
+{
+ DBusConnection *conn = ofono_dbus_get_connection();
+
+ if (agent->disconnect_watch) {
+ coex_agent_send_release(agent);
+
+ g_dbus_remove_watch(conn, agent->disconnect_watch);
+ agent->disconnect_watch = 0;
+ }
+
+ if (agent->removed_cb)
+ agent->removed_cb(agent->removed_data);
+
+ g_free(agent->path);
+ g_free(agent->bus);
+ g_free(agent);
+}
+
+static void coex_agent_disconnect_cb(DBusConnection *conn, void *user_data)
+{
+ struct coex_agent *agent = user_data;
+
+ ofono_debug("Agent exited without calling Unregister");
+
+ agent->disconnect_watch = 0;
+
+ coex_agent_free(agent);
+}
+
+struct coex_agent *coex_agent_new(const char *path, const char *sender,
+ ofono_bool_t remove_on_terminate)
+{
+ struct coex_agent *agent = g_try_new0(struct coex_agent, 1);
+ DBusConnection *conn = ofono_dbus_get_connection();
+
+ DBG("");
+ if (agent == NULL)
+ return NULL;
+
+ agent->path = g_strdup(path);
+ agent->bus = g_strdup(sender);
+
+ agent->remove_on_terminate = remove_on_terminate;
+
+ agent->disconnect_watch = g_dbus_add_disconnect_watch(conn, sender,
+ coex_agent_disconnect_cb,
+ agent, NULL);
+
+ return agent;
+}
+
+int coex_agent_coex_wlan_notify(struct coex_agent *agent,
+ const struct wl_coex_info wlan_info)
+{
+ DBusConnection *conn = ofono_dbus_get_connection();
+ DBusMessageIter wl_args, wl_dict, wl_array;
+ const dbus_int32_t *pwl_array = wlan_info.safe_vector;
+ dbus_int32_t value;
+
+ agent->msg = dbus_message_new_method_call(agent->bus, agent->path,
+ OFONO_COEX_AGENT_INTERFACE,
+ "ReceiveWiFiNotification");
+ if (agent->msg == NULL)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(agent->msg, &wl_args);
+
+ dbus_message_iter_open_container(&wl_args, DBUS_TYPE_ARRAY,
+ DBUS_TYPE_INT32_AS_STRING, &wl_array);
+ dbus_message_iter_append_fixed_array(&wl_array, DBUS_TYPE_INT32,
+ &pwl_array, MAX_WL_SAFE_VECTOR);
+
+ dbus_message_iter_close_container(&wl_args, &wl_array);
+
+ dbus_message_iter_open_container(&wl_args, DBUS_TYPE_ARRAY,
+ "{sv}", &wl_dict);
+
+ value = wlan_info.safe_tx_min;
+ ofono_dbus_dict_append(&wl_dict, "SafeTxMin",
+ DBUS_TYPE_UINT32, &value);
+ value = wlan_info.safe_tx_max;
+ ofono_dbus_dict_append(&wl_dict, "SafeTxMax",
+ DBUS_TYPE_UINT32, &value);
+ value = wlan_info.safe_rx_min;
+ ofono_dbus_dict_append(&wl_dict, "SafeRxMin",
+ DBUS_TYPE_UINT32, &value);
+ value = wlan_info.safe_rx_max;
+ ofono_dbus_dict_append(&wl_dict, "SafeRxMax",
+ DBUS_TYPE_UINT32, &value);
+ value = wlan_info.num_safe_vector;
+ ofono_dbus_dict_append(&wl_dict, "NumSafeVector",
+ DBUS_TYPE_UINT32, &value);
+
+ dbus_message_iter_close_container(&wl_args, &wl_dict);
+ dbus_message_set_no_reply(agent->msg, TRUE);
+
+ if (dbus_connection_send(conn, agent->msg, NULL) == FALSE)
+ return -EIO;
+
+ dbus_message_unref(agent->msg);
+
+ return 0;
+}
+
+int coex_agent_coex_bt_notify(struct coex_agent *agent,
+ const struct bt_coex_info bt_info)
+{
+ DBusConnection *conn = ofono_dbus_get_connection();
+ DBusMessageIter bt_args, bt_dict, bt_array;
+ const dbus_int32_t *pbt_array = bt_info.safe_vector;
+ int len = MAX_BT_SAFE_VECTOR;
+ dbus_int32_t value;
+
+ agent->msg = dbus_message_new_method_call(agent->bus, agent->path,
+ OFONO_COEX_AGENT_INTERFACE,
+ "ReceiveBTNotification");
+
+ if (agent->msg == NULL)
+ return -ENOMEM;
+
+ pbt_array = bt_info.safe_vector;
+
+ for (len = 0 ; len < MAX_BT_SAFE_VECTOR; len++)
+ DBG("pbt_array[%d] = %d", len, pbt_array[len]);
+
+ dbus_message_iter_init_append(agent->msg, &bt_args);
+
+ dbus_message_iter_open_container(&bt_args, DBUS_TYPE_ARRAY,
+ DBUS_TYPE_INT32_AS_STRING, &bt_array);
+
+ dbus_message_iter_append_fixed_array(&bt_array, DBUS_TYPE_INT32,
+ &pbt_array, len);
+
+ dbus_message_iter_close_container(&bt_args, &bt_array);
+
+ dbus_message_iter_open_container(&bt_args,
+ DBUS_TYPE_ARRAY, "{sv}", &bt_dict);
+
+ value = bt_info.safe_tx_min;
+ DBG("value = %d", value);
+ ofono_dbus_dict_append(&bt_dict, "SafeTxMin",
+ DBUS_TYPE_UINT32, &value);
+ value = bt_info.safe_tx_max;
+ DBG("value = %d", value);
+ ofono_dbus_dict_append(&bt_dict, "SafeTxMax",
+ DBUS_TYPE_UINT32, &value);
+ value = bt_info.safe_rx_min;
+ DBG("value = %d", value);
+ ofono_dbus_dict_append(&bt_dict, "SafeRxMin",
+ DBUS_TYPE_UINT32, &value);
+ value = bt_info.safe_rx_max;
+ DBG("value = %d", value);
+ ofono_dbus_dict_append(&bt_dict, "SafeRxMax",
+ DBUS_TYPE_UINT32, &value);
+ value = bt_info.num_safe_vector;
+ DBG("value = %d", value);
+ ofono_dbus_dict_append(&bt_dict, "NumSafeVector",
+ DBUS_TYPE_UINT32, &value);
+
+ dbus_message_iter_close_container(&bt_args, &bt_dict);
+
+ if (dbus_connection_send(conn, agent->msg, NULL) == FALSE) {
+ return -EIO;
+ }
+
+ dbus_message_unref(agent->msg);
+
+ return 0;
+}
+
+static gboolean coex_wlan_bw_from_string(const char *str,
+ enum wlan_bw *band)
+{
+ if (g_str_equal(str, "20")) {
+ *band = OFONO_WLAN_BW_20MHZ;
+ return TRUE;
+ } else if (g_str_equal(str, "40")) {
+ *band = OFONO_WLAN_BW_40MHZ;
+ return TRUE;
+ } else if (g_str_equal(str, "80")) {
+ *band = OFONO_WLAN_BW_80MHZ;
+ return TRUE;
+ } else
+ *band = OFONO_WLAN_BW_UNSUPPORTED;
+
+ return FALSE;
+}
+
+const char *ofono_wlan_bw_to_string(int band)
+{
+ switch (band) {
+ case OFONO_WLAN_BW_20MHZ:
+ return "20MHz";
+ case OFONO_WLAN_BW_40MHZ:
+ return "40MHz";
+ case OFONO_WLAN_BW_80MHZ:
+ return "80MHz";
+ case OFONO_WLAN_BW_UNSUPPORTED:
+ return "UnSupported";
+ }
+
+ return "";
+}
+
+void xmm_get_band_string(int lte_band, char *band)
+{
+ int band_lte = lte_band-NET_BAND_LTE_1+1;
+ if (lte_band >= NET_BAND_LTE_1 && lte_band <= NET_BAND_LTE_43)
+ sprintf(band, "BAND_LTE_%d", band_lte);
+ else
+ sprintf(band, "INVALID");
+}
+
+static DBusMessage *coex_get_properties(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct ofono_coex *coex = data;
+ DBusMessage *reply;
+ DBusMessageIter iter;
+ DBusMessageIter dict;
+ dbus_bool_t value;
+ const char *band = NULL;
+
+ reply = dbus_message_new_method_return(msg);
+ if (reply == NULL)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &iter);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ OFONO_PROPERTIES_ARRAY_SIGNATURE,
+ &dict);
+
+ value = coex->bt_active;
+ ofono_dbus_dict_append(&dict, "BTActive",
+ DBUS_TYPE_BOOLEAN, &value);
+
+ value = coex->wlan_active;
+ ofono_dbus_dict_append(&dict, "WLANActive",
+ DBUS_TYPE_BOOLEAN, &value);
+
+ band = ofono_wlan_bw_to_string(coex->wlan_bw);
+ ofono_dbus_dict_append(&dict, "WLANBandwidth",
+ DBUS_TYPE_STRING, &band);
+
+ band = coex->lte_band;
+ ofono_dbus_dict_append(&dict, "Band", DBUS_TYPE_STRING, &band);
+
+ dbus_message_iter_close_container(&iter, &dict);
+
+ return reply;
+}
+
+static void coex_set_params_cb(gboolean ok, GAtResult *result,
+ gpointer user_data)
+{
+ struct ofono_coex *coex = user_data;
+ DBusMessage *reply;
+ DBusConnection *conn = ofono_dbus_get_connection();
+ const char *path = ofono_modem_get_path(coex->modem);
+
+ DBG("ok %d", ok);
+
+ if (!ok) {
+ coex->pending_bt_active = coex->bt_active;
+ coex->pending_wlan_active = coex->wlan_active;
+ coex->pending_wlan_bw = coex->wlan_bw;
+ reply = __ofono_error_failed(coex->pending);
+ __ofono_dbus_pending_reply(&coex->pending, reply);
+ return;
+ }
+
+ if (coex->bt_active != coex->pending_bt_active) {
+ coex->bt_active = coex->pending_bt_active;
+ ofono_dbus_signal_property_changed(conn, path,
+ OFONO_COEX_INTERFACE,
+ "BTActive",
+ DBUS_TYPE_BOOLEAN,
+ &(coex->bt_active));
+ }
+
+ if (coex->wlan_active != coex->wlan_active) {
+ coex->wlan_active = coex->wlan_active;
+ ofono_dbus_signal_property_changed(conn, path,
+ OFONO_COEX_INTERFACE,
+ "WLANActive",
+ DBUS_TYPE_BOOLEAN,
+ &(coex->wlan_active));
+ }
+
+ if (coex->wlan_bw != coex->pending_wlan_bw) {
+ const char *str_band = ofono_wlan_bw_to_string(coex->wlan_bw);
+ coex->wlan_bw = coex->pending_wlan_bw;
+
+ ofono_dbus_signal_property_changed(conn, path,
+ OFONO_COEX_INTERFACE,
+ "WLANBandwidth",
+ DBUS_TYPE_STRING,
+ &str_band);
+ }
+
+ reply = dbus_message_new_method_return(coex->pending);
+ __ofono_dbus_pending_reply(&coex->pending, reply);
+}
+
+static void coex_set_params(struct ofono_coex *coex, ofono_bool_t bt_active,
+ ofono_bool_t wlan_active, int wlan_bw)
+{
+ char buf[64];
+ DBusMessage *reply;
+
+ DBG("");
+ sprintf(buf, "AT+XNRTCWS=65535,%u,%u,%u", (int)wlan_active,
+ wlan_bw, bt_active);
+ if (g_at_chat_send(coex->chat, buf, none_prefix,
+ coex_set_params_cb, coex, NULL) > 0) {
+ return;
+ }
+
+ coex->pending_bt_active = coex->bt_active;
+ coex->pending_wlan_active = coex->wlan_active;
+ coex->pending_wlan_bw = coex->wlan_bw;
+ reply = __ofono_error_failed(coex->pending);
+ __ofono_dbus_pending_reply(&coex->pending, reply);
+}
+
+static DBusMessage *coex_set_property(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct ofono_coex *coex = data;
+ DBusMessageIter iter;
+ DBusMessageIter var;
+ const char *property;
+ dbus_bool_t value;
+
+ if (coex->pending)
+ return __ofono_error_busy(msg);
+
+ if (!dbus_message_iter_init(msg, &iter))
+ return __ofono_error_invalid_args(msg);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+ return __ofono_error_invalid_args(msg);
+
+ dbus_message_iter_get_basic(&iter, &property);
+ dbus_message_iter_next(&iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
+ return __ofono_error_invalid_args(msg);
+
+ dbus_message_iter_recurse(&iter, &var);
+
+ if (!strcmp(property, "BTActive")) {
+ if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
+ return __ofono_error_invalid_args(msg);
+
+ dbus_message_iter_get_basic(&var, &value);
+
+ if (coex->bt_active == (ofono_bool_t) value)
+ return dbus_message_new_method_return(msg);
+
+ coex->pending_bt_active = value;
+ coex->pending = dbus_message_ref(msg);
+
+ coex_set_params(coex, value, coex->wlan_active, coex->wlan_bw);
+ return NULL;
+ } else if (!strcmp(property, "WLANActive")) {
+ if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
+ return __ofono_error_invalid_args(msg);
+
+ dbus_message_iter_get_basic(&var, &value);
+
+ if (coex->wlan_active == (ofono_bool_t) value)
+ return dbus_message_new_method_return(msg);
+
+ coex->pending_wlan_active = value;
+ coex->pending = dbus_message_ref(msg);
+
+ coex_set_params(coex, coex->bt_active, value, coex->wlan_bw);
+ return NULL;
+ } else if (g_strcmp0(property, "WLANBandwidth") == 0) {
+ const char *value;
+ enum wlan_bw band;
+
+ if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
+ return __ofono_error_invalid_args(msg);
+
+ dbus_message_iter_get_basic(&var, &value);
+ if (coex_wlan_bw_from_string(value, &band) == FALSE)
+ return __ofono_error_invalid_args(msg);
+
+ if (coex->wlan_bw == band)
+ return dbus_message_new_method_return(msg);
+
+ coex->pending_wlan_bw = band;
+ coex->pending = dbus_message_ref(msg);
+
+ coex_set_params(coex, coex->bt_active, coex->wlan_active, band);
+ return NULL;
+ } else {
+ return __ofono_error_invalid_args(msg);
+ }
+
+ return dbus_message_new_method_return(msg);
+}
+
+static void coex_register_agent_cb(gboolean ok, GAtResult *result,
+ gpointer user_data)
+{
+ struct ofono_coex *coex = user_data;
+ DBusMessage *reply;
+
+ if (!ok) {
+ reply = __ofono_error_failed(coex->pending);
+ __ofono_dbus_pending_reply(&coex->pending, reply);
+ coex_agent_free(coex->session_agent);
+ return;
+ }
+
+ reply = dbus_message_new_method_return(coex->pending);
+ __ofono_dbus_pending_reply(&coex->pending, reply);
+}
+
+static void coex_default_agent_notify(gpointer user_data)
+{
+ struct ofono_coex *coex = user_data;
+ coex_agent_free(coex->session_agent);
+
+ g_at_chat_send(coex->chat, "AT+XNRTCWS=0", none_prefix,
+ NULL, NULL, NULL);
+}
+
+static DBusMessage *coex_register_agent(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct ofono_coex *coex = data;
+ const char *agent_path;
+
+ if (dbus_message_get_args(msg, NULL,
+ DBUS_TYPE_OBJECT_PATH, &agent_path,
+ DBUS_TYPE_INVALID) == FALSE)
+ return __ofono_error_invalid_args(msg);
+
+ if (!dbus_validate_path(agent_path, NULL))
+ return __ofono_error_invalid_format(msg);
+
+ if (coex->session_agent) {
+ DBG("Coexistence agent already registered");
+ dbus_message_new_method_return(msg);
+ }
+
+ coex->session_agent = coex_agent_new(agent_path,
+ dbus_message_get_sender(msg),
+ FALSE);
+ if (coex->session_agent == NULL)
+ return __ofono_error_failed(msg);
+
+ coex_agent_set_removed_notify(coex->session_agent,
+ coex_default_agent_notify, coex);
+
+ if (g_at_chat_send(coex->chat, "AT+XNRTCWS=7", none_prefix,
+ coex_register_agent_cb, coex, NULL) > 0) {
+ coex->pending = dbus_message_ref(msg);
+ return NULL;
+ }
+
+ coex_agent_free(coex->session_agent);
+ return __ofono_error_failed(msg);
+}
+
+static DBusMessage *coex_unregister_agent(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct ofono_coex *coex = data;
+ const char *agent_path;
+ const char *agent_bus = dbus_message_get_sender(msg);
+
+ if (dbus_message_get_args(msg, NULL,
+ DBUS_TYPE_OBJECT_PATH, &agent_path,
+ DBUS_TYPE_INVALID) == FALSE)
+ return __ofono_error_invalid_args(msg);
+
+ if (coex->session_agent == NULL)
+ return __ofono_error_failed(msg);
+
+ if (!coex_agent_matches(coex->session_agent, agent_path, agent_bus))
+ return __ofono_error_failed(msg);
+
+ coex_agent_send_release(coex->session_agent);
+ coex_agent_free(coex->session_agent);
+
+ g_at_chat_send(coex->chat, "AT+XNRTCWS=0", none_prefix,
+ NULL, NULL, NULL);
+
+ return dbus_message_new_method_return(msg);
+}
+
+static void append_plmn_properties(struct Plmnhist *list,
+ DBusMessageIter *dict)
+{
+ ofono_dbus_dict_append(dict, "MobileCountryCode",
+ DBUS_TYPE_UINT16, &list->mcc);
+ ofono_dbus_dict_append(dict, "MobileNetworkCode",
+ DBUS_TYPE_UINT16, &list->mnc);
+ ofono_dbus_dict_append(dict, "LteBandsFDD",
+ DBUS_TYPE_UINT32, &list->fdd);
+ ofono_dbus_dict_append(dict, "LteBandsTDD",
+ DBUS_TYPE_UINT32, &list->tdd);
+ ofono_dbus_dict_append(dict, "ChannelBandwidth",
+ DBUS_TYPE_UINT32, &list->bw);
+}
+
+static void append_plmn_history_struct_list(struct Plmnhist *list,
+ DBusMessageIter *arr)
+{
+ DBusMessageIter iter;
+ DBusMessageIter dict;
+
+ dbus_message_iter_open_container(arr, DBUS_TYPE_STRUCT, NULL, &iter);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ OFONO_PROPERTIES_ARRAY_SIGNATURE,
+ &dict);
+
+ append_plmn_properties(list, &dict);
+
+ dbus_message_iter_close_container(&iter, &dict);
+
+ dbus_message_iter_close_container(arr, &iter);
+}
+
+static void coex_get_plmn_history_cb(gboolean ok, GAtResult *result,
+ gpointer user_data)
+{
+ struct ofono_coex *coex = user_data;
+ struct Plmnhist *list = NULL;
+ GAtResultIter iter;
+ int list_size = 0, count;
+ DBusMessage *reply;
+ DBusMessageIter itr, arr;
+
+ DBG("ok %d", ok);
+
+ if (!ok) {
+ __ofono_dbus_pending_reply(&coex->pending,
+ __ofono_error_failed(coex->pending));
+ return;
+ }
+
+ g_at_result_iter_init(&iter, result);
+
+ while (g_at_result_iter_next(&iter, "+XNVMPLMN:")) {
+ if (!list_size)
+ list = g_new0(struct Plmnhist, ++list_size);
+ else
+ list = g_renew(struct Plmnhist, list, ++list_size);
+
+ g_at_result_iter_next_number(&iter, (int *)&list[list_size - 1].mcc);
+ g_at_result_iter_next_number(&iter, (int *)&list[list_size - 1].mnc);
+ g_at_result_iter_next_number(&iter, (int *)&list[list_size - 1].fdd);
+ g_at_result_iter_next_number(&iter, (int *)&list[list_size - 1].tdd);
+ g_at_result_iter_next_number(&iter, (int *)&list[list_size - 1].bw);
+
+ DBG("list_size = %d", list_size);
+ }
+
+ reply = dbus_message_new_method_return(coex->pending);
+ dbus_message_iter_init_append(reply, &itr);
+
+ dbus_message_iter_open_container(&itr, DBUS_TYPE_ARRAY,
+ DBUS_STRUCT_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING
+ DBUS_STRUCT_END_CHAR_AS_STRING,
+ &arr);
+
+ for (count = 0; count < list_size; count++)
+ append_plmn_history_struct_list(list, &arr);
+
+ dbus_message_iter_close_container(&itr, &arr);
+
+ reply = dbus_message_new_method_return(coex->pending);
+ __ofono_dbus_pending_reply(&coex->pending, reply);
+
+ if (list)
+ g_free(list);
+}
+
+static DBusMessage *coex_get_plmn_history(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct ofono_coex *coex = data;
+
+ if (coex->pending)
+ return __ofono_error_busy(msg);
+
+ coex->pending = dbus_message_ref(msg);
+
+ if (g_at_chat_send(coex->chat, "AT+XNVMPLMN=2,2", xnvmplmn_prefix,
+ coex_get_plmn_history_cb, coex, NULL) > 0)
+ return NULL;
+
+ coex->pending = NULL;
+ return __ofono_error_failed(msg);
+}
+
+static const GDBusMethodTable coex_methods[] = {
+ { GDBUS_METHOD("GetProperties",
+ NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
+ coex_get_properties) },
+ { GDBUS_METHOD("SetProperty",
+ GDBUS_ARGS({ "property", "s" }, { "value", "v" }),
+ NULL, coex_set_property) },
+ { GDBUS_METHOD("RegisterAgent",
+ GDBUS_ARGS({ "path", "o" }), NULL,
+ coex_register_agent) },
+ { GDBUS_METHOD("UnregisterAgent",
+ GDBUS_ARGS({ "path", "o" }), NULL,
+ coex_unregister_agent) },
+ { GDBUS_ASYNC_METHOD("GetPlmnHistory",
+ NULL, GDBUS_ARGS({ "plmnhistory", "a(a{sv})" }),
+ coex_get_plmn_history) },
+ { }
+};
+
+static const GDBusSignalTable coex_signals[] = {
+ { GDBUS_SIGNAL("PropertyChanged",
+ GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
+ { }
+};
+
+static void xmm_coex_l_notify(GAtResult *result, gpointer user_data)
+{
+ struct ofono_coex *coex = user_data;
+ GAtResultIter iter;
+ int lte_active;
+
+ g_at_result_iter_init(&iter, result);
+
+ if (!g_at_result_iter_next(&iter, "+XNRTCWSL:"))
+ return;
+
+ if (!g_at_result_iter_next_number(&iter, <e_active))
+ return;
+
+ DBG("lte_active:%d", lte_active);
+
+ coex->lte_active = lte_active;
+}
+
+static void xmm_coex_w_notify(GAtResult *result, gpointer user_data)
+{
+ struct ofono_coex *coex = user_data;
+ GAtResultIter iter;
+ int count;
+ struct wl_coex_info wlan;
+
+ g_at_result_iter_init(&iter, result);
+
+ if (!g_at_result_iter_next(&iter, "+XNRTCWSW:"))
+ return;
+
+ g_at_result_iter_next_number(&iter, &wlan.safe_rx_min);
+
+ g_at_result_iter_skip_next(&iter);
+
+ g_at_result_iter_skip_next(&iter);
+
+ g_at_result_iter_next_number(&iter, &wlan.safe_rx_max);
+
+ g_at_result_iter_skip_next(&iter);
+
+ g_at_result_iter_skip_next(&iter);
+
+ g_at_result_iter_next_number(&iter, &wlan.safe_tx_min);
+
+ g_at_result_iter_skip_next(&iter);
+
+ g_at_result_iter_skip_next(&iter);
+
+ g_at_result_iter_next_number(&iter, &wlan.safe_tx_max);
+
+ 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_next_number(&iter, &wlan.num_safe_vector);
+
+ for (count = 0; count < wlan.num_safe_vector; count++) {
+ g_at_result_iter_next_number(&iter, &wlan.safe_vector[count]);
+ }
+
+ DBG("WLAN notification");
+
+ if (coex->session_agent)
+ coex_agent_coex_wlan_notify(coex->session_agent, wlan);
+}
+
+static void xmm_coex_b_notify(GAtResult *result, gpointer user_data)
+{
+ struct ofono_coex *coex = user_data;
+ GAtResultIter iter;
+ struct bt_coex_info bt;
+ int count;
+
+ g_at_result_iter_init(&iter, result);
+
+ if (!g_at_result_iter_next(&iter, "+XNRTCWSB:"))
+ return;
+
+ g_at_result_iter_next_number(&iter, &bt.safe_rx_min);
+
+ g_at_result_iter_next_number(&iter, &bt.safe_rx_max);
+
+ g_at_result_iter_next_number(&iter, &bt.safe_tx_min);
+
+ g_at_result_iter_next_number(&iter, &bt.safe_tx_max);
+
+ g_at_result_iter_next_number(&iter, &bt.num_safe_vector);
+
+ for (count = 0; count < bt.num_safe_vector; count++) {
+ g_at_result_iter_next_number(&iter, &bt.safe_vector[count]);
+ }
+
+ DBG("BT notification");
+
+ if (coex->session_agent)
+ coex_agent_coex_bt_notify(coex->session_agent, bt);
+}
+
+static void xmm_lte_band_notify(GAtResult *result, gpointer user_data)
+{
+ struct ofono_coex *coex = user_data;
+ GAtResultIter iter;
+ int lte_band;
+ char band[BAND_LEN];
+ const char *path = ofono_modem_get_path(coex->modem);
+ DBusConnection *conn = ofono_dbus_get_connection();
+
+ g_at_result_iter_init(&iter, result);
+
+ if (!g_at_result_iter_next(&iter, "+XCCINFO:"))
+ return;
+
+ 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, <e_band))
+ return;
+
+ xmm_get_band_string(lte_band, band);
+ DBG("band %s", band);
+
+ if (!strcmp(band, coex->lte_band))
+ return;
+
+ g_free(coex->lte_band);
+ coex->lte_band = g_strdup(band);
+
+ if (coex->lte_band == NULL)
+ return;
+
+ ofono_dbus_signal_property_changed(conn, path,
+ OFONO_COEX_INTERFACE,
+ "Band", DBUS_TYPE_STRING, &coex->lte_band);
+
+}
+
+static void coex_cleanup(void *data)
+{
+ struct ofono_coex *coex = data;
+
+ if (coex->pending)
+ __ofono_dbus_pending_reply(&coex->pending,
+ __ofono_error_canceled(coex->pending));
+
+ if (coex->session_agent) {
+ coex_agent_free(coex->session_agent);
+
+ g_at_chat_send(coex->chat, "AT+XNRTCWS=0", none_prefix,
+ NULL, NULL, NULL);
+ }
+
+ g_free(coex);
+}
+
+static int xmm_coex_enable(struct ofono_modem *modem, void *data)
+{
+ struct ofono_coex *coex;
+ DBusConnection *conn = ofono_dbus_get_connection();
+ const char *path = ofono_modem_get_path(modem);
+ coex = g_new0(struct ofono_coex, 1);
+
+ DBG("coex enable");
+
+ coex->chat = data;
+ coex->modem = modem;
+ if (!g_dbus_register_interface(conn, path, OFONO_COEX_INTERFACE,
+ coex_methods,
+ coex_signals,
+ NULL, coex, coex_cleanup)) {
+ ofono_error("Could not register %s interface under %s",
+ OFONO_COEX_INTERFACE, path);
+ g_free(coex);
+ return -EIO;
+ }
+
+ ofono_modem_add_interface(modem, OFONO_COEX_INTERFACE);
+
+ g_at_chat_register(coex->chat, "+XNRTCWSL:", xmm_coex_l_notify,
+ FALSE, NULL, NULL);
+ g_at_chat_register(coex->chat, "+XNRTCWSW:", xmm_coex_w_notify,
+ FALSE, NULL, NULL);
+ g_at_chat_register(coex->chat, "+XNRTCWSB:", xmm_coex_b_notify,
+ FALSE, NULL, NULL);
+ g_at_chat_register(coex->chat, "+XCCINFO:", xmm_lte_band_notify,
+ FALSE, NULL, NULL);
+
+ if (g_at_chat_send(coex->chat, "AT+XCCINFO=1", none_prefix,
+ NULL, NULL, NULL) < 0)
+ goto out;
+
+ if (g_at_chat_send(coex->chat, "AT+XNRTAPP=10,100", none_prefix,
+ NULL, NULL, NULL) > 0)
+ return 0;
+
+out:
+ g_free(coex);
+ return -EIO;
+}
+
+/* Coex Implementation Ends*/
+
static void xmm7xxx_debug(const char *str, void *user_data)
{
const char *prefix = user_data;
@@ -366,6 +1329,29 @@ static void xmm7xxx_post_online(struct ofono_modem *modem)
ofono_netmon_create(modem, 0, "xmm7modem", data->chat);
}
+static void netreg_watch(struct ofono_atom *atom,
+ enum ofono_atom_watch_condition cond,
+ void *data)
+{
+ struct ofono_modem *modem = data;
+ struct xmm7xxx_data *modem_data = ofono_modem_get_data(modem);
+ DBusConnection *conn = ofono_dbus_get_connection();
+ const char *path = ofono_modem_get_path(modem);
+
+ if (cond == OFONO_ATOM_WATCH_CONDITION_UNREGISTERED) {
+ if (g_dbus_unregister_interface(conn, path,
+ OFONO_COEX_INTERFACE))
+ ofono_modem_remove_interface(modem,
+ OFONO_COEX_INTERFACE);
+ return;
+ }
+
+ if (cond == OFONO_ATOM_WATCH_CONDITION_REGISTERED) {
+ xmm_coex_enable(modem, modem_data->chat);
+ return;
+ }
+}
+
static int xmm7xxx_probe(struct ofono_modem *modem)
{
struct xmm7xxx_data *data;
@@ -378,6 +1364,10 @@ static int xmm7xxx_probe(struct ofono_modem *modem)
ofono_modem_set_data(modem, data);
+ data->netreg_watch = __ofono_modem_add_atom_watch(modem,
+ OFONO_ATOM_TYPE_NETREG,
+ netreg_watch, modem, NULL);
+
return 0;
}
@@ -389,6 +1379,11 @@ static void xmm7xxx_remove(struct ofono_modem *modem)
ofono_modem_set_data(modem, NULL);
+ if (data->netreg_watch) {
+ __ofono_modem_remove_atom_watch(modem, data->netreg_watch);
+ data->netreg_watch = 0;
+ }
+
/* Cleanup after hot-unplug */
g_at_chat_unref(data->chat);
--
1.9.1
3 years, 6 months
