colin/ModemManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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.
This commit is contained in:
Dan Williams
2010-02-20 14:55:10 -08:00
parent a431455059
commit a8c7bba19e
24 changed files with 983 additions and 618 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
plugins/mm-modem-anydata-cdma.c
View File

@@ -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);
secondary = mm_generic_cdma_get_port (cdma, MM_PORT_TYPE_SECONDARY);
port = primary = mm_generic_cdma_get_at_port (cdma, MM_PORT_TYPE_PRIMARY);
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);
}

9
plugins/mm-modem-gobi-gsm.c
View File

@@ -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

36
plugins/mm-modem-hso.c
View File

@@ -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);
}
}

20
plugins/mm-modem-huawei-cdma.c
View File

@@ -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,7 +99,7 @@ handle_1x_quality_change (MMSerialPort *port,
}
static void
handle_evdo_quality_change (MMSerialPort *port,
handle_evdo_quality_change (MMAtSerialPort *port,
GMatchInfo *match_info,
gpointer user_data)
{
@@ -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);
secondary = mm_generic_cdma_get_port (cdma, MM_PORT_TYPE_SECONDARY);
port = primary = mm_generic_cdma_get_at_port (cdma, MM_PORT_TYPE_PRIMARY);
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);
}
}

62
plugins/mm-modem-huawei-gsm.c
View File

@@ -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);
}
}

107
plugins/mm-modem-mbm.c
View File

@@ -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_serial_port_queue_command (primary, "+CMER=3,0,0,1", 3, NULL, NULL);
mm_at_serial_port_queue_command (primary, "+CREG=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,17 +593,18 @@ 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,
GError *error,
gpointer user_data)
@@ -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);
}

8
plugins/mm-modem-nokia.c
View File

@@ -56,16 +56,16 @@ 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)) {
mm_serial_port_set_response_parser (MM_SERIAL_PORT (port),
if (port && MM_IS_AT_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_new (),
mm_serial_parser_v1_e1_destroy);

30
plugins/mm-modem-novatel-gsm.c
View File

@@ -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;

16
plugins/mm-modem-option.c
View File

@@ -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);
}

26
plugins/mm-modem-sierra-cdma.c
View File

@@ -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;
MMSerialPort *port;
MMAtSerialPort *primary, *secondary;
MMAtSerialPort *port;
port = primary = mm_generic_cdma_get_port (cdma, MM_PORT_TYPE_PRIMARY);
secondary = mm_generic_cdma_get_port (cdma, MM_PORT_TYPE_SECONDARY);
port = primary = mm_generic_cdma_get_at_port (cdma, MM_PORT_TYPE_PRIMARY);
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);
}
/*****************************************************************************/

8
plugins/mm-modem-sierra-gsm.c
View File

@@ -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);
}

48
plugins/mm-modem-zte.c
View File

@@ -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);
mm_serial_port_queue_command (primary, "+CPMS?", 10, cpms_try_done, info);
primary = mm_generic_gsm_get_at_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
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);
}

15
plugins/mm-plugin-huawei.c
View File

@@ -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,10 +209,10 @@ 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_new (),
mm_serial_parser_v1_destroy);
@@ -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,

6
src/Makefile.am
View File

@@ -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 \

323
src/mm-at-serial-port.c Normal file
View File

@@ -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;
}

85
src/mm-at-serial-port.h Normal file
View File

@@ -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 */

86
src/mm-generic-cdma.c
View File

@@ -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;
MMSerialPort *secondary;
MMAtSerialPort *primary;
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_new (),
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,8 +215,8 @@ release_port (MMModem *modem, const char *subsys, const char *name)
check_valid (MM_GENERIC_CDMA (modem));
}
MMSerialPort *
mm_generic_cdma_get_port (MMGenericCdma *modem,
MMAtSerialPort *
mm_generic_cdma_get_at_port (MMGenericCdma *modem,
MMPortType ptype)
{
g_return_val_if_fail (MM_IS_GENERIC_CDMA (modem), 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_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, "+GMI", 3, get_manufacturer_done, info);
mm_at_serial_port_queue_command_cached (port, "+GMM", 3, get_model_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);
}
/*****************************************************************************/

4
src/mm-generic-cdma.h
View File

@@ -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);

174
src/mm-generic-gsm.c
View File

@@ -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;
MMSerialPort *secondary;
MMAtSerialPort *primary;
MMAtSerialPort *secondary;
MMPort *data;
} MMGenericGsmPrivate;
static void get_registration_status (MMSerialPort *port, MMCallbackInfo *info);
static void read_operator_code_done (MMSerialPort *port,
static void get_registration_status (MMAtSerialPort *port, MMCallbackInfo *info);
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_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,2;+COPS?", 3, read_operator_code_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)) {
mm_serial_port_set_response_parser (MM_SERIAL_PORT (port),
if (port && MM_IS_AT_SERIAL_PORT (port)) {
mm_at_serial_port_set_response_parser (MM_AT_SERIAL_PORT (port),
mm_serial_parser_v1_parse,
mm_serial_parser_v1_new (),
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_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, "+CGMI", 3, get_manufacturer_done, info);
mm_at_serial_port_queue_command_cached (priv->primary, "+CGMM", 3, get_model_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,15 +1925,15 @@ 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 *
mm_generic_gsm_get_port (MMGenericGsm *modem,
MMAtSerialPort *
mm_generic_gsm_get_at_port (MMGenericGsm *modem,
MMPortType ptype)
{
g_return_val_if_fail (MM_IS_GENERIC_GSM (modem), NULL);

4
src/mm-generic-gsm.h
View File

@@ -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,7 +90,7 @@ 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);
MMPort *mm_generic_gsm_grab_port (MMGenericGsm *modem,

4
src/mm-modem-base.c
View File

@@ -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,

40
src/mm-plugin-base.c
View File

@@ -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,
delay_secs,
custom_init_response,
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,7 +666,7 @@ 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_new (),
mm_serial_parser_v1_destroy);

333
src/mm-serial-port.c
View File

@@ -55,16 +55,7 @@ typedef struct {
GHashTable *reply_cache;
GIOChannel *channel;
GQueue *queue;
GString *command;
GString *response;
gboolean connected;
/* Response parser data */
MMSerialResponseParserFn response_parser_fn;
gpointer response_parser_user_data;
GDestroyNotify response_parser_notify;
GSList *unsolicited_msg_handlers;
GByteArray *response;
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;
int status, i = 0;
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);
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);
serial_debug (self, "-->", (const char *) command->data, command->len);
/* Only accept about 3 seconds of EAGAIN */
if (priv->send_delay > 0)
eagain_count = 3000000 / priv->send_delay;
s = priv->command->str;
while (*s) {
status = write (priv->fd, s, 1);
while (i < command->len) {
p = &command->data[i];
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;
MMSerialResponseFn callback;
GByteArray *command;
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)
info->callback (self, priv->response, error, info->user_data);
g_warn_if_fail (MM_SERIAL_PORT_GET_CLASS (self)->handle_response != NULL);
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);
parse_unsolicited_messages (self, response);
return priv->response_parser_fn (priv->response_parser_user_data, response, error);
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);
}
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_string_sized_new (SERIAL_BUF_SIZE);
priv->response = g_byte_array_sized_new (500);
}
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);
}

75
src/mm-serial-port.h
View File

@@ -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 */