meson.build: release v0.4.0

gnss: handle locked SIM

See merge request mobian1/devices/eg25-manager!25

README.md

@@ -29,13 +29,20 @@ $ ninja -C ../eg25-build
 # ninja -C ../eg25-build install
 ```
 
+## Configuration
+
+`eg25-manager` uses device-specific configuration files, named after the
+device-tree `compatible` field. These files are installed to
+`/usr/share/eg25-manager`. They can be copied to `/etc/eg25-manager` then
+modified, that way they won't be overwritten during an upgrade.
+
 ## Running
 
 `eg25-manager` is usually run as a systemd service, but can also be
 manually started from the command-line (requires root privileges):
 
 ```
-# eg25-manager
+# eg25manager
 ```
 
 ## License

data/meson.build

@@ -0,0 +1,13 @@
+#
+# Copyright (C) 2020 Arnaud Ferraris <arnaud.ferraris@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+conf_files = [
+'pine64,pinephone-1.0.toml',
+'pine64,pinephone-1.1.toml',
+'pine64,pinephone-1.2.toml',
+]
+
+install_data(conf_files)

data/pine64,pinephone-1.0.toml

@@ -0,0 +1,99 @@
+[manager]
+need_libusb = true
+usb_vid = 0x2c7c
+usb_pid = 0x0125
+
+# Delay between setting GPIO and PWRKEY sequence, set in microseconds
+poweron_delay = 100000
+
+# Uncomment the following if you need to change the modem detection timeout on
+# resume and/or the time during which suspend is blocked after modem boot
+#[suspend]
+#boot_timeout = 120
+#recovery_timeout = 9
+
+[gpio]
+dtr = 358
+pwrkey = 35
+reset = 68
+apready = 231
+disable = 232
+
+[at]
+uart = "/dev/ttyS2"
+configure = [
+# Each command has 4 possible elements:
+#   * `cmd`   : the AT command itself, which will be translated to "AT+`cmd`"
+#   * `subcmd`: the subcommand in case a single AT command can be used
+#               to change multiple parameters, such as QCFG (optional)
+#   * `value` : the commands, argument, usually used to set the value of
+#               a specific parameter (optional)
+#   * `expect`: the expected return value; the command is first executed
+#               without any value in order to query the current state. This
+#               state is then compared to the `expect` string; if they don't
+#               match, the command is then executed with value `expect` in
+#               order to set the parameter to the configured value (optional)
+# A command can have `expect` OR `value` configured, but it shouldn't have both
+# Print software version
+    { cmd = "QGMR" },
+# Configure audio
+    { cmd = "QDAI", expect = "1,1,0,1,0,0,1,1" },
+# RI signaling using physical RI pin
+    { cmd = "QCFG", subcmd = "risignaltype", expect = "\"physical\"" },
+# Enable VoLTE support
+    { cmd = "QCFG", subcmd = "ims", expect = "1" },
+# Disable APREADY for PP 1.0 because pin is not connected
+    { cmd = "QCFG", subcmd = "apready", expect = "0,0,500" },
+# URC configuration for PP 1.0 (APREADY pin not connected):
+#   * RING URC: extend pulse length
+#   * Incoming SMS URC: extend pulse length
+#   * Other URC: extend pulse length
+#   * Report URCs on all ports (serial and USB) for FOSS firmware
+#   * Delay reporting of URCs
+#   * Configure URC pin to UART Ring Indicator
+    { cmd = "QCFG", subcmd = "urc/ri/ring", expect = "\"pulse\",2000,1000,5000,\"off\",1" },
+    { cmd = "QCFG", subcmd = "urc/ri/smsincoming", expect = "\"pulse\",2000,1" },
+    { cmd = "QCFG", subcmd = "urc/ri/other", expect = "\"off\",1,1" },
+    { cmd = "QCFG", subcmd = "urc/delay", expect = "1" },
+    { cmd = "QCFG", subcmd = "urc/cache", expect = "0" },
+    { cmd = "QCFG", subcmd = "urc/ri/pin", expect = "uart_ri" },
+    { cmd = "QURCCFG", subcmd = "urcport", expect = "\"all\"" },
+# Allow sleeping for power saving
+    { cmd = "QSCLK", value = "1" },
+# GNSS configuration:
+#   * Enable A-GPS data upload support (XTRA)
+#   * Disable On-Demand-Positioning (ODP) mode 
+#     to avoid running the GNSS system in the background, even when not enabled.
+#   * Enable Dynamic Power Optimizations (DPO) mode to turn off GNSS RF radios 
+#     when they are not in use.
+#   * Only enable GPS and GLONASS, disable other GNSS systems.
+#     A-GPS data upload doesn't work for Galileo anyway.
+#   * Avoid turning on GNSS support automatically when the modem boots.
+    { cmd = "QGPSXTRA", expect = "1" },
+    { cmd = "QGPSCFG", subcmd = "gnssconfig", expect = "4" },
+    { cmd = "QGPSCFG", subcmd = "odpcontrol", expect = "0" },
+    { cmd = "QGPSCFG", subcmd = "dpoenable", expect = "1" },
+    { cmd = "QGPSCFG", subcmd = "gpsnmeatype", expect = "31" },
+    { cmd = "QGPSCFG", subcmd = "glonassnmeatype", expect = "7" },
+    { cmd = "QGPSCFG", subcmd = "galileonmeatype", expect = "0" },
+    { cmd = "QGPSCFG", subcmd = "beidounmeatype", expect = "0" },
+    { cmd = "QGPSCFG", subcmd = "autogps", expect = "0" },
+# Disable fast poweroff for stability
+    { cmd = "QCFG", subcmd = "fast/poweroff", expect = "0" },
+# Configure sleep and wake up pin levels to active low
+    { cmd = "QCFG", subcmd = "sleepind/level", expect = "0" },
+    { cmd = "QCFG", subcmd = "wakeupin/level", expect = "0,0" },
+# Do not enter RAMDUMP mode, auto-reset instead
+    { cmd = "QCFG", subcmd = "ApRstLevel", expect = "1" },
+    { cmd = "QCFG", subcmd = "ModemRstLevel", expect = "1" },
+]
+suspend = [
+]
+resume = [
+]
+reset = [ { cmd = "CFUN", value = "1,1" } ]
+
+[gnss]
+enabled = true
+url = "https://xtrapath4.izatcloud.net"
+file = "xtra2.bin"

data/pine64,pinephone-1.1.toml

@@ -0,0 +1,99 @@
+[manager]
+need_libusb = true
+usb_vid = 0x2c7c
+usb_pid = 0x0125
+
+# Delay between setting GPIO and PWRKEY sequence, set in microseconds
+poweron_delay = 100000
+
+# Uncomment the following if you need to change the modem detection timeout on
+# resume and/or the time during which suspend is blocked after modem boot
+#[suspend]
+#boot_timeout = 120
+#recovery_timeout = 9
+
+[gpio]
+dtr = 358
+pwrkey = 35
+reset = 68
+apready = 231
+disable = 232
+
+[at]
+uart = "/dev/ttyS2"
+configure = [
+# Each command has 4 possible elements:
+#   * `cmd`   : the AT command itself, which will be translated to "AT+`cmd`"
+#   * `subcmd`: the subcommand in case a single AT command can be used
+#               to change multiple parameters, such as QCFG (optional)
+#   * `value` : the commands, argument, usually used to set the value of
+#               a specific parameter (optional)
+#   * `expect`: the expected return value; the command is first executed
+#               without any value in order to query the current state. This
+#               state is then compared to the `expect` string; if they don't
+#               match, the command is then executed with value `expect` in
+#               order to set the parameter to the configured value (optional)
+# A command can have `expect` OR `value` configured, but it shouldn't have both
+# Print software version
+    { cmd = "QGMR" },
+# Configure audio
+    { cmd = "QDAI", expect = "1,1,0,1,0,0,1,1" },
+# RI signaling using physical RI pin
+    { cmd = "QCFG", subcmd = "risignaltype", expect = "\"physical\"" },
+# Enable VoLTE support
+    { cmd = "QCFG", subcmd = "ims", expect = "1" },
+# Disable APREADY for PP 1.1 because pin is not connected
+    { cmd = "QCFG", subcmd = "apready", expect = "0,0,500" },
+# URC configuration for PP 1.1 (APREADY pin not connected):
+#   * RING URC: extend pulse length
+#   * Incoming SMS URC: extend pulse length
+#   * Other URC: extend pulse length
+#   * Report URCs on all ports (serial and USB) for FOSS firmware
+#   * Delay reporting of URCs
+#   * Configure URC pin to UART Ring Indicator
+    { cmd = "QCFG", subcmd = "urc/ri/ring", expect = "\"pulse\",2000,1000,5000,\"off\",1" },
+    { cmd = "QCFG", subcmd = "urc/ri/smsincoming", expect = "\"pulse\",2000,1" },
+    { cmd = "QCFG", subcmd = "urc/ri/other", expect = "\"off\",1,1" },
+    { cmd = "QCFG", subcmd = "urc/delay", expect = "1" },
+    { cmd = "QCFG", subcmd = "urc/cache", expect = "0" },
+    { cmd = "QCFG", subcmd = "urc/ri/pin", expect = "uart_ri" },
+    { cmd = "QURCCFG", subcmd = "urcport", expect = "\"all\"" },
+# Allow sleeping for power saving
+    { cmd = "QSCLK", value = "1" },
+# GNSS configuration:
+#   * Enable A-GPS data upload support (XTRA)
+#   * Disable On-Demand-Positioning (ODP) mode 
+#     to avoid running the GNSS system in the background, even when not enabled.
+#   * Enable Dynamic Power Optimizations (DPO) mode to turn off GNSS RF radios 
+#     when they are not in use.
+#   * Only enable GPS and GLONASS, disable other GNSS systems.
+#     A-GPS data upload doesn't work for Galileo anyway.
+#   * Avoid turning on GNSS support automatically when the modem boots.
+    { cmd = "QGPSXTRA", expect = "1" },
+    { cmd = "QGPSCFG", subcmd = "gnssconfig", expect = "4" },
+    { cmd = "QGPSCFG", subcmd = "odpcontrol", expect = "0" },
+    { cmd = "QGPSCFG", subcmd = "dpoenable", expect = "1" },
+    { cmd = "QGPSCFG", subcmd = "gpsnmeatype", expect = "31" },
+    { cmd = "QGPSCFG", subcmd = "glonassnmeatype", expect = "7" },
+    { cmd = "QGPSCFG", subcmd = "galileonmeatype", expect = "0" },
+    { cmd = "QGPSCFG", subcmd = "beidounmeatype", expect = "0" },
+    { cmd = "QGPSCFG", subcmd = "autogps", expect = "0" },
+# Disable fast poweroff for stability
+    { cmd = "QCFG", subcmd = "fast/poweroff", expect = "0" },
+# Configure sleep and wake up pin levels to active low
+    { cmd = "QCFG", subcmd = "sleepind/level", expect = "0" },
+    { cmd = "QCFG", subcmd = "wakeupin/level", expect = "0,0" },
+# Do not enter RAMDUMP mode, auto-reset instead
+    { cmd = "QCFG", subcmd = "ApRstLevel", expect = "1" },
+    { cmd = "QCFG", subcmd = "ModemRstLevel", expect = "1" },
+]
+suspend = [
+]
+resume = [
+]
+reset = [ { cmd = "CFUN", value = "1,1" } ]
+
+[gnss]
+enabled = true
+url = "https://xtrapath4.izatcloud.net"
+file = "xtra2.bin"

data/pine64,pinephone-1.2.toml

@@ -0,0 +1,96 @@
+[manager]
+# Delay between setting GPIO and PWRKEY sequence, set in microseconds
+poweron_delay = 100000
+
+# Uncomment the following if you need to change the modem detection timeout on
+# resume and/or the time during which suspend is blocked after modem boot
+#[suspend]
+#boot_timeout = 120
+#recovery_timeout = 9
+
+[gpio]
+dtr = 34
+pwrkey = 35
+reset = 68
+apready = 231
+disable = 232
+status = 233
+
+[at]
+uart = "/dev/ttyS2"
+configure = [
+# Each command has 4 possible elements:
+#   * `cmd`   : the AT command itself, which will be translated to "AT+`cmd`"
+#   * `subcmd`: the subcommand in case a single AT command can be used
+#               to change multiple parameters, such as QCFG (optional)
+#   * `value` : the commands, argument, usually used to set the value of
+#               a specific parameter (optional)
+#   * `expect`: the expected return value; the command is first executed
+#               without any value in order to query the current state. This
+#               state is then compared to the `expect` string; if they don't
+#               match, the command is then executed with value `expect` in
+#               order to set the parameter to the configured value (optional)
+# A command can have `expect` OR `value` configured, but it shouldn't have both
+# Print software version
+    { cmd = "QGMR" },
+# Configure audio
+    { cmd = "QDAI", expect = "1,1,0,1,0,0,1,1" },
+# RI signaling using physical RI pin
+    { cmd = "QCFG", subcmd = "risignaltype", expect = "\"physical\"" },
+# Enable VoLTE support
+    { cmd = "QCFG", subcmd = "ims", expect = "1" },
+# Enable APREADY for PP 1.2
+    { cmd = "QCFG", subcmd = "apready", expect = "1,0,500" },
+# URC configuration for PP 1.2 (APREADY pin connected):
+#   * RING URC: normal pulse length
+#   * Incoming SMS URC: default pulse length
+#   * Other URC: default length
+#   * Report URCs on all ports (serial and USB) for FOSS firmware
+#   * Reporting of URCs without any delay
+#   * Configure URC pin to UART Ring Indicator
+    { cmd = "QCFG", subcmd = "urc/ri/ring", expect = "\"pulse\",120,1000,5000,\"off\",1" },
+    { cmd = "QCFG", subcmd = "urc/ri/smsincoming", expect = "\"pulse\",120,1" },
+    { cmd = "QCFG", subcmd = "urc/ri/other", expect = "\"off\",1,1" },
+    { cmd = "QCFG", subcmd = "urc/delay", expect = "0" },
+    { cmd = "QCFG", subcmd = "urc/cache", expect = "0" },
+    { cmd = "QCFG", subcmd = "urc/ri/pin", expect = "uart_ri" },
+    { cmd = "QURCCFG", subcmd = "urcport", expect = "\"all\"" },
+# Allow sleeping for power saving
+    { cmd = "QSCLK", value = "1" },
+# GNSS configuration:
+#   * Enable A-GPS data upload support (XTRA)
+#   * Disable On-Demand-Positioning (ODP) mode 
+#     to avoid running the GNSS system in the background, even when not enabled.
+#   * Enable Dynamic Power Optimizations (DPO) mode to turn off GNSS RF radios 
+#     when they are not in use.
+#   * Only enable GPS and GLONASS, disable other GNSS systems.
+#     A-GPS data upload doesn't work for Galileo anyway.
+#   * Avoid turning on GNSS support automatically when the modem boots.
+    { cmd = "QGPSXTRA", expect = "1" },
+    { cmd = "QGPSCFG", subcmd = "gnssconfig", expect = "4" },
+    { cmd = "QGPSCFG", subcmd = "odpcontrol", expect = "0" },
+    { cmd = "QGPSCFG", subcmd = "dpoenable", expect = "1" },
+    { cmd = "QGPSCFG", subcmd = "gpsnmeatype", expect = "31" },
+    { cmd = "QGPSCFG", subcmd = "glonassnmeatype", expect = "7" },
+    { cmd = "QGPSCFG", subcmd = "galileonmeatype", expect = "0" },
+    { cmd = "QGPSCFG", subcmd = "beidounmeatype", expect = "0" },
+    { cmd = "QGPSCFG", subcmd = "autogps", expect = "0" },
+# Disable fast poweroff for stability
+    { cmd = "QCFG", subcmd = "fast/poweroff", expect = "0" },
+# Configure sleep and wake up pin levels to active low
+    { cmd = "QCFG", subcmd = "sleepind/level", expect = "0" },
+    { cmd = "QCFG", subcmd = "wakeupin/level", expect = "0,0" },
+# Do not enter RAMDUMP mode, auto-reset instead
+    { cmd = "QCFG", subcmd = "ApRstLevel", expect = "1" },
+    { cmd = "QCFG", subcmd = "ModemRstLevel", expect = "1" },
+]
+suspend = [
+]
+resume = [
+]
+reset = [ { cmd = "CFUN", value = "1,1" } ]
+
+[gnss]
+enabled = true
+url = "https://xtrapath4.izatcloud.net"
+file = "xtra2.bin"

meson.build

@@ -6,9 +6,9 @@
 #
 
 project (
-  'eg25manager',
+  'eg25-manager',
   'c',
-  version : '0.0.1',
+  version : '0.4.0',
   license : 'GPLv3+',
   meson_version : '>= 0.50.0',
   default_options :
@@ -27,6 +27,7 @@ prefix = get_option('prefix')
 datadir = get_option('datadir')
 sysconfdir = get_option('sysconfdir')
 bindir = join_paths(prefix, get_option('bindir'))
+udevrulesdir = join_paths(prefix, 'lib/udev/rules.d')
 
 if datadir.startswith('/')
   full_datadir = datadir
@@ -40,11 +41,27 @@ else
   full_sysconfdir = join_paths(prefix, sysconfdir)
 endif
 
+eg25_confdir = join_paths(full_sysconfdir, meson.project_name())
+eg25_datadir = join_paths(full_datadir, meson.project_name())
+
+add_global_arguments('-D@0@="@1@"'.format('EG25_CONFDIR', eg25_confdir), language : 'c')
+add_global_arguments('-D@0@="@1@"'.format('EG25_DATADIR', eg25_datadir), language : 'c')
+
+mmglib_dep = dependency('mm-glib', required : false)
+if mmglib_dep.found()
+  add_global_arguments('-DHAVE_MMGLIB=1', language : 'c')
+endif
+
 mgr_deps = [
     dependency('glib-2.0'),
     dependency('gio-unix-2.0'),
+    dependency('gudev-1.0'),
     dependency('libgpiod'),
-    dependency('mm-glib'),
+    dependency('libusb-1.0'),
+    dependency('libcurl'),
+    mmglib_dep,
 ]
 
+subdir('data')
 subdir('src')
+subdir('udev')

src/at.c

@@ -6,6 +6,8 @@
 
 #include "at.h"
 #include "suspend.h"
+#include "gpio.h"
+#include "gnss.h"
 
 #include <fcntl.h>
 #include <stdio.h>
@@ -16,22 +18,17 @@
 
 #include <glib-unix.h>
 
-#define MODEM_UART "/dev/ttyS2"
-
-struct AtCommand {
-    char *cmd;
-    char *subcmd;
-    char *value;
-    char *expected;
-    int retries;
-};
+static GArray *configure_commands = NULL;
+static GArray *suspend_commands = NULL;
+static GArray *resume_commands = NULL;
+static GArray *reset_commands = NULL;
 
 static int configure_serial(const char *tty)
 {
     struct termios ttycfg;
     int fd;
 
-    fd = open(tty, O_RDWR | O_NOCTTY);
+    fd = open(tty, O_RDWR | O_NOCTTY | O_NONBLOCK);
     if (fd > 0) {
         tcgetattr(fd, &ttycfg);
         ttycfg.c_iflag &= ~(IGNBRK | BRKINT | ICRNL | INLCR | PARMRK | INPCK | ISTRIP | IXON);
@@ -49,101 +46,128 @@ static int configure_serial(const char *tty)
     return fd;
 }
 
-static gboolean send_at_command(struct EG25Manager *manager)
+gboolean at_send_command(struct EG25Manager *manager)
 {
     char command[256];
-    struct AtCommand *at_cmd = g_list_nth_data(manager->at_cmds, 0);
+    struct AtCommand *at_cmd = manager->at_cmds ? g_list_nth_data(manager->at_cmds, 0) : NULL;
+    int ret, len = 0;
 
     if (at_cmd) {
-        if (at_cmd->subcmd == NULL && at_cmd->value == NULL)
-            sprintf(command, "AT+%s?\r\n", at_cmd->cmd);
-        else if (at_cmd->subcmd == NULL && at_cmd->value)
-            sprintf(command, "AT+%s=%s\r\n", at_cmd->cmd, at_cmd->value);
-        else if (at_cmd->subcmd && at_cmd->value == NULL)
-            sprintf(command, "AT+%s=\"%s\"\r\n", at_cmd->cmd, at_cmd->subcmd);
-        else if (at_cmd->subcmd && at_cmd->value)
-            sprintf(command, "AT+%s=\"%s\",%s\r\n", at_cmd->cmd, at_cmd->subcmd, at_cmd->value);
+    	/* Wake up the modem from soft sleep before sending an AT command */
+    	gpio_sequence_wake(manager);
 
-        write(manager->at_fd, command, strlen(command));
+	/* Send AT command */
+        if (at_cmd->subcmd == NULL && at_cmd->value == NULL && at_cmd->expected == NULL)
+            len = sprintf(command, "AT+%s\r\n", at_cmd->cmd);
+        else if (at_cmd->subcmd == NULL && at_cmd->value == NULL)
+            len = sprintf(command, "AT+%s?\r\n", at_cmd->cmd);
+        else if (at_cmd->subcmd == NULL && at_cmd->value)
+            len = sprintf(command, "AT+%s=%s\r\n", at_cmd->cmd, at_cmd->value);
+        else if (at_cmd->subcmd && at_cmd->value == NULL)
+            len = sprintf(command, "AT+%s=\"%s\"\r\n", at_cmd->cmd, at_cmd->subcmd);
+        else if (at_cmd->subcmd && at_cmd->value)
+            len = sprintf(command, "AT+%s=\"%s\",%s\r\n", at_cmd->cmd, at_cmd->subcmd, at_cmd->value);
+        manager->at_callback = at_cmd->callback;
+
+        ret = write(manager->at_fd, command, len);
+        if (ret < len)
+            g_warning("Couldn't write full AT command: wrote %d/%d bytes", ret, len);
 
         g_message("Sending command: %s", g_strstrip(command));
-    } else if (manager->modem_state < EG25_STATE_CONFIGURED) {
-        MMModemState modem_state = mm_modem_get_state(manager->mm_modem);
+    } else {
+    	/* Allow the modem to enter soft sleep again when we sent the AT command*/
+    	gpio_sequence_sleep(manager);
+	
+	if (manager->modem_state < EG25_STATE_CONFIGURED) {
+	    if (manager->modem_iface == MODEM_IFACE_MODEMMANAGER) {
+#ifdef HAVE_MMGLIB
+                MMModemState modem_state = mm_modem_get_state(manager->mm_modem);
 
-        if (manager->mm_modem && modem_state >= MM_MODEM_STATE_REGISTERED)
-            modem_update_state(manager, modem_state);
-        else
-            manager->modem_state = EG25_STATE_CONFIGURED;
-    } else if (manager->modem_state == EG25_STATE_SUSPENDING) {
-        g_message("suspend sequence is over, drop inhibitor");
-        suspend_inhibit(manager, FALSE);
-    } else if (manager->modem_state == EG25_STATE_RESETTING) {
-        manager->modem_state = EG25_STATE_POWERED;
+		if (manager->mm_modem && modem_state >= MM_MODEM_STATE_REGISTERED)
+                    modem_update_state(manager, modem_state);
+		else
+                    manager->modem_state = EG25_STATE_CONFIGURED;
+#endif
+            } else {
+                manager->modem_state = EG25_STATE_CONFIGURED;
+	    }
+        } else if (manager->modem_state == EG25_STATE_SUSPENDING) {
+            modem_suspend_post(manager);
+        } else if (manager->modem_state == EG25_STATE_RESETTING) {
+            manager->modem_state = EG25_STATE_POWERED;
+        }
     }
 
     return FALSE;
 }
 
-static void next_at_command(struct EG25Manager *manager)
+void at_next_command(struct EG25Manager *manager)
 {
-    struct AtCommand *at_cmd = g_list_nth_data(manager->at_cmds, 0);
+    struct AtCommand *at_cmd = manager->at_cmds ? g_list_nth_data(manager->at_cmds, 0) : NULL;
 
-    if (at_cmd->cmd)
-        g_free(at_cmd->cmd);
-    if (at_cmd->subcmd)
-        g_free(at_cmd->subcmd);
-    if (at_cmd->value)
-        g_free(at_cmd->value);
-    if (at_cmd->expected)
-        g_free(at_cmd->expected);
+    if (!at_cmd)
+        return;
+
+    g_free(at_cmd->cmd);
+    g_free(at_cmd->subcmd);
+    g_free(at_cmd->value);
+    g_free(at_cmd->expected);
     g_free(at_cmd);
     manager->at_cmds = g_list_remove(manager->at_cmds, at_cmd);
 
-    send_at_command(manager);
+    at_send_command(manager);
 }
 
 static void retry_at_command(struct EG25Manager *manager)
 {
-    struct AtCommand *at_cmd = g_list_nth_data(manager->at_cmds, 0);
+    struct AtCommand *at_cmd = manager->at_cmds ? g_list_nth_data(manager->at_cmds, 0) : NULL;
+
+    if (!at_cmd)
+        return;
 
     at_cmd->retries++;
     if (at_cmd->retries > 3) {
         g_critical("Command %s retried %d times, aborting...", at_cmd->cmd, at_cmd->retries);
-        next_at_command(manager);
+        at_next_command(manager);
     } else {
-        g_timeout_add_seconds(3, G_SOURCE_FUNC(send_at_command), manager);
+        g_timeout_add(500, G_SOURCE_FUNC(at_send_command), manager);
     }
 }
 
-static void process_at_result(struct EG25Manager *manager, char *response)
+void at_process_result(struct EG25Manager *manager,
+                       const char         *response)
 {
-    struct AtCommand *at_cmd = g_list_nth_data(manager->at_cmds, 0);
+    struct AtCommand *at_cmd = manager->at_cmds ? g_list_nth_data(manager->at_cmds, 0) : NULL;
+
+    if (!at_cmd)
+        return;
 
     if (at_cmd->expected && !strstr(response, at_cmd->expected)) {
-        if (at_cmd->value)
-            g_free(at_cmd->value);
+        g_free(at_cmd->value);
         at_cmd->value = at_cmd->expected;
-        at_cmd->expected = NULL;
         g_message("Got a different result than expected, changing value...");
-        g_message("\t%s\n\t%s", at_cmd->expected, response);
-        send_at_command(manager);
+        g_message("Expected: [%s]\nResponse: [%s]", at_cmd->expected, response);
+        at_cmd->expected = NULL;
+        at_send_command(manager);
     } else {
-        next_at_command(manager);
+        at_next_command(manager);
     }
 }
 
-static int append_at_command(struct EG25Manager *manager,
-                             const char         *cmd,
-                             const char         *subcmd,
-                             const char         *value,
-                             const char         *expected)
+int at_append_command(struct EG25Manager *manager,
+                      const char         *cmd,
+                      const char         *subcmd,
+                      const char         *value,
+                      const char         *expected,
+                      void              (*callback)
+                                        (struct EG25Manager *manager,
+                                         const char *response))
 {
     struct AtCommand *at_cmd = calloc(1, sizeof(struct AtCommand));
 
     if (!at_cmd)
         return -1;
 
-    at_cmd->retries = 0;
     at_cmd->cmd = g_strdup(cmd);
     if (subcmd)
         at_cmd->subcmd = g_strdup(subcmd);
@@ -151,55 +175,168 @@ static int append_at_command(struct EG25Manager *manager,
         at_cmd->value = g_strdup(value);
     if (expected)
         at_cmd->expected = g_strdup(expected);
+    if (callback)
+        at_cmd->callback = callback;
 
     manager->at_cmds = g_list_append(manager->at_cmds, at_cmd);
 
     return 0;
 }
 
+#define READ_BUFFER_SIZE 256
+
 static gboolean modem_response(gint fd,
                                GIOCondition event,
                                gpointer data)
 {
     struct EG25Manager *manager = data;
-    char response[256];
-    int ret;
+    char response[READ_BUFFER_SIZE*4+1];
+    char tmp[READ_BUFFER_SIZE];
+    ssize_t ret, pos = 0;
 
     /*
-     * TODO: several reads can be necessary to get the full response, we could
-     * loop until we read 0 chars with a reasonable delay between attempts
+     * Several reads can be necessary to get the full response, so we loop
+     * until we read 0 chars with a reasonable delay between attempts
      * (remember the transfer rate is 115200 here)
      */
-    ret = read(fd, response, sizeof(response));
-    if (ret > 0) {
-        response[ret] = 0;
+    do {
+        ret = read(fd, tmp, sizeof(tmp));
+        if (ret > 0) {
+            memcpy(&response[pos], tmp, ret);
+            pos += ret;
+            usleep(10000);
+        }
+    } while (ret > 0 && pos < (sizeof(response) - 1));
+
+    if (pos > 0) {
+        response[pos] = 0;
         g_strstrip(response);
         if (strlen(response) == 0)
             return TRUE;
 
         g_message("Response: [%s]", response);
 
-        if (strcmp(response, "RDY") == 0)
+        /*
+         * When the modem is started, it outputs 'RDY' to indicate that
+         * it is ready to receive AT commands.
+         */
+        if (strcmp(response, "RDY") == 0) {
+            suspend_inhibit(manager, TRUE, TRUE);
             manager->modem_state = EG25_STATE_STARTED;
-        else if (strcmp(response, "ERROR") == 0)
+        }
+        /*
+         * Search for 'QGPSURC: "xtradataexpire"' in response to detect
+         * if GNSS assistance data must be re-uploaded.
+         * If that's the case, check if no AT commands are being processed
+         * to avoid deadlocks and start upload.
+         */
+        else if (strstr(response, "QGPSURC: \"xtradataexpire\"") && manager->at_cmds == NULL)
+            gnss_upload_assistance_data(manager);
+        /*
+         * AT command failed, retry.
+         * QCFG="fast/poweroff" configuration is only available in
+         * newer firmware versions, skip retrying that specific AT command.
+         */
+        else if (strstr(response, "ERROR") && !strstr(response, "fast/poweroff"))
             retry_at_command(manager);
-        else if (strstr(response, "OK"))
-            process_at_result(manager, response);
+        /*
+         * Successfull AT responses contain 'OK', except for AT+QFUPL which also
+         * returns 'CONNECT' when the modem is ready to receive data over serial
+         */
+        else if (strstr(response, "OK") || strstr(response, "CONNECT")) {
+            if (manager->at_callback != NULL)
+                manager->at_callback(manager, response);
+            else
+                g_warning("AT command succesfull but no callback registered");
+        }
+        /* Not a recognized response, try running next command, just in case */
+        else
+            at_next_command(manager);
     }
 
     return TRUE;
 }
 
-int at_init(struct EG25Manager *manager)
+static void parse_commands_list(toml_array_t *array, GArray **cmds)
 {
-    manager->at_fd = configure_serial(MODEM_UART);
+    int len;
+
+    len = toml_array_nelem(array);
+    *cmds = g_array_new(FALSE, TRUE, sizeof(struct AtCommand));
+    g_array_set_size(*cmds, (guint)len);
+    for (int i = 0; i < len; i++) {
+        struct AtCommand *cmd = &g_array_index(*cmds, struct AtCommand, i);
+        toml_table_t *table = toml_table_at(array, i);
+        toml_datum_t value;
+
+        if (!table)
+            continue;
+
+        value = toml_string_in(table, "cmd");
+        if (value.ok) {
+            cmd->cmd = g_strdup(value.u.s);
+            free(value.u.s);
+        }
+
+        value = toml_string_in(table, "subcmd");
+        if (value.ok) {
+            cmd->subcmd = g_strdup(value.u.s);
+            free(value.u.s);
+        }
+
+        value = toml_string_in(table, "value");
+        if (value.ok) {
+            cmd->value = g_strdup(value.u.s);
+            free(value.u.s);
+        }
+
+        value = toml_string_in(table, "expect");
+        if (value.ok) {
+            cmd->expected = g_strdup(value.u.s);
+            free(value.u.s);
+        }
+    }
+}
+
+int at_init(struct EG25Manager *manager, toml_table_t *config)
+{
+    toml_array_t *commands;
+    toml_datum_t uart_port;
+
+    uart_port = toml_string_in(config, "uart");
+    if (!uart_port.ok)
+        g_error("Configuration file lacks UART port definition");
+
+    manager->at_fd = configure_serial(uart_port.u.s);
     if (manager->at_fd < 0) {
-        g_critical("Unable to configure %s", MODEM_UART);
+        g_critical("Unable to configure %s", uart_port.u.s);
+        free(uart_port.u.s);
         return 1;
     }
+    free(uart_port.u.s);
 
     manager->at_source = g_unix_fd_add(manager->at_fd, G_IO_IN, modem_response, manager);
 
+    commands = toml_array_in(config, "configure");
+    if (!commands)
+        g_error("Configuration file lacks initial AT commands list");
+    parse_commands_list(commands, &configure_commands);
+
+    commands = toml_array_in(config, "suspend");
+    if (!commands)
+        g_error("Configuration file lacks suspend AT commands list");
+    parse_commands_list(commands, &suspend_commands);
+
+    commands = toml_array_in(config, "resume");
+    if (!commands)
+        g_error("Configuration file lacks resume AT commands list");
+    parse_commands_list(commands, &resume_commands);
+
+    commands = toml_array_in(config, "reset");
+    if (!commands)
+        g_error("Configuration file lacks reset AT commands list");
+    parse_commands_list(commands, &reset_commands);
+
     return 0;
 }
 
@@ -208,61 +345,45 @@ void at_destroy(struct EG25Manager *manager)
     g_source_remove(manager->at_source);
     if (manager->at_fd > 0)
         close(manager->at_fd);
+
+    g_array_free(configure_commands, TRUE);
+    g_array_free(suspend_commands, TRUE);
+    g_array_free(resume_commands, TRUE);
+    g_array_free(reset_commands, TRUE);
 }
 
 void at_sequence_configure(struct EG25Manager *manager)
 {
-    /*
-     * Default parameters in megi's driver which differ with our own:
-     *   - urc/ri/* are always set the same way on both BH and CE
-     *   - urc/ri/* pulse duration is 1 ms and urc/delay is 0 (no need to delay
-     *     URCs if the pulse is that short)
-     *   - apready is disabled
-     *
-     * Parameters set in megi's kernel but not here:
-     *   - sleepind/level = 0
-     *   - wakeupin/level = 0
-     *   - ApRstLevel = 0
-     *   - ModemRstLevel = 0
-     *   - airplanecontrol = 1
-     *   - fast/poweroff = 1
-     * (those would need to be researched to check their usefulness for our
-     * use-case)
-     */
-
-    append_at_command(manager, "QDAI", NULL, NULL, "1,1,0,1,0,0,1,1");
-    append_at_command(manager, "QCFG", "risignaltype", NULL, "\"physical\"");
-    append_at_command(manager, "QCFG", "ims", NULL, "1");
-    if (manager->braveheart) {
-        append_at_command(manager, "QCFG", "urc/ri/ring", NULL, "\"pulse\",2000,1000,5000,\"off\",1");
-        append_at_command(manager, "QCFG", "urc/ri/smsincoming", NULL, "\"pulse\",2000");
-        append_at_command(manager, "QCFG", "urc/ri/other", NULL, "\"off\",1");
-        append_at_command(manager, "QCFG", "urc/delay", NULL, "1");
-    } else {
-        append_at_command(manager, "QCFG", "apready", NULL, "1,0,500");
+    for (guint i = 0; i < configure_commands->len; i++) {
+        struct AtCommand *cmd = &g_array_index(configure_commands, struct AtCommand, i);
+        at_append_command(manager, cmd->cmd, cmd->subcmd, cmd->value, cmd->expected, at_process_result);
     }
-    append_at_command(manager, "QURCCFG", "urcport", NULL, "\"usbat\"");
-    append_at_command(manager, "QGPS", NULL, NULL, "1");
-    append_at_command(manager, "QSCLK", NULL, "1", NULL);
-    send_at_command(manager);
+    at_send_command(manager);
 }
 
 void at_sequence_suspend(struct EG25Manager *manager)
 {
-    append_at_command(manager, "QGPS", NULL, NULL, "0");
-    append_at_command(manager, "QCFG", "urc/cache", "1", NULL);
-    send_at_command(manager);
+    for (guint i = 0; i < suspend_commands->len; i++) {
+        struct AtCommand *cmd = &g_array_index(suspend_commands, struct AtCommand, i);
+        at_append_command(manager, cmd->cmd, cmd->subcmd, cmd->value, cmd->expected, at_process_result);
+    }
+    at_send_command(manager);
 }
 
 void at_sequence_resume(struct EG25Manager *manager)
 {
-    append_at_command(manager, "QCFG", "urc/cache", "0", NULL);
-    append_at_command(manager, "QGPS", NULL, NULL, "1");
-    send_at_command(manager);
+    for (guint i = 0; i < resume_commands->len; i++) {
+        struct AtCommand *cmd = &g_array_index(resume_commands, struct AtCommand, i);
+        at_append_command(manager, cmd->cmd, cmd->subcmd, cmd->value, cmd->expected, at_process_result);
+    }
+    at_send_command(manager);
 }
 
 void at_sequence_reset(struct EG25Manager *manager)
 {
-    append_at_command(manager, "CFUN", NULL, "1,1", NULL);
-    send_at_command(manager);
+    for (guint i = 0; i < reset_commands->len; i++) {
+        struct AtCommand *cmd = &g_array_index(reset_commands, struct AtCommand, i);
+        at_append_command(manager, cmd->cmd, cmd->subcmd, cmd->value, cmd->expected, at_process_result);
+    }
+    at_send_command(manager);
 }

src/at.h

@@ -8,10 +8,32 @@
 
 #include "manager.h"
 
-int at_init(struct EG25Manager *data);
-void at_destroy(struct EG25Manager *data);
+typedef struct AtCommand {
+    char *cmd;
+    char *subcmd;
+    char *value;
+    char *expected;
+    void (*callback)(struct EG25Manager *manager, const char *response);
+    int retries;
+} AtCommand;
 
-void at_sequence_configure(struct EG25Manager *data);
-void at_sequence_suspend(struct EG25Manager *data);
-void at_sequence_resume(struct EG25Manager *data);
-void at_sequence_reset(struct EG25Manager *data);
+int at_init(struct EG25Manager *manager, toml_table_t *config);
+void at_destroy(struct EG25Manager *manager);
+
+void at_process_result(struct EG25Manager *manager,
+                       const char         *response);
+void at_next_command(struct EG25Manager *manager);
+gboolean at_send_command(struct EG25Manager *manager);
+int at_append_command(struct EG25Manager *manager,
+                      const char         *cmd,
+                      const char         *subcmd,
+                      const char         *value,
+                      const char         *expected,
+                      void              (*callback)
+                                        (struct EG25Manager *manager,
+                                         const char *response));
+
+void at_sequence_configure(struct EG25Manager *manager);
+void at_sequence_suspend(struct EG25Manager *manager);
+void at_sequence_resume(struct EG25Manager *manager);
+void at_sequence_reset(struct EG25Manager *manager);

src/gnss.c

@@ -0,0 +1,488 @@
+/*
+ * Copyright (C) 2021 Dylan Van Assche <me@dylanvanassche.be>
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#include "gnss.h"
+#include "manager.h"
+#include "at.h"
+
+#define BUFFER_SIZE 256
+#define UPLOAD_DELAY 100000
+#define RESCHEDULE_IN_SECS 30
+
+static void gnss_step(struct EG25Manager *manager);
+
+gboolean gnss_upload_assistance_data(struct EG25Manager *manager)
+{
+    if (!manager->gnss_assistance_enabled) {
+        g_message("GNSS assistance is disabled!");
+        return FALSE;
+    }
+
+    if (manager->gnss_assistance_step < EG25_GNSS_STEP_LAST) {
+        g_warning("GNSS assistance data upload already in process (%d/%d)",
+                  manager->gnss_assistance_step, EG25_GNSS_STEP_LAST);
+        return FALSE;
+    }
+
+    /* ModemManager's Location is only available after unlocking */
+    if(!manager->mm_location) {
+        g_message ("Rescheduling upload since Location interface is not available, in %ds",
+                   RESCHEDULE_IN_SECS);
+        manager->gnss_assistance_step = EG25_GNSS_STEP_LAST;
+        return TRUE;
+    }
+
+    manager->gnss_assistance_step = EG25_GNSS_STEP_FIRST;
+    gnss_step(manager);
+    return FALSE;
+}
+
+void gnss_init(struct EG25Manager *manager, toml_table_t *config)
+{
+    toml_datum_t enabled;
+    toml_datum_t url;
+    toml_datum_t file;
+    g_autoptr (GError) error = NULL;
+
+    /*
+     * GNSS assistance is an optional feature, you can disable it
+     * if you want in the configuration file.
+     * In case the configuration is missing, we assume GNSS assistance
+     * to be disabled.
+     */
+    enabled = toml_bool_in(config, "enabled");
+    manager->gnss_assistance_enabled = FALSE;
+    if (enabled.ok)
+        manager->gnss_assistance_enabled = enabled.u.b;
+
+    if (!manager->gnss_assistance_enabled) {
+        g_message("GNSS assistance is disabled!");
+        return;
+    }
+
+    url = toml_string_in(config, "url");
+    if (url.ok)
+        manager->gnss_assistance_url = url.u.s;
+    else
+        g_error("GNSS assistance server URL is missing from config file");
+    file = toml_string_in(config, "file");
+    if (file.ok)
+        manager->gnss_assistance_file = file.u.s;
+    else
+        g_error("GNSS assistance file name is missing from config file");
+
+    /* Create temporary file to store assistance data */
+    manager->gnss_assistance_fd = g_file_open_tmp(NULL, NULL, &error);
+    if (error != NULL)
+        g_error ("Unable to create temporary file: %s", error->message);
+
+    /* Initialize state and schedule upload */
+    manager->gnss_assistance_step = EG25_GNSS_STEP_LAST;
+    g_timeout_add_seconds(RESCHEDULE_IN_SECS,
+                          G_SOURCE_FUNC(gnss_upload_assistance_data), manager);
+}
+
+void gnss_destroy(struct EG25Manager *manager)
+{
+    close(manager->gnss_assistance_fd);
+}
+
+/******************************************************************************/
+
+#ifdef HAVE_MMGLIB
+static void disable_mm_gnss(struct EG25Manager *manager)
+{
+    MMModemLocationSource sources;
+    gboolean signals_location;
+    g_autoptr (GError) error = NULL;
+
+    sources = mm_modem_location_get_enabled(manager->mm_location);
+    signals_location = mm_modem_location_signals_location(manager->mm_location);
+    manager->gnss_sources = EG25_GNSS_SOURCE_NONE;
+
+    /* Save GNSS engine state */
+    if (sources & MM_MODEM_LOCATION_SOURCE_GPS_NMEA)
+        manager->gnss_sources |= EG25_GNSS_SOURCE_NMEA;
+    else
+        manager->gnss_sources &= ~EG25_GNSS_SOURCE_NMEA;
+
+    if (sources & MM_MODEM_LOCATION_SOURCE_GPS_RAW)
+        manager->gnss_sources |= EG25_GNSS_SOURCE_RAW;
+    else
+        manager->gnss_sources &= ~EG25_GNSS_SOURCE_RAW;
+
+    if (sources & MM_MODEM_LOCATION_SOURCE_GPS_UNMANAGED)
+        manager->gnss_sources |= EG25_GNSS_SOURCE_UNMANAGED;
+    else
+        manager->gnss_sources &= ~EG25_GNSS_SOURCE_UNMANAGED;
+
+    /* Disable GNSS engine */
+    sources &= ~MM_MODEM_LOCATION_SOURCE_GPS_RAW;
+    sources &= ~MM_MODEM_LOCATION_SOURCE_GPS_NMEA;
+    sources &= ~MM_MODEM_LOCATION_SOURCE_GPS_UNMANAGED;
+    mm_modem_location_setup_sync(manager->mm_location, sources,
+                                 signals_location, NULL, &error);
+    if (error != NULL) {
+        g_warning("Unable to disable GNSS engine through ModemManager: %s",
+                  error->message);
+    }
+}
+#endif
+
+static void disable_at_gnss_cb(struct EG25Manager *manager,
+                               const char *response)
+{
+    /* Clear QGPSEND AT command and process next */
+    at_next_command(manager);
+
+    /* Go to the next step */
+    manager->gnss_assistance_step++;
+    gnss_step(manager);
+}
+
+static void state_at_gnss_cb(struct EG25Manager *manager, const char *response)
+{
+    struct AtCommand *at_cmd = manager->at_cmds ? g_list_nth_data(manager->at_cmds, 0) : NULL;
+
+    if (!at_cmd)
+        return;
+
+    /* Parse GNSS engine status and disable it if needed */
+    if (strstr(response, "QGPS: 1")) {
+        manager->gnss_sources |= EG25_GNSS_SOURCE_QGPS;
+        g_free(at_cmd->value);
+        g_free(at_cmd->cmd);
+        at_cmd->expected = NULL;
+        at_cmd->subcmd = NULL;
+        at_cmd->value = NULL;
+        at_cmd->cmd = g_strdup("QGPSEND");
+        at_cmd->callback = disable_at_gnss_cb;
+        at_send_command(manager);
+    }
+    /* QGPS is already disabled, move on to next step */
+    else {
+        at_next_command(manager);
+        manager->gnss_sources &= ~EG25_GNSS_SOURCE_QGPS;
+        manager->gnss_assistance_step++;
+        gnss_step(manager);
+    }
+}
+
+static void state_at_gnss(struct EG25Manager *manager)
+{
+    /* Asynchronously send AT command to query status of GNSS engine */
+    at_append_command(manager, "QGPS?", NULL, NULL, NULL, state_at_gnss_cb);
+    at_send_command(manager);
+}
+
+/******************************************************************************/
+
+static void fetch_assistance_data(struct EG25Manager *manager)
+{
+    CURL *curl;
+    CURLcode response;
+    long status_code;
+    gchar *url = NULL;
+    FILE *tmp_file = NULL;
+    long int size;
+
+    /* Fetch assistance data with curl */
+    tmp_file = fdopen(manager->gnss_assistance_fd, "wb");
+    url = g_strconcat(manager->gnss_assistance_url, "/",
+                      manager->gnss_assistance_file, NULL);
+    curl = curl_easy_init();
+    if (!curl)
+        g_error ("Unable to initialize curl");
+    curl_easy_setopt(curl, CURLOPT_URL, url);
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, NULL);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, tmp_file);
+    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+    curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1L);
+    response = curl_easy_perform(curl);
+    if (response == CURLE_HTTP_RETURNED_ERROR) {
+        curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &status_code);
+        curl_easy_cleanup(curl);
+        g_warning ("Unable to fetch GNSS assistance data from %s (HTTP %ld)",
+                   url, status_code);
+
+        /* Restart upload on HTTP error status code */
+        g_message ("Rescheduling upload because of failure in %ds",
+                   RESCHEDULE_IN_SECS);
+        manager->gnss_assistance_step = EG25_GNSS_STEP_LAST;
+        g_timeout_add_seconds(RESCHEDULE_IN_SECS,
+                              G_SOURCE_FUNC(gnss_upload_assistance_data),
+                              manager);
+        return;
+    }
+
+    /* Get file size in bytes */
+    size = (long int)lseek(manager->gnss_assistance_fd, 0, SEEK_END);
+    lseek(manager->gnss_assistance_fd, 0, SEEK_SET);
+
+    if (size <= 0) {
+        g_warning ("GNSS assistance data contains 0 bytes,"
+                   "check network connection.");
+        /*
+         * Restart upload when file does not contain any data,
+         * mostly because of no network connection.
+         */
+        g_message ("Rescheduling upload because of failure in %ds",
+                   RESCHEDULE_IN_SECS);
+        manager->gnss_assistance_step = EG25_GNSS_STEP_LAST;
+        g_timeout_add_seconds(RESCHEDULE_IN_SECS,
+                              G_SOURCE_FUNC(gnss_upload_assistance_data),
+                              manager);
+        return;
+    }
+
+    g_message("Fetching GNSS assistance data from %s was successfull", url);
+    curl_easy_cleanup(curl);
+    g_free(url);
+
+    /* Go to the next step */
+    manager->gnss_assistance_step++;
+    gnss_step(manager);
+}
+
+/******************************************************************************/
+
+static void init_assistance_data_upload_ready(struct EG25Manager *manager,
+                                              const char *response)
+{
+    /* Search for 'CONNECT' in response to start upload */
+    if (strstr(response, "CONNECT")) {
+        g_message("Modem ready for GNSS assistance data upload");
+        manager->gnss_assistance_step++;
+        gnss_step(manager);
+    }
+}
+
+static void init_assistance_data_upload_start(struct EG25Manager *manager,
+                                              const char *response)
+{
+    gchar value[BUFFER_SIZE];
+    long int size;
+
+    /* Process AT response */
+    at_process_result(manager, response);
+
+    /* Get file size in bytes */
+    size = (long int)lseek(manager->gnss_assistance_fd, 0, SEEK_END);
+    lseek(manager->gnss_assistance_fd, 0, SEEK_SET);
+
+    /* Start upload */
+    g_snprintf(value, BUFFER_SIZE, "\"RAM:%s\",%ld\r\n",
+               manager->gnss_assistance_file, size);
+    g_message("Initiate GNSS assistance data upload: %s", value);
+    at_append_command(manager, "QFUPL", NULL, value, NULL,
+                      init_assistance_data_upload_ready);
+    at_send_command(manager);
+}
+
+static void init_assistance_data_upload(struct EG25Manager *manager)
+{
+    /*
+     * Delete all previous GNSS assistance data files in RAM
+     * and start uploading the latest one to RAM.
+     */
+    at_append_command(manager, "QFDEL", NULL, "\"RAM:*\"\r\n",
+                         NULL, init_assistance_data_upload_start);
+    at_send_command(manager);
+}
+
+static void upload_assistance_data(struct EG25Manager *manager)
+{
+    char buffer[2*BUFFER_SIZE];
+    gint len;
+    gboolean success = TRUE;
+
+    /* Copy downloaded XTRA assistance data to the modem over serial */
+    while((len = read(manager->gnss_assistance_fd, buffer, 2*BUFFER_SIZE)) > 0)
+    {
+        len = write(manager->at_fd, buffer, len);
+        if (len < 0) {
+            success = FALSE;
+            g_error("Writing GNSS assistance data failed: %d", len);
+            break;
+        }
+        usleep(UPLOAD_DELAY);
+        g_message("Uploaded %d bytes", len);
+    }
+
+    /* Clear QFUPL AT command and process next */
+    at_next_command(manager);
+
+    /* Go to the next step if successful */
+    if (success) {
+        manager->gnss_assistance_step++;
+        gnss_step(manager);
+    }
+    /* Restart upload */
+    else {
+        g_message ("Rescheduling upload because of failure in %ds",
+                   RESCHEDULE_IN_SECS);
+        manager->gnss_assistance_step = EG25_GNSS_STEP_LAST;
+        g_timeout_add_seconds(RESCHEDULE_IN_SECS,
+                              G_SOURCE_FUNC(gnss_upload_assistance_data),
+                              manager);
+    }
+}
+
+static void finish_assistance_data_upload_cb(struct EG25Manager *manager,
+                                             const char *response)
+{
+    /* Process response */
+    at_process_result(manager, response);
+    g_message("GNSS assistance data upload finished");
+
+    /* Go to the next step */
+    manager->gnss_assistance_step++;
+    gnss_step(manager);
+}
+
+static void finish_assistance_data_upload(struct EG25Manager *manager)
+{
+    gchar value[BUFFER_SIZE];
+    GDateTime *datetime;
+    gchar *timestring;
+
+    /* Configure GNSS assistance clock to current system time (UTC) */
+    datetime = g_date_time_new_now_utc();
+    timestring = g_date_time_format(datetime, "0,\"%Y/%m/%d,%H:%M:%S\"\r\n");
+    g_message("Setting GNSS assistance UTC clock to: %s", timestring);
+    at_append_command(manager, "QGPSXTRATIME", NULL, timestring, NULL,
+                         at_process_result);
+
+    /* Configure GNSS engine to use uploaded GNSS assistance data */
+    g_snprintf(value, BUFFER_SIZE, "\"RAM:%s\"\r\n",
+               manager->gnss_assistance_file);
+    g_message("Setting GNSS assistance file to: %s", value);
+    at_append_command(manager, "QGPSXTRADATA", NULL, value, NULL,
+                         finish_assistance_data_upload_cb);
+    at_send_command(manager);
+}
+
+/******************************************************************************/
+
+#ifdef HAVE_MMGLIB
+static void enable_mm_gnss(struct EG25Manager *manager)
+{
+    MMModemLocationSource sources;
+    gboolean signal_location;
+    g_autoptr (GError) error = NULL;
+
+    if (manager->gnss_sources & EG25_GNSS_SOURCE_UNMANAGED)
+        sources |= MM_MODEM_LOCATION_SOURCE_GPS_UNMANAGED;
+    if (manager->gnss_sources & EG25_GNSS_SOURCE_NMEA)
+        sources |= MM_MODEM_LOCATION_SOURCE_GPS_NMEA;
+    if (manager->gnss_sources & EG25_GNSS_SOURCE_RAW)
+        sources |= MM_MODEM_LOCATION_SOURCE_GPS_RAW;
+
+    sources = mm_modem_location_get_enabled(manager->mm_location);
+    signal_location = mm_modem_location_signals_location(manager->mm_location);
+    mm_modem_location_setup_sync(manager->mm_location, sources,
+                                 signal_location, NULL, &error);
+    if (error != NULL)
+        g_warning("Unable to enable GNSS engine through ModemManager: %s",
+                  error->message);
+}
+#endif
+
+static void enable_at_gnss_cb(struct EG25Manager *manager, const char *response)
+{
+    manager->gnss_assistance_step++;
+    gnss_step(manager);
+}
+
+static void enable_at_gnss(struct EG25Manager *manager)
+{
+    if (manager->gnss_sources & EG25_GNSS_SOURCE_QGPS) {
+        at_append_command(manager, "QGPS", NULL, "1", NULL,
+                             enable_at_gnss_cb);
+        at_send_command(manager);
+        return;
+    }
+    manager->gnss_assistance_step++;
+    gnss_step(manager);
+}
+
+/******************************************************************************/
+
+void gnss_step(struct EG25Manager *manager)
+{
+    switch(manager->gnss_assistance_step) {
+    case EG25_GNSS_STEP_FIRST:
+        manager->gnss_assistance_step++;
+        g_message("GNSS assistance upload started...");
+        /* fall-through */
+
+#ifdef HAVE_MMGLIB
+    case EG25_GNSS_STEP_MM_GNSS_DISABLE:
+        g_message("GNSS assistance upload step (%d/%d): "
+                  "disabling GNSS engine through ModemManager",
+                  manager->gnss_assistance_step, EG25_GNSS_STEP_LAST);
+        disable_mm_gnss(manager);
+        manager->gnss_assistance_step++;
+        /* fall-through */
+#endif
+
+    case EG25_GNSS_STEP_AT_GNSS_DISABLE:
+        g_message("GNSS assistance upload step (%d/%d): "
+                  "disabling GNSS engine through AT+QGPS",
+                  manager->gnss_assistance_step, EG25_GNSS_STEP_LAST);
+        state_at_gnss(manager);
+        break;
+
+    case EG25_GNSS_STEP_FETCH_ASSISTANCE_DATA:
+        g_message("GNSS assistance upload step (%d/%d): "
+                  "fetching assistance data",
+                  manager->gnss_assistance_step, EG25_GNSS_STEP_LAST);
+        fetch_assistance_data(manager);
+        break;
+
+    case EG25_GNSS_STEP_INIT_UPLOAD:
+        g_message("GNSS assistance upload step (%d/%d): initiating upload",
+                  manager->gnss_assistance_step, EG25_GNSS_STEP_LAST);
+        init_assistance_data_upload(manager);
+        break;
+
+    case EG25_GNSS_STEP_UPLOAD:
+        g_message("GNSS assistance upload step (%d/%d): "
+                  "uploading assistance data",
+                  manager->gnss_assistance_step, EG25_GNSS_STEP_LAST);
+        upload_assistance_data(manager);
+        break;
+
+    case EG25_GNSS_STEP_FINISH_UPLOAD:
+        g_message("GNSS assistance upload step (%d/%d): finishing upload",
+                  manager->gnss_assistance_step, EG25_GNSS_STEP_LAST);
+        finish_assistance_data_upload(manager);
+        break;
+
+#ifdef HAVE_MMGLIB
+    case EG25_GNSS_STEP_MM_GNSS_ENABLE:
+        g_message("GNSS assistance upload step (%d/%d): "
+                  "re-enabling GNSS through ModemManager",
+                  manager->gnss_assistance_step, EG25_GNSS_STEP_LAST);
+        enable_mm_gnss(manager);
+        manager->gnss_assistance_step++;
+        /* fall-through */
+#endif
+
+    case EG25_GNSS_STEP_AT_QGPS_ENABLE:
+        g_message("GNSS assistance upload step (%d/%d): "
+                  "re-enabling GNSS through AT+QGPS",
+                  manager->gnss_assistance_step, EG25_GNSS_STEP_LAST);
+        enable_at_gnss(manager);
+        break;
+
+    case EG25_GNSS_STEP_LAST:
+        g_message("GNSS assistance upload step (%d/%d): finished",
+                  manager->gnss_assistance_step, EG25_GNSS_STEP_LAST);
+        break;
+    }
+}
+

src/gnss.h

@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2021 Dylan Van Assche <me@dylanvanassche.be>
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#pragma once
+
+#include <time.h>
+#include <curl/curl.h>
+
+#include "manager.h"
+
+void gnss_init(struct EG25Manager *manager, toml_table_t *config);
+void gnss_destroy(struct EG25Manager *manager);
+gboolean gnss_upload_assistance_data(struct EG25Manager *manager);

src/gpio.c

@@ -6,6 +6,8 @@
 
 #include "gpio.h"
 
+#include <unistd.h>
+
 #define GPIO_CHIP1_LABEL "1c20800.pinctrl"
 #define GPIO_CHIP2_LABEL "1f02c00.pinctrl"
 
@@ -22,42 +24,19 @@ enum {
     GPIO_OUT_COUNT
 };
 
-static unsigned gpio_out_idx_bh[] = {
-    358,
-    35,
-    68,
-    231,
-    232
-};
-
-static unsigned gpio_out_idx_ce[] = {
-    34,
-    35,
-    68,
-    231,
-    232
-};
 
 enum {
     GPIO_IN_STATUS = 0,
     GPIO_IN_COUNT
 };
 
-static unsigned gpio_in_idx_bh[] = {
-    GPIO_IDX_INVAL,
-};
-
-static unsigned gpio_in_idx_ce[] = {
-    233,
-};
-
 int gpio_sequence_poweron(struct EG25Manager *manager)
 {
     gpiod_line_set_value(manager->gpio_out[GPIO_OUT_PWRKEY], 1);
     sleep(1);
     gpiod_line_set_value(manager->gpio_out[GPIO_OUT_PWRKEY], 0);
 
-    g_message("Executed power-on sequence");
+    g_message("Executed power-on/off sequence");
 
     return 0;
 }
@@ -75,7 +54,6 @@ int gpio_sequence_shutdown(struct EG25Manager *manager)
 int gpio_sequence_suspend(struct EG25Manager *manager)
 {
     gpiod_line_set_value(manager->gpio_out[GPIO_OUT_APREADY], 1);
-    gpiod_line_set_value(manager->gpio_out[GPIO_OUT_DTR], 1);
 
     g_message("Executed suspend sequence");
 
@@ -85,18 +63,50 @@ int gpio_sequence_suspend(struct EG25Manager *manager)
 int gpio_sequence_resume(struct EG25Manager *manager)
 {
     gpiod_line_set_value(manager->gpio_out[GPIO_OUT_APREADY], 0);
-    gpiod_line_set_value(manager->gpio_out[GPIO_OUT_DTR], 0);
 
     g_message("Executed resume sequence");
 
     return 0;
 }
 
-int gpio_init(struct EG25Manager *manager)
+int gpio_sequence_wake(struct EG25Manager *manager)
+{
+    gpiod_line_set_value(manager->gpio_out[GPIO_OUT_DTR], 0);
+
+    /* Give the modem 200ms to wake from soft sleep */
+    usleep(200000);
+
+    g_message("Executed soft wake sequence");
+
+    return 0;
+}
+
+int gpio_sequence_sleep(struct EG25Manager *manager)
+{
+    gpiod_line_set_value(manager->gpio_out[GPIO_OUT_DTR], 1);
+    g_message("Executed soft sleep sequence");
+
+    return 0;
+}
+
+static guint get_config_gpio(toml_table_t *config, const char *id)
+{
+    toml_datum_t value = toml_int_in(config, id);
+    guint gpio;
+
+    if (!value.ok)
+        return GPIO_IDX_INVAL;
+
+    gpio = (guint)value.u.i;
+
+    return gpio;
+}
+
+int gpio_init(struct EG25Manager *manager, toml_table_t *config)
 {
     int i, ret;
-    unsigned *gpio_in_idx;
-    unsigned *gpio_out_idx;
+    guint gpio_out_idx[GPIO_OUT_COUNT];
+    guint gpio_in_idx[GPIO_IN_COUNT];
 
     manager->gpiochip[0] = gpiod_chip_open_by_label(GPIO_CHIP1_LABEL);
     if (!manager->gpiochip[0]) {
@@ -110,16 +120,15 @@ int gpio_init(struct EG25Manager *manager)
         return 1;
     }
 
-    if (manager->braveheart) {
-        gpio_in_idx = gpio_in_idx_bh;
-        gpio_out_idx = gpio_out_idx_bh;
-    } else {
-        gpio_in_idx = gpio_in_idx_ce;
-        gpio_out_idx = gpio_out_idx_ce;
-    }
+    gpio_out_idx[GPIO_OUT_DTR] = get_config_gpio(config, "dtr");
+    gpio_out_idx[GPIO_OUT_PWRKEY] = get_config_gpio(config, "pwrkey");
+    gpio_out_idx[GPIO_OUT_RESET] = get_config_gpio(config, "reset");
+    gpio_out_idx[GPIO_OUT_APREADY] = get_config_gpio(config, "apready");
+    gpio_out_idx[GPIO_OUT_DISABLE] = get_config_gpio(config, "disable");
+    gpio_in_idx[GPIO_IN_STATUS] = get_config_gpio(config, "status");
 
     for (i = 0; i < GPIO_OUT_COUNT; i++) {
-        unsigned int offset, chipidx;
+        guint offset, chipidx;
 
         if (gpio_out_idx[i] < MAX_GPIOCHIP_LINES) {
             offset = gpio_out_idx[i];
@@ -131,19 +140,19 @@ int gpio_init(struct EG25Manager *manager)
 
         manager->gpio_out[i] = gpiod_chip_get_line(manager->gpiochip[chipidx], offset);
         if (!manager->gpio_out[i]) {
-            g_critical("Unable to get output GPIO %d", i);
+            g_error("Unable to get output GPIO %d", i);
             return 1;
         }
 
         ret = gpiod_line_request_output(manager->gpio_out[i], "eg25manager", 0);
         if (ret < 0) {
-            g_critical("Unable to request output GPIO %d", i);
+            g_error("Unable to request output GPIO %d", i);
             return 1;
         }
     }
 
     for (i = 0; i < GPIO_IN_COUNT; i++) {
-        unsigned int offset, chipidx;
+        guint offset, chipidx;
 
         if (gpio_in_idx[i] == GPIO_IDX_INVAL)
             continue;
@@ -172,13 +181,16 @@ int gpio_init(struct EG25Manager *manager)
     return 0;
 }
 
-gboolean gpio_check_poweroff(struct EG25Manager *manager)
+gboolean gpio_check_poweroff(struct EG25Manager *manager, gboolean keep_down)
 {
     if (manager->gpio_in[GPIO_IN_STATUS] &&
         gpiod_line_get_value(manager->gpio_in[GPIO_IN_STATUS]) == 1) {
 
-        // Asserting RESET line to prevent modem from rebooting
-        gpiod_line_set_value(manager->gpio_out[GPIO_OUT_RESET], 1);
+        if (keep_down && manager->gpio_out[GPIO_OUT_RESET]) {
+            // Asserting RESET line to prevent modem from rebooting
+            gpiod_line_set_value(manager->gpio_out[GPIO_OUT_RESET], 1);
+        }
+
         return TRUE;
     }
 

src/gpio.h

@@ -8,12 +8,14 @@
 
 #include "manager.h"
 
-int gpio_init(struct EG25Manager *state);
+int gpio_init(struct EG25Manager *state, toml_table_t *config);
 void gpio_destroy(struct EG25Manager *state);
 
 int gpio_sequence_poweron(struct EG25Manager *state);
 int gpio_sequence_shutdown(struct EG25Manager *state);
 int gpio_sequence_suspend(struct EG25Manager *state);
 int gpio_sequence_resume(struct EG25Manager *state);
+int gpio_sequence_wake(struct EG25Manager *state);
+int gpio_sequence_sleep(struct EG25Manager *state);
 
-gboolean gpio_check_poweroff(struct EG25Manager *manager);
+gboolean gpio_check_poweroff(struct EG25Manager *manager, gboolean keep_down);

src/libgdbofono/dbus-introspect.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+DEST="$1"
+OBJ_PATH="$2"
+METHOD="$3"
+shift 3
+
+dbus-send "$@" --print-reply --dest="$DEST" "$OBJ_PATH" "$METHOD" | \
+    grep -v '^method return' | \
+    sed -e 's/^[[:space:]]\+string "</</' \
+        -e 's_</node>"_</node>_'

src/libgdbofono/manager.xml

@@ -0,0 +1,13 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+
+  <interface name="org.ofono.Manager"><method name="GetModems"><arg name="modems" type="a(oa{sv})" direction="out"/>
+</method><signal name="ModemAdded"><arg name="path" type="o"/>
+<arg name="properties" type="a{sv}"/>
+</signal>
+<signal name="ModemRemoved"><arg name="path" type="o"/>
+</signal>
+  </interface>
+
+</node>

src/libgdbofono/meson.build

@@ -0,0 +1,50 @@
+#
+# Copyright (C) 2018 Purism SPC
+#
+# This file is part of Calls.
+#
+# Calls 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 3 of the License, or
+# (at your option) any later version.
+#
+# Calls 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 Calls.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: Bob Ham <bob.ham@puri.sm>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+
+gnome = import('gnome')
+dbus_interfaces = ['manager', 'modem']
+
+gdbofono_src = []
+gdbofono_headers = []
+foreach iface: dbus_interfaces
+  src = gnome.gdbus_codegen(
+    'gdbo-' + iface,
+    iface + '.xml',
+    interface_prefix: 'org.ofono.',
+    namespace: 'GDBO'
+  )
+  gdbofono_src += src
+  gdbofono_headers += src[1]
+endforeach
+
+gdbofono_deps = [
+  dependency('gio-2.0'),
+  dependency('gio-unix-2.0'),
+]
+
+gdbofono_lib = static_library(
+  'gdbofono',
+  gdbofono_src,
+  dependencies: gdbofono_deps
+)

src/libgdbofono/modem-full.xml

@@ -0,0 +1,249 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+
+  <interface name="org.ofono.Modem"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="SetProperty"><arg name="property" type="s" direction="in"/>
+<arg name="value" type="v" direction="in"/>
+</method><signal name="PropertyChanged"><arg name="name" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.SimManager"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="SetProperty"><arg name="property" type="s" direction="in"/>
+<arg name="value" type="v" direction="in"/>
+</method><method name="ChangePin"><arg name="type" type="s" direction="in"/>
+<arg name="oldpin" type="s" direction="in"/>
+<arg name="newpin" type="s" direction="in"/>
+</method><method name="EnterPin"><arg name="type" type="s" direction="in"/>
+<arg name="pin" type="s" direction="in"/>
+</method><method name="ResetPin"><arg name="type" type="s" direction="in"/>
+<arg name="puk" type="s" direction="in"/>
+<arg name="newpin" type="s" direction="in"/>
+</method><method name="LockPin"><arg name="type" type="s" direction="in"/>
+<arg name="pin" type="s" direction="in"/>
+</method><method name="UnlockPin"><arg name="type" type="s" direction="in"/>
+<arg name="pin" type="s" direction="in"/>
+</method><method name="GetIcon"><arg name="id" type="y" direction="in"/>
+<arg name="icon" type="ay" direction="out"/>
+</method><signal name="PropertyChanged"><arg name="name" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.VoiceCallManager"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="Dial"><arg name="number" type="s" direction="in"/>
+<arg name="hide_callerid" type="s" direction="in"/>
+<arg name="path" type="o" direction="out"/>
+</method><method name="DialLast"></method><method name="DialMemory"><arg name="memory_location" type="u" direction="in"/>
+</method><method name="Transfer"></method><method name="SwapCalls"></method><method name="ReleaseAndAnswer"></method><method name="ReleaseAndSwap"></method><method name="HoldAndAnswer"></method><method name="HangupAll"></method><method name="PrivateChat"><arg name="call" type="o" direction="in"/>
+<arg name="calls" type="ao" direction="out"/>
+</method><method name="CreateMultiparty"><arg name="calls" type="ao" direction="out"/>
+</method><method name="HangupMultiparty"></method><method name="SendTones"><arg name="SendTones" type="s" direction="in"/>
+</method><method name="GetCalls"><arg name="calls_with_properties" type="a(oa{sv})" direction="out"/>
+</method><signal name="Forwarded"><arg name="type" type="s"/>
+</signal>
+<signal name="BarringActive"><arg name="type" type="s"/>
+</signal>
+<signal name="PropertyChanged"><arg name="name" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+<signal name="CallAdded"><arg name="path" type="o"/>
+<arg name="properties" type="a{sv}"/>
+</signal>
+<signal name="CallRemoved"><arg name="path" type="o"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.AllowedAccessPoints"><method name="GetAllowedAccessPoints"><arg name="apnlist" type="as" direction="out"/>
+  </method></interface>
+
+  <interface name="org.ofono.SimAuthentication"><method name="GetApplications"><arg name="applications" type="a{oa{sv}}" direction="out"/>
+</method><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+  </method></interface>
+
+  <interface name="org.ofono.SimToolkit"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="SelectItem"><arg name="item" type="y" direction="in"/>
+<arg name="agent" type="o" direction="in"/>
+</method><method name="RegisterAgent"><arg name="path" type="o" direction="in"/>
+</method><method name="UnregisterAgent"><arg name="path" type="o" direction="in"/>
+</method><signal name="PropertyChanged"><arg name="name" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.CallForwarding"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="SetProperty"><arg name="property" type="s" direction="in"/>
+<arg name="value" type="v" direction="in"/>
+</method><method name="DisableAll"><arg name="type" type="s" direction="in"/>
+</method><signal name="PropertyChanged"><arg name="name" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.RadioSettings"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="SetProperty"><arg name="property" type="s" direction="in"/>
+<arg name="value" type="v" direction="in"/>
+</method><signal name="PropertyChanged"><arg name="name" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.TextTelephony"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="SetProperty"><arg name="property" type="s" direction="in"/>
+<arg name="value" type="v" direction="in"/>
+</method><signal name="PropertyChanged"><arg name="name" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.Phonebook"><method name="Import"><arg name="entries" type="s" direction="out"/>
+  </method></interface>
+
+  <interface name="org.ofono.MessageManager"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="SetProperty"><arg name="property" type="s" direction="in"/>
+<arg name="value" type="v" direction="in"/>
+</method><method name="SendMessage"><arg name="to" type="s" direction="in"/>
+<arg name="text" type="s" direction="in"/>
+<arg name="path" type="o" direction="out"/>
+</method><method name="GetMessages"><arg name="messages" type="a(oa{sv})" direction="out"/>
+</method><signal name="PropertyChanged"><arg name="name" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+<signal name="IncomingMessage"><arg name="message" type="s"/>
+<arg name="info" type="a{sv}"/>
+</signal>
+<signal name="ImmediateMessage"><arg name="message" type="s"/>
+<arg name="info" type="a{sv}"/>
+</signal>
+<signal name="MessageAdded"><arg name="path" type="o"/>
+<arg name="properties" type="a{sv}"/>
+</signal>
+<signal name="MessageRemoved"><arg name="path" type="o"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.PushNotification"><method name="RegisterAgent"><arg name="path" type="o" direction="in"/>
+</method><method name="UnregisterAgent"><arg name="path" type="o" direction="in"/>
+  </method></interface>
+
+  <interface name="org.ofono.SmartMessaging"><method name="RegisterAgent"><arg name="path" type="o" direction="in"/>
+</method><method name="UnregisterAgent"><arg name="path" type="o" direction="in"/>
+</method><method name="SendBusinessCard"><arg name="to" type="s" direction="in"/>
+<arg name="card" type="ay" direction="in"/>
+<arg name="path" type="o" direction="out"/>
+</method><method name="SendAppointment"><arg name="to" type="s" direction="in"/>
+<arg name="appointment" type="ay" direction="in"/>
+<arg name="path" type="o" direction="out"/>
+  </method></interface>
+
+  <interface name="org.ofono.MessageWaiting"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="SetProperty"><arg name="property" type="s" direction="in"/>
+<arg name="value" type="v" direction="in"/>
+</method><signal name="PropertyChanged"><arg name="name" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.CallSettings"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="SetProperty"><arg name="property" type="s" direction="in"/>
+<arg name="value" type="v" direction="in"/>
+</method><signal name="PropertyChanged"><arg name="property" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.CallBarring"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="SetProperty"><arg name="property" type="s" direction="in"/>
+<arg name="value" type="v" direction="in"/>
+<arg name="pin2" type="s" direction="in"/>
+</method><method name="DisableAll"><arg name="password" type="s" direction="in"/>
+</method><method name="DisableAllIncoming"><arg name="password" type="s" direction="in"/>
+</method><method name="DisableAllOutgoing"><arg name="password" type="s" direction="in"/>
+</method><method name="ChangePassword"><arg name="old" type="s" direction="in"/>
+<arg name="new" type="s" direction="in"/>
+</method><signal name="PropertyChanged"><arg name="name" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.SupplementaryServices"><method name="Initiate"><arg name="command" type="s" direction="in"/>
+<arg name="result_name" type="s" direction="out"/>
+<arg name="value" type="v" direction="out"/>
+</method><method name="Respond"><arg name="reply" type="s" direction="in"/>
+<arg name="result" type="s" direction="out"/>
+</method><method name="Cancel"></method><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><signal name="NotificationReceived"><arg name="message" type="s"/>
+</signal>
+<signal name="RequestReceived"><arg name="message" type="s"/>
+</signal>
+<signal name="PropertyChanged"><arg name="name" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.CallMeter"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="SetProperty"><arg name="property" type="s" direction="in"/>
+<arg name="value" type="v" direction="in"/>
+<arg name="password" type="s" direction="in"/>
+</method><method name="Reset"><arg name="passoword" type="s" direction="in"/>
+</method><signal name="PropertyChanged"><arg name="property" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+<signal name="NearMaximumWarning"></signal>
+  </interface>
+
+  <interface name="org.ofono.CallVolume"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="SetProperty"><arg name="property" type="s" direction="in"/>
+<arg name="value" type="v" direction="in"/>
+</method><signal name="PropertyChanged"><arg name="property" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.NetworkRegistration"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="Register"></method><method name="GetOperators"><arg name="operators_with_properties" type="a(oa{sv})" direction="out"/>
+</method><method name="Scan"><arg name="operators_with_properties" type="a(oa{sv})" direction="out"/>
+</method><signal name="PropertyChanged"><arg name="name" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.CellBroadcast"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="SetProperty"><arg name="property" type="s" direction="in"/>
+<arg name="value" type="v" direction="in"/>
+</method><signal name="PropertyChanged"><arg name="property" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+<signal name="IncomingBroadcast"><arg name="message" type="s"/>
+<arg name="channel" type="q"/>
+</signal>
+<signal name="EmergencyBroadcast"><arg name="message" type="s"/>
+<arg name="dict" type="a{sv}"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.AssistedSatelliteNavigation"><method name="SendPositioningElement"><arg name="xml_elements" type="(null)" direction="in"/>
+</method><method name="RegisterPositioningRequestAgent"><arg name="agent" type="o" direction="in"/>
+</method><method name="UnregisterPositioningRequestAgent"><arg name="agent" type="o" direction="in"/>
+  </method></interface>
+
+  <interface name="org.ofono.ConnectionManager"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="SetProperty"><arg name="property" type="s" direction="in"/>
+<arg name="value" type="v" direction="in"/>
+</method><method name="AddContext"><arg name="type" type="s" direction="in"/>
+<arg name="path" type="o" direction="out"/>
+</method><method name="RemoveContext"><arg name="path" type="o" direction="in"/>
+</method><method name="DeactivateAll"></method><method name="GetContexts"><arg name="contexts_with_properties" type="a(oa{sv})" direction="out"/>
+</method><method name="ResetContexts"></method><signal name="PropertyChanged"><arg name="name" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+<signal name="ContextAdded"><arg name="path" type="o"/>
+<arg name="properties" type="a{sv}"/>
+</signal>
+<signal name="ContextRemoved"><arg name="path" type="o"/>
+</signal>
+  </interface>
+
+</node>

src/libgdbofono/modem.xml

@@ -0,0 +1,37 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+
+  <interface name="org.ofono.Modem"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="SetProperty"><arg name="property" type="s" direction="in"/>
+<arg name="value" type="v" direction="in"/>
+</method><signal name="PropertyChanged"><arg name="name" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+  </interface>
+
+  <interface name="org.ofono.VoiceCallManager"><method name="GetProperties"><arg name="properties" type="a{sv}" direction="out"/>
+</method><method name="Dial"><arg name="number" type="s" direction="in"/>
+<arg name="hide_callerid" type="s" direction="in"/>
+<arg name="path" type="o" direction="out"/>
+</method><method name="DialLast"></method><method name="DialMemory"><arg name="memory_location" type="u" direction="in"/>
+</method><method name="Transfer"></method><method name="SwapCalls"></method><method name="ReleaseAndAnswer"></method><method name="ReleaseAndSwap"></method><method name="HoldAndAnswer"></method><method name="HangupAll"></method><method name="PrivateChat"><arg name="call" type="o" direction="in"/>
+<arg name="calls" type="ao" direction="out"/>
+</method><method name="CreateMultiparty"><arg name="calls" type="ao" direction="out"/>
+</method><method name="HangupMultiparty"></method><method name="SendTones"><arg name="SendTones" type="s" direction="in"/>
+</method><method name="GetCalls"><arg name="calls_with_properties" type="a(oa{sv})" direction="out"/>
+</method><signal name="Forwarded"><arg name="type" type="s"/>
+</signal>
+<signal name="BarringActive"><arg name="type" type="s"/>
+</signal>
+<signal name="PropertyChanged"><arg name="name" type="s"/>
+<arg name="value" type="v"/>
+</signal>
+<signal name="CallAdded"><arg name="path" type="o"/>
+<arg name="properties" type="a{sv}"/>
+</signal>
+<signal name="CallRemoved"><arg name="path" type="o"/>
+</signal>
+  </interface>
+
+</node>

src/manager.c

@@ -7,8 +7,15 @@
 #include "at.h"
 #include "gpio.h"
 #include "manager.h"
+
+#ifdef HAVE_MMGLIB
 #include "mm-iface.h"
+#endif
+
+#include "ofono-iface.h"
 #include "suspend.h"
+#include "udev.h"
+#include "gnss.h"
 
 #include <fcntl.h>
 #include <signal.h>
@@ -16,6 +23,15 @@
 #include <unistd.h>
 
 #include <glib-unix.h>
+#include <libusb.h>
+
+#ifndef EG25_CONFDIR
+#define EG25_CONFDIR "/etc/eg25-manager"
+#endif
+
+#ifndef EG25_DATADIR
+#define EG25_DATADIR "/usr/share/eg25-manager"
+#endif
 
 static gboolean quit_app(struct EG25Manager *manager)
 {
@@ -24,15 +40,19 @@ static gboolean quit_app(struct EG25Manager *manager)
     g_message("Request to quit...");
 
     at_destroy(manager);
+#ifdef HAVE_MMGLIB
     mm_iface_destroy(manager);
+#endif
+    ofono_iface_destroy(manager);
     suspend_destroy(manager);
+    udev_destroy(manager);
 
     if (manager->modem_state >= EG25_STATE_STARTED) {
         g_message("Powering down the modem...");
         gpio_sequence_shutdown(manager);
         manager->modem_state = EG25_STATE_FINISHING;
         for (i = 0; i < 30; i++) {
-            if (gpio_check_poweroff(manager))
+            if (gpio_check_poweroff(manager, TRUE))
                 break;
             sleep(1);
         }
@@ -46,13 +66,48 @@ static gboolean quit_app(struct EG25Manager *manager)
 
 static gboolean modem_start(struct EG25Manager *manager)
 {
-    g_message("Starting modem...");
-    gpio_sequence_poweron(manager);
-    manager->modem_state = EG25_STATE_POWERED;
+    ssize_t i, count;
+    gboolean should_boot = TRUE;
+    libusb_context *ctx = NULL;
+    libusb_device **devices = NULL;
+    struct libusb_device_descriptor desc;
+
+    if (manager->use_libusb) {
+        // BH don't have the STATUS line connected, so check if USB device is present
+        libusb_init(&ctx);
+
+        count = libusb_get_device_list(ctx, &devices);
+        for (i = 0; i < count; i++) {
+            libusb_get_device_descriptor(devices[i], &desc);
+            if (desc.idVendor == manager->usb_vid && desc.idProduct == manager->usb_pid) {
+                g_message("Found corresponding USB device, modem already powered");
+                should_boot = FALSE;
+                break;
+            }
+        }
+
+        libusb_free_device_list(devices, 1);
+        libusb_exit(ctx);
+    } else if (!gpio_check_poweroff(manager, FALSE)) {
+        g_message("STATUS is low, modem already powered");
+        should_boot = FALSE;
+    }
+
+    if (should_boot) {
+        g_message("Starting modem...");
+        // Modem might crash on boot (especially with worn battery) if we don't delay here
+        if (manager->poweron_delay > 0)
+            g_usleep(manager->poweron_delay);
+        gpio_sequence_poweron(manager);
+        manager->modem_state = EG25_STATE_POWERED;
+    } else {
+        manager->modem_state = EG25_STATE_STARTED;
+    }
 
     return FALSE;
 }
 
+#ifdef HAVE_MMGLIB
 void modem_update_state(struct EG25Manager *manager, MMModemState state)
 {
     switch (state) {
@@ -69,41 +124,95 @@ void modem_update_state(struct EG25Manager *manager, MMModemState state)
         break;
     }
 }
+#endif
 
 void modem_configure(struct EG25Manager *manager)
 {
     at_sequence_configure(manager);
 }
 
+static gboolean modem_reset_done(struct EG25Manager* manager)
+{
+    manager->modem_state = EG25_STATE_RESUMING;
+    manager->reset_timer = 0;
+    return FALSE;
+}
+
 void modem_reset(struct EG25Manager *manager)
 {
-    int fd;
+    int fd, ret, len;
+
+    if (manager->reset_timer)
+        return;
+
+    /*
+     * If we are managing the modem through lets say ofono, we should not
+     * reset the modem based on the availability of USB ID
+     * TODO: Improve ofono plugin and add support for fetching USB ID
+     */
+    if (manager->modem_iface != MODEM_IFACE_MODEMMANAGER)
+        return;        
+
+    if (manager->modem_recovery_timer) {
+        g_source_remove(manager->modem_recovery_timer);
+        manager->modem_recovery_timer = 0;
+    }
+
+    if (!manager->modem_usb_id) {
+        g_warning("Unknown modem USB ID");
+        goto error;
+    }
+
+    len = strlen(manager->modem_usb_id);
+
+    manager->modem_state = EG25_STATE_RESETTING;
 
     fd = open("/sys/bus/usb/drivers/usb/unbind", O_WRONLY);
     if (fd < 0)
         goto error;
-    write(fd, manager->modem_usb_id, strlen(manager->modem_usb_id));
+    ret = write(fd, manager->modem_usb_id, len);
+    if (ret < len)
+        g_warning("Couldn't unbind modem: wrote %d/%d bytes", ret, len);
     close(fd);
 
     fd = open("/sys/bus/usb/drivers/usb/bind", O_WRONLY);
     if (fd < 0)
         goto error;
-    write(fd, manager->modem_usb_id, strlen(manager->modem_usb_id));
+    ret = write(fd, manager->modem_usb_id, len);
+    if (ret < len)
+        g_warning("Couldn't bind modem: wrote %d/%d bytes", ret, len);
     close(fd);
 
-    manager->modem_state = EG25_STATE_CONFIGURED;
+    /*
+     * 3s is long enough to make sure the modem has been bound back and
+     * short enough to ensure it hasn't been acquired by ModemManager
+     */
+    manager->reset_timer = g_timeout_add_seconds(3, G_SOURCE_FUNC(modem_reset_done), manager);
+
     return;
 
 error:
-    // Everything else failed, reset the modem
+    // Release blocking sleep inhibitor
+    if (manager->suspend_block_fd >= 0)
+        suspend_inhibit(manager, FALSE, TRUE);
+    if (manager->modem_boot_timer) {
+        g_source_remove(manager->modem_boot_timer);
+        manager->modem_boot_timer = 0;
+    }
+    // Everything else failed, reboot the modem
     at_sequence_reset(manager);
-    manager->modem_state = EG25_STATE_RESETTING;
 }
 
-void modem_suspend(struct EG25Manager *manager)
+void modem_suspend_pre(struct EG25Manager *manager)
+{
+    at_sequence_suspend(manager);
+}
+
+void modem_suspend_post(struct EG25Manager *manager)
 {
     gpio_sequence_suspend(manager);
-    at_sequence_suspend(manager);
+    g_message("suspend sequence is over, drop inhibitor");
+    suspend_inhibit(manager, FALSE, FALSE);
 }
 
 void modem_resume_pre(struct EG25Manager *manager)
@@ -116,32 +225,125 @@ void modem_resume_post(struct EG25Manager *manager)
     at_sequence_resume(manager);
 }
 
+static toml_table_t *parse_config_file(char *config_file)
+{
+    toml_table_t *toml_config;
+    gchar *compatible;
+    gchar error[256];
+    gsize len;
+    FILE *f = NULL;
+
+    if (config_file) {
+        f = fopen(config_file, "r");
+    } else if (g_file_get_contents("/proc/device-tree/compatible", &compatible, &len, NULL)) {
+        g_autoptr (GPtrArray) compat = g_ptr_array_new();
+        gsize pos = 0;
+
+        /*
+         * `compatible` file is a list of NULL-terminated strings, convert it
+         * to an array
+         */
+        do {
+            g_ptr_array_add(compat, &compatible[pos]);
+            pos += strlen(&compatible[pos]) + 1;
+        } while (pos < len);
+
+        for (pos = 0; pos < compat->len; pos++) {
+            g_autofree gchar *filename = g_strdup_printf(EG25_CONFDIR "/%s.toml", (gchar *)g_ptr_array_index(compat, pos));
+            if (access(filename, F_OK) == 0) {
+                g_message("Opening config file: %s", filename);
+                f = fopen(filename, "r");
+                break;
+            }
+        }
+
+        if (!f) {
+            for (pos = 0; pos < compat->len; pos++) {
+                g_autofree gchar *filename = g_strdup_printf(EG25_DATADIR "/%s.toml", (gchar *)g_ptr_array_index(compat, pos));
+                if (access(filename, F_OK) == 0) {
+                    g_message("Opening config file: %s", filename);
+                    f = fopen(filename, "r");
+                    break;
+                }
+            }
+        }
+    }
+
+    if (!f)
+        g_error("unable to find a suitable config file!");
+
+    toml_config = toml_parse_file(f, error, sizeof(error));
+    if (!toml_config)
+        g_error("unable to parse config file: %s", error);
+
+    return toml_config;
+}
+
 int main(int argc, char *argv[])
 {
+    g_autoptr(GOptionContext) opt_context = NULL;
+    g_autoptr(GError) err = NULL;
     struct EG25Manager manager;
-    char compatible[32];
-    int fd;
+    gchar *config_file = NULL;
+    toml_table_t *toml_config;
+    toml_table_t *toml_manager;
+    toml_datum_t toml_value;
+    const GOptionEntry options[] = {
+        { "config", 'c', 0, G_OPTION_ARG_STRING, &config_file, "Config file to use.", NULL },
+        { NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
+    };
 
     memset(&manager, 0, sizeof(manager));
     manager.at_fd = -1;
-    manager.suspend_inhibit_fd = -1;
+    manager.suspend_delay_fd = -1;
+    manager.suspend_block_fd = -1;
+
+    opt_context = g_option_context_new ("- Power management for the Quectel EG25 modem");
+    g_option_context_add_main_entries (opt_context, options, NULL);
+    if (!g_option_context_parse (opt_context, &argc, &argv, &err)) {
+        g_warning ("%s", err->message);
+        return 1;
+    }
 
     manager.loop = g_main_loop_new(NULL, FALSE);
 
-    fd = open("/proc/device-tree/compatible", O_RDONLY);
-    if (fd < 0) {
-        g_critical("Unable to read 'compatible' string from device tree");
-        return 1;
-    }
-    read(fd, compatible, sizeof(compatible));
-    if (!strstr(compatible, "pine64,pinephone-1.2"))
-        manager.braveheart = TRUE;
-    close(fd);
+    toml_config = parse_config_file(config_file);
 
-    at_init(&manager);
-    gpio_init(&manager);
-    mm_iface_init(&manager);
-    suspend_init(&manager);
+    toml_manager = toml_table_in(toml_config, "manager");
+    if (toml_manager) {
+        toml_value = toml_bool_in(toml_manager, "need_libusb");
+        if (toml_value.ok)
+            manager.use_libusb = toml_value.u.b;
+
+        toml_value = toml_int_in(toml_manager, "usb_vid");
+        if (toml_value.ok)
+            manager.usb_vid = toml_value.u.i;
+
+        toml_value = toml_int_in(toml_manager, "usb_pid");
+        if (toml_value.ok)
+            manager.usb_pid = toml_value.u.i;
+
+        toml_value = toml_int_in(toml_manager, "poweron_delay");
+        if (toml_value.ok) {
+            if (toml_value.u.i >= 0 && toml_value.u.i <= G_MAXULONG) {
+                // Safe to cast into gulong
+                manager.poweron_delay = (gulong) toml_value.u.i;
+            } else {
+                // Changed from initialized default value but not in range
+                g_message("Configured poweron_delay out of range, using default");
+            }
+        }
+    }
+
+    at_init(&manager, toml_table_in(toml_config, "at"));
+    gpio_init(&manager, toml_table_in(toml_config, "gpio"));
+#ifdef HAVE_MMGLIB
+    mm_iface_init(&manager, toml_table_in(toml_config, "mm-iface"));
+#endif
+    ofono_iface_init(&manager);
+    suspend_init(&manager, toml_table_in(toml_config, "suspend"));
+    udev_init(&manager, toml_table_in(toml_config, "udev"));
+    gnss_init(&manager, toml_table_in(toml_config, "gnss"));
 
     g_idle_add(G_SOURCE_FUNC(modem_start), &manager);
 

src/manager.h

@@ -8,7 +8,39 @@
 
 #include <glib.h>
 #include <gpiod.h>
+#include <gudev/gudev.h>
+#ifdef HAVE_MMGLIB
 #include <libmm-glib.h>
+#endif
+#include <libgdbofono/gdbo-manager.h>
+
+#include "toml.h"
+
+typedef enum {
+    EG25_GNSS_STEP_FIRST = 0,
+#ifdef HAVE_MMGLIB
+    EG25_GNSS_STEP_MM_GNSS_DISABLE,
+#endif
+    EG25_GNSS_STEP_AT_GNSS_DISABLE,
+    EG25_GNSS_STEP_FETCH_ASSISTANCE_DATA,
+    EG25_GNSS_STEP_INIT_UPLOAD,
+    EG25_GNSS_STEP_UPLOAD,
+    EG25_GNSS_STEP_FINISH_UPLOAD,
+#ifdef HAVE_MMGLIB
+    EG25_GNSS_STEP_MM_GNSS_ENABLE,
+#endif
+    EG25_GNSS_STEP_AT_QGPS_ENABLE,
+    EG25_GNSS_STEP_LAST,
+} EG25GNSSStep;
+
+typedef enum {
+    EG25_GNSS_SOURCE_NONE = 0,
+    EG25_GNSS_SOURCE_NMEA = 1 << 0,
+    EG25_GNSS_SOURCE_RAW = 1 << 1,
+    EG25_GNSS_SOURCE_UNMANAGED = 1 << 2,
+    EG25_GNSS_SOURCE_QGPS = 1 << 3,
+} EG25GNSSSource;
+
 
 enum EG25State {
     EG25_STATE_INIT = 0,
@@ -24,25 +56,56 @@ enum EG25State {
     EG25_STATE_FINISHING
 };
 
+enum ModemIface {
+    MODEM_IFACE_NONE = 0,
+    MODEM_IFACE_MODEMMANAGER,
+    MODEM_IFACE_OFONO
+};
+
 struct EG25Manager {
     GMainLoop *loop;
-
-    enum EG25State modem_state;
-    gchar *modem_usb_id;
-    gboolean braveheart;
-
-    guint mm_watch;
-    MMManager *mm_manager;
-    MMModem *mm_modem;
-
-    GDBusProxy *suspend_proxy;
-    int suspend_inhibit_fd;
-    guint suspend_source;
-
+    guint reset_timer;
+    gboolean use_libusb;
+    guint usb_vid;
+    guint usb_pid;
+    gulong poweron_delay;
 
     int at_fd;
     guint at_source;
     GList *at_cmds;
+    void (*at_callback)(struct EG25Manager *manager, const char *response);
+
+    enum EG25State modem_state;
+    gchar *modem_usb_id;
+
+    gboolean gnss_assistance_enabled;
+    EG25GNSSSource gnss_sources;
+    EG25GNSSStep gnss_assistance_step;
+    gint gnss_assistance_fd;
+    gchar *gnss_assistance_url;
+    gchar *gnss_assistance_file;
+
+    enum ModemIface modem_iface;
+    guint mm_watch;
+#ifdef HAVE_MMGLIB
+    MMManager *mm_manager;
+    MMModem *mm_modem;
+    MMModemLocation *mm_location;
+#endif
+    guint ofono_watch;
+    GDBOManager *ofono_manager;
+    GDBusConnection *ofono_connection;
+
+    GDBusProxy *suspend_proxy;
+    int suspend_delay_fd;
+    int suspend_block_fd;
+
+    guint modem_recovery_timer;
+    guint modem_recovery_timeout;
+    guint modem_boot_timer;
+    guint modem_boot_timeout;
+
+    GUdevClient *udev;
 
     struct gpiod_chip *gpiochip[2];
     struct gpiod_line *gpio_out[5];
@@ -51,7 +114,10 @@ struct EG25Manager {
 
 void modem_configure(struct EG25Manager *data);
 void modem_reset(struct EG25Manager *data);
-void modem_suspend(struct EG25Manager *data);
+void modem_suspend_pre(struct EG25Manager *data);
+void modem_suspend_post(struct EG25Manager *data);
 void modem_resume_pre(struct EG25Manager *data);
 void modem_resume_post(struct EG25Manager *data);
+#ifdef HAVE_MMGLIB
 void modem_update_state(struct EG25Manager *data, MMModemState state);
+#endif

src/meson.build

@@ -4,15 +4,29 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 #
 
-executable (
-    'eg25manager',
-    [
+
+subdir('libgdbofono')
+
+src = [
         'at.c', 'at.h',
         'gpio.c', 'gpio.h',
         'manager.c', 'manager.h',
-        'mm-iface.c', 'mm-iface.h',
+        'ofono-iface.c', 'ofono-iface.h',
         'suspend.c', 'suspend.h',
-    ],
+        'toml.c', 'toml.h',
+        'udev.c', 'udev.h',
+        'gnss.c', 'gnss.h',
+        gdbofono_headers,
+]
+
+if mmglib_dep.found()
+  src += ['mm-iface.c', 'mm-iface.h']
+endif
+
+executable (
+    'eg25manager',
+    src,
     dependencies : mgr_deps,
+    link_with: gdbofono_lib,
     install : true
 )

src/mm-iface.c

@@ -32,10 +32,13 @@ static void add_modem(struct EG25Manager *manager, GDBusObject *object)
 
     g_assert(MM_IS_OBJECT (object));
     manager->mm_modem = mm_object_get_modem(MM_OBJECT(object));
-    g_assert(manager->mm_modem != NULL);
+    g_assert_nonnull(manager->mm_modem);
 
     if (manager->modem_state == EG25_STATE_RESUMING) {
-        g_source_remove(manager->suspend_source);
+        if (manager->modem_recovery_timer) {
+            g_source_remove(manager->modem_recovery_timer);
+            manager->modem_recovery_timer = 0;
+        }
         modem_resume_post(manager);
         manager->modem_state = EG25_STATE_CONFIGURED;
     }
@@ -57,6 +60,16 @@ static void add_modem(struct EG25Manager *manager, GDBusObject *object)
     g_signal_connect(gdbus_modem, "state-changed", G_CALLBACK(state_changed_cb), manager);
 }
 
+static void add_modem_location(struct EG25Manager *manager, GDBusObject *object)
+{
+    const gchar *path;
+
+    path = g_dbus_object_get_object_path(object);
+    g_message("Adding new modem with location capabilities `%s'", path);
+    manager->mm_location = mm_object_get_modem_location(MM_OBJECT(object));
+    g_assert_nonnull(manager->mm_location);
+}
+
 static void interface_added_cb (struct EG25Manager *manager,
                                 GDBusObject        *object,
                                 GDBusInterface     *interface)
