diff mbox

simultaneous voice/data works (was Re: call/normal switch was Re: omap4-droid4: voice call support was)

Message ID 20180410105840.GA13697@amd (mailing list archive)
State New, archived
Headers show

Commit Message

Pavel Machek April 10, 2018, 10:58 a.m. UTC
On Mon 2018-04-09 07:08:47, Tony Lindgren wrote:
> * Dan Williams <dcbw@redhat.com> [180408 02:46]:
> > On Sat, 2018-04-07 at 14:22 +0200, Pavel Machek wrote:
> > > I tried --location-enable-gps-unmanaged , but that did not work for
> > > me.
> > 
> > That requires a TTY that would spit out the GPS data; in this mode MM
> > only sends the start/stop commands, and what comes out the GPS TTY is
> > undefined (at least by MM).
> > 
> > So unless you know that one of the 6600's TTYs does GPS and in what
> > format it does GPS, then no.
> 
> There should be a NMEA port within the unknown port range ttyUSB[123].
> 
> Is there some easy way to enable --location-enable-gps-unmanaged for
> testing so I can check if GPS gets enabled for one of the ports?

This should be userful for testing:

Just pass --pds-start-gps and you should get NMEA on stdout.

Cleanup does _not_ work properly, so it will fail if you run it too
many times.

								Pavel

Comments

Tony Lindgren April 10, 2018, 1:50 p.m. UTC | #1
* Pavel Machek <pavel@ucw.cz> [180410 11:00]:
> On Mon 2018-04-09 07:08:47, Tony Lindgren wrote:
> > * Dan Williams <dcbw@redhat.com> [180408 02:46]:
> > > On Sat, 2018-04-07 at 14:22 +0200, Pavel Machek wrote:
> > > > I tried --location-enable-gps-unmanaged , but that did not work for
> > > > me.
> > > 
> > > That requires a TTY that would spit out the GPS data; in this mode MM
> > > only sends the start/stop commands, and what comes out the GPS TTY is
> > > undefined (at least by MM).
> > > 
> > > So unless you know that one of the 6600's TTYs does GPS and in what
> > > format it does GPS, then no.
> > 
> > There should be a NMEA port within the unknown port range ttyUSB[123].
> > 
> > Is there some easy way to enable --location-enable-gps-unmanaged for
> > testing so I can check if GPS gets enabled for one of the ports?
> 
> This should be userful for testing:
> 
> Just pass --pds-start-gps and you should get NMEA on stdout.

Hmm maybe also try to check if enabling the GPS this way starts
printing something out of /dev/ttyUSB[123]?

Regards,

Tony
--
To unsubscribe from this list: send the line "unsubscribe linux-omap" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Pavel Machek April 11, 2018, 11:43 a.m. UTC | #2
On Tue 2018-04-10 06:50:29, Tony Lindgren wrote:
> * Pavel Machek <pavel@ucw.cz> [180410 11:00]:
> > On Mon 2018-04-09 07:08:47, Tony Lindgren wrote:
> > > * Dan Williams <dcbw@redhat.com> [180408 02:46]:
> > > > On Sat, 2018-04-07 at 14:22 +0200, Pavel Machek wrote:
> > > > > I tried --location-enable-gps-unmanaged , but that did not work for
> > > > > me.
> > > > 
> > > > That requires a TTY that would spit out the GPS data; in this mode MM
> > > > only sends the start/stop commands, and what comes out the GPS TTY is
> > > > undefined (at least by MM).
> > > > 
> > > > So unless you know that one of the 6600's TTYs does GPS and in what
> > > > format it does GPS, then no.
> > > 
> > > There should be a NMEA port within the unknown port range ttyUSB[123].
> > > 
> > > Is there some easy way to enable --location-enable-gps-unmanaged for
> > > testing so I can check if GPS gets enabled for one of the ports?
> > 
> > This should be userful for testing:
> > 
> > Just pass --pds-start-gps and you should get NMEA on stdout.
> 
> Hmm maybe also try to check if enabling the GPS this way starts
> printing something out of /dev/ttyUSB[123]?

