serial: refactor MMSerialPort into a base class and an AT-capable serial port

For QCDM devices we want most of what MMSerialPort does, but not
the AT command handling stuff since the commands and responses
aren't AT commands nor are they even strings.  So convert everything
that MMSerialPort does into a GByteArray, and let MMAtSerialPort
handle the conversion to strings when necessary.

plugins/mm-modem-anydata-cdma.c

@@ -112,7 +112,7 @@ int_from_match_item (GMatchInfo *match_info, guint32 num, gint *val)
 }
 
 static void
-evdo_state_done (MMSerialPort *port,
+evdo_state_done (MMAtSerialPort *port,
                  GString *response,
                  GError *error,
                  gpointer user_data)
@@ -191,7 +191,7 @@ evdo_state_done (MMSerialPort *port,
 }
 
 static void
-state_done (MMSerialPort *port,
+state_done (MMAtSerialPort *port,
             GString *response,
             GError *error,
             gpointer user_data)
@@ -265,7 +265,7 @@ state_done (MMSerialPort *port,
     mm_generic_cdma_query_reg_state_set_callback_1x_state (info, reg_state);
 
     /* Try for EVDO state too */
-    mm_serial_port_queue_command (port, "*HSTATE?", 3, evdo_state_done, info);
+    mm_at_serial_port_queue_command (port, "*HSTATE?", 3, evdo_state_done, info);
 }
 
 static void
@@ -274,10 +274,10 @@ query_registration_state (MMGenericCdma *cdma,
                           gpointer user_data)
 {
     MMCallbackInfo *info;
-    MMSerialPort *primary, *secondary, *port;
+    MMAtSerialPort *primary, *secondary, *port;
 
-    port = primary = mm_generic_cdma_get_port (cdma, MM_PORT_TYPE_PRIMARY);
+    port = primary = mm_generic_cdma_get_at_port (cdma, MM_PORT_TYPE_PRIMARY);
-    secondary = mm_generic_cdma_get_port (cdma, MM_PORT_TYPE_SECONDARY);
+    secondary = mm_generic_cdma_get_at_port (cdma, MM_PORT_TYPE_SECONDARY);
 
     info = mm_generic_cdma_query_reg_state_callback_info_new (cdma, callback, user_data);
 
@@ -293,7 +293,7 @@ query_registration_state (MMGenericCdma *cdma,
         port = secondary;        
     }
 
-    mm_serial_port_queue_command (port, "*STATE?", 3, state_done, info);
+    mm_at_serial_port_queue_command (port, "*STATE?", 3, state_done, info);
 }
 
 /*****************************************************************************/
@@ -310,22 +310,22 @@ grab_port (MMModem *modem,
     GRegex *regex;
 
     port = mm_generic_cdma_grab_port (MM_GENERIC_CDMA (modem), subsys, name, suggested_type, user_data, error);
-    if (port && MM_IS_SERIAL_PORT (port)) {
+    if (port && MM_IS_AT_SERIAL_PORT (port)) {
         /* Data state notifications */
 
         /* Data call has connected */
         regex = g_regex_new ("\\r\\n\\*ACTIVE:(.*)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, NULL, NULL, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, NULL, NULL);
         g_regex_unref (regex);
 
         /* Data call disconnected */
         regex = g_regex_new ("\\r\\n\\*INACTIVE:(.*)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, NULL, NULL, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, NULL, NULL);
         g_regex_unref (regex);
 
         /* Modem is now dormant */
         regex = g_regex_new ("\\r\\n\\*DORMANT:(.*)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, NULL, NULL, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, NULL, NULL);
         g_regex_unref (regex);
 
         /* Abnomral state notifications
@@ -336,17 +336,17 @@ grab_port (MMModem *modem,
 
         /* Network acquisition fail */
         regex = g_regex_new ("\\r\\n\\*OFFLINE:(.*)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, NULL, NULL, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, NULL, NULL);
         g_regex_unref (regex);
 
         /* Registration fail */
         regex = g_regex_new ("\\r\\n\\*REGREQ:(.*)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, NULL, NULL, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, NULL, NULL);
         g_regex_unref (regex);
 
         /* Authentication fail */
         regex = g_regex_new ("\\r\\n\\*AUTHREQ:(.*)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, NULL, NULL, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, NULL, NULL);
         g_regex_unref (regex);
     }
 

plugins/mm-modem-gobi-gsm.c

@@ -23,6 +23,7 @@
 #include "mm-errors.h"
 #include "mm-callback-info.h"
 #include "mm-modem-gsm-card.h"
+#include "mm-at-serial-port.h"
 
 static void modem_init (MMModem *modem_class);
 static void modem_gsm_card_init (MMModemGsmCard *gsm_card_class);
@@ -51,7 +52,7 @@ mm_modem_gobi_gsm_new (const char *device,
 /*****************************************************************************/
 
 static void
-get_string_done (MMSerialPort *port,
+get_string_done (MMAtSerialPort *port,
                  GString *response,
                  GError *error,
                  gpointer user_data)
@@ -75,13 +76,13 @@ get_imsi (MMModemGsmCard *modem,
           MMModemStringFn callback,
           gpointer user_data)
 {
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
     MMCallbackInfo *info;
 
     info = mm_callback_info_string_new (MM_MODEM (modem), callback, user_data);
-    primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
-    mm_serial_port_queue_command_cached (primary, "+CIMI", 3, get_string_done, info);
+    mm_at_serial_port_queue_command_cached (primary, "+CIMI", 3, get_string_done, info);
 }
 
 static void

plugins/mm-modem-hso.c

@@ -88,7 +88,7 @@ mm_modem_hso_new (const char *device,
 #define IGNORE_ERRORS_TAG "ignore-errors"
 
 static void
-hso_call_control_done (MMSerialPort *port,
+hso_call_control_done (MMAtSerialPort *port,
                        GString *response,
                        GError *error,
                        gpointer user_data)
@@ -122,15 +122,15 @@ hso_call_control (MMModemHso *self,
 {
     MMCallbackInfo *info;
     char *command;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     info = mm_callback_info_new (MM_MODEM (self), callback, user_data);
     mm_callback_info_set_data (info, IGNORE_ERRORS_TAG, GUINT_TO_POINTER (ignore_errors), NULL);
 
     command = g_strdup_printf ("AT_OWANCALL=%d,%d,1", hso_get_cid (self), activate ? 1 : 0);
-    primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (self), MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (self), MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
-    mm_serial_port_queue_command (primary, command, 3, hso_call_control_done, info);
+    mm_at_serial_port_queue_command (primary, command, 3, hso_call_control_done, info);
     g_free (command);
 }
 
@@ -203,7 +203,7 @@ clear_old_context (MMModem *modem,
 }
 
 static void
-auth_done (MMSerialPort *port,
+auth_done (MMAtSerialPort *port,
            GString *response,
            GError *error,
            gpointer user_data)
@@ -236,12 +236,12 @@ static void
 _internal_hso_modem_authenticate (MMModemHso *self, MMCallbackInfo *info)
 {
     MMModemHsoPrivate *priv = MM_MODEM_HSO_GET_PRIVATE (self);
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
     guint32 cid;
     char *command;
     const char *username, *password;
 
-    primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (self), MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (self), MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
 
     cid = hso_get_cid (self);
@@ -260,7 +260,7 @@ _internal_hso_modem_authenticate (MMModemHso *self, MMCallbackInfo *info)
 
     }
 
-    mm_serial_port_queue_command (primary, command, 3, auth_done, info);
+    mm_at_serial_port_queue_command (primary, command, 3, auth_done, info);
     g_free (command);
 }
 
@@ -390,7 +390,7 @@ ip4_config_invoke (MMCallbackInfo *info)
 }
 
 static void
-get_ip4_config_done (MMSerialPort *port,
+get_ip4_config_done (MMAtSerialPort *port,
                      GString *response,
                      GError *error,
                      gpointer user_data)
@@ -453,13 +453,13 @@ get_ip4_config (MMModem *modem,
 {
     MMCallbackInfo *info;
     char *command;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     info = mm_callback_info_new_full (modem, ip4_config_invoke, G_CALLBACK (callback), user_data);
     command = g_strdup_printf ("AT_OWANDATA=%d", hso_get_cid (MM_MODEM_HSO (modem)));
-    primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
-    mm_serial_port_queue_command (primary, command, 3, get_ip4_config_done, info);
+    mm_at_serial_port_queue_command (primary, command, 3, get_ip4_config_done, info);
     g_free (command);
 }
 
@@ -469,12 +469,12 @@ disconnect (MMModem *modem,
             gpointer user_data)
 {
     MMCallbackInfo *info;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     info = mm_callback_info_new (modem, callback, user_data);
-    primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
-    mm_serial_port_queue_command (primary, "AT_OWANCALL=1,0,0", 3, NULL, info);
+    mm_at_serial_port_queue_command (primary, "AT_OWANCALL=1,0,0", 3, NULL, info);
 }
 
 /*****************************************************************************/
@@ -508,7 +508,7 @@ impl_hso_authenticate (MMModemHso *self,
 }
 
 static void
-connection_enabled (MMSerialPort *port,
+connection_enabled (MMAtSerialPort *port,
                     GMatchInfo *info,
                     gpointer user_data)
 {
@@ -676,7 +676,7 @@ grab_port (MMModem *modem,
     if (!port)
         goto out;
 
-    if (MM_IS_SERIAL_PORT (port)) {
+    if (MM_IS_AT_SERIAL_PORT (port)) {
         g_object_set (G_OBJECT (port), MM_SERIAL_PORT_SEND_DELAY, (guint64) 10000, NULL);
         if (ptype == MM_PORT_TYPE_PRIMARY) {
             GRegex *regex;
@@ -684,7 +684,7 @@ grab_port (MMModem *modem,
             mm_generic_gsm_set_unsolicited_registration (gsm, TRUE);
 
             regex = g_regex_new ("_OWANCALL: (\\d),\\s*(\\d)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-            mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, connection_enabled, modem, NULL);
+            mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, connection_enabled, modem, NULL);
             g_regex_unref (regex);
         }
     }

plugins/mm-modem-huawei-cdma.c

@@ -82,7 +82,7 @@ parse_quality (const char *str, const char *detail)
 }
 
 static void
-handle_1x_quality_change (MMSerialPort *port,
+handle_1x_quality_change (MMAtSerialPort *port,
                           GMatchInfo *match_info,
                           gpointer user_data)
 {
@@ -99,9 +99,9 @@ handle_1x_quality_change (MMSerialPort *port,
 }
 
 static void
-handle_evdo_quality_change (MMSerialPort *port,
+handle_evdo_quality_change (MMAtSerialPort *port,
-                          GMatchInfo *match_info,
+                            GMatchInfo *match_info,
-                          gpointer user_data)
+                            gpointer user_data)
 {
     MMModemHuaweiCdma *self = MM_MODEM_HUAWEI_CDMA (user_data);
     char *str;
@@ -152,7 +152,7 @@ uint_from_match_item (GMatchInfo *match_info, guint32 num, guint32 *val)
 }
 
 static void
-sysinfo_done (MMSerialPort *port,
+sysinfo_done (MMAtSerialPort *port,
               GString *response,
               GError *error,
               gpointer user_data)
@@ -239,10 +239,10 @@ query_registration_state (MMGenericCdma *cdma,
                           gpointer user_data)
 {
     MMCallbackInfo *info;
-    MMSerialPort *primary, *secondary, *port;
+    MMAtSerialPort *primary, *secondary, *port;
 
-    port = primary = mm_generic_cdma_get_port (cdma, MM_PORT_TYPE_PRIMARY);
+    port = primary = mm_generic_cdma_get_at_port (cdma, MM_PORT_TYPE_PRIMARY);
-    secondary = mm_generic_cdma_get_port (cdma, MM_PORT_TYPE_SECONDARY);
+    secondary = mm_generic_cdma_get_at_port (cdma, MM_PORT_TYPE_SECONDARY);
 
     info = mm_generic_cdma_query_reg_state_callback_info_new (cdma, callback, user_data);
 
@@ -258,7 +258,7 @@ query_registration_state (MMGenericCdma *cdma,
         port = secondary;
     }
 
-    mm_serial_port_queue_command (port, "^SYSINFO", 3, sysinfo_done, info);
+    mm_at_serial_port_queue_command (port, "^SYSINFO", 3, sysinfo_done, info);
 }
 
 /*****************************************************************************/
@@ -275,14 +275,14 @@ grab_port (MMModem *modem,
     GRegex *regex;
 
 	port = mm_generic_cdma_grab_port (MM_GENERIC_CDMA (modem), subsys, name, suggested_type, user_data, error);
-    if (port && MM_IS_SERIAL_PORT (port)) {
+    if (port && MM_IS_AT_SERIAL_PORT (port)) {
         gboolean evdo0 = FALSE, evdoA = FALSE;
 
         g_object_set (G_OBJECT (port), MM_PORT_CARRIER_DETECT, FALSE, NULL);
 
         /* 1x signal level */
         regex = g_regex_new ("\\r\\n\\^RSSILVL:(\\d+)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, handle_1x_quality_change, modem, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, handle_1x_quality_change, modem, NULL);
         g_regex_unref (regex);
 
         g_object_get (G_OBJECT (modem),
@@ -293,7 +293,7 @@ grab_port (MMModem *modem,
         if (evdo0 || evdoA) {
             /* EVDO signal level */
             regex = g_regex_new ("\\r\\n\\^HRSSILVL:(\\d+)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-            mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, handle_evdo_quality_change, modem, NULL);
+            mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, handle_evdo_quality_change, modem, NULL);
             g_regex_unref (regex);
         }
     }

plugins/mm-modem-huawei-gsm.c

@@ -25,7 +25,7 @@
 #include "mm-modem-gsm-network.h"
 #include "mm-errors.h"
 #include "mm-callback-info.h"
-#include "mm-serial-port.h"
+#include "mm-at-serial-port.h"
 #include "mm-serial-parsers.h"
 
 static void modem_init (MMModem *modem_class);
@@ -101,7 +101,7 @@ parse_syscfg (MMModemHuaweiGsm *self,
 }
 
 static void
-set_network_mode_done (MMSerialPort *port,
+set_network_mode_done (MMAtSerialPort *port,
                        GString *response,
                        GError *error,
                        gpointer user_data)
@@ -120,7 +120,7 @@ set_network_mode_done (MMSerialPort *port,
 }
 
 static void
-set_network_mode_get_done (MMSerialPort *port,
+set_network_mode_get_done (MMAtSerialPort *port,
                            GString *response,
                            GError *error,
                            gpointer user_data)
@@ -169,7 +169,7 @@ set_network_mode_get_done (MMSerialPort *port,
             }
 
             command = g_strdup_printf ("AT^SYSCFG=%d,%d,%X,%d,%d", a, b, band, u1, u2);
-            mm_serial_port_queue_command (port, command, 3, set_network_mode_done, info);
+            mm_at_serial_port_queue_command (port, command, 3, set_network_mode_done, info);
             g_free (command);
         }
     }
@@ -182,7 +182,7 @@ set_network_mode (MMModemGsmNetwork *modem,
                   gpointer user_data)
 {
     MMCallbackInfo *info;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     info = mm_callback_info_new (MM_MODEM (modem), callback, user_data);
 
@@ -200,9 +200,9 @@ set_network_mode (MMModemGsmNetwork *modem,
     case MM_MODEM_GSM_MODE_3G_ONLY:
         /* Allowed values */
         mm_callback_info_set_data (info, "mode", GUINT_TO_POINTER (mode), NULL);
-        primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
+        primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
         g_assert (primary);
-        mm_serial_port_queue_command (primary, "AT^SYSCFG?", 3, set_network_mode_get_done, info);
+        mm_at_serial_port_queue_command (primary, "AT^SYSCFG?", 3, set_network_mode_get_done, info);
         return;
     default:
         info->error = g_error_new_literal (MM_MODEM_ERROR, MM_MODEM_ERROR_GENERAL, "Invalid mode.");
@@ -213,7 +213,7 @@ set_network_mode (MMModemGsmNetwork *modem,
 }
 
 static void
-get_network_mode_done (MMSerialPort *port,
+get_network_mode_done (MMAtSerialPort *port,
                        GString *response,
                        GError *error,
                        gpointer user_data)
@@ -249,17 +249,17 @@ get_network_mode (MMModemGsmNetwork *modem,
     } else {
         /* Get it from modem */
         MMCallbackInfo *info;
-        MMSerialPort *primary;
+        MMAtSerialPort *primary;
 
         info = mm_callback_info_uint_new (MM_MODEM (modem), callback, user_data);
-        primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
+        primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
         g_assert (primary);
-        mm_serial_port_queue_command (primary, "AT^SYSCFG?", 3, get_network_mode_done, info);
+        mm_at_serial_port_queue_command (primary, "AT^SYSCFG?", 3, get_network_mode_done, info);
     }
 }
 
 static void
-set_band_done (MMSerialPort *port,
+set_band_done (MMAtSerialPort *port,
                GString *response,
                GError *error,
                gpointer user_data)
@@ -278,7 +278,7 @@ set_band_done (MMSerialPort *port,
 }
 
 static void
-set_band_get_done (MMSerialPort *port,
+set_band_get_done (MMAtSerialPort *port,
                    GString *response,
                    GError *error,
                    gpointer user_data)
@@ -320,7 +320,7 @@ set_band_get_done (MMSerialPort *port,
             }
 
             command = g_strdup_printf ("AT^SYSCFG=%d,%d,%X,%d,%d", a, b, band, u1, u2);
-            mm_serial_port_queue_command (port, command, 3, set_band_done, info);
+            mm_at_serial_port_queue_command (port, command, 3, set_band_done, info);
             g_free (command);
         }
     }
@@ -333,7 +333,7 @@ set_band (MMModemGsmNetwork *modem,
           gpointer user_data)
 {
     MMCallbackInfo *info;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     info = mm_callback_info_new (MM_MODEM (modem), callback, user_data);
 
@@ -344,9 +344,9 @@ set_band (MMModemGsmNetwork *modem,
     case MM_MODEM_GSM_BAND_U2100:
     case MM_MODEM_GSM_BAND_PCS:
         mm_callback_info_set_data (info, "band", GUINT_TO_POINTER (band), NULL);
-        primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
+        primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
         g_assert (primary);
-        mm_serial_port_queue_command (primary, "AT^SYSCFG?", 3, set_band_get_done, info);
+        mm_at_serial_port_queue_command (primary, "AT^SYSCFG?", 3, set_band_get_done, info);
         return;
     default:
         info->error = g_error_new_literal (MM_MODEM_ERROR, MM_MODEM_ERROR_GENERAL, "Invalid band.");
@@ -357,7 +357,7 @@ set_band (MMModemGsmNetwork *modem,
 }
 
 static void
-get_band_done (MMSerialPort *port,
+get_band_done (MMAtSerialPort *port,
                GString *response,
                GError *error,
                gpointer user_data)
@@ -382,7 +382,7 @@ get_band (MMModemGsmNetwork *modem,
           gpointer user_data)
 {
     MMModemHuaweiGsmPrivate *priv = MM_MODEM_HUAWEI_GSM_GET_PRIVATE (modem);
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     if (priv->band != MM_MODEM_GSM_BAND_ANY) {
         /* have cached mode (from an unsolicited message). Use that */
@@ -396,9 +396,9 @@ get_band (MMModemGsmNetwork *modem,
         MMCallbackInfo *info;
 
         info = mm_callback_info_uint_new (MM_MODEM (modem), callback, user_data);
-        primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
+        primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
         g_assert (primary);
-        mm_serial_port_queue_command (primary, "AT^SYSCFG?", 3, get_band_done, info);
+        mm_at_serial_port_queue_command (primary, "AT^SYSCFG?", 3, get_band_done, info);
     }
 }
 
@@ -428,7 +428,7 @@ get_signal_quality (MMModemGsmNetwork *modem,
 /* Unsolicited message handlers */
 
 static void
-handle_signal_quality_change (MMSerialPort *port,
+handle_signal_quality_change (MMAtSerialPort *port,
                               GMatchInfo *match_info,
                               gpointer user_data)
 {
@@ -454,7 +454,7 @@ handle_signal_quality_change (MMSerialPort *port,
 }
 
 static void
-handle_mode_change (MMSerialPort *port,
+handle_mode_change (MMAtSerialPort *port,
                     GMatchInfo *match_info,
                     gpointer user_data)
 {
@@ -494,7 +494,7 @@ handle_mode_change (MMSerialPort *port,
 }
 
 static void
-handle_status_change (MMSerialPort *port,
+handle_status_change (MMAtSerialPort *port,
                       GMatchInfo *match_info,
                       gpointer user_data)
 {
@@ -546,16 +546,16 @@ grab_port (MMModem *modem,
     }
 
     if (usbif == 0) {
-        if (!mm_generic_gsm_get_port (gsm, MM_PORT_TYPE_PRIMARY))
+        if (!mm_generic_gsm_get_at_port (gsm, MM_PORT_TYPE_PRIMARY))
             ptype = MM_PORT_TYPE_PRIMARY;
     } else if (suggested_type == MM_PORT_TYPE_SECONDARY) {
-        if (!mm_generic_gsm_get_port (gsm, MM_PORT_TYPE_SECONDARY))
+        if (!mm_generic_gsm_get_at_port (gsm, MM_PORT_TYPE_SECONDARY))
             ptype = MM_PORT_TYPE_SECONDARY;
     }
 
     port = mm_generic_gsm_grab_port (gsm, subsys, name, ptype, error);
 
-    if (port && MM_IS_SERIAL_PORT (port)) {
+    if (port && MM_IS_AT_SERIAL_PORT (port)) {
         g_object_set (G_OBJECT (port), MM_PORT_CARRIER_DETECT, FALSE, NULL);
         if (ptype == MM_PORT_TYPE_SECONDARY) {
             GRegex *regex;
@@ -563,19 +563,19 @@ grab_port (MMModem *modem,
             mm_generic_gsm_set_unsolicited_registration (MM_GENERIC_GSM (modem), TRUE);
 
             regex = g_regex_new ("\\r\\n\\^RSSI:(\\d+)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-            mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, handle_signal_quality_change, modem, NULL);
+            mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, handle_signal_quality_change, modem, NULL);
             g_regex_unref (regex);
 
             regex = g_regex_new ("\\r\\n\\^MODE:(\\d),(\\d)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-            mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, handle_mode_change, modem, NULL);
+            mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, handle_mode_change, modem, NULL);
             g_regex_unref (regex);
 
             regex = g_regex_new ("\\r\\n\\^DSFLOWRPT:(.+)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-            mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, handle_status_change, modem, NULL);
+            mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, handle_status_change, modem, NULL);
             g_regex_unref (regex);
 
             regex = g_regex_new ("\\r\\n\\^BOOT:.+\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-            mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, NULL, modem, NULL);
+            mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, modem, NULL);
             g_regex_unref (regex);
         }
     }

plugins/mm-modem-mbm.c

@@ -120,15 +120,15 @@ register_done (gpointer user_data)
     MMModemMbm *self = MM_MODEM_MBM (reg_data->modem);
     MMModemMbmPrivate *priv = MM_MODEM_MBM_GET_PRIVATE (self);
     MMModemGsmNetwork *parent_modem_iface;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     priv->reg_id = 0;
 
-    primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (self), MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (self), MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
 
-    mm_serial_port_queue_command (primary, "+CREG=1", 3, NULL, NULL);
+    mm_at_serial_port_queue_command (primary, "+CREG=1", 3, NULL, NULL);
-    mm_serial_port_queue_command (primary, "+CMER=3,0,0,1", 3, NULL, NULL);
+    mm_at_serial_port_queue_command (primary, "+CMER=3,0,0,1", 3, NULL, NULL);
 
     parent_modem_iface = g_type_interface_peek_parent (MM_MODEM_GSM_NETWORK_GET_INTERFACE (self));
     parent_modem_iface->do_register (MM_MODEM_GSM_NETWORK (self),
@@ -185,7 +185,7 @@ mbm_parse_network_mode (MMModemGsmMode network_mode)
 }
 
 static void
-mbm_set_network_mode_done (MMSerialPort *port,
+mbm_set_network_mode_done (MMAtSerialPort *port,
                            GString *response,
                            GError *error,
                            gpointer user_data)
@@ -206,19 +206,19 @@ set_network_mode (MMModemGsmNetwork *modem,
 {
     MMCallbackInfo *info;
     char *command;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     info = mm_callback_info_new (MM_MODEM (modem), callback, user_data);
-    primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
 
     command = g_strdup_printf ("+CFUN=%d", mbm_parse_network_mode (mode));
-    mm_serial_port_queue_command (primary, command, 3, mbm_set_network_mode_done, info);
+    mm_at_serial_port_queue_command (primary, command, 3, mbm_set_network_mode_done, info);
     g_free (command);
 }
 
 static void
-get_network_mode_done (MMSerialPort *port,
+get_network_mode_done (MMAtSerialPort *port,
                        GString *response,
                        GError *error,
                        gpointer user_data)
@@ -273,12 +273,12 @@ get_network_mode (MMModemGsmNetwork *modem,
                   gpointer user_data)
 {
     MMCallbackInfo *info;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     info = mm_callback_info_uint_new (MM_MODEM (modem), callback, user_data);
-    primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
-    mm_serial_port_queue_command (primary, "*ERINFO?", 3, get_network_mode_done, info);
+    mm_at_serial_port_queue_command (primary, "*ERINFO?", 3, get_network_mode_done, info);
 }
 
 /*****************************************************************************/
@@ -311,7 +311,7 @@ simple_connect (MMModemSimple *simple,
 /*****************************************************************************/
 
 static void
-mbm_enable_done (MMSerialPort *port,
+mbm_enable_done (MMAtSerialPort *port,
                  GString *response,
                  GError *error,
                  gpointer user_data)
@@ -322,7 +322,7 @@ mbm_enable_done (MMSerialPort *port,
 }
 
 static void
-mbm_enap0_done (MMSerialPort *port,
+mbm_enap0_done (MMAtSerialPort *port,
                GString *response,
                GError *error,
                gpointer user_data)
@@ -335,12 +335,12 @@ mbm_enap0_done (MMSerialPort *port,
         priv->network_mode = MBM_NETWORK_MODE_ANY;
 
     command = g_strdup_printf ("+CFUN=%d", priv->network_mode);
-    mm_serial_port_queue_command (port, command, 3, mbm_enable_done, info);
+    mm_at_serial_port_queue_command (port, command, 3, mbm_enable_done, info);
     g_free (command);
 }
 
 static void
-mbm_init_done (MMSerialPort *port,
+mbm_init_done (MMAtSerialPort *port,
                GString *response,
                GError *error,
                gpointer user_data)
@@ -356,17 +356,17 @@ mbm_init_done (MMSerialPort *port,
     if (!priv->network_mode)
         priv->network_mode = MBM_NETWORK_MODE_ANY;
 
-    mm_serial_port_queue_command (port, "*ENAP=0", 3, mbm_enap0_done, info);
+    mm_at_serial_port_queue_command (port, "*ENAP=0", 3, mbm_enap0_done, info);
 }
 
 static void
-do_init (MMSerialPort *port, MMCallbackInfo *info)
+do_init (MMAtSerialPort *port, MMCallbackInfo *info)
 {
-    mm_serial_port_queue_command (port, "&F E0 V1 X4 &C1 +CMEE=1", 3, mbm_init_done, info);
+    mm_at_serial_port_queue_command (port, "&F E0 V1 X4 &C1 +CMEE=1", 3, mbm_init_done, info);
 }
 
 static void
-mbm_emrdy_done (MMSerialPort *port,
+mbm_emrdy_done (MMAtSerialPort *port,
                 GString *response,
                 GError *error,
                 gpointer user_data)
@@ -389,18 +389,18 @@ do_enable (MMGenericGsm *self, MMModemFn callback, gpointer user_data)
 {
     MMModemMbmPrivate *priv = MM_MODEM_MBM_GET_PRIVATE (self);
     MMCallbackInfo *info;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     info = mm_callback_info_new (MM_MODEM (self), callback, user_data);
 
-    primary = mm_generic_gsm_get_port (self, MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (self, MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
 
     if (priv->have_emrdy) {
         /* Modem is ready, no need to check EMRDY */
         do_init (primary, info);
     } else
-        mm_serial_port_queue_command (primary, "*EMRDY?", 5, mbm_emrdy_done, info);
+        mm_at_serial_port_queue_command (primary, "*EMRDY?", 5, mbm_emrdy_done, info);
 }
 
 typedef struct {
@@ -410,7 +410,7 @@ typedef struct {
 } DisableInfo;
 
 static void
-disable_creg_cmer_done (MMSerialPort *port,
+disable_creg_cmer_done (MMAtSerialPort *port,
                         GString *response,
                         GError *error,
                         gpointer user_data)
@@ -429,7 +429,7 @@ disable (MMModem *modem,
          MMModemFn callback,
          gpointer user_data)
 {
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
     DisableInfo *info;
 
     info = g_malloc0 (sizeof (DisableInfo));
@@ -437,11 +437,11 @@ disable (MMModem *modem,
     info->user_data = user_data;
     info->modem = modem;
 
-    primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
 
     /* Turn off unsolicited +CIEV signal strength indicator */
-    mm_serial_port_queue_command (primary, "+CREG=0;+CMER=0", 5, disable_creg_cmer_done, info);
+    mm_at_serial_port_queue_command (primary, "+CREG=0;+CMER=0", 5, disable_creg_cmer_done, info);
 }
 
 static void
@@ -467,13 +467,13 @@ disconnect (MMModem *modem,
             gpointer user_data)
 {
     MMCallbackInfo *info;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     mm_modem_set_state (modem, MM_MODEM_STATE_DISCONNECTING, MM_MODEM_STATE_REASON_NONE);
 
-    primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
-    mm_serial_port_queue_command (primary, "*ENAP=0", 3, NULL, NULL);
+    mm_at_serial_port_queue_command (primary, "*ENAP=0", 3, NULL, NULL);
 
     mm_generic_gsm_update_enabled_state (MM_GENERIC_GSM (modem), FALSE, MM_MODEM_STATE_REASON_NONE);
 
@@ -484,7 +484,7 @@ disconnect (MMModem *modem,
 /*****************************************************************************/
 
 static void
-mbm_emrdy_received (MMSerialPort *port,
+mbm_emrdy_received (MMAtSerialPort *port,
                     GMatchInfo *info,
                     gpointer user_data)
 {
@@ -492,7 +492,7 @@ mbm_emrdy_received (MMSerialPort *port,
 }
 
 static void
-mbm_pacsp_received (MMSerialPort *port,
+mbm_pacsp_received (MMAtSerialPort *port,
                      GMatchInfo *info,
                      gpointer user_data)
 {
@@ -500,7 +500,7 @@ mbm_pacsp_received (MMSerialPort *port,
 }
 
 static void
-mbm_ciev_received (MMSerialPort *port,
+mbm_ciev_received (MMAtSerialPort *port,
                    GMatchInfo *info,
                    gpointer user_data)
 {
@@ -532,7 +532,7 @@ mbm_do_connect_done (MMModemMbm *self)
 }
 
 static void
-mbm_e2nap_received (MMSerialPort *port,
+mbm_e2nap_received (MMAtSerialPort *port,
                     GMatchInfo *info,
                     gpointer user_data)
 {
@@ -558,7 +558,7 @@ mbm_e2nap_received (MMSerialPort *port,
 }
 
 static void
-enap_poll_response (MMSerialPort *port,
+enap_poll_response (MMAtSerialPort *port,
                     GString *response,
                     GError *error,
                     gpointer user_data)
@@ -593,20 +593,21 @@ static gboolean
 enap_poll (gpointer user_data)
 {
     MMCallbackInfo *info = (MMCallbackInfo *) user_data;
-    MMSerialPort *port = mm_generic_gsm_get_port (MM_GENERIC_GSM (info->modem), MM_PORT_TYPE_PRIMARY);
+    MMAtSerialPort *port;
 
+    port = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (info->modem), MM_PORT_TYPE_PRIMARY);
     g_assert (port);
 
-    mm_serial_port_queue_command (port, "AT*ENAP?", 3, enap_poll_response, user_data);
+    mm_at_serial_port_queue_command (port, "AT*ENAP?", 3, enap_poll_response, user_data);
     /* we cancel this in the _done function if all is fine */
     return TRUE;
 }
 
 static void
-enap_done (MMSerialPort *port,
+enap_done (MMAtSerialPort *port,
-            GString *response,
+           GString *response,
-            GError *error,
+           GError *error,
-            gpointer user_data)
+           gpointer user_data)
 {
     MMCallbackInfo *info = (MMCallbackInfo *) user_data;
     guint tid;
@@ -619,11 +620,11 @@ enap_done (MMSerialPort *port,
     tid = g_timeout_add_seconds (1, enap_poll, user_data);
     /* remember poll id as callback info object, with source_remove as free func */
     mm_callback_info_set_data (info, "mbm-enap-poll-id", GUINT_TO_POINTER (tid), (GFreeFunc) g_source_remove);
-    mm_serial_port_queue_command (port, "AT*E2NAP=1", 3, NULL, NULL);
+    mm_at_serial_port_queue_command (port, "AT*E2NAP=1", 3, NULL, NULL);
 }
 
 static void
-mbm_auth_done (MMSerialPort *port,
+mbm_auth_done (MMAtSerialPort *port,
                GString *response,
                GError *error,
                gpointer user_data)
@@ -640,7 +641,7 @@ mbm_auth_done (MMSerialPort *port,
 
     cid = mm_generic_gsm_get_cid (modem);
     command = g_strdup_printf ("AT*ENAP=1,%d", cid);
-    mm_serial_port_queue_command (port, command, 3, enap_done, user_data);
+    mm_at_serial_port_queue_command (port, command, 3, enap_done, user_data);
     g_free (command);
 }
 
@@ -650,9 +651,9 @@ mbm_modem_authenticate (MMModemMbm *self,
                         const char *password,
                         gpointer user_data)
 {
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
-    primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (self), MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (self), MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
 
     if (username || password) {
@@ -663,7 +664,7 @@ mbm_modem_authenticate (MMModemMbm *self,
                                    username ? username : "",
                                    password ? password : "");
 
-        mm_serial_port_queue_command (primary, command, 3, mbm_auth_done, user_data);
+        mm_at_serial_port_queue_command (primary, command, 3, mbm_auth_done, user_data);
         g_free (command);
     } else
         mbm_auth_done (primary, NULL, NULL, user_data);
@@ -723,43 +724,43 @@ grab_port (MMModem *modem,
 
     if (!strcmp (subsys, "tty")) {
         if (suggested_type == MM_PORT_TYPE_UNKNOWN) {
-            if (!mm_generic_gsm_get_port (gsm, MM_PORT_TYPE_PRIMARY))
+            if (!mm_generic_gsm_get_at_port (gsm, MM_PORT_TYPE_PRIMARY))
                     ptype = MM_PORT_TYPE_PRIMARY;
-            else if (!mm_generic_gsm_get_port (gsm, MM_PORT_TYPE_SECONDARY))
+            else if (!mm_generic_gsm_get_at_port (gsm, MM_PORT_TYPE_SECONDARY))
                 ptype = MM_PORT_TYPE_SECONDARY;
         } else
             ptype = suggested_type;
     }
 
     port = mm_generic_gsm_grab_port (gsm, subsys, name, ptype, error);
-    if (port && MM_IS_SERIAL_PORT (port) && (ptype == MM_PORT_TYPE_PRIMARY)) {
+    if (port && MM_IS_AT_SERIAL_PORT (port) && (ptype == MM_PORT_TYPE_PRIMARY)) {
         GRegex *regex;
 
         mm_generic_gsm_set_unsolicited_registration (MM_GENERIC_GSM (modem), TRUE);
 
         regex = g_regex_new ("\\r\\n\\*EMRDY: \\d\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, mbm_emrdy_received, modem, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, mbm_emrdy_received, modem, NULL);
         g_regex_unref (regex);
 
         regex = g_regex_new ("\\r\\n\\*E2NAP: (\\d)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, mbm_e2nap_received, modem, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, mbm_e2nap_received, modem, NULL);
         g_regex_unref (regex);
 
         regex = g_regex_new ("\\r\\n\\+PACSP(\\d)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, mbm_pacsp_received, modem, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, mbm_pacsp_received, modem, NULL);
         g_regex_unref (regex);
 
         regex = g_regex_new ("\\r\\n\\+CIEV: (\\d),(\\d)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, mbm_ciev_received, modem, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, mbm_ciev_received, modem, NULL);
         g_regex_unref (regex);
 
         /* also consume unsolicited mbm messages we are not interested in them - see LP: #416418 */
         regex = g_regex_new ("\\R\\*ESTKSMENU:.*\\R", G_REGEX_RAW | G_REGEX_OPTIMIZE | G_REGEX_MULTILINE | G_REGEX_NEWLINE_CRLF, G_REGEX_MATCH_NEWLINE_CRLF, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, NULL, modem, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, modem, NULL);
         g_regex_unref (regex);
 
         regex = g_regex_new ("\\r\\n\\*EMWI: (\\d),(\\d).*\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, NULL, NULL, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, NULL, NULL);
         g_regex_unref (regex);
     }
 

plugins/mm-modem-nokia.c

@@ -56,19 +56,19 @@ grab_port (MMModem *modem,
     MMPort *port = NULL;
 
     if (suggested_type == MM_PORT_TYPE_UNKNOWN) {
-        if (!mm_generic_gsm_get_port (gsm, MM_PORT_TYPE_PRIMARY))
+        if (!mm_generic_gsm_get_at_port (gsm, MM_PORT_TYPE_PRIMARY))
                 ptype = MM_PORT_TYPE_PRIMARY;
-        else if (!mm_generic_gsm_get_port (gsm, MM_PORT_TYPE_SECONDARY))
+        else if (!mm_generic_gsm_get_at_port (gsm, MM_PORT_TYPE_SECONDARY))
             ptype = MM_PORT_TYPE_SECONDARY;
     } else
         ptype = suggested_type;
 
     port = mm_generic_gsm_grab_port (gsm, subsys, name, ptype, error);
-    if (port && MM_IS_SERIAL_PORT (port)) {
+    if (port && MM_IS_AT_SERIAL_PORT (port)) {
-        mm_serial_port_set_response_parser (MM_SERIAL_PORT (port),
+        mm_at_serial_port_set_response_parser (MM_AT_SERIAL_PORT (port),
-                                            mm_serial_parser_v1_e1_parse,
+                                               mm_serial_parser_v1_e1_parse,
-                                            mm_serial_parser_v1_e1_new (),
+                                               mm_serial_parser_v1_e1_new (),
-                                            mm_serial_parser_v1_e1_destroy);
+                                               mm_serial_parser_v1_e1_destroy);
     }
 
     return !!port;

plugins/mm-modem-novatel-gsm.c

@@ -49,7 +49,7 @@ mm_modem_novatel_gsm_new (const char *device,
 /*****************************************************************************/
 
 static void
-init_modem_done (MMSerialPort *port,
+init_modem_done (MMAtSerialPort *port,
                  GString *response,
                  GError *error,
                  gpointer user_data)
@@ -64,7 +64,7 @@ pin_check_done (MMModem *modem, GError *error, gpointer user_data)
 {
     MMCallbackInfo *info = (MMCallbackInfo *) user_data;
     MMGenericGsm *self = MM_GENERIC_GSM (modem);
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     if (error) {
         mm_generic_gsm_enable_complete (self, error, info);
@@ -72,13 +72,13 @@ pin_check_done (MMModem *modem, GError *error, gpointer user_data)
     }
 
     /* Finish the initialization */
-    primary = mm_generic_gsm_get_port (self, MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (self, MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
-    mm_serial_port_queue_command (primary, "Z E0 V1 X4 &C1 +CMEE=1;+CFUN=1", 10, init_modem_done, info);
+    mm_at_serial_port_queue_command (primary, "Z E0 V1 X4 &C1 +CMEE=1;+CFUN=1", 10, init_modem_done, info);
 }
 
 static void
-pre_init_done (MMSerialPort *port,
+pre_init_done (MMAtSerialPort *port,
                GString *response,
                GError *error,
                gpointer user_data)
@@ -104,29 +104,29 @@ enable_flash_done (MMSerialPort *port, GError *error, gpointer user_data)
     if (error)
         mm_generic_gsm_enable_complete (MM_GENERIC_GSM (info->modem), error, info);
     else
-        mm_serial_port_queue_command (port, "E0 V1", 3, pre_init_done, user_data);
+        mm_at_serial_port_queue_command (MM_AT_SERIAL_PORT (port), "E0 V1", 3, pre_init_done, user_data);
 }
 
 static void
 do_enable (MMGenericGsm *modem, MMModemFn callback, gpointer user_data)
 {
     MMCallbackInfo *info;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
-    primary = mm_generic_gsm_get_port (modem, MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (modem, MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
 
     info = mm_callback_info_new (MM_MODEM (modem), callback, user_data);
-    mm_serial_port_flash (primary, 100, enable_flash_done, info);
+    mm_serial_port_flash (MM_SERIAL_PORT (primary), 100, enable_flash_done, info);
 }
 
 static void
-dmat_callback (MMSerialPort *port,
+dmat_callback (MMAtSerialPort *port,
                GString *response,
                GError *error,
                gpointer user_data)
 {
-    mm_serial_port_close (port);
+    mm_serial_port_close (MM_SERIAL_PORT (port));
 }
 
 static gboolean
@@ -142,18 +142,18 @@ grab_port (MMModem *modem,
     MMPort *port = NULL;
 
     if (suggested_type == MM_PORT_TYPE_UNKNOWN) {
-        if (!mm_generic_gsm_get_port (gsm, MM_PORT_TYPE_PRIMARY))
+        if (!mm_generic_gsm_get_at_port (gsm, MM_PORT_TYPE_PRIMARY))
                 ptype = MM_PORT_TYPE_PRIMARY;
-        else if (!mm_generic_gsm_get_port (gsm, MM_PORT_TYPE_SECONDARY))
+        else if (!mm_generic_gsm_get_at_port (gsm, MM_PORT_TYPE_SECONDARY))
             ptype = MM_PORT_TYPE_SECONDARY;
     } else
         ptype = suggested_type;
 
     port = mm_generic_gsm_grab_port (gsm, subsys, name, ptype, error);
-    if (port && MM_IS_SERIAL_PORT (port) && (ptype == MM_PORT_TYPE_PRIMARY)) {
+    if (port && MM_IS_AT_SERIAL_PORT (port) && (ptype == MM_PORT_TYPE_PRIMARY)) {
         /* Flip secondary ports to AT mode */
         if (mm_serial_port_open (MM_SERIAL_PORT (port), NULL))
-            mm_serial_port_queue_command (MM_SERIAL_PORT (port), "$NWDMAT=1", 2, dmat_callback, NULL);
+            mm_at_serial_port_queue_command (MM_AT_SERIAL_PORT (port), "$NWDMAT=1", 2, dmat_callback, NULL);
     }
 
     return !!port;

plugins/mm-modem-option.c

@@ -98,7 +98,7 @@ enable (MMModem *modem,
 }
 
 static void
-get_network_mode_done (MMSerialPort *port,
+get_network_mode_done (MMAtSerialPort *port,
                        GString *response,
                        GError *error,
                        gpointer user_data)
@@ -149,16 +149,16 @@ get_network_mode (MMModemGsmNetwork *modem,
                   gpointer user_data)
 {
     MMCallbackInfo *info;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     info = mm_callback_info_uint_new (MM_MODEM (modem), callback, user_data);
-    primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
-    mm_serial_port_queue_command (primary, "AT_OPSYS?", 3, get_network_mode_done, info);
+    mm_at_serial_port_queue_command (primary, "AT_OPSYS?", 3, get_network_mode_done, info);
 }
 
 static void
-set_network_mode_done (MMSerialPort *port,
+set_network_mode_done (MMAtSerialPort *port,
                        GString *response,
                        GError *error,
                        gpointer user_data)
@@ -178,7 +178,7 @@ set_network_mode (MMModemGsmNetwork *modem,
                   gpointer user_data)
 {
     MMCallbackInfo *info;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
     char *command;
     int i;
 
@@ -210,9 +210,9 @@ set_network_mode (MMModemGsmNetwork *modem,
     }
 
     command = g_strdup_printf ("AT_OPSYS=%d,2", i);
-    primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
-    mm_serial_port_queue_command (primary, command, 3, set_network_mode_done, info);
+    mm_at_serial_port_queue_command (primary, command, 3, set_network_mode_done, info);
     g_free (command);
 }
 

plugins/mm-modem-sierra-cdma.c

@@ -110,7 +110,7 @@ sys_mode_has_service (SysMode mode)
 }
 
 static void
-status_done (MMSerialPort *port,
+status_done (MMAtSerialPort *port,
              GString *response,
              GError *error,
              gpointer user_data)
@@ -293,11 +293,11 @@ query_registration_state (MMGenericCdma *cdma,
                           gpointer user_data)
 {
     MMCallbackInfo *info;
-    MMSerialPort *primary, *secondary;
+    MMAtSerialPort *primary, *secondary;
-    MMSerialPort *port;
+    MMAtSerialPort *port;
 
-    port = primary = mm_generic_cdma_get_port (cdma, MM_PORT_TYPE_PRIMARY);
+    port = primary = mm_generic_cdma_get_at_port (cdma, MM_PORT_TYPE_PRIMARY);
-    secondary = mm_generic_cdma_get_port (cdma, MM_PORT_TYPE_SECONDARY);
+    secondary = mm_generic_cdma_get_at_port (cdma, MM_PORT_TYPE_SECONDARY);
 
     info = mm_generic_cdma_query_reg_state_callback_info_new (cdma, callback, user_data);
 
@@ -313,11 +313,11 @@ query_registration_state (MMGenericCdma *cdma,
         port = secondary;
     }
 
-    mm_serial_port_queue_command (port, "!STATUS", 3, status_done, info);
+    mm_at_serial_port_queue_command (port, "!STATUS", 3, status_done, info);
 }
 
 static void
-pcstate_done (MMSerialPort *port,
+pcstate_done (MMAtSerialPort *port,
               GString *response,
               GError *error,
               gpointer user_data)
@@ -334,14 +334,14 @@ post_enable (MMGenericCdma *cdma,
              gpointer user_data)
 {
     MMCallbackInfo *info;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     info = mm_callback_info_new (MM_MODEM (cdma), callback, user_data);
 
-    primary = mm_generic_cdma_get_port (cdma, MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_cdma_get_at_port (cdma, MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
 
-    mm_serial_port_queue_command (primary, "!pcstate=1", 5, pcstate_done, info);
+    mm_at_serial_port_queue_command (primary, "!pcstate=1", 5, pcstate_done, info);
 }
 
 static void
@@ -350,14 +350,14 @@ post_disable (MMGenericCdma *cdma,
               gpointer user_data)
 {
     MMCallbackInfo *info;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     info = mm_callback_info_new (MM_MODEM (cdma), callback, user_data);
 
-    primary = mm_generic_cdma_get_port (cdma, MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_cdma_get_at_port (cdma, MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
 
-    mm_serial_port_queue_command (primary, "!pcstate=0", 5, pcstate_done, info);
+    mm_at_serial_port_queue_command (primary, "!pcstate=0", 5, pcstate_done, info);
 }
 
 /*****************************************************************************/

plugins/mm-modem-sierra-gsm.c

@@ -108,22 +108,22 @@ grab_port (MMModem *modem,
     MMPort *port;
 
     if (suggested_type == MM_PORT_TYPE_UNKNOWN) {
-        if (!mm_generic_gsm_get_port (gsm, MM_PORT_TYPE_PRIMARY))
+        if (!mm_generic_gsm_get_at_port (gsm, MM_PORT_TYPE_PRIMARY))
                 ptype = MM_PORT_TYPE_PRIMARY;
-        else if (!mm_generic_gsm_get_port (gsm, MM_PORT_TYPE_SECONDARY))
+        else if (!mm_generic_gsm_get_at_port (gsm, MM_PORT_TYPE_SECONDARY))
             ptype = MM_PORT_TYPE_SECONDARY;
     } else
         ptype = suggested_type;
 
     port = mm_generic_gsm_grab_port (gsm, subsys, name, ptype, error);
 
-    if (port && MM_IS_SERIAL_PORT (port)) {
+    if (port && MM_IS_AT_SERIAL_PORT (port)) {
         GRegex *regex;
 
         g_object_set (G_OBJECT (port), MM_PORT_CARRIER_DETECT, FALSE, NULL);
 
         regex = g_regex_new ("\\r\\n\\+PACSP0\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, NULL, NULL, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, NULL, NULL);
         g_regex_unref (regex);
     }
 

plugins/mm-modem-zte.c

@@ -56,7 +56,7 @@ mm_modem_zte_new (const char *device,
 /*    Modem class override functions                                         */
 /*****************************************************************************/
 
-static void cpms_try_done (MMSerialPort *port,
+static void cpms_try_done (MMAtSerialPort *port,
                            GString *response,
                            GError *error,
                            gpointer user_data);
@@ -67,17 +67,17 @@ cpms_timeout_cb (gpointer user_data)
     MMCallbackInfo *info = user_data;
     MMModem *modem = info->modem;
     MMModemZtePrivate *priv = MM_MODEM_ZTE_GET_PRIVATE (modem);
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     priv->cpms_timeout = 0;
 
-    primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
-    mm_serial_port_queue_command (primary, "+CPMS?", 10, cpms_try_done, info);
+    mm_at_serial_port_queue_command (primary, "+CPMS?", 10, cpms_try_done, info);
     return FALSE;
 }
 
 static void
-cpms_try_done (MMSerialPort *port,
+cpms_try_done (MMAtSerialPort *port,
                GString *response,
                GError *error,
                gpointer user_data)
@@ -103,7 +103,7 @@ cpms_try_done (MMSerialPort *port,
 }
 
 static void
-init_modem_done (MMSerialPort *port,
+init_modem_done (MMAtSerialPort *port,
                  GString *response,
                  GError *error,
                  gpointer user_data)
@@ -115,14 +115,14 @@ init_modem_done (MMSerialPort *port,
      * done during probing, but if the device has a PIN enabled it won't
      * accept the +CPMS? during the probe and we have to do it here.
      */
-    mm_serial_port_queue_command (port, "+CPMS?", 10, cpms_try_done, info);
+    mm_at_serial_port_queue_command (port, "+CPMS?", 10, cpms_try_done, info);
 }
 
 static void
 pin_check_done (MMModem *modem, GError *error, gpointer user_data)
 {
     MMCallbackInfo *info = (MMCallbackInfo *) user_data;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     if (error) {
         mm_generic_gsm_enable_complete (MM_GENERIC_GSM (modem), error, info);
@@ -130,9 +130,9 @@ pin_check_done (MMModem *modem, GError *error, gpointer user_data)
     }
 
     /* Finish the initialization */
-    primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
-    mm_serial_port_queue_command (primary, "Z E0 V1 X4 &C1 +CMEE=1;+CFUN=1;", 10, init_modem_done, info);
+    mm_at_serial_port_queue_command (primary, "Z E0 V1 X4 &C1 +CMEE=1;+CFUN=1;", 10, init_modem_done, info);
 }
 
 static void enable_flash_done (MMSerialPort *port,
@@ -140,7 +140,7 @@ static void enable_flash_done (MMSerialPort *port,
                                gpointer user_data);
 
 static void
-pre_init_done (MMSerialPort *port,
+pre_init_done (MMAtSerialPort *port,
                GString *response,
                GError *error,
                gpointer user_data)
@@ -153,7 +153,7 @@ pre_init_done (MMSerialPort *port,
         if (   !priv->init_retried
             && g_error_matches (error, MM_SERIAL_ERROR, MM_SERIAL_RESPONSE_TIMEOUT)) {
             priv->init_retried = TRUE;
-            enable_flash_done (port, NULL, user_data);
+            enable_flash_done (MM_SERIAL_PORT (port), NULL, user_data);
         } else
             mm_generic_gsm_enable_complete (MM_GENERIC_GSM (info->modem), error, info);
     } else {
@@ -171,7 +171,7 @@ enable_flash_done (MMSerialPort *port, GError *error, gpointer user_data)
     if (error)
         mm_generic_gsm_enable_complete (MM_GENERIC_GSM (info->modem), error, info);
     else
-        mm_serial_port_queue_command (port, "E0 V1", 3, pre_init_done, user_data);
+        mm_at_serial_port_queue_command (MM_AT_SERIAL_PORT (port), "E0 V1", 3, pre_init_done, user_data);
 }
 
 static void
@@ -179,15 +179,15 @@ do_enable (MMGenericGsm *modem, MMModemFn callback, gpointer user_data)
 {
     MMModemZtePrivate *priv = MM_MODEM_ZTE_GET_PRIVATE (modem);
     MMCallbackInfo *info;
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
 
     priv->init_retried = FALSE;
 
-    primary = mm_generic_gsm_get_port (modem, MM_PORT_TYPE_PRIMARY);
+    primary = mm_generic_gsm_get_at_port (modem, MM_PORT_TYPE_PRIMARY);
     g_assert (primary);
 
     info = mm_callback_info_new (MM_MODEM (modem), callback, user_data);
-    mm_serial_port_flash (primary, 100, enable_flash_done, info);
+    mm_serial_port_flash (MM_SERIAL_PORT (primary), 100, enable_flash_done, info);
 }
 
 static void
@@ -218,42 +218,42 @@ grab_port (MMModem *modem,
     MMPort *port = NULL;
 
     if (suggested_type == MM_PORT_TYPE_UNKNOWN) {
-        if (!mm_generic_gsm_get_port (gsm, MM_PORT_TYPE_PRIMARY))
+        if (!mm_generic_gsm_get_at_port (gsm, MM_PORT_TYPE_PRIMARY))
                 ptype = MM_PORT_TYPE_PRIMARY;
-        else if (!mm_generic_gsm_get_port (gsm, MM_PORT_TYPE_SECONDARY))
+        else if (!mm_generic_gsm_get_at_port (gsm, MM_PORT_TYPE_SECONDARY))
             ptype = MM_PORT_TYPE_SECONDARY;
     } else
         ptype = suggested_type;
 
     port = mm_generic_gsm_grab_port (gsm, subsys, name, ptype, error);
-    if (port && MM_IS_SERIAL_PORT (port)) {
+    if (port && MM_IS_AT_SERIAL_PORT (port)) {
         GRegex *regex;
 
         mm_generic_gsm_set_unsolicited_registration (gsm, TRUE);
         g_object_set (port, MM_PORT_CARRIER_DETECT, FALSE, NULL);
 
         regex = g_regex_new ("\\r\\n\\+ZUSIMR:(.*)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, NULL, NULL, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, NULL, NULL);
         g_regex_unref (regex);
 
         /* Unsolicted operator display */
         regex = g_regex_new ("\\r\\n\\+ZDONR: (.*)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, NULL, NULL, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, NULL, NULL);
         g_regex_unref (regex);
 
         /* Current network and service domain */
         regex = g_regex_new ("\\r\\n\\+ZPASR: (.*)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, NULL, NULL, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, NULL, NULL);
         g_regex_unref (regex);
 
         /* SIM request to Build Main Menu */
         regex = g_regex_new ("\\r\\n\\+ZPSTM: (.*)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, NULL, NULL, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, NULL, NULL);
         g_regex_unref (regex);
 
         /* SIM request to Rebuild Main Menu */
         regex = g_regex_new ("\\r\\n\\+ZEND\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, NULL, NULL, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, NULL, NULL);
         g_regex_unref (regex);
     }
 

plugins/mm-plugin-huawei.c

@@ -26,6 +26,7 @@
 #include "mm-modem-huawei-gsm.h"
 #include "mm-modem-huawei-cdma.h"
 #include "mm-serial-parsers.h"
+#include "mm-at-serial-port.h"
 
 G_DEFINE_TYPE (MMPluginHuawei, mm_plugin_huawei, MM_TYPE_PLUGIN_BASE)
 
@@ -69,7 +70,7 @@ probe_result (MMPluginBase *base,
 #define TAG_SUPPORTS_INFO "huawei-supports-info"
 
 typedef struct {
-    MMSerialPort *serial;
+    MMAtSerialPort *serial;
     guint id;
     gboolean secondary;
 } HuaweiSupportsInfo;
@@ -106,7 +107,7 @@ probe_secondary_supported (gpointer user_data)
 }
 
 static void
-probe_secondary_handle_msg (MMSerialPort *port,
+probe_secondary_handle_msg (MMAtSerialPort *port,
                             GMatchInfo *match_info,
                             gpointer user_data)
 {
@@ -135,12 +136,12 @@ probe_secondary_timeout (gpointer user_data)
 }
 
 static void
-add_regex (MMSerialPort *port, const char *match, gpointer user_data)
+add_regex (MMAtSerialPort *port, const char *match, gpointer user_data)
 {
     GRegex *regex;
 
     regex = g_regex_new (match, G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-    mm_serial_port_add_unsolicited_msg_handler (port, regex, probe_secondary_handle_msg, user_data, NULL);
+    mm_at_serial_port_add_unsolicited_msg_handler (port, regex, probe_secondary_handle_msg, user_data, NULL);
     g_regex_unref (regex);
 }
 
@@ -208,13 +209,13 @@ supports_port (MMPluginBase *base,
         /* Listen for Huawei-specific unsolicited messages */
         info = g_malloc0 (sizeof (HuaweiSupportsInfo));
 
-        info->serial = mm_serial_port_new (name, MM_PORT_TYPE_PRIMARY);
+        info->serial = mm_at_serial_port_new (name, MM_PORT_TYPE_PRIMARY);
         g_object_set (G_OBJECT (info->serial), MM_PORT_CARRIER_DETECT, FALSE, NULL);
 
-        mm_serial_port_set_response_parser (info->serial,
+        mm_at_serial_port_set_response_parser (info->serial,
-                                            mm_serial_parser_v1_parse,
+                                               mm_serial_parser_v1_parse,
-                                            mm_serial_parser_v1_new (),
+                                               mm_serial_parser_v1_new (),
-                                            mm_serial_parser_v1_destroy);
+                                               mm_serial_parser_v1_destroy);
 
         add_regex (info->serial, "\\r\\n\\^RSSI:(\\d+)\\r\\n", task);
         add_regex (info->serial, "\\r\\n\\^MODE:(\\d),(\\d)\\r\\n", task);
@@ -227,7 +228,7 @@ supports_port (MMPluginBase *base,
         g_object_set_data_full (G_OBJECT (task), TAG_SUPPORTS_INFO,
                                 info, huawei_supports_info_destroy);
 
-        if (!mm_serial_port_open (info->serial, &error)) {
+        if (!mm_serial_port_open (MM_SERIAL_PORT (info->serial), &error)) {
             g_warning ("%s: (Huawei) %s: couldn't open serial port: (%d) %s",
                        __func__, name,
                        error ? error->code : -1,

src/Makefile.am

@@ -35,12 +35,14 @@ modem_manager_SOURCES = \
 	mm-modem.h \
 	mm-port.c \
 	mm-port.h \
-	mm-modem-base.c \
-	mm-modem-base.h \
 	mm-serial-port.c \
 	mm-serial-port.h \
+	mm-at-serial-port.c \
+	mm-at-serial-port.h \
 	mm-serial-parsers.c \
 	mm-serial-parsers.h \
+	mm-modem-base.c \
+	mm-modem-base.h \
 	mm-generic-cdma.c \
 	mm-generic-cdma.h \
 	mm-generic-gsm.c \

src/mm-at-serial-port.c

@@ -0,0 +1,323 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details:
+ *
+ * Copyright (C) 2008 - 2009 Novell, Inc.
+ * Copyright (C) 2009 Red Hat, Inc.
+ */
+
+#define _GNU_SOURCE  /* for strcasestr() */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "mm-at-serial-port.h"
+#include "mm-errors.h"
+#include "mm-options.h"
+
+G_DEFINE_TYPE (MMAtSerialPort, mm_at_serial_port, MM_TYPE_SERIAL_PORT)
+
+#define MM_AT_SERIAL_PORT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MM_TYPE_AT_SERIAL_PORT, MMAtSerialPortPrivate))
+
+typedef struct {
+    /* Response parser data */
+    MMAtSerialResponseParserFn response_parser_fn;
+    gpointer response_parser_user_data;
+    GDestroyNotify response_parser_notify;
+    GSList *unsolicited_msg_handlers;
+} MMAtSerialPortPrivate;
+
+
+/*****************************************************************************/
+
+void
+mm_at_serial_port_set_response_parser (MMAtSerialPort *self,
+                                       MMAtSerialResponseParserFn fn,
+                                       gpointer user_data,
+                                       GDestroyNotify notify)
+{
+    MMAtSerialPortPrivate *priv = MM_AT_SERIAL_PORT_GET_PRIVATE (self);
+
+    g_return_if_fail (MM_IS_AT_SERIAL_PORT (self));
+
+    if (priv->response_parser_notify)
+        priv->response_parser_notify (priv->response_parser_user_data);
+
+    priv->response_parser_fn = fn;
+    priv->response_parser_user_data = user_data;
+    priv->response_parser_notify = notify;
+}
+
+static gboolean
+parse_response (MMSerialPort *port, GByteArray *response, GError **error)
+{
+    MMAtSerialPort *self = MM_AT_SERIAL_PORT (port);
+    MMAtSerialPortPrivate *priv = MM_AT_SERIAL_PORT_GET_PRIVATE (self);
+    gboolean found;
+    GString *string;
+
+    g_return_val_if_fail (priv->response_parser_fn != NULL, FALSE);
+
+    /* Construct the string that AT-parsing functions expect */
+    string = g_string_sized_new (response->len + 1);
+    g_string_append_len (string, (const char *) response->data, response->len);
+
+    /* Parse it */
+    found = priv->response_parser_fn (priv->response_parser_user_data, string, error);
+
+    /* And copy it back into the response array after the parser has removed
+     * matches and cleaned it up.
+     */
+    g_byte_array_remove_range (response, 0, response->len);
+    g_byte_array_append (response, (const guint8 *) string->str, string->len);
+    g_string_free (string, TRUE);
+    return found;
+}
+
+static void
+handle_response (MMSerialPort *port,
+                 GByteArray *response,
+                 GError *error,
+                 GCallback callback,
+                 gpointer callback_data)
+{
+    MMAtSerialPort *self = MM_AT_SERIAL_PORT (port);
+    MMAtSerialResponseFn response_callback = (MMAtSerialResponseFn) callback;
+    GString *string;
+
+    /* Convert to a string and call the callback */
+    string = g_string_sized_new (response->len + 1);
+    g_string_append_len (string, (const char *) response->data, response->len);
+    response_callback (self, string, error, callback_data);
+    g_string_free (string, TRUE);
+}
+
+/*****************************************************************************/
+
+typedef struct {
+    GRegex *regex;
+    MMAtSerialUnsolicitedMsgFn callback;
+    gpointer user_data;
+    GDestroyNotify notify;
+} MMAtUnsolicitedMsgHandler;
+
+void
+mm_at_serial_port_add_unsolicited_msg_handler (MMAtSerialPort *self,
+                                               GRegex *regex,
+                                               MMAtSerialUnsolicitedMsgFn callback,
+                                               gpointer user_data,
+                                               GDestroyNotify notify)
+{
+    MMAtUnsolicitedMsgHandler *handler;
+    MMAtSerialPortPrivate *priv;
+
+    g_return_if_fail (MM_IS_AT_SERIAL_PORT (self));
+    g_return_if_fail (regex != NULL);
+
+    handler = g_slice_new (MMAtUnsolicitedMsgHandler);
+    handler->regex = g_regex_ref (regex);
+    handler->callback = callback;
+    handler->user_data = user_data;
+    handler->notify = notify;
+
+    priv = MM_AT_SERIAL_PORT_GET_PRIVATE (self);
+    priv->unsolicited_msg_handlers = g_slist_append (priv->unsolicited_msg_handlers, handler);
+}
+
+static gboolean
+remove_eval_cb (const GMatchInfo *match_info,
+                GString *result,
+                gpointer user_data)
+{
+    int *result_len = (int *) user_data;
+    int start;
+    int end;
+
+    if (g_match_info_fetch_pos  (match_info, 0, &start, &end))
+        *result_len -= (end - start);
+
+    return FALSE;
+}
+
+static void
+parse_unsolicited (MMSerialPort *port, GByteArray *response)
+{
+    MMAtSerialPort *self = MM_AT_SERIAL_PORT (port);
+    MMAtSerialPortPrivate *priv = MM_AT_SERIAL_PORT_GET_PRIVATE (self);
+    GSList *iter;
+
+    for (iter = priv->unsolicited_msg_handlers; iter; iter = iter->next) {
+        MMAtUnsolicitedMsgHandler *handler = (MMAtUnsolicitedMsgHandler *) iter->data;
+        GMatchInfo *match_info;
+        gboolean matches;
+
+        matches = g_regex_match_full (handler->regex,
+                                      (const char *) response->data,
+                                      response->len,
+                                      0, 0, &match_info, NULL);
+        if (handler->callback) {
+            while (g_match_info_matches (match_info)) {
+                handler->callback (self, match_info, handler->user_data);
+                g_match_info_next (match_info, NULL);
+            }
+        }
+
+        g_match_info_free (match_info);
+
+        if (matches) {
+            /* Remove matches */
+            char *str;
+            int result_len = response->len;
+
+            str = g_regex_replace_eval (handler->regex,
+                                        (const char *) response->data,
+                                        response->len,
+                                        0, 0,
+                                        remove_eval_cb, &result_len, NULL);
+
+            g_byte_array_remove_range (response, 0, response->len);
+            g_byte_array_append (response, (const guint8 *) str, result_len);
+            g_free (str);
+        }
+    }
+}
+
+/*****************************************************************************/
+
+static GByteArray *
+at_command_to_byte_array (const char *command)
+{
+    GByteArray *buf;
+    int cmdlen;
+
+    g_return_val_if_fail (command != NULL, NULL);
+
+    cmdlen = strlen (command);
+    buf = g_byte_array_sized_new (cmdlen + 3);
+
+    /* Make sure there's an AT in the front */
+    if (!g_str_has_prefix (command, "AT"))
+        g_byte_array_append (buf, (const guint8 *) "AT", 2);
+    g_byte_array_append (buf, (const guint8 *) command, cmdlen);
+
+    /* Make sure there's a trailing carriage return */
+    if (command[cmdlen] != '\r')
+        g_byte_array_append (buf, (const guint8 *) "\r", 1);
+
+    return buf;
+}
+
+void
+mm_at_serial_port_queue_command (MMAtSerialPort *self,
+                                 const char *command,
+                                 guint32 timeout_seconds,
+                                 MMAtSerialResponseFn callback,
+                                 gpointer user_data)
+{
+    GByteArray *buf;
+
+    g_return_if_fail (self != NULL);
+    g_return_if_fail (MM_IS_AT_SERIAL_PORT (self));
+    g_return_if_fail (command != NULL);
+
+    buf = at_command_to_byte_array (command);
+    g_return_if_fail (buf != NULL);
+
+    mm_serial_port_queue_command (MM_SERIAL_PORT (self),
+                                  buf,
+                                  TRUE,
+                                  timeout_seconds,
+                                  G_CALLBACK (callback),
+                                  user_data);
+}
+
+void
+mm_at_serial_port_queue_command_cached (MMAtSerialPort *self,
+                                        const char *command,
+                                        guint32 timeout_seconds,
+                                        MMAtSerialResponseFn callback,
+                                        gpointer user_data)
+{
+    GByteArray *buf;
+
+    g_return_if_fail (self != NULL);
+    g_return_if_fail (MM_IS_AT_SERIAL_PORT (self));
+    g_return_if_fail (command != NULL);
+
+    buf = at_command_to_byte_array (command);
+    g_return_if_fail (buf != NULL);
+
+    mm_serial_port_queue_command_cached (MM_SERIAL_PORT (self),
+                                         buf,
+                                         TRUE,
+                                         timeout_seconds,
+                                         G_CALLBACK (callback),
+                                         user_data);
+}
+
+/*****************************************************************************/
+
+MMAtSerialPort *
+mm_at_serial_port_new (const char *name, MMPortType ptype)
+{
+    return MM_AT_SERIAL_PORT (g_object_new (MM_TYPE_AT_SERIAL_PORT,
+                                            MM_PORT_DEVICE, name,
+                                            MM_PORT_SUBSYS, MM_PORT_SUBSYS_TTY,
+                                            MM_PORT_TYPE, ptype,
+                                            NULL));
+}
+
+static void
+mm_at_serial_port_init (MMAtSerialPort *self)
+{
+}
+
+static void
+finalize (GObject *object)
+{
+    MMAtSerialPort *self = MM_AT_SERIAL_PORT (object);
+    MMAtSerialPortPrivate *priv = MM_AT_SERIAL_PORT_GET_PRIVATE (self);
+
+    while (priv->unsolicited_msg_handlers) {
+        MMAtUnsolicitedMsgHandler *handler = (MMAtUnsolicitedMsgHandler *) priv->unsolicited_msg_handlers->data;
+
+        if (handler->notify)
+            handler->notify (handler->user_data);
+
+        g_regex_unref (handler->regex);
+        g_slice_free (MMAtUnsolicitedMsgHandler, handler);
+        priv->unsolicited_msg_handlers = g_slist_delete_link (priv->unsolicited_msg_handlers,
+                                                              priv->unsolicited_msg_handlers);
+    }
+
+    if (priv->response_parser_notify)
+        priv->response_parser_notify (priv->response_parser_user_data);
+
+    G_OBJECT_CLASS (mm_at_serial_port_parent_class)->finalize (object);
+}
+
+static void
+mm_at_serial_port_class_init (MMAtSerialPortClass *klass)
+{
+    GObjectClass *object_class = G_OBJECT_CLASS (klass);
+    MMSerialPortClass *port_class = MM_SERIAL_PORT_CLASS (klass);
+
+    g_type_class_add_private (object_class, sizeof (MMAtSerialPortPrivate));
+
+    /* Virtual methods */
+    object_class->finalize = finalize;
+
+    port_class->parse_unsolicited = parse_unsolicited;
+    port_class->parse_response = parse_response;
+    port_class->handle_response = handle_response;
+}

src/mm-at-serial-port.h

@@ -0,0 +1,85 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details:
+ *
+ * Copyright (C) 2008 - 2009 Novell, Inc.
+ * Copyright (C) 2009 - 2010 Red Hat, Inc.
+ */
+
+#ifndef MM_AT_SERIAL_PORT_H
+#define MM_AT_SERIAL_PORT_H
+
+#include <glib.h>
+#include <glib/gtypes.h>
+#include <glib-object.h>
+
+#include "mm-serial-port.h"
+
+#define MM_TYPE_AT_SERIAL_PORT            (mm_at_serial_port_get_type ())
+#define MM_AT_SERIAL_PORT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MM_TYPE_AT_SERIAL_PORT, MMAtSerialPort))
+#define MM_AT_SERIAL_PORT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  MM_TYPE_AT_SERIAL_PORT, MMAtSerialPortClass))
+#define MM_IS_AT_SERIAL_PORT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MM_TYPE_AT_SERIAL_PORT))
+#define MM_IS_AT_SERIAL_PORT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  MM_TYPE_AT_SERIAL_PORT))
+#define MM_AT_SERIAL_PORT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  MM_TYPE_AT_SERIAL_PORT, MMAtSerialPortClass))
+
+typedef struct _MMAtSerialPort MMAtSerialPort;
+typedef struct _MMAtSerialPortClass MMAtSerialPortClass;
+
+typedef gboolean (*MMAtSerialResponseParserFn) (gpointer user_data,
+                                                GString *response,
+                                                GError **error);
+
+typedef void (*MMAtSerialUnsolicitedMsgFn) (MMAtSerialPort *port,
+                                            GMatchInfo *match_info,
+                                            gpointer user_data);
+
+typedef void (*MMAtSerialResponseFn)     (MMAtSerialPort *port,
+                                          GString *response,
+                                          GError *error,
+                                          gpointer user_data);
+
+struct _MMAtSerialPort {
+    MMSerialPort parent;
+};
+
+struct _MMAtSerialPortClass {
+    MMSerialPortClass parent;
+};
+
+GType mm_at_serial_port_get_type (void);
+
+MMAtSerialPort *mm_at_serial_port_new (const char *name, MMPortType ptype);
+
+void     mm_at_serial_port_add_unsolicited_msg_handler (MMAtSerialPort *self,
+                                                        GRegex *regex,
+                                                        MMAtSerialUnsolicitedMsgFn callback,
+                                                        gpointer user_data,
+                                                        GDestroyNotify notify);
+
+void     mm_at_serial_port_set_response_parser (MMAtSerialPort *self,
+                                                MMAtSerialResponseParserFn fn,
+                                                gpointer user_data,
+                                                GDestroyNotify notify);
+
+void     mm_at_serial_port_queue_command     (MMAtSerialPort *self,
+                                              const char *command,
+                                              guint32 timeout_seconds,
+                                              MMAtSerialResponseFn callback,
+                                              gpointer user_data);
+
+void     mm_at_serial_port_queue_command_cached (MMAtSerialPort *self,
+                                                 const char *command,
+                                                 guint32 timeout_seconds,
+                                                 MMAtSerialResponseFn callback,
+                                                 gpointer user_data);
+
+#endif /* MM_AT_SERIAL_PORT_H */
+

src/mm-generic-cdma.c

@@ -23,7 +23,7 @@
 #include "mm-generic-cdma.h"
 #include "mm-modem-cdma.h"
 #include "mm-modem-simple.h"
-#include "mm-serial-port.h"
+#include "mm-at-serial-port.h"
 #include "mm-errors.h"
 #include "mm-callback-info.h"
 #include "mm-serial-parsers.h"
@@ -67,8 +67,8 @@ typedef struct {
     guint reg_state_changed_id;
     MMCallbackInfo *simple_connect_info;
 
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
-    MMSerialPort *secondary;
+    MMAtSerialPort *secondary;
     MMPort *data;
 } MMGenericCdmaPrivate;
 
@@ -148,22 +148,22 @@ mm_generic_cdma_grab_port (MMGenericCdma *self,
     }
 
     port = mm_modem_base_add_port (MM_MODEM_BASE (self), subsys, name, ptype);
-    if (port && MM_IS_SERIAL_PORT (port)) {
+    if (port && MM_IS_AT_SERIAL_PORT (port)) {
         g_object_set (G_OBJECT (port), MM_PORT_CARRIER_DETECT, FALSE, NULL);
-        mm_serial_port_set_response_parser (MM_SERIAL_PORT (port),
+        mm_at_serial_port_set_response_parser (MM_AT_SERIAL_PORT (port),
-                                            mm_serial_parser_v1_parse,
+                                               mm_serial_parser_v1_parse,
-                                            mm_serial_parser_v1_new (),
+                                               mm_serial_parser_v1_new (),
-                                            mm_serial_parser_v1_destroy);
+                                               mm_serial_parser_v1_destroy);
 
         if (ptype == MM_PORT_TYPE_PRIMARY) {
-            priv->primary = MM_SERIAL_PORT (port);
+            priv->primary = MM_AT_SERIAL_PORT (port);
             if (!priv->data) {
                 priv->data = port;
                 g_object_notify (G_OBJECT (self), MM_MODEM_DATA_DEVICE);
             }
             check_valid (self);
         } else if (ptype == MM_PORT_TYPE_SECONDARY)
-            priv->secondary = MM_SERIAL_PORT (port);
+            priv->secondary = MM_AT_SERIAL_PORT (port);
     } else {
         /* Net device (if any) is the preferred data port */
         if (!priv->data || MM_IS_SERIAL_PORT (priv->data)) {
@@ -215,9 +215,9 @@ release_port (MMModem *modem, const char *subsys, const char *name)
     check_valid (MM_GENERIC_CDMA (modem));
 }
 
-MMSerialPort *
+MMAtSerialPort *
-mm_generic_cdma_get_port (MMGenericCdma *modem,
+mm_generic_cdma_get_at_port (MMGenericCdma *modem,
-                          MMPortType ptype)
+                             MMPortType ptype)
 {
     g_return_val_if_fail (MM_IS_GENERIC_CDMA (modem), NULL);
     g_return_val_if_fail (ptype != MM_PORT_TYPE_UNKNOWN, NULL);
@@ -360,7 +360,7 @@ enable_all_done (MMModem *modem, GError *error, gpointer user_data)
     else {
         /* Open up the second port, if one exists */
         if (priv->secondary) {
-            if (!mm_serial_port_open (priv->secondary, &info->error)) {
+            if (!mm_serial_port_open (MM_SERIAL_PORT (priv->secondary), &info->error)) {
                 g_assert (info->error);
                 goto out;
             }
@@ -380,7 +380,7 @@ out:
 }
 
 static void
-enable_error_reporting_done (MMSerialPort *port,
+enable_error_reporting_done (MMAtSerialPort *port,
                              GString *response,
                              GError *error,
                              gpointer user_data)
@@ -399,7 +399,7 @@ enable_error_reporting_done (MMSerialPort *port,
 }
 
 static void
-init_done (MMSerialPort *port,
+init_done (MMAtSerialPort *port,
            GString *response,
            GError *error,
            gpointer user_data)
@@ -419,7 +419,7 @@ init_done (MMSerialPort *port,
         FIXME: It's mandatory by spec, so it really shouldn't be optional. Figure
         out which CDMA modems have problems with it and implement plugin for them.
         */
-        mm_serial_port_queue_command (port, "+CMEE=1", 3, enable_error_reporting_done, user_data);
+        mm_at_serial_port_queue_command (port, "+CMEE=1", 3, enable_error_reporting_done, user_data);
     }
 }
 
@@ -439,7 +439,7 @@ flash_done (MMSerialPort *port, GError *error, gpointer user_data)
         return;
     }
 
-    mm_serial_port_queue_command (port, "Z E0 V1 X4 &C1", 3, init_done, user_data);
+    mm_at_serial_port_queue_command (MM_AT_SERIAL_PORT (port), "Z E0 V1 X4 &C1", 3, init_done, user_data);
 }
 
 static void
@@ -453,7 +453,7 @@ enable (MMModem *modem,
 
     info = mm_callback_info_new (modem, callback, user_data);
 
-    if (!mm_serial_port_open (priv->primary, &info->error)) {
+    if (!mm_serial_port_open (MM_SERIAL_PORT (priv->primary), &info->error)) {
         g_assert (info->error);
         mm_callback_info_schedule (info);
         return;
@@ -463,7 +463,7 @@ enable (MMModem *modem,
                         MM_MODEM_STATE_ENABLING,
                         MM_MODEM_STATE_REASON_NONE);
 
-    mm_serial_port_flash (priv->primary, 100, flash_done, info);
+    mm_serial_port_flash (MM_SERIAL_PORT (priv->primary), 100, flash_done, info);
 }
 
 static void
@@ -489,7 +489,7 @@ disable_all_done (MMModem *modem, GError *error, gpointer user_data)
         MMGenericCdma *self = MM_GENERIC_CDMA (info->modem);
         MMGenericCdmaPrivate *priv = MM_GENERIC_CDMA_GET_PRIVATE (self);
 
-        mm_serial_port_close (priv->primary);
+        mm_serial_port_close (MM_SERIAL_PORT (priv->primary));
         mm_modem_set_state (modem, MM_MODEM_STATE_DISABLED, MM_MODEM_STATE_REASON_NONE);
 
         priv->cdma_1x_reg_state = MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN;
@@ -546,20 +546,20 @@ disable (MMModem *modem,
                                NULL);
 
     if (priv->secondary)
-        mm_serial_port_close (priv->secondary);
+        mm_serial_port_close (MM_SERIAL_PORT (priv->secondary));
 
     mm_modem_set_state (MM_MODEM (info->modem),
                         MM_MODEM_STATE_DISABLING,
                         MM_MODEM_STATE_REASON_NONE);
 
     if (mm_port_get_connected (MM_PORT (priv->primary)))
-        mm_serial_port_flash (priv->primary, 1000, disable_flash_done, info);
+        mm_serial_port_flash (MM_SERIAL_PORT (priv->primary), 1000, disable_flash_done, info);
     else
-        disable_flash_done (priv->primary, NULL, info);
+        disable_flash_done (MM_SERIAL_PORT (priv->primary), NULL, info);
 }
 
 static void
-dial_done (MMSerialPort *port,
+dial_done (MMAtSerialPort *port,
            GString *response,
            GError *error,
            gpointer user_data)
@@ -598,7 +598,7 @@ connect (MMModem *modem,
 
     info = mm_callback_info_new (modem, callback, user_data);
     command = g_strconcat ("DT", number, NULL);
-    mm_serial_port_queue_command (priv->primary, command, 90, dial_done, info);
+    mm_at_serial_port_queue_command (priv->primary, command, 90, dial_done, info);
     g_free (command);
 }
 
@@ -648,7 +648,7 @@ disconnect (MMModem *modem,
                                NULL);
 
     mm_modem_set_state (modem, MM_MODEM_STATE_DISCONNECTING, MM_MODEM_STATE_REASON_NONE);
-    mm_serial_port_flash (priv->primary, 1000, disconnect_flash_done, info);
+    mm_serial_port_flash (MM_SERIAL_PORT (priv->primary), 1000, disconnect_flash_done, info);
 }
 
 static void
@@ -678,7 +678,7 @@ strip_response (const char *resp, const char *cmd)
 }
 
 static void
-get_version_done (MMSerialPort *port,
+get_version_done (MMAtSerialPort *port,
                   GString *response,
                   GError *error,
                   gpointer user_data)
@@ -696,7 +696,7 @@ get_version_done (MMSerialPort *port,
 }
 
 static void
-get_model_done (MMSerialPort *port,
+get_model_done (MMAtSerialPort *port,
                 GString *response,
                 GError *error,
                 gpointer user_data)
@@ -712,7 +712,7 @@ get_model_done (MMSerialPort *port,
 }
 
 static void
-get_manufacturer_done (MMSerialPort *port,
+get_manufacturer_done (MMAtSerialPort *port,
                        GString *response,
                        GError *error,
                        gpointer user_data)
@@ -734,7 +734,7 @@ get_card_info (MMModem *modem,
 {
     MMGenericCdmaPrivate *priv = MM_GENERIC_CDMA_GET_PRIVATE (modem);
     MMCallbackInfo *info;
-    MMSerialPort *port = priv->primary;
+    MMAtSerialPort *port = priv->primary;
 
     info = mm_callback_info_new_full (MM_MODEM (modem),
                                       card_info_invoke,
@@ -753,9 +753,9 @@ get_card_info (MMModem *modem,
         port = priv->secondary;
     }
 
-    mm_serial_port_queue_command_cached (port, "+GMI", 3, get_manufacturer_done, info);
+    mm_at_serial_port_queue_command_cached (port, "+GMI", 3, get_manufacturer_done, info);
-    mm_serial_port_queue_command_cached (port, "+GMM", 3, get_model_done, info);
+    mm_at_serial_port_queue_command_cached (port, "+GMM", 3, get_model_done, info);
-    mm_serial_port_queue_command_cached (port, "+GMR", 3, get_version_done, info);
+    mm_at_serial_port_queue_command_cached (port, "+GMR", 3, get_version_done, info);
 }
 
 /*****************************************************************************/
@@ -793,7 +793,7 @@ mm_generic_cdma_update_evdo_quality (MMGenericCdma *self, guint32 quality)
 #define CSQ2_TRIED "csq?-tried"
 
 static void
-get_signal_quality_done (MMSerialPort *port,
+get_signal_quality_done (MMAtSerialPort *port,
                          GString *response,
                          GError *error,
                          gpointer user_data)
@@ -811,7 +811,7 @@ get_signal_quality_done (MMSerialPort *port,
              * try the other command if the first one fails.
              */
             mm_callback_info_set_data (info, CSQ2_TRIED, GUINT_TO_POINTER (1), NULL);
-            mm_serial_port_queue_command (port, "+CSQ?", 3, get_signal_quality_done, info);
+            mm_at_serial_port_queue_command (port, "+CSQ?", 3, get_signal_quality_done, info);
             return;
         }
     } else {
@@ -853,7 +853,7 @@ get_signal_quality (MMModemCdma *modem,
 {
     MMGenericCdmaPrivate *priv = MM_GENERIC_CDMA_GET_PRIVATE (modem);
     MMCallbackInfo *info;
-    MMSerialPort *port = priv->primary;
+    MMAtSerialPort *port = priv->primary;
 
     if (mm_port_get_connected (MM_PORT (priv->primary))) {
         if (!priv->secondary) {
@@ -867,11 +867,11 @@ get_signal_quality (MMModemCdma *modem,
     }
 
     info = mm_callback_info_uint_new (MM_MODEM (modem), callback, user_data);
-    mm_serial_port_queue_command (port, "+CSQ", 3, get_signal_quality_done, info);
+    mm_at_serial_port_queue_command (port, "+CSQ", 3, get_signal_quality_done, info);
 }
 
 static void
-get_string_done (MMSerialPort *port,
+get_string_done (MMAtSerialPort *port,
                  GString *response,
                  GError *error,
                  gpointer user_data)
@@ -897,7 +897,7 @@ get_esn (MMModemCdma *modem,
     MMGenericCdmaPrivate *priv = MM_GENERIC_CDMA_GET_PRIVATE (modem);
     MMCallbackInfo *info;
     GError *error;
-    MMSerialPort *port = priv->primary;
+    MMAtSerialPort *port = priv->primary;
 
     if (mm_port_get_connected (MM_PORT (priv->primary))) {
         if (!priv->secondary) {
@@ -913,7 +913,7 @@ get_esn (MMModemCdma *modem,
     }
 
     info = mm_callback_info_string_new (MM_MODEM (modem), callback, user_data);
-    mm_serial_port_queue_command_cached (port, "+GSN", 3, get_string_done, info);
+    mm_at_serial_port_queue_command_cached (port, "+GSN", 3, get_string_done, info);
 }
 
 static void
@@ -997,7 +997,7 @@ convert_sid (const char *sid)
 }
 
 static void
-serving_system_done (MMSerialPort *port,
+serving_system_done (MMAtSerialPort *port,
                      GString *response,
                      GError *error,
                      gpointer user_data)
@@ -1116,7 +1116,7 @@ get_serving_system (MMModemCdma *modem,
     MMGenericCdmaPrivate *priv = MM_GENERIC_CDMA_GET_PRIVATE (modem);
     MMCallbackInfo *info;
     GError *error;
-    MMSerialPort *port = priv->primary;
+    MMAtSerialPort *port = priv->primary;
 
     if (mm_port_get_connected (MM_PORT (priv->primary))) {
         if (!priv->secondary) {
@@ -1136,7 +1136,7 @@ get_serving_system (MMModemCdma *modem,
                                       G_CALLBACK (callback),
                                       user_data);
 
-    mm_serial_port_queue_command (port, "+CSS?", 3, serving_system_done, info);
+    mm_at_serial_port_queue_command (port, "+CSS?", 3, serving_system_done, info);
 }
 
 #define CDMA_1X_STATE_TAG     "cdma-1x-reg-state"
@@ -1298,7 +1298,7 @@ reg_state_css_response (MMModemCdma *cdma,
 }
 
 static void
-get_analog_digital_done (MMSerialPort *port,
+get_analog_digital_done (MMAtSerialPort *port,
                          GString *response,
                          GError *error,
                          gpointer user_data)
@@ -1365,7 +1365,7 @@ get_registration_state (MMModemCdma *modem,
 {
     MMGenericCdmaPrivate *priv = MM_GENERIC_CDMA_GET_PRIVATE (modem);
     MMCallbackInfo *info;
-    MMSerialPort *port = priv->primary;
+    MMAtSerialPort *port = priv->primary;
 
     if (mm_port_get_connected (MM_PORT (priv->primary))) {
         if (!priv->secondary) {
@@ -1380,7 +1380,7 @@ get_registration_state (MMModemCdma *modem,
     }
 
     info = mm_generic_cdma_query_reg_state_callback_info_new (MM_GENERIC_CDMA (modem), callback, user_data);
-    mm_serial_port_queue_command (port, "+CAD?", 3, get_analog_digital_done, info);
+    mm_at_serial_port_queue_command (port, "+CAD?", 3, get_analog_digital_done, info);
 }
 
 /*****************************************************************************/

src/mm-generic-cdma.h

@@ -20,7 +20,7 @@
 #include "mm-modem.h"
 #include "mm-modem-base.h"
 #include "mm-modem-cdma.h"
-#include "mm-serial-port.h"
+#include "mm-at-serial-port.h"
 #include "mm-callback-info.h"
 
 #define MM_TYPE_GENERIC_CDMA            (mm_generic_cdma_get_type ())
@@ -80,7 +80,7 @@ MMPort * mm_generic_cdma_grab_port (MMGenericCdma *self,
                                     gpointer user_data,
                                     GError **error);
 
-MMSerialPort *mm_generic_cdma_get_port (MMGenericCdma *modem, MMPortType ptype);
+MMAtSerialPort *mm_generic_cdma_get_at_port (MMGenericCdma *modem, MMPortType ptype);
 
 void mm_generic_cdma_update_cdma1x_quality (MMGenericCdma *self, guint32 quality);
 void mm_generic_cdma_update_evdo_quality (MMGenericCdma *self, guint32 quality);

src/mm-generic-gsm.c

@@ -26,6 +26,7 @@
 #include "mm-modem-simple.h"
 #include "mm-errors.h"
 #include "mm-callback-info.h"
+#include "mm-at-serial-port.h"
 #include "mm-serial-parsers.h"
 #include "mm-modem-helpers.h"
 
@@ -66,23 +67,23 @@ typedef struct {
     guint32 signal_quality;
     guint32 cid;
 
-    MMSerialPort *primary;
+    MMAtSerialPort *primary;
-    MMSerialPort *secondary;
+    MMAtSerialPort *secondary;
     MMPort *data;
 } MMGenericGsmPrivate;
 
-static void get_registration_status (MMSerialPort *port, MMCallbackInfo *info);
+static void get_registration_status (MMAtSerialPort *port, MMCallbackInfo *info);
-static void read_operator_code_done (MMSerialPort *port,
+static void read_operator_code_done (MMAtSerialPort *port,
                                      GString *response,
                                      GError *error,
                                      gpointer user_data);
 
-static void read_operator_name_done (MMSerialPort *port,
+static void read_operator_name_done (MMAtSerialPort *port,
                                      GString *response,
                                      GError *error,
                                      gpointer user_data);
 
-static void reg_state_changed (MMSerialPort *port,
+static void reg_state_changed (MMAtSerialPort *port,
                                GMatchInfo *match_info,
                                gpointer user_data);
 
@@ -152,8 +153,8 @@ mm_generic_gsm_set_reg_status (MMGenericGsm *modem,
 
         if (status == MM_MODEM_GSM_NETWORK_REG_STATUS_HOME ||
             status == MM_MODEM_GSM_NETWORK_REG_STATUS_ROAMING) {
-            mm_serial_port_queue_command (priv->primary, "+COPS=3,2;+COPS?", 3, read_operator_code_done, modem);
+            mm_at_serial_port_queue_command (priv->primary, "+COPS=3,2;+COPS?", 3, read_operator_code_done, modem);
-            mm_serial_port_queue_command (priv->primary, "+COPS=3,0;+COPS?", 3, read_operator_name_done, modem);
+            mm_at_serial_port_queue_command (priv->primary, "+COPS=3,0;+COPS?", 3, read_operator_name_done, modem);
             mm_modem_gsm_network_get_signal_quality (MM_MODEM_GSM_NETWORK (modem), got_signal_quality, NULL);
         } else {
             g_free (priv->oper_code);
@@ -175,7 +176,7 @@ typedef struct {
 } CPinResult;
 
 static void
-pin_check_done (MMSerialPort *port,
+pin_check_done (MMAtSerialPort *port,
                 GString *response,
                 GError *error,
                 gpointer user_data)
@@ -252,7 +253,7 @@ mm_generic_gsm_check_pin (MMGenericGsm *modem,
 
     priv = MM_GENERIC_GSM_GET_PRIVATE (modem);
     info = mm_callback_info_new (MM_MODEM (modem), callback, user_data);
-    mm_serial_port_queue_command (priv->primary, "+CPIN?", 3, pin_check_done, info);
+    mm_at_serial_port_queue_command (priv->primary, "+CPIN?", 3, pin_check_done, info);
 }
 
 /*****************************************************************************/
@@ -338,7 +339,7 @@ initial_pin_check_done (MMModem *modem, GError *error, gpointer user_data)
     } else {
         priv->pin_checked = TRUE;
         if (close_port)
-            mm_serial_port_close (priv->primary);
+            mm_serial_port_close (MM_SERIAL_PORT (priv->primary));
         check_valid (MM_GENERIC_GSM (modem));
     }
 }
@@ -354,7 +355,7 @@ initial_pin_check (MMGenericGsm *self)
 
     g_return_if_fail (priv->primary != NULL);
 
-    if (mm_serial_port_open (priv->primary, &error))
+    if (mm_serial_port_open (MM_SERIAL_PORT (priv->primary), &error))
         mm_generic_gsm_check_pin (self, initial_pin_check_done, GUINT_TO_POINTER (TRUE));
     else {
         g_warning ("%s: failed to open serial port: (%d) %s",
@@ -390,18 +391,20 @@ mm_generic_gsm_grab_port (MMGenericGsm *self,
     g_return_val_if_fail (!strcmp (subsys, "net") || !strcmp (subsys, "tty"), FALSE);
 
     port = mm_modem_base_add_port (MM_MODEM_BASE (self), subsys, name, ptype);
-    if (port && MM_IS_SERIAL_PORT (port)) {
+    if (port && MM_IS_AT_SERIAL_PORT (port)) {
-        mm_serial_port_set_response_parser (MM_SERIAL_PORT (port),
+        mm_at_serial_port_set_response_parser (MM_AT_SERIAL_PORT (port),
-                                            mm_serial_parser_v1_parse,
+                                               mm_serial_parser_v1_parse,
-                                            mm_serial_parser_v1_new (),
+                                               mm_serial_parser_v1_new (),
-                                            mm_serial_parser_v1_destroy);
+                                               mm_serial_parser_v1_destroy);
 
         regex = g_regex_new ("\\r\\n\\+CREG: (\\d+)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
-        mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, reg_state_changed, self, NULL);
+        mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port),
+                                                       regex, reg_state_changed,
+                                                       self, NULL);
         g_regex_unref (regex);
 
         if (ptype == MM_PORT_TYPE_PRIMARY) {
-            priv->primary = MM_SERIAL_PORT (port);
+            priv->primary = MM_AT_SERIAL_PORT (port);
             if (!priv->data) {
                 priv->data = port;
                 g_object_notify (G_OBJECT (self), MM_MODEM_DATA_DEVICE);
@@ -411,7 +414,7 @@ mm_generic_gsm_grab_port (MMGenericGsm *self,
             initial_pin_check (self);
 
         } else if (ptype == MM_PORT_TYPE_SECONDARY)
-            priv->secondary = MM_SERIAL_PORT (port);
+            priv->secondary = MM_AT_SERIAL_PORT (port);
     } else {
         /* Net device (if any) is the preferred data port */
         if (!priv->data || MM_IS_SERIAL_PORT (priv->data)) {
@@ -508,7 +511,7 @@ mm_generic_gsm_enable_complete (MMGenericGsm *modem,
 }
 
 static void
-enable_done (MMSerialPort *port,
+enable_done (MMAtSerialPort *port,
              GString *response,
              GError *error,
              gpointer user_data)
@@ -528,7 +531,7 @@ enable_done (MMSerialPort *port,
 }
 
 static void
-init_done (MMSerialPort *port,
+init_done (MMAtSerialPort *port,
            GString *response,
            GError *error,
            gpointer user_data)
@@ -544,20 +547,20 @@ init_done (MMSerialPort *port,
     /* Ensure echo is off after the init command; some modems ignore the
         * E0 when it's in the same like as ATZ (Option GIO322).
         */
-    mm_serial_port_queue_command (port, "E0 +CMEE=1", 2, NULL, NULL);
+    mm_at_serial_port_queue_command (port, "E0 +CMEE=1", 2, NULL, NULL);
 
     g_object_get (G_OBJECT (info->modem), MM_GENERIC_GSM_INIT_CMD_OPTIONAL, &cmd, NULL);
-    mm_serial_port_queue_command (port, cmd, 2, NULL, NULL);
+    mm_at_serial_port_queue_command (port, cmd, 2, NULL, NULL);
     g_free (cmd);
 
     if (MM_GENERIC_GSM_GET_PRIVATE (info->modem)->unsolicited_registration)
-        mm_serial_port_queue_command (port, "+CREG=1", 5, NULL, NULL);
+        mm_at_serial_port_queue_command (port, "+CREG=1", 5, NULL, NULL);
     else
-        mm_serial_port_queue_command (port, "+CREG=0", 5, NULL, NULL);
+        mm_at_serial_port_queue_command (port, "+CREG=0", 5, NULL, NULL);
 
     g_object_get (G_OBJECT (info->modem), MM_GENERIC_GSM_POWER_UP_CMD, &cmd, NULL);
     if (cmd && strlen (cmd))
-        mm_serial_port_queue_command (port, cmd, 5, enable_done, user_data);
+        mm_at_serial_port_queue_command (port, cmd, 5, enable_done, user_data);
     else
         enable_done (port, NULL, NULL, user_data);
     g_free (cmd);
@@ -575,7 +578,7 @@ enable_flash_done (MMSerialPort *port, GError *error, gpointer user_data)
     }
 
     g_object_get (G_OBJECT (info->modem), MM_GENERIC_GSM_INIT_CMD, &cmd, NULL);
-    mm_serial_port_queue_command (port, cmd, 3, init_done, user_data);
+    mm_at_serial_port_queue_command (MM_AT_SERIAL_PORT (port), cmd, 3, init_done, user_data);
     g_free (cmd);
 }
 
@@ -586,7 +589,7 @@ real_do_enable (MMGenericGsm *self, MMModemFn callback, gpointer user_data)
     MMCallbackInfo *info;
 
     info = mm_callback_info_new (MM_MODEM (self), callback, user_data);
-    mm_serial_port_flash (priv->primary, 100, enable_flash_done, info);
+    mm_serial_port_flash (MM_SERIAL_PORT (priv->primary), 100, enable_flash_done, info);
 }
 
 static void
@@ -600,7 +603,7 @@ enable (MMModem *modem,
     /* First, reset the previously used CID */
     mm_generic_gsm_set_cid (MM_GENERIC_GSM (modem), 0);
 
-    if (!mm_serial_port_open (priv->primary, &error)) {
+    if (!mm_serial_port_open (MM_SERIAL_PORT (priv->primary), &error)) {
         MMCallbackInfo *info;
 
         g_assert (error);
@@ -617,7 +620,7 @@ enable (MMModem *modem,
 }
 
 static void
-disable_done (MMSerialPort *port,
+disable_done (MMAtSerialPort *port,
               GString *response,
               GError *error,
               gpointer user_data)
@@ -628,7 +631,7 @@ disable_done (MMSerialPort *port,
     if (!info->error) {
         MMGenericGsmPrivate *priv = MM_GENERIC_GSM_GET_PRIVATE (info->modem);
 
-        mm_serial_port_close (port);
+        mm_serial_port_close (MM_SERIAL_PORT (port));
         mm_modem_set_state (MM_MODEM (info->modem),
                             MM_MODEM_STATE_DISABLED,
                             MM_MODEM_STATE_REASON_NONE);
@@ -662,9 +665,9 @@ disable_flash_done (MMSerialPort *port,
 
     g_object_get (G_OBJECT (info->modem), MM_GENERIC_GSM_POWER_DOWN_CMD, &cmd, NULL);
     if (cmd && strlen (cmd))
-        mm_serial_port_queue_command (port, cmd, 5, disable_done, user_data);
+        mm_at_serial_port_queue_command (MM_AT_SERIAL_PORT (port), cmd, 5, disable_done, user_data);
     else
-        disable_done (port, NULL, NULL, user_data);
+        disable_done (MM_AT_SERIAL_PORT (port), NULL, NULL, user_data);
     g_free (cmd);
 }
 
@@ -695,13 +698,13 @@ disable (MMModem *modem,
                         MM_MODEM_STATE_REASON_NONE);
 
     if (mm_port_get_connected (MM_PORT (priv->primary)))
-        mm_serial_port_flash (priv->primary, 1000, disable_flash_done, info);
+        mm_serial_port_flash (MM_SERIAL_PORT (priv->primary), 1000, disable_flash_done, info);
     else
-        disable_flash_done (priv->primary, NULL, info);
+        disable_flash_done (MM_SERIAL_PORT (priv->primary), NULL, info);
 }
 
 static void
-get_string_done (MMSerialPort *port,
+get_string_done (MMAtSerialPort *port,
                  GString *response,
                  GError *error,
                  gpointer user_data)
@@ -725,7 +728,7 @@ get_imei (MMModemGsmCard *modem,
     MMCallbackInfo *info;
 
     info = mm_callback_info_string_new (MM_MODEM (modem), callback, user_data);
-    mm_serial_port_queue_command_cached (priv->primary, "+CGSN", 3, get_string_done, info);
+    mm_at_serial_port_queue_command_cached (priv->primary, "+CGSN", 3, get_string_done, info);
 }
 
 static void
@@ -737,7 +740,7 @@ get_imsi (MMModemGsmCard *modem,
     MMCallbackInfo *info;
 
     info = mm_callback_info_string_new (MM_MODEM (modem), callback, user_data);
-    mm_serial_port_queue_command_cached (priv->primary, "+CIMI", 3, get_string_done, info);
+    mm_at_serial_port_queue_command_cached (priv->primary, "+CIMI", 3, get_string_done, info);
 }
 
 static void
@@ -768,7 +771,7 @@ strip_tag (const char *str, const char *tag)
 }
 
 static void
-get_version_done (MMSerialPort *port,
+get_version_done (MMAtSerialPort *port,
                   GString *response,
                   GError *error,
                   gpointer user_data)
@@ -785,7 +788,7 @@ get_version_done (MMSerialPort *port,
 }
 
 static void
-get_model_done (MMSerialPort *port,
+get_model_done (MMAtSerialPort *port,
                 GString *response,
                 GError *error,
                 gpointer user_data)
@@ -800,7 +803,7 @@ get_model_done (MMSerialPort *port,
 }
 
 static void
-get_manufacturer_done (MMSerialPort *port,
+get_manufacturer_done (MMAtSerialPort *port,
                        GString *response,
                        GError *error,
                        gpointer user_data)
@@ -827,9 +830,9 @@ get_card_info (MMModem *modem,
                                       G_CALLBACK (callback),
                                       user_data);
 
-    mm_serial_port_queue_command_cached (priv->primary, "+CGMI", 3, get_manufacturer_done, info);
+    mm_at_serial_port_queue_command_cached (priv->primary, "+CGMI", 3, get_manufacturer_done, info);
-    mm_serial_port_queue_command_cached (priv->primary, "+CGMM", 3, get_model_done, info);
+    mm_at_serial_port_queue_command_cached (priv->primary, "+CGMM", 3, get_model_done, info);
-    mm_serial_port_queue_command_cached (priv->primary, "+CGMR", 3, get_version_done, info);
+    mm_at_serial_port_queue_command_cached (priv->primary, "+CGMR", 3, get_version_done, info);
 }
 
 static void
@@ -841,17 +844,20 @@ pin_puk_recheck_done (MMModem *modem, GError *error, gpointer user_data)
      * 'modem' will be NULL.
      */
     if (modem) {
+        MMGenericGsmPrivate *priv;
+
         g_return_if_fail (MM_IS_GENERIC_GSM (modem));
 
+        priv = MM_GENERIC_GSM_GET_PRIVATE (modem);
         if (close_port)
-            mm_serial_port_close (MM_GENERIC_GSM_GET_PRIVATE (modem)->primary);
+            mm_serial_port_close (MM_SERIAL_PORT (priv->primary));
     }
 }
 
 #define PIN_CLOSE_PORT_TAG "close-port"
 
 static void
-send_puk_done (MMSerialPort *port,
+send_puk_done (MMAtSerialPort *port,
                GString *response,
                GError *error,
                gpointer user_data)
@@ -892,11 +898,11 @@ send_puk (MMModemGsmCard *modem,
                                            "Cannot unlock device while connected");
         mm_callback_info_schedule (info);
         return;
-    } else if (!mm_serial_port_is_open (priv->primary)) {
+    } else if (!mm_serial_port_is_open (MM_SERIAL_PORT (priv->primary))) {
         /* Modem may not be enabled yet, which sometimes can't be done until
          * the device has been unlocked.
          */
-        if (!mm_serial_port_open (priv->primary, &info->error)) {
+        if (!mm_serial_port_open (MM_SERIAL_PORT (priv->primary), &info->error)) {
             mm_callback_info_schedule (info);
             return;
         }
@@ -906,12 +912,12 @@ send_puk (MMModemGsmCard *modem,
     }
 
     command = g_strdup_printf ("+CPIN=\"%s\",\"%s\"", puk, pin);
-    mm_serial_port_queue_command (connected ? priv->secondary : priv->primary, command, 3, send_puk_done, info);
+    mm_at_serial_port_queue_command (connected ? priv->secondary : priv->primary, command, 3, send_puk_done, info);
     g_free (command);
 }
 
 static void
-send_pin_done (MMSerialPort *port,
+send_pin_done (MMAtSerialPort *port,
                GString *response,
                GError *error,
                gpointer user_data)
@@ -951,11 +957,11 @@ send_pin (MMModemGsmCard *modem,
                                            "Cannot unlock device while connected");
         mm_callback_info_schedule (info);
         return;
-    } else if (!mm_serial_port_is_open (priv->primary)) {
+    } else if (!mm_serial_port_is_open (MM_SERIAL_PORT (priv->primary))) {
         /* Modem may not be enabled yet, which sometimes can't be done until
          * the device has been unlocked.
          */
-        if (!mm_serial_port_open (priv->primary, &info->error)) {
+        if (!mm_serial_port_open (MM_SERIAL_PORT (priv->primary), &info->error)) {
             mm_callback_info_schedule (info);
             return;
         }
@@ -965,12 +971,12 @@ send_pin (MMModemGsmCard *modem,
     }
 
     command = g_strdup_printf ("+CPIN=\"%s\"", pin);
-    mm_serial_port_queue_command (connected ? priv->secondary : priv->primary, command, 3, send_pin_done, info);
+    mm_at_serial_port_queue_command (connected ? priv->secondary : priv->primary, command, 3, send_pin_done, info);
     g_free (command);
 }
 
 static void
-enable_pin_done (MMSerialPort *port,
+enable_pin_done (MMAtSerialPort *port,
                  GString *response,
                  GError *error,
                  gpointer user_data)
@@ -995,12 +1001,12 @@ enable_pin (MMModemGsmCard *modem,
 
     info = mm_callback_info_new (MM_MODEM (modem), callback, user_data);
     command = g_strdup_printf ("+CLCK=\"SC\",%d,\"%s\"", enabled ? 1 : 0, pin);
-    mm_serial_port_queue_command (priv->primary, command, 3, enable_pin_done, info);
+    mm_at_serial_port_queue_command (priv->primary, command, 3, enable_pin_done, info);
     g_free (command);
 }
 
 static void
-change_pin_done (MMSerialPort *port,
+change_pin_done (MMAtSerialPort *port,
                  GString *response,
                  GError *error,
                  gpointer user_data)
@@ -1025,7 +1031,7 @@ change_pin (MMModemGsmCard *modem,
 
     info = mm_callback_info_new (MM_MODEM (modem), callback, user_data);
     command = g_strdup_printf ("+CPWD=\"SC\",\"%s\",\"%s\"", old_pin, new_pin);
-    mm_serial_port_queue_command (priv->primary, command, 3, change_pin_done, info);
+    mm_at_serial_port_queue_command (priv->primary, command, 3, change_pin_done, info);
     g_free (command);
 }
 
@@ -1056,7 +1062,7 @@ parse_operator (const char *reply)
 }
 
 static void
-read_operator_code_done (MMSerialPort *port,
+read_operator_code_done (MMAtSerialPort *port,
                          GString *response,
                          GError *error,
                          gpointer user_data)
@@ -1076,7 +1082,7 @@ read_operator_code_done (MMSerialPort *port,
 }
 
 static void
-read_operator_name_done (MMSerialPort *port,
+read_operator_name_done (MMAtSerialPort *port,
                          GString *response,
                          GError *error,
                          gpointer user_data)
@@ -1186,7 +1192,7 @@ reg_status_updated (MMGenericGsm *self, int new_value, GError **error)
 }
 
 static void
-reg_state_changed (MMSerialPort *port,
+reg_state_changed (MMAtSerialPort *port,
                    GMatchInfo *match_info,
                    gpointer user_data)
 {
@@ -1236,7 +1242,7 @@ reg_status_again_remove (gpointer data)
 }
 
 static void
-get_reg_status_done (MMSerialPort *port,
+get_reg_status_done (MMAtSerialPort *port,
                      GString *response,
                      GError *error,
                      gpointer user_data)
@@ -1303,17 +1309,17 @@ reg_done:
 }
 
 static void
-get_registration_status (MMSerialPort *port, MMCallbackInfo *info)
+get_registration_status (MMAtSerialPort *port, MMCallbackInfo *info)
 {
     MMGenericGsmPrivate *priv = MM_GENERIC_GSM_GET_PRIVATE (info->modem);
 
     g_warn_if_fail (info == priv->pending_reg_info);
 
-    mm_serial_port_queue_command (port, "+CREG?", 10, get_reg_status_done, info);
+    mm_at_serial_port_queue_command (port, "+CREG?", 10, get_reg_status_done, info);
 }
 
 static void
-register_done (MMSerialPort *port,
+register_done (MMAtSerialPort *port,
                GString *response,
                GError *error,
                gpointer user_data)
@@ -1394,7 +1400,7 @@ do_register (MMModemGsmNetwork *modem,
      * the +COPS response is never received.
      */
     mm_callback_info_ref (info);
-    mm_serial_port_queue_command (priv->primary, command, 120, register_done, info);
+    mm_at_serial_port_queue_command (priv->primary, command, 120, register_done, info);
     g_free (command);
 }
 
@@ -1455,7 +1461,7 @@ mm_generic_gsm_connect_complete (MMGenericGsm *modem,
 }
 
 static void
-connect_report_done (MMSerialPort *port,
+connect_report_done (MMAtSerialPort *port,
                      GString *response,
                      GError *error,
                      gpointer user_data)
@@ -1486,7 +1492,7 @@ connect_report_done (MMSerialPort *port,
 }
 
 static void
-connect_done (MMSerialPort *port,
+connect_done (MMAtSerialPort *port,
               GString *response,
               GError *error,
               gpointer user_data)
@@ -1498,7 +1504,7 @@ connect_done (MMSerialPort *port,
         info->error = g_error_copy (error);
         /* Try to get more information why it failed */
         priv = MM_GENERIC_GSM_GET_PRIVATE (info->modem);
-        mm_serial_port_queue_command (priv->primary, "+CEER", 3, connect_report_done, info);
+        mm_at_serial_port_queue_command (priv->primary, "+CEER", 3, connect_report_done, info);
     } else
         mm_generic_gsm_connect_complete (MM_GENERIC_GSM (info->modem), NULL, info);
 }
@@ -1532,7 +1538,7 @@ connect (MMModem *modem,
     } else
         command = g_strconcat ("DT", number, NULL);
 
-    mm_serial_port_queue_command (priv->primary, command, 60, connect_done, info);
+    mm_at_serial_port_queue_command (priv->primary, command, 60, connect_done, info);
     g_free (command);
 }
 
@@ -1586,7 +1592,7 @@ disconnect (MMModem *modem,
                                NULL);
 
     mm_modem_set_state (modem, MM_MODEM_STATE_DISCONNECTING, MM_MODEM_STATE_REASON_NONE);
-    mm_serial_port_flash (priv->primary, 1000, disconnect_flash_done, info);
+    mm_serial_port_flash (MM_SERIAL_PORT (priv->primary), 1000, disconnect_flash_done, info);
 }
 
 static void
@@ -1601,7 +1607,7 @@ gsm_network_scan_invoke (MMCallbackInfo *info)
 }
 
 static void
-scan_done (MMSerialPort *port,
+scan_done (MMAtSerialPort *port,
            GString *response,
            GError *error,
            gpointer user_data)
@@ -1633,13 +1639,13 @@ scan (MMModemGsmNetwork *modem,
                                       G_CALLBACK (callback),
                                       user_data);
 
-    mm_serial_port_queue_command (priv->primary, "+COPS=?", 120, scan_done, info);
+    mm_at_serial_port_queue_command (priv->primary, "+COPS=?", 120, scan_done, info);
 }
 
 /* SetApn */
 
 static void
-set_apn_done (MMSerialPort *port,
+set_apn_done (MMAtSerialPort *port,
               GString *response,
               GError *error,
               gpointer user_data)
@@ -1656,7 +1662,7 @@ set_apn_done (MMSerialPort *port,
 }
 
 static void
-cid_range_read (MMSerialPort *port,
+cid_range_read (MMAtSerialPort *port,
                 GString *response,
                 GError *error,
                 gpointer user_data)
@@ -1716,13 +1722,13 @@ cid_range_read (MMSerialPort *port,
         mm_callback_info_set_data (info, "cid", GUINT_TO_POINTER (cid), NULL);
 
         command = g_strdup_printf ("+CGDCONT=%d,\"IP\",\"%s\"", cid, apn);
-        mm_serial_port_queue_command (port, command, 3, set_apn_done, info);
+        mm_at_serial_port_queue_command (port, command, 3, set_apn_done, info);
         g_free (command);
     }
 }
 
 static void
-existing_apns_read (MMSerialPort *port,
+existing_apns_read (MMAtSerialPort *port,
                     GString *response,
                     GError *error,
                     gpointer user_data)
@@ -1787,7 +1793,7 @@ existing_apns_read (MMSerialPort *port,
         mm_callback_info_schedule (info);
     else
         /* APN not configured on the card. Get the allowed CID range */
-        mm_serial_port_queue_command_cached (port, "+CGDCONT=?", 3, cid_range_read, info);
+        mm_at_serial_port_queue_command_cached (port, "+CGDCONT=?", 3, cid_range_read, info);
 }
 
 static void
@@ -1803,13 +1809,13 @@ set_apn (MMModemGsmNetwork *modem,
     mm_callback_info_set_data (info, "apn", g_strdup (apn), g_free);
 
     /* Start by searching if the APN is already in card */
-    mm_serial_port_queue_command (priv->primary, "+CGDCONT?", 3, existing_apns_read, info);
+    mm_at_serial_port_queue_command (priv->primary, "+CGDCONT?", 3, existing_apns_read, info);
 }
 
 /* GetSignalQuality */
 
 static void
-get_signal_quality_done (MMSerialPort *port,
+get_signal_quality_done (MMAtSerialPort *port,
                          GString *response,
                          GError *error,
                          gpointer user_data)
@@ -1866,14 +1872,14 @@ get_signal_quality (MMModemGsmNetwork *modem,
     }
 
     info = mm_callback_info_uint_new (MM_MODEM (modem), callback, user_data);
-    mm_serial_port_queue_command (connected ? priv->secondary : priv->primary, "+CSQ", 3, get_signal_quality_done, info);
+    mm_at_serial_port_queue_command (connected ? priv->secondary : priv->primary, "+CSQ", 3, get_signal_quality_done, info);
 }
 
 /*****************************************************************************/
 /* MMModemGsmSms interface */
 
 static void
-sms_send_done (MMSerialPort *port,
+sms_send_done (MMAtSerialPort *port,
                GString *response,
                GError *error,
                gpointer user_data)
@@ -1900,7 +1906,7 @@ sms_send (MMModemGsmSms *modem,
     MMCallbackInfo *info;
     char *command;
     gboolean connected;
-    MMSerialPort *port = NULL;
+    MMAtSerialPort *port = NULL;
 
     info = mm_callback_info_new (MM_MODEM (modem), callback, user_data);
 
@@ -1919,16 +1925,16 @@ sms_send (MMModemGsmSms *modem,
     }
 
     /* FIXME: use the PDU mode instead */
-    mm_serial_port_queue_command (port, "AT+CMGF=1", 3, NULL, NULL);
+    mm_at_serial_port_queue_command (port, "AT+CMGF=1", 3, NULL, NULL);
 
     command = g_strdup_printf ("+CMGS=\"%s\"\r%s\x1a", number, text);
-    mm_serial_port_queue_command (port, command, 10, sms_send_done, info);
+    mm_at_serial_port_queue_command (port, command, 10, sms_send_done, info);
     g_free (command);
 }
 
-MMSerialPort *
+MMAtSerialPort *
-mm_generic_gsm_get_port (MMGenericGsm *modem,
+mm_generic_gsm_get_at_port (MMGenericGsm *modem,
-                         MMPortType ptype)
+                           MMPortType ptype)
 {
     g_return_val_if_fail (MM_IS_GENERIC_GSM (modem), NULL);
     g_return_val_if_fail (ptype != MM_PORT_TYPE_UNKNOWN, NULL);

src/mm-generic-gsm.h

@@ -20,7 +20,7 @@
 #include "mm-modem-gsm.h"
 #include "mm-modem-gsm-network.h"
 #include "mm-modem-base.h"
-#include "mm-serial-port.h"
+#include "mm-at-serial-port.h"
 #include "mm-callback-info.h"
 
 #define MM_TYPE_GENERIC_GSM            (mm_generic_gsm_get_type ())
@@ -90,8 +90,8 @@ void mm_generic_gsm_check_pin (MMGenericGsm *modem,
                                MMModemFn callback,
                                gpointer user_data);
 
-MMSerialPort *mm_generic_gsm_get_port (MMGenericGsm *modem,
+MMAtSerialPort *mm_generic_gsm_get_at_port (MMGenericGsm *modem,
-                                       MMPortType ptype);
+                                            MMPortType ptype);
 
 MMPort *mm_generic_gsm_grab_port (MMGenericGsm *modem,
                                   const char *subsys,

src/mm-modem-base.c

@@ -21,7 +21,7 @@
 
 #include "mm-modem-base.h"
 #include "mm-modem.h"
-#include "mm-serial-port.h"
+#include "mm-at-serial-port.h"
 #include "mm-errors.h"
 #include "mm-options.h"
 #include "mm-properties-changed-signal.h"
@@ -113,7 +113,7 @@ mm_modem_base_add_port (MMModemBase *self,
     }
 
     if (!strcmp (subsys, "tty"))
-        port = MM_PORT (mm_serial_port_new (name, ptype));
+        port = MM_PORT (mm_at_serial_port_new (name, ptype));
     else if (!strcmp (subsys, "net")) {
         port = MM_PORT (g_object_new (MM_TYPE_PORT,
                                       MM_PORT_DEVICE, name,

src/mm-plugin-base.c

@@ -26,7 +26,7 @@
 #include <gudev/gudev.h>
 
 #include "mm-plugin-base.h"
-#include "mm-serial-port.h"
+#include "mm-at-serial-port.h"
 #include "mm-serial-parsers.h"
 #include "mm-errors.h"
 #include "mm-marshal.h"
@@ -92,7 +92,7 @@ typedef struct {
     guint open_id;
     guint32 open_tries;
 
-    MMSerialPort *probe_port;
+    MMAtSerialPort *probe_port;
     guint32 probed_caps;
     ProbeState probe_state;
     guint probe_id;
@@ -378,7 +378,7 @@ probe_complete (MMPluginBaseSupportsTask *task)
 }
 
 static void
-parse_response (MMSerialPort *port,
+parse_response (MMAtSerialPort *port,
                 GString *response,
                 GError *error,
                 gpointer user_data);
@@ -391,7 +391,7 @@ real_handle_probe_response (MMPluginBase *self,
                             const GError *error)
 {
     MMPluginBaseSupportsTaskPrivate *task_priv = MM_PLUGIN_BASE_SUPPORTS_TASK_GET_PRIVATE (task);
-    MMSerialPort *port = task_priv->probe_port;
+    MMAtSerialPort *port = task_priv->probe_port;
     gboolean ignore_error = FALSE;
 
     /* Some modems (Huawei E160g) won't respond to +GCAP with no SIM, but
@@ -405,7 +405,7 @@ real_handle_probe_response (MMPluginBase *self,
             /* Try GCAP again */
             if (task_priv->probe_state < PROBE_STATE_GCAP_TRY3) {
                 task_priv->probe_state++;
-                mm_serial_port_queue_command (port, "+GCAP", 3, parse_response, task);
+                mm_at_serial_port_queue_command (port, "+GCAP", 3, parse_response, task);
             } else {
                /* Otherwise, if all the GCAP tries timed out, ignore the port
                 * as it's probably not an AT-capable port.
@@ -459,19 +459,19 @@ real_handle_probe_response (MMPluginBase *self,
     switch (task_priv->probe_state) {
     case PROBE_STATE_GCAP_TRY2:
     case PROBE_STATE_GCAP_TRY3:
-        mm_serial_port_queue_command (port, "+GCAP", 3, parse_response, task);
+        mm_at_serial_port_queue_command (port, "+GCAP", 3, parse_response, task);
         break;
     case PROBE_STATE_ATI:
         /* After the last GCAP attempt, try ATI */
-        mm_serial_port_queue_command (port, "I", 3, parse_response, task);
+        mm_at_serial_port_queue_command (port, "I", 3, parse_response, task);
         break;
     case PROBE_STATE_CPIN:
         /* After the ATI attempt, try CPIN */
-        mm_serial_port_queue_command (port, "+CPIN?", 3, parse_response, task);
+        mm_at_serial_port_queue_command (port, "+CPIN?", 3, parse_response, task);
         break;
     case PROBE_STATE_CGMM:
         /* After the CPIN attempt, try CGMM */
-        mm_serial_port_queue_command (port, "+CGMM", 3, parse_response, task);
+        mm_at_serial_port_queue_command (port, "+CGMM", 3, parse_response, task);
         break;
     default:
         /* Probably not GSM or CDMA */
@@ -515,7 +515,7 @@ handle_probe_response (gpointer user_data)
 }
 
 static void
-parse_response (MMSerialPort *port,
+parse_response (MMAtSerialPort *port,
                 GString *response,
                 GError *error,
                 gpointer user_data)
@@ -545,7 +545,7 @@ parse_response (MMSerialPort *port,
 static void flash_done (MMSerialPort *port, GError *error, gpointer user_data);
 
 static void
-custom_init_response (MMSerialPort *port,
+custom_init_response (MMAtSerialPort *port,
                       GString *response,
                       GError *error,
                       gpointer user_data)
@@ -557,7 +557,7 @@ custom_init_response (MMSerialPort *port,
         task_priv->custom_init_tries++;
         if (task_priv->custom_init_tries < task_priv->custom_init_max_tries) {
             /* Try the custom command again */
-            flash_done (port, NULL, user_data);
+            flash_done (MM_SERIAL_PORT (port), NULL, user_data);
             return;
         } else if (task_priv->custom_init_fail_if_timeout) {
             /* Fail the probe if the plugin wanted it and the command timed out */
@@ -569,7 +569,7 @@ custom_init_response (MMSerialPort *port,
     }
 
     /* Otherwise proceed to probing */
-    mm_serial_port_queue_command (port, "+GCAP", 3, parse_response, user_data);
+    mm_at_serial_port_queue_command (port, "+GCAP", 3, parse_response, user_data);
 }
 
 static void
@@ -583,14 +583,14 @@ flash_done (MMSerialPort *port, GError *error, gpointer user_data)
     if (task_priv->custom_init) {
         if (!delay_secs)
             delay_secs = 3;
-        mm_serial_port_queue_command (port,
+        mm_at_serial_port_queue_command (MM_AT_SERIAL_PORT (port),
-                                      task_priv->custom_init,
+                                         task_priv->custom_init,
-                                      delay_secs,
+                                         delay_secs,
-                                      custom_init_response,
+                                         custom_init_response,
-                                      user_data);
+                                         user_data);
     } else {
         /* Otherwise start normal probing */
-        custom_init_response (port, NULL, NULL, user_data);
+        custom_init_response (MM_AT_SERIAL_PORT (port), NULL, NULL, user_data);
     }
 }
 
@@ -603,7 +603,7 @@ try_open (gpointer user_data)
 
     task_priv->open_id = 0;
 
-    if (!mm_serial_port_open (task_priv->probe_port, &error)) {
+    if (!mm_serial_port_open (MM_SERIAL_PORT (task_priv->probe_port), &error)) {
         if (++task_priv->open_tries > 4) {
             /* took too long to open the port; give up */
             g_warning ("(%s): failed to open after 4 tries.",
@@ -629,7 +629,7 @@ try_open (gpointer user_data)
         g_debug ("(%s): probe requested by plugin '%s'",
                  g_udev_device_get_name (port),
                  mm_plugin_get_name (MM_PLUGIN (task_priv->plugin)));
-        mm_serial_port_flash (task_priv->probe_port, 100, flash_done, task);
+        mm_serial_port_flash (MM_SERIAL_PORT (task_priv->probe_port), 100, flash_done, task);
     }
 
     return FALSE;
@@ -641,7 +641,7 @@ mm_plugin_base_probe_port (MMPluginBase *self,
                            GError **error)
 {
     MMPluginBaseSupportsTaskPrivate *task_priv = MM_PLUGIN_BASE_SUPPORTS_TASK_GET_PRIVATE (task);
-    MMSerialPort *serial;
+    MMAtSerialPort *serial;
     const char *name;
     GUdevDevice *port;
 
@@ -654,7 +654,7 @@ mm_plugin_base_probe_port (MMPluginBase *self,
     name = g_udev_device_get_name (port);
     g_assert (name);
 
-    serial = mm_serial_port_new (name, MM_PORT_TYPE_PRIMARY);
+    serial = mm_at_serial_port_new (name, MM_PORT_TYPE_PRIMARY);
     if (serial == NULL) {
         g_set_error_literal (error, MM_MODEM_ERROR, MM_MODEM_ERROR_GENERAL,
                              "Failed to create new serial port.");
@@ -666,10 +666,10 @@ mm_plugin_base_probe_port (MMPluginBase *self,
                   MM_PORT_CARRIER_DETECT, FALSE,
                   NULL);
 
-    mm_serial_port_set_response_parser (serial,
+    mm_at_serial_port_set_response_parser (serial,
-                                        mm_serial_parser_v1_parse,
+                                           mm_serial_parser_v1_parse,
-                                        mm_serial_parser_v1_new (),
+                                           mm_serial_parser_v1_new (),
-                                        mm_serial_parser_v1_destroy);
+                                           mm_serial_parser_v1_destroy);
 
     /* Open the port */
     task_priv->probe_port = serial;

src/mm-serial-port.c

@@ -55,16 +55,7 @@ typedef struct {
     GHashTable *reply_cache;
     GIOChannel *channel;
     GQueue *queue;
-    GString *command;
+    GByteArray *response;
-    GString *response;
-
-    gboolean connected;
-
-    /* Response parser data */
-    MMSerialResponseParserFn response_parser_fn;
-    gpointer response_parser_user_data;
-    GDestroyNotify response_parser_notify;
-    GSList *unsolicited_msg_handlers;
 
     struct termios old_t;
 
@@ -165,33 +156,6 @@ mm_serial_port_print_config (MMSerialPort *port, const char *detail)
 }
 #endif
 
-typedef struct {
-    GRegex *regex;
-    MMSerialUnsolicitedMsgFn callback;
-    gpointer user_data;
-    GDestroyNotify notify;
-} MMUnsolicitedMsgHandler;
-
-static void
-mm_serial_port_set_cached_reply (MMSerialPort *self,
-                                 const char *command,
-                                 const char *reply)
-{
-    if (reply)
-        g_hash_table_insert (MM_SERIAL_PORT_GET_PRIVATE (self)->reply_cache,
-                             g_strdup (command),
-                             g_strdup (reply));
-    else
-        g_hash_table_remove (MM_SERIAL_PORT_GET_PRIVATE (self)->reply_cache, command);
-}
-
-static const char *
-mm_serial_port_get_cached_reply (MMSerialPort *self,
-                                 const char *command)
-{
-    return (char *) g_hash_table_lookup (MM_SERIAL_PORT_GET_PRIVATE (self)->reply_cache, command);
-}
-
 static int
 parse_baudrate (guint i)
 {
@@ -411,13 +375,13 @@ serial_debug (MMSerialPort *self, const char *prefix, const char *buf, int len)
 
 static gboolean
 mm_serial_port_send_command (MMSerialPort *self,
-                             const char *command,
+                             GByteArray *command,
                              GError **error)
 {
     MMSerialPortPrivate *priv = MM_SERIAL_PORT_GET_PRIVATE (self);
-    const char *s;
+    int status, i = 0;
-    int status;
     int eagain_count = 1000;
+    const guint8 *p;
 
     if (priv->fd < 0) {
         g_set_error (error, MM_SERIAL_ERROR, MM_SERIAL_SEND_FAILED,
@@ -431,21 +395,15 @@ mm_serial_port_send_command (MMSerialPort *self,
         return FALSE;
     }
 
-    g_string_truncate (priv->command, g_str_has_prefix (command, "AT") ? 0 : 2);
+    serial_debug (self, "-->", (const char *) command->data, command->len);
-    g_string_append (priv->command, command);
-
-    if (command[strlen (command)] != '\r')
-        g_string_append_c (priv->command, '\r');
-
-    serial_debug (self, "-->", priv->command->str, -1);
 
     /* Only accept about 3 seconds of EAGAIN */
     if (priv->send_delay > 0)
         eagain_count = 3000000 / priv->send_delay;
 
-    s = priv->command->str;
+    while (i < command->len) {
-    while (*s) {
+        p = &command->data[i];
-        status = write (priv->fd, s, 1);
+        status = write (priv->fd, p, 1);
         if (status < 0) {
             if (errno == EAGAIN) {
                 eagain_count--;
@@ -460,18 +418,46 @@ mm_serial_port_send_command (MMSerialPort *self,
                 break;
             }
         } else
-            s++;
+            i++;
 
         if (priv->send_delay)
             usleep (priv->send_delay);
     }
 
-    return *s == '\0';
+    return i == command->len;
+}
+
+static void
+mm_serial_port_set_cached_reply (MMSerialPort *self,
+                                 const GByteArray *command,
+                                 const GByteArray *response)
+{
+    MMSerialPortPrivate *priv = MM_SERIAL_PORT_GET_PRIVATE (self);
+
+    g_return_if_fail (self != NULL);
+    g_return_if_fail (MM_IS_SERIAL_PORT (self));
+    g_return_if_fail (command != NULL);
+
+    if (response) {
+        GByteArray *cmd_copy = g_byte_array_sized_new (command->len);
+        GByteArray *rsp_copy = g_byte_array_sized_new (response->len);
+
+        g_byte_array_append (cmd_copy, command->data, command->len);
+        g_byte_array_append (rsp_copy, response->data, response->len);
+        g_hash_table_insert (priv->reply_cache, cmd_copy, rsp_copy);
+    } else
+        g_hash_table_remove (MM_SERIAL_PORT_GET_PRIVATE (self)->reply_cache, command);
+}
+
+static const GByteArray *
+mm_serial_port_get_cached_reply (MMSerialPort *self, GByteArray *command)
+{
+    return (const GByteArray *) g_hash_table_lookup (MM_SERIAL_PORT_GET_PRIVATE (self)->reply_cache, command);
 }
 
 typedef struct {
-    char *command;
+    GByteArray *command;
-    MMSerialResponseFn callback;
+    GCallback callback;
     gpointer user_data;
     guint32 timeout;
     gboolean cached;
@@ -514,19 +500,24 @@ mm_serial_port_got_response (MMSerialPort *self, GError *error)
     info = (MMQueueData *) g_queue_pop_head (priv->queue);
     if (info) {
         if (info->cached && !error)
-            mm_serial_port_set_cached_reply (self, info->command, priv->response->str);
+            mm_serial_port_set_cached_reply (self, info->command, priv->response);
 
-        if (info->callback)
+        g_warn_if_fail (MM_SERIAL_PORT_GET_CLASS (self)->handle_response != NULL);
-            info->callback (self, priv->response, error, info->user_data);
+        MM_SERIAL_PORT_GET_CLASS (self)->handle_response (self,
+                                                          priv->response,
+                                                          error,
+                                                          info->callback,
+                                                          info->user_data);
 
-        g_free (info->command);
+        g_byte_array_free (info->command, TRUE);
         g_slice_free (MMQueueData, info);
     }
 
     if (error)
         g_error_free (error);
 
-    g_string_truncate (priv->response, 0);
+    if (priv->response->len)
+        g_byte_array_remove_range (priv->response, 0, priv->response->len);
     if (!g_queue_is_empty (priv->queue))
         mm_serial_port_schedule_queue_process (self);
 }
@@ -566,10 +557,10 @@ mm_serial_port_queue_process (gpointer data)
         return FALSE;
 
     if (info->cached) {
-        const char *cached = mm_serial_port_get_cached_reply (self, info->command);
+        const GByteArray *cached = mm_serial_port_get_cached_reply (self, info->command);
 
         if (cached) {
-            g_string_append (priv->response, cached);
+            g_byte_array_append (priv->response, cached->data, cached->len);
             mm_serial_port_got_response (self, NULL);
             return FALSE;
         }
@@ -590,111 +581,16 @@ mm_serial_port_queue_process (gpointer data)
     return FALSE;
 }
 
-void
-mm_serial_port_add_unsolicited_msg_handler (MMSerialPort *self,
-                                            GRegex *regex,
-                                            MMSerialUnsolicitedMsgFn callback,
-                                            gpointer user_data,
-                                            GDestroyNotify notify)
-{
-    MMUnsolicitedMsgHandler *handler;
-    MMSerialPortPrivate *priv;
-
-    g_return_if_fail (MM_IS_SERIAL_PORT (self));
-    g_return_if_fail (regex != NULL);
-
-    handler = g_slice_new (MMUnsolicitedMsgHandler);
-    handler->regex = g_regex_ref (regex);
-    handler->callback = callback;
-    handler->user_data = user_data;
-    handler->notify = notify;
-
-    priv = MM_SERIAL_PORT_GET_PRIVATE (self);
-    priv->unsolicited_msg_handlers = g_slist_append (priv->unsolicited_msg_handlers, handler);
-}
-
-void
-mm_serial_port_set_response_parser (MMSerialPort *self,
-                                    MMSerialResponseParserFn fn,
-                                    gpointer user_data,
-                                    GDestroyNotify notify)
-{
-    MMSerialPortPrivate *priv = MM_SERIAL_PORT_GET_PRIVATE (self);
-
-    g_return_if_fail (MM_IS_SERIAL_PORT (self));
-
-    if (priv->response_parser_notify)
-        priv->response_parser_notify (priv->response_parser_user_data);
-
-    priv->response_parser_fn = fn;
-    priv->response_parser_user_data = user_data;
-    priv->response_parser_notify = notify;
-}
-
-static gboolean
-remove_eval_cb (const GMatchInfo *match_info,
-                GString *result,
-                gpointer user_data)
-{
-    int *result_len = (int *) user_data;
-    int start;
-    int end;
-
-    if (g_match_info_fetch_pos  (match_info, 0, &start, &end))
-        *result_len -= (end - start);
-
-    return FALSE;
-}
-
-static void
-parse_unsolicited_messages (MMSerialPort *self,
-                            GString *response)
-{
-    MMSerialPortPrivate *priv = MM_SERIAL_PORT_GET_PRIVATE (self);
-    GSList *iter;
-
-    for (iter = priv->unsolicited_msg_handlers; iter; iter = iter->next) {
-        MMUnsolicitedMsgHandler *handler = (MMUnsolicitedMsgHandler *) iter->data;
-        GMatchInfo *match_info;
-        gboolean matches;
-
-        matches = g_regex_match_full (handler->regex, response->str, response->len, 0, 0, &match_info, NULL);
-        if (handler->callback) {
-            while (g_match_info_matches (match_info)) {
-                handler->callback (self, match_info, handler->user_data);
-                g_match_info_next (match_info, NULL);
-            }
-        }
-
-        g_match_info_free (match_info);
-
-        if (matches) {
-            /* Remove matches */
-            char *str;
-            int result_len = response->len;
-
-            str = g_regex_replace_eval (handler->regex, response->str, response->len, 0, 0,
-                                        remove_eval_cb, &result_len, NULL);
-
-            g_string_truncate (response, 0);
-            g_string_append_len (response, str, result_len);
-            g_free (str);
-        }
-    }
-}
-
 static gboolean
 parse_response (MMSerialPort *self,
-                GString *response,
+                GByteArray *response,
                 GError **error)
 {
-    MMSerialPortPrivate *priv = MM_SERIAL_PORT_GET_PRIVATE (self);
+    if (MM_SERIAL_PORT_GET_CLASS (self)->parse_unsolicited)
+        MM_SERIAL_PORT_GET_CLASS (self)->parse_unsolicited (self, response);
 
-    g_return_val_if_fail (priv->response_parser_fn != NULL, FALSE);
+    g_return_val_if_fail (MM_SERIAL_PORT_GET_CLASS (self)->parse_response, FALSE);
-
+    return MM_SERIAL_PORT_GET_CLASS (self)->parse_response (self, response, error);
-    parse_unsolicited_messages (self, response);
-
-    return priv->response_parser_fn (priv->response_parser_user_data, response, error);
 }
 
 static gboolean
@@ -709,13 +605,15 @@ data_available (GIOChannel *source,
     GIOStatus status;
 
     if (condition & G_IO_HUP) {
-        g_string_truncate (priv->response, 0);
+        if (priv->response->len)
+            g_byte_array_remove_range (priv->response, 0, priv->response->len);
         mm_serial_port_close (self);
         return FALSE;
     }
 
     if (condition & G_IO_ERR) {
-        g_string_truncate (priv->response, 0);
+        if (priv->response->len)
+            g_byte_array_remove_range (priv->response, 0, priv->response->len);
         return TRUE;
     }
 
@@ -735,14 +633,14 @@ data_available (GIOChannel *source,
 
         if (bytes_read > 0) {
             serial_debug (self, "<--", buf, bytes_read);
-            g_string_append_len (priv->response, buf, bytes_read);
+            g_byte_array_append (priv->response, (const guint8 *) buf, bytes_read);
         }
 
-        /* Make sure the string doesn't grow too long */
+        /* Make sure the response doesn't grow too long */
 		if (priv->response->len > SERIAL_BUF_SIZE) {
 			g_warning ("%s (%s): response buffer filled before repsonse received",
 			           G_STRFUNC, mm_port_get_device (MM_PORT (self)));
-			g_string_erase (priv->response, 0, (SERIAL_BUF_SIZE / 2));
+            g_byte_array_remove_range (priv->response, 0, (SERIAL_BUF_SIZE / 2));
         }
 
         if (parse_response (self, priv->response, &err))
@@ -865,6 +763,7 @@ void
 mm_serial_port_close (MMSerialPort *self)
 {
     MMSerialPortPrivate *priv;
+    int i;
 
     g_return_if_fail (MM_IS_SERIAL_PORT (self));
 
@@ -896,14 +795,24 @@ mm_serial_port_close (MMSerialPort *self)
         close (priv->fd);
         priv->fd = -1;
     }
+
+    /* Clear the command queue */
+    for (i = 0; i < g_queue_get_length (priv->queue); i++) {
+        MMQueueData *item = g_queue_peek_nth (priv->queue, i);
+
+        g_byte_array_free (item->command, TRUE);
+        g_slice_free (MMQueueData, item);
+    }
+    g_queue_clear (priv->queue);
 }
 
 static void
 internal_queue_command (MMSerialPort *self,
-                        const char *command,
+                        GByteArray *command,
+                        gboolean take_command,
                         gboolean cached,
                         guint32 timeout_seconds,
-                        MMSerialResponseFn callback,
+                        GCallback callback,
                         gpointer user_data)
 {
     MMSerialPortPrivate *priv = MM_SERIAL_PORT_GET_PRIVATE (self);
@@ -913,7 +822,12 @@ internal_queue_command (MMSerialPort *self,
     g_return_if_fail (command != NULL);
 
     info = g_slice_new0 (MMQueueData);
-    info->command = g_strdup (command);
+    if (take_command)
+        info->command = command;
+    else {
+        info->command = g_byte_array_sized_new (command->len);
+        g_byte_array_append (info->command, command->data, command->len);
+    }
     info->cached = cached;
     info->timeout = timeout_seconds;
     info->callback = callback;
@@ -921,7 +835,7 @@ internal_queue_command (MMSerialPort *self,
 
     /* Clear the cached value for this command if not asking for cached value */
     if (!cached)
-        mm_serial_port_set_cached_reply (self, command, NULL);
+        mm_serial_port_set_cached_reply (self, info->command, NULL);
 
     g_queue_push_tail (priv->queue, info);
 
@@ -931,22 +845,24 @@ internal_queue_command (MMSerialPort *self,
 
 void
 mm_serial_port_queue_command (MMSerialPort *self,
-                              const char *command,
+                              GByteArray *command,
+                              gboolean take_command,
                               guint32 timeout_seconds,
-                              MMSerialResponseFn callback,
+                              GCallback callback,
                               gpointer user_data)
 {
-    internal_queue_command (self, command, FALSE, timeout_seconds, callback, user_data);
+    internal_queue_command (self, command, take_command, FALSE, timeout_seconds, callback, user_data);
 }
 
 void
 mm_serial_port_queue_command_cached (MMSerialPort *self,
-                                     const char *command,
+                                     GByteArray *command,
+                                     gboolean take_command,
                                      guint32 timeout_seconds,
-                                     MMSerialResponseFn callback,
+                                     GCallback callback,
                                      gpointer user_data)
 {
-    internal_queue_command (self, command, TRUE, timeout_seconds, callback, user_data);
+    internal_queue_command (self, command, take_command, TRUE, timeout_seconds, callback, user_data);
 }
 
 typedef struct {
@@ -1122,12 +1038,54 @@ mm_serial_port_new (const char *name, MMPortType ptype)
                                          NULL));
 }
 
+static gboolean
+ba_equal (gconstpointer v1, gconstpointer v2)
+{
+    const GByteArray *a = v1;
+    const GByteArray *b = v2;
+
+    if (!a && b)
+        return -1;
+    else if (a && !b)
+        return 1;
+    else if (!a && !b)
+        return 0;
+
+    g_assert (a && b);
+    if (a->len < b->len)
+        return -1;
+    else if (a->len > b->len)
+        return 1;
+
+    g_assert (a->len == b->len);
+    return !memcmp (a->data, b->data, a->len);
+}
+
+static guint
+ba_hash (gconstpointer v)
+{
+    /* 31 bit hash function */
+    const GByteArray *array = v;
+    guint32 i, h = (const signed char) array->data[0];
+
+    for (i = 1; i < array->len; i++)
+        h = (h << 5) - h + (const signed char) array->data[i];
+
+    return h;
+}
+
+static void
+ba_free (gpointer v)
+{
+    g_byte_array_free ((GByteArray *) v, TRUE);
+}
+
 static void
 mm_serial_port_init (MMSerialPort *self)
 {
     MMSerialPortPrivate *priv = MM_SERIAL_PORT_GET_PRIVATE (self);
 
-    priv->reply_cache = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
+    priv->reply_cache = g_hash_table_new_full (ba_hash, ba_equal, ba_free, ba_free);
 
     priv->fd = -1;
     priv->baud = 57600;
@@ -1137,8 +1095,7 @@ mm_serial_port_init (MMSerialPort *self)
     priv->send_delay = 1000;
 
     priv->queue = g_queue_new ();
-    priv->command  = g_string_new_len   ("AT", SERIAL_BUF_SIZE);
+    priv->response = g_byte_array_sized_new (500);
-    priv->response = g_string_sized_new (SERIAL_BUF_SIZE);
 }
 
 static void
@@ -1212,24 +1169,8 @@ finalize (GObject *object)
     MMSerialPortPrivate *priv = MM_SERIAL_PORT_GET_PRIVATE (self);
 
     g_hash_table_destroy (priv->reply_cache);
+    g_byte_array_free (priv->response, TRUE);
     g_queue_free (priv->queue);
-    g_string_free (priv->command, TRUE);
-    g_string_free (priv->response, TRUE);
-
-    while (priv->unsolicited_msg_handlers) {
-        MMUnsolicitedMsgHandler *handler = (MMUnsolicitedMsgHandler *) priv->unsolicited_msg_handlers->data;
-
-        if (handler->notify)
-            handler->notify (handler->user_data);
-
-        g_regex_unref (handler->regex);
-        g_slice_free (MMUnsolicitedMsgHandler, handler);
-        priv->unsolicited_msg_handlers = g_slist_delete_link (priv->unsolicited_msg_handlers,
-                                                              priv->unsolicited_msg_handlers);
-    }
-
-    if (priv->response_parser_notify)
-        priv->response_parser_notify (priv->response_parser_user_data);
 
     G_OBJECT_CLASS (mm_serial_port_parent_class)->finalize (object);
 }

src/mm-serial-port.h

@@ -39,19 +39,6 @@
 typedef struct _MMSerialPort MMSerialPort;
 typedef struct _MMSerialPortClass MMSerialPortClass;
 
-typedef gboolean (*MMSerialResponseParserFn) (gpointer user_data,
-                                              GString *response,
-                                              GError **error);
-
-typedef void (*MMSerialUnsolicitedMsgFn) (MMSerialPort *port,
-                                          GMatchInfo *match_info,
-                                          gpointer user_data);
-
-typedef void (*MMSerialResponseFn)     (MMSerialPort *port,
-                                        GString *response,
-                                        GError *error,
-                                        gpointer user_data);
-
 typedef void (*MMSerialFlashFn)        (MMSerialPort *port,
                                         GError *error,
                                         gpointer user_data);
@@ -62,40 +49,44 @@ struct _MMSerialPort {
 
 struct _MMSerialPortClass {
     MMPortClass parent;
+
+    /* Called for subclasses to parse unsolicited responses.  If any recognized
+     * unsolicited response is found, it should be removed from the 'response'
+     * byte array before returning.
+     */
+    void     (*parse_unsolicited) (MMSerialPort *self, GByteArray *response);
+
+    /* Called to parse the device's response to a command or determine if the
+     * response was an error response.  If the response indicates an error, an
+     * appropriate error should be returned in the 'error' argument.  The
+     * function should return FALSE if there is not enough data yet to determine
+     * the device's reply (whether success *or* error), and should return TRUE
+     * when the device's response has been recognized and parsed.
+     */
+    gboolean (*parse_response)    (MMSerialPort *self,
+                                   GByteArray *response,
+                                   GError **error);
+
+    /* Called after parsing to allow the command response to be delivered to
+     * it's callback to be handled.
+     */
+    void     (*handle_response)   (MMSerialPort *self,
+                                   GByteArray *response,
+                                   GError *error,
+                                   GCallback callback,
+                                   gpointer callback_data);
 };
 
 GType mm_serial_port_get_type (void);
 
 MMSerialPort *mm_serial_port_new (const char *name, MMPortType ptype);
 
-void     mm_serial_port_add_unsolicited_msg_handler (MMSerialPort *self,
-                                                     GRegex *regex,
-                                                     MMSerialUnsolicitedMsgFn callback,
-                                                     gpointer user_data,
-                                                     GDestroyNotify notify);
-
-void     mm_serial_port_set_response_parser (MMSerialPort *self,
-                                             MMSerialResponseParserFn fn,
-                                             gpointer user_data,
-                                             GDestroyNotify notify);
-
 gboolean mm_serial_port_is_open           (MMSerialPort *self);
 
 gboolean mm_serial_port_open              (MMSerialPort *self,
                                            GError  **error);
 
 void     mm_serial_port_close             (MMSerialPort *self);
-void     mm_serial_port_queue_command     (MMSerialPort *self,
-                                           const char *command,
-                                           guint32 timeout_seconds,
-                                           MMSerialResponseFn callback,
-                                           gpointer user_data);
-
-void     mm_serial_port_queue_command_cached (MMSerialPort *self,
-                                              const char *command,
-                                              guint32 timeout_seconds,
-                                              MMSerialResponseFn callback,
-                                              gpointer user_data);
 
 gboolean mm_serial_port_flash             (MMSerialPort *self,
                                            guint32 flash_time,
@@ -103,5 +94,19 @@ gboolean mm_serial_port_flash             (MMSerialPort *self,
                                            gpointer user_data);
 void     mm_serial_port_flash_cancel      (MMSerialPort *self);
 
+void     mm_serial_port_queue_command     (MMSerialPort *self,
+                                           GByteArray *command,
+                                           gboolean take_command,
+                                           guint32 timeout_seconds,
+                                           GCallback callback,
+                                           gpointer user_data);
+
+void     mm_serial_port_queue_command_cached (MMSerialPort *self,
+                                              GByteArray *command,
+                                              gboolean take_command,
+                                              guint32 timeout_seconds,
+                                              GCallback callback,
+                                              gpointer user_data);
+
 #endif /* MM_SERIAL_PORT_H */