@@ -69,6 +82,9 @@ static void interface_added_cb (struct EG25Manager *manager,
 
     if (g_strcmp0(info->name, MM_DBUS_INTERFACE_MODEM) == 0)
         add_modem(manager, object);
+
+    if (g_strcmp0(info->name, MM_DBUS_INTERFACE_MODEM_LOCATION) == 0)
+        add_modem_location(manager, object);
 }
 
 
@@ -84,13 +100,8 @@ static void interface_removed_cb(struct EG25Manager *manager,
 
     g_message("ModemManager interface `%s' removed on object `%s'", info->name, path);
 
-    if (g_strcmp0(info->name, MM_DBUS_INTERFACE_MODEM) == 0) {
+    if (g_strcmp0(info->name, MM_DBUS_INTERFACE_MODEM) == 0)
         manager->mm_modem = NULL;
-        if (manager->modem_usb_id) {
-            g_free(manager->modem_usb_id);
-            manager->modem_usb_id = NULL;
-        }
-    }
 }
 
 
@@ -133,10 +144,6 @@ static void object_removed_cb(struct EG25Manager *manager, GDBusObject *object)
     g_message("ModemManager object `%s' removed", path);
 
     manager->mm_modem = NULL;
-    if (manager->modem_usb_id) {
-        g_free(manager->modem_usb_id);
-        manager->modem_usb_id = NULL;
-    }
 }
 
 