No, I did not find anything there :-(.

This combination seems to give me working gps:

sudo src/qmicli/qmicli -d /dev/cdc-wdm0 --pds-start-gps | nc -u 127.0.0.1 5000

/usr/sbin/gpsd -ND 4 udp://127.0.0.1:5000

Best regards,
									Pavel
diff mbox

Patch

diff --git a/src/qmicli/Makefile.am b/src/qmicli/Makefile.am
index eb63fa7..2c5e935 100644
--- a/src/qmicli/Makefile.am
+++ b/src/qmicli/Makefile.am
@@ -42,6 +42,7 @@  qmicli_SOURCES = \
 	qmicli-pdc.c \
 	qmicli-uim.c \
 	qmicli-wms.c \
+	qmicli-pds.c \
 	qmicli-wda.c \
 	qmicli-voice.c \
 	qmicli-charsets.c \
diff --git a/src/qmicli/qmicli-loc.c b/src/qmicli/qmicli-loc.c
new file mode 100644
index 0000000..e69de29
diff --git a/src/qmicli/qmicli-pds.c b/src/qmicli/qmicli-pds.c
new file mode 100644
index 0000000..f21ba2e
--- /dev/null
+++ b/src/qmicli/qmicli-pds.c
@@ -0,0 +1,315 @@ 
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * qmicli -- Command line interface to control QMI devices
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2015-2017 Aleksander Morgado <aleksander@aleksander.es>
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <locale.h>
+#include <string.h>
+
+#include <glib.h>
+#include <gio/gio.h>
+
+#include <libqmi-glib.h>
+
+#include "qmicli.h"
+#include "qmicli-helpers.h"
+
+/* Context */
+typedef struct {
+    QmiDevice *device;
+    QmiClientPds *client;
+    GCancellable *cancellable;
+} Context;
+static Context *ctx;
+
+/* Options */
+static gboolean get_supported_messages_flag;
+static gboolean reset_flag;
+static gboolean noop_flag;
+static gboolean start_flag;
+
+static GOptionEntry entries[] = {
+    { "pds-start-gps", 0, 0, G_OPTION_ARG_NONE, &start_flag,
+      "Start gps",
+      NULL
+    },
+
+    { NULL }
+};
+
+GOptionGroup *
+qmicli_pds_get_option_group (void)
+{
+	GOptionGroup *group;
+
+	group = g_option_group_new ("pds",
+	                            "PDS options",
+	                            "Show Wireless Messaging Service options",
+	                            NULL,
+	                            NULL);
+	g_option_group_add_entries (group, entries);
+
+	return group;
+}
+
+gboolean
+qmicli_pds_options_enabled (void)
+{
+    static guint n_actions = 0;
+    static gboolean checked = FALSE;
+
+    if (checked)
+        return !!n_actions;
+
+    n_actions = (get_supported_messages_flag +
+                 reset_flag +
+                 noop_flag +
+                 start_flag);
+
+    if (n_actions > 1) {
+        g_printerr ("error: too many PDS actions requested\n");
+        exit (EXIT_FAILURE);
+    }
+
+    checked = TRUE;
+    return !!n_actions;
+}
+
+#if 0
+static void
+context_free (Context *context)
+{
+    if (!context)
+        return;
+
+    if (context->client)
+        g_object_unref (context->client);
+    g_object_unref (context->cancellable);
+    g_object_unref (context->device);
+    g_slice_free (Context, context);
+}
+
+static void
+operation_shutdown (gboolean operation_status)
+{
+    /* Cleanup context and finish async operation */
+    context_free (ctx);
+    qmicli_async_operation_done (operation_status, FALSE);
+}
+#endif
+
+static void
+ser_location_ready (QmiClientPds *client,
+                    GAsyncResult *res,
+                    GTask *task);
+
+static void
+location_event_report_indication_cb (QmiClientPds *client,
+                                     QmiIndicationPdsEventReportOutput *output,
+                                     void *self)
+{
+    QmiPdsPositionSessionStatus session_status;
+    const gchar *nmea;
+
+    if (qmi_indication_pds_event_report_output_get_position_session_status (
+                                                                            output,
+                                                                            &session_status,
+                                                                            NULL)) {
+        printf ("[GPS] session status changed: '%s'",
+                qmi_pds_position_session_status_get_string (session_status));
+    }
+
+    if (qmi_indication_pds_event_report_output_get_nmea_position (
+                                                                  output,
+                                                                  &nmea,
+                                                                  NULL)) {
+        printf ("%s", nmea);
+    }
+}
+
+static void
+gather_nmea(GTask *task)
+{
+    QmiMessagePdsSetEventReportInput *input;
+    
+    /* Only gather standard NMEA traces */
+    input = qmi_message_pds_set_event_report_input_new ();
+    qmi_message_pds_set_event_report_input_set_nmea_position_reporting (input, TRUE, NULL);
+    qmi_client_pds_set_event_report (
+                                     ctx->client,
+                                     input,
+                                     5,
+                                     NULL,
+                                     (GAsyncReadyCallback)ser_location_ready,
+                                     task);
+    qmi_message_pds_set_event_report_input_unref (input);
+
+}
+
+static void
+ser_location_ready (QmiClientPds *client,
+                    GAsyncResult *res,
+                    GTask *task)
+{
+    QmiMessagePdsSetEventReportOutput *output = NULL;
+    GError *error = NULL;
+
+    output = qmi_client_pds_set_event_report_finish (client, res, &error);
+    if (!output) {
+        g_prefix_error (&error, "QMI operation failed: ");
+        g_task_return_error (task, error);
+        g_object_unref (task);
+        return;
+    }
+
+    if (!qmi_message_pds_set_event_report_output_get_result (output, &error)) {
+        g_prefix_error (&error, "Couldn't set event report: ");
+        g_task_return_error (task, error);
+        g_object_unref (task);
+        qmi_message_pds_set_event_report_output_unref (output);
+        return;
+    }
+
+    qmi_message_pds_set_event_report_output_unref (output);
+
+    g_signal_connect (client,
+                      "event-report",
+                      G_CALLBACK (location_event_report_indication_cb),
+                      NULL);
+}
+
+static void
+auto_tracking_state_start_ready (QmiClientPds *client,
+                                 GAsyncResult *res,
+                                 GTask *task)
+{
+    QmiMessagePdsSetAutoTrackingStateOutput *output = NULL;
+    GError *error = NULL;
+
+    output = qmi_client_pds_set_auto_tracking_state_finish (client, res, &error);
+    if (!output) {
+        g_prefix_error (&error, "QMI operation failed: ");
+        g_task_return_error (task, error);
+        g_object_unref (task);
+        return;
+    }
+
+    if (!qmi_message_pds_set_auto_tracking_state_output_get_result (output, &error)) {
+        if (!g_error_matches (error,
+                              QMI_PROTOCOL_ERROR,
+                              QMI_PROTOCOL_ERROR_NO_EFFECT)) {
+            g_prefix_error (&error, "Couldn't set auto-tracking state: ");
+            g_task_return_error (task, error);
+            g_object_unref (task);
+            qmi_message_pds_set_auto_tracking_state_output_unref (output);
+            return;
+        }
+        g_error_free (error);
+        printf("no matches: was already enabled?\n");
+    }
+    qmi_message_pds_set_auto_tracking_state_output_unref (output);
+    gather_nmea(task);
+}
+
+
+static void
+gps_service_state_start_ready (QmiClientPds *client,
+                               GAsyncResult *res,
+                               GTask *task)
+{
+    QmiMessagePdsSetAutoTrackingStateInput *input;
+    QmiMessagePdsSetGpsServiceStateOutput *output = NULL;
+    GError *error = NULL;
+
+    output = qmi_client_pds_set_gps_service_state_finish (client, res, &error);
+    if (!output) {
+        g_prefix_error (&error, "QMI operation failed: ");
+        g_task_return_error (task, error);
+        g_object_unref (task);
+        return;
+    }
+
+    if (!qmi_message_pds_set_gps_service_state_output_get_result (output, &error)) {
+        if (!g_error_matches (error,
+                              QMI_PROTOCOL_ERROR,
+                              QMI_PROTOCOL_ERROR_NO_EFFECT)) {
+            g_prefix_error (&error, "Couldn't set GPS service state: ");
+            g_task_return_error (task, error);
+            g_object_unref (task);
+            qmi_message_pds_set_gps_service_state_output_unref (output);
+            return;
+        }
+        g_error_free (error);
+    }
+    qmi_message_pds_set_gps_service_state_output_unref (output);
+
+    /* Enable auto-tracking for a continuous fix */
+    input = qmi_message_pds_set_auto_tracking_state_input_new ();
+    qmi_message_pds_set_auto_tracking_state_input_set_state (input, TRUE, NULL);
+    qmi_client_pds_set_auto_tracking_state (
+                                            ctx->client,
+                                            input,
+                                            10,
+                                            NULL, /* cancellable */
+                                            (GAsyncReadyCallback)auto_tracking_state_start_ready,
+                                            task);
+    qmi_message_pds_set_auto_tracking_state_input_unref (input);
+}
+
+
+void
+qmicli_pds_run (QmiDevice *device,
+                QmiClientPds *client,
+                GCancellable *cancellable)
+{
+    /* Initialize context */
+    ctx = g_slice_new (Context);
+    ctx->device = g_object_ref (device);
+    ctx->client = g_object_ref (client);
+    ctx->cancellable = g_object_ref (cancellable);
+
+    if (start_flag) {
+        QmiMessagePdsSetGpsServiceStateInput *input;
+
+        input = qmi_message_pds_set_gps_service_state_input_new ();
+        qmi_message_pds_set_gps_service_state_input_set_state (input, TRUE, NULL);
+        qmi_client_pds_set_gps_service_state (
+                                              ctx->client,
+                                              input,
+                                              10,
+                                              NULL, /* cancellable */
+                                              (GAsyncReadyCallback)gps_service_state_start_ready,
+                                              ctx);
+        qmi_message_pds_set_gps_service_state_input_unref (input);
+        printf("GPS started?\n");
+        return;
+    }
+
+    if (1) { // run_flag)
+        g_signal_connect (client,
+                          "event-report",
+                          G_CALLBACK (location_event_report_indication_cb),
+                          NULL);
+    }
+
+    g_warn_if_reached ();
+}
diff --git a/src/qmicli/qmicli.c b/src/qmicli/qmicli.c
index fecae8d..32d1052 100644
--- a/src/qmicli/qmicli.c
+++ b/src/qmicli/qmicli.c
@@ -366,6 +366,9 @@  allocate_client_ready (QmiDevice *dev,
     case QMI_SERVICE_WMS:
         qmicli_wms_run (dev, QMI_CLIENT_WMS (client), cancellable);
         return;
+    case QMI_SERVICE_PDS:
+        qmicli_pds_run (dev, QMI_CLIENT_PDS (client), cancellable);
+        return;
     case QMI_SERVICE_WDA:
         qmicli_wda_run (dev, QMI_CLIENT_WDA (client), cancellable);
         return;
@@ -719,6 +722,12 @@  parse_actions (void)
         actions_enabled++;
     }
 
+    /* PDS options? */
+    if (qmicli_pds_options_enabled ()) {
+        service = QMI_SERVICE_PDS;
+        actions_enabled++;
+    }
+
     /* WDA options? */
     if (qmicli_wda_options_enabled ()) {
         service = QMI_SERVICE_WDA;
@@ -769,6 +778,8 @@  int main (int argc, char **argv)
     g_option_context_add_group (context,
                                 qmicli_uim_get_option_group ());
     g_option_context_add_group (context,
+                                qmicli_pds_get_option_group ());
+    g_option_context_add_group (context,
                                 qmicli_wms_get_option_group ());
     g_option_context_add_group (context,
                                 qmicli_wda_get_option_group ());
diff --git a/src/qmicli/qmicli.h b/src/qmicli/qmicli.h
index 7db7905..0986b66 100644
--- a/src/qmicli/qmicli.h
+++ b/src/qmicli/qmicli.h
@@ -69,6 +69,14 @@  void          qmicli_uim_run              (QmiDevice *device,
                                            QmiClientUim *client,
                                            GCancellable *cancellable);
 
+
+/* PDS group */
+GOptionGroup *qmicli_pds_get_option_group (void);
+gboolean      qmicli_pds_options_enabled  (void);
+void          qmicli_pds_run              (QmiDevice *device,
+                                           QmiClientPds *client,
+                                           GCancellable *cancellable);
+
 /* WMS group */
 GOptionGroup *qmicli_wms_get_option_group (void);
 gboolean      qmicli_wms_options_enabled  (void);