From: Antara <[email protected]>
Added coex implementation in xmm7modem plugin
---
Makefile.am | 3 +-
doc/coex-api.txt | 122 +++++++++
plugins/xmm7xxx.c | 724 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 848 insertions(+), 1 deletion(-)
create mode 100644 doc/coex-api.txt
diff --git a/Makefile.am b/Makefile.am
index e8e4ed9..578af2f 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -669,7 +669,8 @@ src_ofonod_SOURCES = $(builtin_sources) $(gatchat_sources)
src/ofono.ver \
src/handsfree-audio.c src/bluetooth.h \
src/hfp.h src/siri.c \
src/netmon.c src/lte.c src/ims.c \
- src/netmonagent.c src/netmonagent.h
+ src/netmonagent.c src/netmonagent.h \
+ src/coexagent.c src/coexagent.h
src_ofonod_LDADD = gdbus/libgdbus-internal.la $(builtin_libadd) \
@GLIB_LIBS@ @DBUS_LIBS@ -ldl
diff --git a/doc/coex-api.txt b/doc/coex-api.txt
new file mode 100644
index 0000000..12693a4
--- /dev/null
+++ b/doc/coex-api.txt
@@ -0,0 +1,122 @@
+LTE Coexistence hierarchy
+===============
+
+Service org.ofono
+Interface org.ofono.IntelLTECoex*
+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.
+ *most recently uused
+ *privacy
+
+ 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.IntelLTECoexAgent
+Object path freely definable
+
+Methods void ReceiveBluetoothNotification(array{byte}
notification, dict info)
+
+ 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)
+
+ Requests the agent to process WiFi 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 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 LTEBand [readwrite]
+ Frequency band in which the modem is operating when
using "lte" mode.
+
+ boolean CoexBTActive [readwrite]
+ Maintains whether BT Coex is activated or not.
+
+ boolean CoexWLANActive [readwrite]
+ Maintains whether WLAN Coex is activated or not.
+
+ string CoexWLANBandwidth [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.
diff --git a/plugins/xmm7xxx.c b/plugins/xmm7xxx.c
index 1223008..381a90a 100644
--- a/plugins/xmm7xxx.c
+++ b/plugins/xmm7xxx.c
@@ -53,12 +53,23 @@
#include <ofono/sms.h>
#include <ofono/phonebook.h>
#include <ofono/netmon.h>
+#include "coexagent.h"
#include <drivers/atmodem/atutil.h>
#include <drivers/atmodem/vendor.h>
+#include "ofono.h"
+#include "gdbus.h"
+
+#define OFONO_COEX_INTERFACE OFONO_SERVICE ".LTECoex"
+#define NET_BAND_LTE_INVALID 0
+#define NET_BAND_LTE_1 101
+#define NET_BAND_LTE_43 143
+#define BAND_LEN 20
+
static const char *none_prefix[] = { NULL };
static const char *xsimstate_prefix[] = { "+XSIMSTATE:", NULL };
+static const char *xnvmplmn_prefix[] = { "+XNVMPLMN:", NULL };
struct xmm7xxx_data {
GAtChat *chat; /* AT chat */
@@ -67,6 +78,712 @@ struct xmm7xxx_data {
ofono_bool_t sms_phonebook_added;
};
+/* Coex Implementation */
+enum ofono_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 ofono_wlan_bw wlan_bw;
+ char* lte_band;
+
+ ofono_bool_t pending_bt_active;
+ ofono_bool_t pending_wlan_active;
+ enum ofono_wlan_bw pending_wlan_bw;
+ ofono_bool_t lte_active;
+
+ struct coex_agent *session_agent;
+};
+
+static gboolean coex_wlan_bw_from_string(const char *str,
+ enum ofono_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, "CoexBTActive",
+ DBUS_TYPE_BOOLEAN, &value);
+
+ value = coex->wlan_active;
+ ofono_dbus_dict_append(&dict, "CoexWLANActive",DBUS_TYPE_BOOLEAN,
&value);
+
+ band = ofono_wlan_bw_to_string(coex->wlan_bw);
+ ofono_dbus_dict_append(&dict, "CoexWLANBandwidth",DBUS_TYPE_STRING,
&band);
+
+ band = coex->lte_band;
+ ofono_dbus_dict_append(&dict, "LTEBand",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,
+ "CoexBTActive",
+ 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,
+ "CoexWLANActive",
+ 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,
+ "CoexWLANBandwidth",
+ 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);
+
+ return;
+}
+
+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, "CoexBTActive")) {
+ 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, "CoexWLANActive")) {
+ 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, "CoexWLANBandwidth") == 0) {
+ const char *value;
+ enum ofono_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);
+ 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->session_agent = 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);
+
+ 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;
+ }
+
+ return __ofono_error_failed(msg);
+}
+
+static void coex_unregister_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);
+ return;
+ }
+
+ reply = dbus_message_new_method_return(coex->pending);
+ __ofono_dbus_pending_reply(&coex->pending, reply);
+}
+
+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);
+
+ if(g_at_chat_send(coex->chat, "AT+XNRTCWS=0", none_prefix,
+ coex_unregister_agent_cb, coex, NULL) > 0) {
+ coex->pending = dbus_message_ref(msg);
+ return NULL;
+ }
+
+ return __ofono_error_failed(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;
+
+ 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,
+ FALSE, NULL, NULL);
+}
+
+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,
+ FALSE, NULL, NULL);
+}
+
+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,
+ "LTEBand", 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));
+
+ 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:
+ return -EIO;
+}
+
+/* Coex Implementation Ends*/
+
static void xmm7xxx_debug(const char *str, void *user_data)
{
const char *prefix = user_data;
@@ -336,6 +1053,7 @@ static void xmm7xxx_post_sim(struct ofono_modem *modem)
ofono_lte_create(modem, 0, "atmodem", data->chat);
ofono_radio_settings_create(modem, 0, "xmm7modem", data->chat);
ofono_sim_auth_create(modem);
+ xmm_coex_enable(modem, data->chat);
}
static void xmm7xxx_post_online(struct ofono_modem *modem)
@@ -378,8 +1096,14 @@ static int xmm7xxx_probe(struct ofono_modem *modem)
static void xmm7xxx_remove(struct ofono_modem *modem)
{
struct xmm7xxx_data *data = ofono_modem_get_data(modem);
+ DBusConnection *conn = ofono_dbus_get_connection();
+ const char *path = ofono_modem_get_path(modem);
DBG("%p", modem);
+ if (g_dbus_unregister_interface(conn, path,
+ OFONO_COEX_INTERFACE))
+ ofono_modem_remove_interface(modem,
+ OFONO_COEX_INTERFACE);
ofono_modem_set_data(modem, NULL);
--
1.9.1
_______________________________________________
ofono mailing list
[email protected]
https://lists.ofono.org/mailman/listinfo/ofono