@@ -144,7 +151,7 @@ static void mm_manager_new_cb(GDBusConnection    *connection,
                               GAsyncResult       *res,
                               struct EG25Manager *manager)
 {
-    GError *error = NULL;
+    g_autoptr (GError) error = NULL;
 
     manager->mm_manager = mm_manager_new_finish(res, &error);
     if (!manager->mm_manager)
@@ -169,19 +176,40 @@ static void mm_appeared_cb(GDBusConnection    *connection,
 {
     g_message("ModemManager appeared on D-Bus");
 
+    if (manager->modem_iface != MODEM_IFACE_NONE) {
+        g_critical("Modem interface already found! Make sure to only run either of ModemManager or oFono.");
+        return;
+    }
+    manager->modem_iface = MODEM_IFACE_MODEMMANAGER;
+
     mm_manager_new(connection, G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,
                    NULL, (GAsyncReadyCallback)mm_manager_new_cb, manager);
 }
 
+static void mm_iface_clean(struct EG25Manager *manager)
+{
+    if (manager->mm_manager) {
+        g_clear_object(&manager->mm_manager);
+        manager->mm_manager = NULL;
+    }
+    if (manager->modem_usb_id) {
+        g_free(manager->modem_usb_id);
+        manager->modem_usb_id = NULL;
+    }
+    if (manager->modem_iface == MODEM_IFACE_MODEMMANAGER) {
+        manager->modem_iface = MODEM_IFACE_NONE;
+    }
+}
+
 static void mm_vanished_cb(GDBusConnection    *connection,
                            const gchar        *name,
                            struct EG25Manager *manager)
 {
     g_message("ModemManager vanished from D-Bus");
-    mm_iface_destroy(manager);
+    mm_iface_clean(manager);
 }
 
-void mm_iface_init(struct EG25Manager *manager)
+void mm_iface_init(struct EG25Manager *manager, toml_table_t *config)
 {
     manager->mm_watch = g_bus_watch_name(G_BUS_TYPE_SYSTEM, MM_DBUS_SERVICE,
                                          G_BUS_NAME_WATCHER_FLAGS_AUTO_START,
@@ -192,10 +220,7 @@ void mm_iface_init(struct EG25Manager *manager)
 
 void mm_iface_destroy(struct EG25Manager *manager)
 {
-    if (manager->mm_manager) {
-        g_clear_object(&manager->mm_manager);
-        manager->mm_manager = NULL;
-    }
+    mm_iface_clean(manager);
     if (manager->mm_watch != 0) {
         g_bus_unwatch_name(manager->mm_watch);
         manager->mm_watch = 0;

src/mm-iface.h

@@ -8,5 +8,5 @@
 
 #include "manager.h"
 
-void mm_iface_init(struct EG25Manager *data);
+void mm_iface_init(struct EG25Manager *data, toml_table_t *config);
 void mm_iface_destroy(struct EG25Manager *data);

src/ofono-iface.c

@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2020 Oliver Smith <ollieparanoid@postmarketos.org>
+ * Copyright (C) 2021 Bhushan Shah <bshah@kde.org>
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#include "ofono-iface.h"
+
+#include <string.h>
+
+#include <libgdbofono/gdbo-manager.h>
+#include <libgdbofono/gdbo-modem.h>
+
+#define OFONO_SERVICE "org.ofono"
+
+static void modem_added_cb(GDBOManager *manager_proxy,
+                           const gchar *path,
+                           GVariant *properties,
+                           struct EG25Manager *manager)
+{
+    GVariant *modem_path;
+    g_debug("Adding ofono modem '%s'", path);
+
+    if (manager->modem_state == EG25_STATE_RESUMING) {
+        if (manager->modem_recovery_timer) {
+            g_source_remove(manager->modem_recovery_timer);
+            manager->modem_recovery_timer = 0;
+        }
+        modem_resume_post(manager);
+        manager->modem_state = EG25_STATE_CONFIGURED;
+    }
+
+    if (manager->modem_state < EG25_STATE_ACQUIRED)
+        manager->modem_state = EG25_STATE_ACQUIRED;
+
+    if (manager->modem_state < EG25_STATE_CONFIGURED)
+        modem_configure(manager);
+
+    modem_path = g_variant_lookup_value(properties, "SystemPath", G_VARIANT_TYPE_STRING);
+    if (manager->modem_usb_id)
+        g_free(manager->modem_usb_id);
+    manager->modem_usb_id = g_strdup(strrchr(g_variant_dup_string(modem_path, NULL), '/') + 1);
+}
+
+static void modem_removed_cb(GDBOManager *manager_proxy,
+                             const gchar *path,
+                             struct EG25Manager *manager)
+{
+}
+
+static void get_modems_cb(GDBOManager *manager_proxy,
+                          GAsyncResult *res,
+                          struct EG25Manager *manager)
+{
+    gboolean ok;
+    GVariant *modems;
+    GVariantIter *modems_iter = NULL;
+    g_autoptr(GError) error = NULL;
+
+    const gchar *path;
+    GVariant *properties;
+
+    ok = gdbo_manager_call_get_modems_finish(manager_proxy, &modems,
+                                             res, &error);
+    if (!ok) {
+        g_warning("Error getting modems from ofono manager: %s", error->message);
+        return;
+    }
+
+    g_variant_get(modems, "a(oa{sv})", &modems_iter);
+    while(g_variant_iter_loop(modems_iter, "(&o@a{sv})", &path, &properties)) {
+        g_debug("Got modem object path '%s'", path);
+        modem_added_cb(manager_proxy, path, properties, manager);
+    }
+    g_variant_iter_free(modems_iter);
+    g_variant_unref(modems);
+}
+
+static void ofono_appeared_cb(GDBusConnection    *connection,
+                              const gchar        *name,
+                              const gchar        *name_owner,
+                              struct EG25Manager *manager)
+{
+    GError *error = NULL;
+
+    g_message("oFono appeared on D-Bus");
+
+    if (manager->modem_iface != MODEM_IFACE_NONE) {
+        g_critical("Modem interface already found! Make sure to only run either of ModemManager or oFono.");
+        return;
+    }
+    /* now connect to oFono! */
+    manager->ofono_connection = connection;
+    manager->ofono_manager = gdbo_manager_proxy_new_sync(connection,
+                                                         G_DBUS_PROXY_FLAGS_NONE,
+                                                         OFONO_SERVICE,
+                                                         "/",
+                                                         NULL,
+                                                         &error);
+    if (!manager->ofono_manager) {
+        g_critical("Error creating ofono object manager proxy: %s", error->message);
+        return;
+    }
+
+    manager->modem_iface = MODEM_IFACE_OFONO;
+
+    g_signal_connect(manager->ofono_manager, "modem-added",
+                     G_CALLBACK(modem_added_cb), manager);
+    g_signal_connect(manager->ofono_manager, "modem-removed",
+                     G_CALLBACK(modem_removed_cb), manager);
+
+    gdbo_manager_call_get_modems(manager->ofono_manager,
+                                 NULL,
+                                 (GAsyncReadyCallback) get_modems_cb,
+                                 manager);
+}
+
+static void ofono_vanished_cb(GDBusConnection    *connection,
+                              const gchar        *name,
+                              struct EG25Manager *manager)
+{
+    g_message("oFono vanished from D-Bus");
+
+    if (manager->modem_iface == MODEM_IFACE_OFONO) {
+        manager->modem_iface = MODEM_IFACE_NONE;
+        ofono_iface_destroy(manager);
+    }
+}
+
+void ofono_iface_init(struct EG25Manager *manager)
+{
+    manager->ofono_watch = g_bus_watch_name(G_BUS_TYPE_SYSTEM, OFONO_SERVICE,
+                                            G_BUS_NAME_WATCHER_FLAGS_AUTO_START,
+                                            (GBusNameAppearedCallback)ofono_appeared_cb,
+                                            (GBusNameVanishedCallback)ofono_vanished_cb,
+                                            manager, NULL);
+}
+
+void ofono_iface_destroy(struct EG25Manager *manager)
+{
+    if (manager->modem_usb_id) {
+        g_free(manager->modem_usb_id);
+        manager->modem_usb_id = NULL;
+    }
+    if (manager->ofono_watch != 0) {
+        g_bus_unwatch_name(manager->ofono_watch);
+        manager->ofono_watch = 0;
+    }
+}

src/ofono-iface.h

@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2020 Oliver Smith <ollieparanoid@postmarketos.org>
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#pragma once
+
+#include "manager.h"
+
+void ofono_iface_init(struct EG25Manager *data);
+void ofono_iface_destroy(struct EG25Manager *data);

src/suspend.c

@@ -13,67 +13,139 @@
 
 #include <gio/gunixfdlist.h>
 
-#define SD_NAME      "org.freedesktop.login1"
-#define SD_PATH      "/org/freedesktop/login1"
-#define SD_INTERFACE "org.freedesktop.login1.Manager"
+#define SD_NAME         "org.freedesktop.login1"
+#define SD_PATH         "/org/freedesktop/login1"
+#define SD_INTERFACE    "org.freedesktop.login1.Manager"
 
 static gboolean check_modem_resume(struct EG25Manager *manager)
 {
     g_message("Modem wasn't probed in time, restart it!");
+    manager->modem_recovery_timer = 0;
     modem_reset(manager);
 
     return FALSE;
 }
 
-static gboolean drop_inhibitor(struct EG25Manager *manager)
+static gboolean drop_inhibitor(struct EG25Manager *manager, gboolean block)
 {
-    if (manager->suspend_inhibit_fd >= 0) {
-        g_message("dropping systemd sleep inhibitor");
-        close(manager->suspend_inhibit_fd);
-        manager->suspend_inhibit_fd = -1;
-        return TRUE;
+    if (block) {
+        if (manager->suspend_block_fd >= 0) {
+            g_message("dropping systemd sleep block inhibitor");
+            close(manager->suspend_block_fd);
+            manager->suspend_block_fd = -1;
+            return TRUE;
+        }
+    }
+    else {
+        if (manager->suspend_delay_fd >= 0) {
+            g_message("dropping systemd sleep delay inhibitor");
+            close(manager->suspend_delay_fd);
+            manager->suspend_delay_fd = -1;
+            return TRUE;
+        }
     }
     return FALSE;
 }
 
-static void inhibit_done(GObject *source,
-                         GAsyncResult *result,
-                         gpointer user_data)
+static void inhibit_done_delay(GObject *source,
+                               GAsyncResult *result,
+                               gpointer user_data)
 {
     GDBusProxy *suspend_proxy = G_DBUS_PROXY(source);
     struct EG25Manager *manager = user_data;
-    GError *error = NULL;
+    g_autoptr (GError) error = NULL;
     GVariant *res;
     GUnixFDList *fd_list;
 
-    res = g_dbus_proxy_call_with_unix_fd_list_finish(suspend_proxy, &fd_list, result, &error);
+    res = g_dbus_proxy_call_with_unix_fd_list_finish(suspend_proxy, &fd_list,
+                                                     result, &error);
     if (!res) {
         g_warning("inhibit failed: %s", error->message);
-        g_error_free(error);
     } else {
         if (!fd_list || g_unix_fd_list_get_length(fd_list) != 1)
             g_warning("didn't get a single fd back");
 
-        manager->suspend_inhibit_fd = g_unix_fd_list_get(fd_list, 0, NULL);
+        manager->suspend_delay_fd = g_unix_fd_list_get(fd_list, 0, NULL);
 
-        g_message("inhibitor fd is %d", manager->suspend_inhibit_fd);
+        g_message("inhibitor sleep fd is %d", manager->suspend_delay_fd);
         g_object_unref(fd_list);
         g_variant_unref(res);
     }
 }
 
-static void take_inhibitor(struct EG25Manager *manager)
+static void inhibit_done_block(GObject *source,
+                               GAsyncResult *result,
+                               gpointer user_data)
+{
+    GDBusProxy *suspend_proxy = G_DBUS_PROXY(source);
+    struct EG25Manager *manager = user_data;
+    g_autoptr (GError) error = NULL;
+    GVariant *res;
+    GUnixFDList *fd_list;
+
+    res = g_dbus_proxy_call_with_unix_fd_list_finish(suspend_proxy, &fd_list,
+                                                     result, &error);
+    if (!res) {
+        g_warning("inhibit failed: %s", error->message);
+    } else {
+        if (!fd_list || g_unix_fd_list_get_length(fd_list) != 1)
+            g_warning("didn't get a single fd back");
+
+        manager->suspend_block_fd = g_unix_fd_list_get(fd_list, 0, NULL);
+
+        g_message("inhibitor block fd is %d", manager->suspend_block_fd);
+        g_object_unref(fd_list);
+        g_variant_unref(res);
+    }
+}
+
+/*
+ * After the EG25 modem sends 'RDY', it takes up to 2 minutes before all
+ * capabilities are operational. If the modem is suspended before that,
+ * calls and texts may be not recognized properly.
+ */
+static gboolean modem_fully_booted(struct EG25Manager *manager)
+{
+    g_message("Modem is up for %u seconds and fully ready", manager->modem_boot_timeout);
+    manager->modem_boot_timer = 0;
+    drop_inhibitor(manager, TRUE);
+
+    return FALSE;
+}
+
+static void take_inhibitor(struct EG25Manager *manager, gboolean block)
 {
     GVariant *variant_arg;
 
-    g_assert(manager->suspend_inhibit_fd == -1);
+    if (block) {
+        if(manager->suspend_block_fd != -1)
+            drop_inhibitor(manager, TRUE);
 
-    variant_arg = g_variant_new ("(ssss)", "sleep", "eg25manager",
-                                 "eg25manager needs to prepare modem for sleep", "delay");
+        variant_arg = g_variant_new ("(ssss)", "sleep", "eg25manager",
+                                     "eg25manager needs to wait for modem to be fully booted",
+                                     "block");
 
-    g_message("taking systemd sleep inhibitor");
-    g_dbus_proxy_call_with_unix_fd_list(manager->suspend_proxy, "Inhibit", variant_arg,
-                                        0, G_MAXINT, NULL, NULL, inhibit_done, manager);
+        g_message("taking systemd sleep inhibitor (blocking)");
+        g_dbus_proxy_call_with_unix_fd_list(manager->suspend_proxy, "Inhibit",
+                                            variant_arg, 0, G_MAXINT, NULL, NULL,
+                                            inhibit_done_block, manager);
+        manager->modem_boot_timer = g_timeout_add_seconds(manager->modem_boot_timeout,
+                                                          G_SOURCE_FUNC(modem_fully_booted),
+                                                          manager);
+    }
+    else {
+        if(manager->suspend_delay_fd != -1)
+            drop_inhibitor(manager, FALSE);
+
+        variant_arg = g_variant_new ("(ssss)", "sleep", "eg25manager",
+                                     "eg25manager needs to prepare modem for sleep",
+                                     "delay");
+
+        g_message("taking systemd sleep inhibitor");
+        g_dbus_proxy_call_with_unix_fd_list(manager->suspend_proxy, "Inhibit",
+                                            variant_arg, 0, G_MAXINT, NULL, NULL,
+                                            inhibit_done_delay, manager);
+    }
 }
 
 static void signal_cb(GDBusProxy *proxy,
@@ -93,13 +165,32 @@ static void signal_cb(GDBusProxy *proxy,
     if (is_about_to_suspend) {
         g_message("system is about to suspend");
         manager->modem_state = EG25_STATE_SUSPENDING;
-        modem_suspend(manager);
+        modem_suspend_pre(manager);
     } else {
         g_message("system is resuming");
-        take_inhibitor(manager);
+        take_inhibitor(manager, FALSE);
         modem_resume_pre(manager);
-        manager->modem_state = EG25_STATE_RESUMING;
-        manager->suspend_source = g_timeout_add_seconds(8, G_SOURCE_FUNC(check_modem_resume), manager);
+        if (
+#ifdef HAVE_MMGLIB
+            manager->mm_modem || 
+#endif
+            manager->modem_iface == MODEM_IFACE_OFONO) {
+            /*
+             * On some systems ModemManager doesn't handle suspend/resume, so
+             * we still have a valid/managed modem when resuming. In this case,
+             * do the whole resume sequence immediately.
+             *
+             * If modem is managed by ofono, we also do resume sequence immediately
+             * as ofono handles resuming from sleep itself.
+             */
+            manager->modem_state = EG25_STATE_CONFIGURED;
+            modem_resume_post(manager);
+        } else {
+            manager->modem_state = EG25_STATE_RESUMING;
+            manager->modem_recovery_timer = g_timeout_add_seconds(manager->modem_recovery_timeout,
+                                                                  G_SOURCE_FUNC(check_modem_resume),
+                                                                  manager);
+        }
     }
 }
 
@@ -115,10 +206,10 @@ static void name_owner_cb(GObject *object,
 
     owner = g_dbus_proxy_get_name_owner(proxy);
     if (owner) {
-        take_inhibitor(manager);
+        take_inhibitor(manager, FALSE);
         g_free(owner);
     } else {
-        drop_inhibitor(manager);
+        drop_inhibitor(manager, FALSE);
     }
 }
 
@@ -126,28 +217,46 @@ static void on_proxy_acquired(GObject *object,
                               GAsyncResult *res,
                               struct EG25Manager *manager)
 {
-    GError *error = NULL;
+    g_autoptr (GError) error = NULL;
     char *owner;
 
     manager->suspend_proxy = g_dbus_proxy_new_for_bus_finish(res, &error);
     if (!manager->suspend_proxy) {
         g_warning("failed to acquire logind proxy: %s", error->message);
-        g_clear_error(&error);
         return;
     }
 
-    g_signal_connect(manager->suspend_proxy, "notify::g-name-owner", G_CALLBACK(name_owner_cb), manager);
-    g_signal_connect(manager->suspend_proxy, "g-signal", G_CALLBACK(signal_cb), manager);
+    g_signal_connect(manager->suspend_proxy, "notify::g-name-owner",
+                     G_CALLBACK(name_owner_cb), manager);
+    g_signal_connect(manager->suspend_proxy, "g-signal",
+                     G_CALLBACK(signal_cb), manager);
 
     owner = g_dbus_proxy_get_name_owner(manager->suspend_proxy);
     if (owner) {
-        take_inhibitor(manager);
+        take_inhibitor(manager, FALSE);
         g_free(owner);
     }
 }
 
-void suspend_init(struct EG25Manager *manager)
+void suspend_init(struct EG25Manager *manager, toml_table_t *config)
 {
+    toml_datum_t timeout_value;
+
+    if (config) {
+        timeout_value = toml_int_in(config, "boot_timeout");
+        if (timeout_value.ok)
+            manager->modem_boot_timeout = (guint)timeout_value.u.i;
+
+        timeout_value = toml_int_in(config, "recovery_timeout");
+        if (timeout_value.ok)
+            manager->modem_recovery_timeout = (guint)timeout_value.u.i;
+    }
+
+    if (manager->modem_boot_timeout == 0)
+        manager->modem_boot_timeout = 120;
+    if (manager->modem_recovery_timeout == 0)
+        manager->modem_recovery_timeout = 9;
+
     g_dbus_proxy_new_for_bus(G_BUS_TYPE_SYSTEM,
                              G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START |
                              G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
@@ -157,17 +266,26 @@ void suspend_init(struct EG25Manager *manager)
 
 void suspend_destroy(struct EG25Manager *manager)
 {
-    drop_inhibitor(manager);
+    drop_inhibitor(manager, FALSE);
+    drop_inhibitor(manager, TRUE);
+    if (manager->modem_recovery_timer) {
+        g_source_remove(manager->modem_recovery_timer);
+        manager->modem_recovery_timer = 0;
+    }
+    if (manager->modem_boot_timer) {
+        g_source_remove(manager->modem_boot_timer);
+        manager->modem_boot_timer = 0;
+    }
     if (manager->suspend_proxy) {
         g_object_unref(manager->suspend_proxy);
         manager->suspend_proxy = NULL;
     }
 }
 
-void suspend_inhibit(struct EG25Manager *manager, gboolean inhibit)
+void suspend_inhibit(struct EG25Manager *manager, gboolean inhibit, gboolean block)
 {
     if (inhibit)
-        take_inhibitor(manager);
+        take_inhibitor(manager, block);
     else
-        drop_inhibitor(manager);
+        drop_inhibitor(manager, block);
 }

src/suspend.h

@@ -8,7 +8,7 @@
 
 #include "manager.h"
 
-void suspend_init (struct EG25Manager *data);
+void suspend_init (struct EG25Manager *data, toml_table_t *config);
 void suspend_destroy (struct EG25Manager *data);
 
-void suspend_inhibit (struct EG25Manager *data, gboolean inhibit);
+void suspend_inhibit (struct EG25Manager *data, gboolean inhibit, gboolean block);

src/toml.h

@@ -0,0 +1,175 @@
+/*
+  MIT License
+  
+  Copyright (c) 2017 - 2019 CK Tan
+  https://github.com/cktan/tomlc99
+  
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+  
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+  
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#ifndef TOML_H
+#define TOML_H
+
+
+#include <stdio.h>
+#include <stdint.h>
+
+
+#ifdef __cplusplus
+#define TOML_EXTERN extern "C"
+#else
+#define TOML_EXTERN extern
+#endif
+
+typedef struct toml_timestamp_t toml_timestamp_t;
+typedef struct toml_table_t toml_table_t;
+typedef struct toml_array_t toml_array_t;
+typedef struct toml_datum_t toml_datum_t;
+
+/* Parse a file. Return a table on success, or 0 otherwise. 
+ * Caller must toml_free(the-return-value) after use.
+ */
+TOML_EXTERN toml_table_t* toml_parse_file(FILE* fp, 
+										  char* errbuf,
+										  int errbufsz);
+
+/* Parse a string containing the full config. 
+ * Return a table on success, or 0 otherwise.
+ * Caller must toml_free(the-return-value) after use.
+ */
+TOML_EXTERN toml_table_t* toml_parse(char* conf, /* NUL terminated, please. */
+									 char* errbuf,
+									 int errbufsz);
+
+/* Free the table returned by toml_parse() or toml_parse_file(). Once 
+ * this function is called, any handles accessed through this tab 
+ * directly or indirectly are no longer valid.
+ */
+TOML_EXTERN void toml_free(toml_table_t* tab);
+
+
+/* Timestamp types. The year, month, day, hour, minute, second, z 
+ * fields may be NULL if they are not relevant. e.g. In a DATE
+ * type, the hour, minute, second and z fields will be NULLs.
+ */
+struct toml_timestamp_t {
+	struct { /* internal. do not use. */
+		int year, month, day;
+		int hour, minute, second, millisec;
+		char z[10];
+	} __buffer;
+	int *year, *month, *day;
+	int *hour, *minute, *second, *millisec;
+	char* z;
+};
+
+
+/*-----------------------------------------------------------------
+ *  Enhanced access methods 
+ */
+struct toml_datum_t {
+	int ok;
+	union {
+		toml_timestamp_t* ts; /* ts must be freed after use */
+		char*   s; /* string value. s must be freed after use */
+		int     b; /* bool value */
+		int64_t i; /* int value */
+		double  d; /* double value */
+	} u;
+};
+
+/* on arrays: */
+/* ... retrieve size of array. */
+TOML_EXTERN int toml_array_nelem(const toml_array_t* arr);
+/* ... retrieve values using index. */
+TOML_EXTERN toml_datum_t toml_string_at(const toml_array_t* arr, int idx);
+TOML_EXTERN toml_datum_t toml_bool_at(const toml_array_t* arr, int idx);
+TOML_EXTERN toml_datum_t toml_int_at(const toml_array_t* arr, int idx);
+TOML_EXTERN toml_datum_t toml_double_at(const toml_array_t* arr, int idx);
+TOML_EXTERN toml_datum_t toml_timestamp_at(const toml_array_t* arr, int idx);
+/* ... retrieve array or table using index. */
+TOML_EXTERN toml_array_t* toml_array_at(const toml_array_t* arr, int idx);
+TOML_EXTERN toml_table_t* toml_table_at(const toml_array_t* arr, int idx);
+
+/* on tables: */
+/* ... retrieve the key in table at keyidx. Return 0 if out of range. */
+TOML_EXTERN const char* toml_key_in(const toml_table_t* tab, int keyidx);
+/* ... retrieve values using key. */
+TOML_EXTERN toml_datum_t toml_string_in(const toml_table_t* arr, const char* key);
+TOML_EXTERN toml_datum_t toml_bool_in(const toml_table_t* arr, const char* key);
+TOML_EXTERN toml_datum_t toml_int_in(const toml_table_t* arr, const char* key);
+TOML_EXTERN toml_datum_t toml_double_in(const toml_table_t* arr, const char* key);
+TOML_EXTERN toml_datum_t toml_timestamp_in(const toml_table_t* arr, const char* key);
+/* .. retrieve array or table using key. */
+TOML_EXTERN toml_array_t* toml_array_in(const toml_table_t* tab,
+										const char* key);
+TOML_EXTERN toml_table_t* toml_table_in(const toml_table_t* tab,
+										const char* key);
+
+/*-----------------------------------------------------------------
+ * lesser used 
+ */
+/* Return the array kind: 't'able, 'a'rray, 'v'alue */
+TOML_EXTERN char toml_array_kind(const toml_array_t* arr);
+
+/* For array kind 'v'alue, return the type of values 
+   i:int, d:double, b:bool, s:string, t:time, D:date, T:timestamp
+   0 if unknown
+*/
+TOML_EXTERN char toml_array_type(const toml_array_t* arr);
+
+/* Return the key of an array */
+TOML_EXTERN const char* toml_array_key(const toml_array_t* arr);
+
+/* Return the number of key-values in a table */
+TOML_EXTERN int toml_table_nkval(const toml_table_t* tab);
+
+/* Return the number of arrays in a table */
+TOML_EXTERN int toml_table_narr(const toml_table_t* tab);
+
+/* Return the number of sub-tables in a table */
+TOML_EXTERN int toml_table_ntab(const toml_table_t* tab);
+
+/* Return the key of a table*/
+TOML_EXTERN const char* toml_table_key(const toml_table_t* tab);
+
+/*--------------------------------------------------------------
+ * misc 
+ */
+TOML_EXTERN int toml_utf8_to_ucs(const char* orig, int len, int64_t* ret);
+TOML_EXTERN int toml_ucs_to_utf8(int64_t code, char buf[6]);
+TOML_EXTERN void toml_set_memutil(void* (*xxmalloc)(size_t),
+								  void	(*xxfree)(void*));
+
+
+/*--------------------------------------------------------------
+ *  deprecated 
+ */
+/* A raw value, must be processed by toml_rto* before using. */
+typedef const char* toml_raw_t;
+TOML_EXTERN toml_raw_t toml_raw_in(const toml_table_t* tab, const char* key);
+TOML_EXTERN toml_raw_t toml_raw_at(const toml_array_t* arr, int idx);
+TOML_EXTERN int toml_rtos(toml_raw_t s, char** ret);
+TOML_EXTERN int toml_rtob(toml_raw_t s, int* ret);
+TOML_EXTERN int toml_rtoi(toml_raw_t s, int64_t* ret);
+TOML_EXTERN int toml_rtod(toml_raw_t s, double* ret);
+TOML_EXTERN int toml_rtod_ex(toml_raw_t s, double* ret, char* buf, int buflen);
+TOML_EXTERN int toml_rtots(toml_raw_t s, toml_timestamp_t* ret);
+
+
+#endif /* TOML_H */

src/udev.c

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2020 Arnaud Ferraris <arnaud.ferraris@gmail.com>
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#include "udev.h"
+
+#include <string.h>
+
+static void udev_event_cb(GUdevClient *client, gchar *action, GUdevDevice *device, gpointer data)
+{
+    struct EG25Manager *manager = data;
+
+    if (strcmp(action, "unbind") != 0 ||
+        manager->modem_state == EG25_STATE_RESETTING ||
+        !manager->modem_usb_id) {
+        return;
+    }
+
+    if (strncmp(g_udev_device_get_name(device), manager->modem_usb_id, strlen(manager->modem_usb_id)) == 0 &&
+        manager->reset_timer == 0) {
+        g_message("Lost modem, resetting...");
+        modem_reset(manager);
+    }
+}
+
+void udev_init (struct EG25Manager *manager, toml_table_t *config)
+{
+    const char * const subsystems[] = { "usb", NULL };
+
+    manager->udev = g_udev_client_new(subsystems);
+    g_signal_connect(manager->udev, "uevent", G_CALLBACK(udev_event_cb), manager);
+
+    return;
+}
+
+void udev_destroy (struct EG25Manager *manager)
+{
+    if (manager->udev) {
+        g_object_unref(manager->udev);
+        manager->udev = NULL;
+    }
+}

src/udev.h

@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2020 Arnaud Ferraris <arnaud.ferraris@gmail.com>
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#pragma once
+
+#include "manager.h"
+
+void udev_init (struct EG25Manager *data, toml_table_t *config);
+void udev_destroy (struct EG25Manager *data);

udev/80-modem-eg25.rules

@@ -0,0 +1,4 @@
+ACTION=="add", SUBSYSTEM=="usb", DRIVERS=="usb", ENV{DEVTYPE}=="usb_device", ATTRS{idVendor}=="2c7c", ATTRS{idProduct}=="0125", ATTR{power/control}="auto"
+ACTION=="add", SUBSYSTEM=="usb", DRIVERS=="usb", ENV{DEVTYPE}=="usb_device", ATTRS{idVendor}=="2c7c", ATTRS{idProduct}=="0125", ATTR{power/autosuspend_delay_ms}="3000"
+ACTION=="add", SUBSYSTEM=="usb", DRIVERS=="usb", ENV{DEVTYPE}=="usb_device", ATTRS{idVendor}=="2c7c", ATTRS{idProduct}=="0125", ATTR{power/wakeup}="enabled"
+ACTION=="add", SUBSYSTEM=="usb", DRIVERS=="usb", ENV{DEVTYPE}=="usb_device", ATTRS{idVendor}=="2c7c", ATTRS{idProduct}=="0125", ATTR{power/persist}="0"

udev/meson.build

@@ -0,0 +1,7 @@
+#
+# Copyright (C) 2020 Arnaud Ferraris <arnaud.ferraris@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+install_data ('80-modem-eg25.rules', install_dir: udevrulesdir)