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

x22x: plugin fully ported

Browse Source
This commit is contained in:
Aleksander Morgado
2012-07-12 06:36:04 +02:00
parent 14d482286f
commit aab8524285
4 changed files with 0 additions and 599 deletions
Download Patch File Download Diff File Expand all files Collapse all files

267
plugins/mm-modem-x22x-gsm.c
View File

@@ -1,267 +0,0 @@
/* -*- 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.
*/
#include <config.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
#include "mm-modem-x22x-gsm.h"
#include "mm-at-serial-port.h"
#include "mm-errors.h"
#include "mm-callback-info.h"
#include "mm-modem-helpers.h"
G_DEFINE_TYPE (MMModemX22xGsm, mm_modem_x22x_gsm, MM_TYPE_GENERIC_GSM)
MMModem *
mm_modem_x22x_gsm_new (const char *device,
const char *driver,
const char *plugin,
guint32 vendor,
guint32 product)
{
g_return_val_if_fail (device != NULL, NULL);
g_return_val_if_fail (driver != NULL, NULL);
g_return_val_if_fail (plugin != NULL, NULL);
return MM_MODEM (g_object_new (MM_TYPE_MODEM_X22X_GSM,
MM_MODEM_MASTER_DEVICE, device,
MM_MODEM_DRIVER, driver,
MM_MODEM_PLUGIN, plugin,
MM_MODEM_HW_VID, vendor,
MM_MODEM_HW_PID, product,
NULL));
}
/*****************************************************************************/
static gboolean
parse_syssel_response (GString *response,
MMModemGsmAllowedMode *out_mode,
GError **error)
{
GRegex *r;
GMatchInfo *match_info;
char *str;
gint mode = -1;
gboolean success = FALSE;
g_return_val_if_fail (response != NULL, FALSE);
g_return_val_if_fail (out_mode != NULL, FALSE);
r = g_regex_new ("\\+SYSSEL:\\s*(\\d),(\\d),(\\d),(\\d)", G_REGEX_UNGREEDY, 0, NULL);
if (!r) {
g_set_error_literal (error, MM_MODEM_ERROR, MM_MODEM_ERROR_GENERAL,
"Internal error parsing mode/tech response");
return FALSE;
}
if (!g_regex_match_full (r, response->str, response->len, 0, 0, &match_info, NULL)) {
g_set_error_literal (error, MM_MODEM_ERROR, MM_MODEM_ERROR_GENERAL,
"Failed to parse mode/tech response");
goto out;
}
str = g_match_info_fetch (match_info, 3);
mode = atoi (str);
g_free (str);
if (mode < 0 || mode > 2) {
g_set_error_literal (error, MM_MODEM_ERROR, MM_MODEM_ERROR_GENERAL,
"Failed to parse mode/tech response");
goto out;
}
if (out_mode) {
if (mode == 0)
*out_mode = MM_MODEM_GSM_ALLOWED_MODE_ANY;
else if (mode == 1)
*out_mode = MM_MODEM_GSM_ALLOWED_MODE_2G_ONLY;
else if (mode == 2)
*out_mode = MM_MODEM_GSM_ALLOWED_MODE_3G_ONLY;
else
*out_mode = MM_MODEM_GSM_ALLOWED_MODE_ANY;
}
success = TRUE;
out:
g_match_info_free (match_info);
g_regex_unref (r);
return success;
}
static void
get_allowed_mode_done (MMAtSerialPort *port,
GString *response,
GError *error,
gpointer user_data)
{
MMCallbackInfo *info = (MMCallbackInfo *) user_data;
MMModemGsmAllowedMode mode = MM_MODEM_GSM_ALLOWED_MODE_ANY;
/* If the modem has already been removed, return without
* scheduling callback */
if (mm_callback_info_check_modem_removed (info))
return;
if (error)
info->error = g_error_copy (error);
else {
parse_syssel_response (response, &mode, &info->error);
mm_callback_info_set_result (info, GUINT_TO_POINTER (mode), NULL);
}
mm_callback_info_schedule (info);
}
static void
get_allowed_mode (MMGenericGsm *gsm,
MMModemUIntFn callback,
gpointer user_data)
{
MMCallbackInfo *info;
MMAtSerialPort *port;
info = mm_callback_info_uint_new (MM_MODEM (gsm), callback, user_data);
port = mm_generic_gsm_get_best_at_port (gsm, &info->error);
if (!port) {
mm_callback_info_schedule (info);
return;
}
mm_at_serial_port_queue_command (port, "+SYSSEL?", 3, get_allowed_mode_done, info);
}
static void
set_allowed_mode_done (MMAtSerialPort *port,
GString *response,
GError *error,
gpointer user_data)
{
MMCallbackInfo *info = (MMCallbackInfo *) user_data;
/* If the modem has already been removed, return without
* scheduling callback */
if (mm_callback_info_check_modem_removed (info))
return;
if (error)
info->error = g_error_copy (error);
mm_callback_info_schedule (info);
}
static void
set_allowed_mode (MMGenericGsm *gsm,
MMModemGsmAllowedMode mode,
MMModemFn callback,
gpointer user_data)
{
MMCallbackInfo *info;
MMAtSerialPort *port;
char *command = NULL;
info = mm_callback_info_new (MM_MODEM (gsm), callback, user_data);
port = mm_generic_gsm_get_best_at_port (gsm, &info->error);
if (!port) {
mm_callback_info_schedule (info);
return;
}
switch (mode) {
case MM_MODEM_GSM_ALLOWED_MODE_2G_ONLY:
command = "+SYSSEL=,1,0";
break;
case MM_MODEM_GSM_ALLOWED_MODE_3G_ONLY:
command = "+SYSSEL=,2,0";
break;
case MM_MODEM_GSM_ALLOWED_MODE_ANY:
default:
command = "+SYSSEL=,0,0";
break;
}
mm_at_serial_port_queue_command (port, command, 3, set_allowed_mode_done, info);
}
static void
get_act_request_done (MMAtSerialPort *port,
GString *response,
GError *error,
gpointer user_data)
{
MMCallbackInfo *info = user_data;
MMModemGsmAccessTech act = MM_MODEM_GSM_ACCESS_TECH_UNKNOWN;
const char *p;
/* If the modem has already been removed, return without
* scheduling callback */
if (mm_callback_info_check_modem_removed (info))
return;
if (error)
info->error = g_error_copy (error);
else {
p = mm_strip_tag (response->str, "+SSND:");
act = mm_gsm_string_to_access_tech (p);
}
mm_callback_info_set_result (info, GUINT_TO_POINTER (act), NULL);
mm_callback_info_schedule (info);
}
static void
get_access_technology (MMGenericGsm *modem,
MMModemUIntFn callback,
gpointer user_data)
{
MMAtSerialPort *port;
MMCallbackInfo *info;
info = mm_callback_info_uint_new (MM_MODEM (modem), callback, user_data);
port = mm_generic_gsm_get_best_at_port (modem, &info->error);
if (!port) {
mm_callback_info_schedule (info);
return;
}
mm_at_serial_port_queue_command (port, "+SSND?", 3, get_act_request_done, info);
}
/*****************************************************************************/
static void
mm_modem_x22x_gsm_init (MMModemX22xGsm *self)
{
}
static void
mm_modem_x22x_gsm_class_init (MMModemX22xGsmClass *klass)
{
MMGenericGsmClass *gsm_class = MM_GENERIC_GSM_CLASS (klass);
mm_modem_x22x_gsm_parent_class = g_type_class_peek_parent (klass);
gsm_class->set_allowed_mode = set_allowed_mode;
gsm_class->get_allowed_mode = get_allowed_mode;
gsm_class->get_access_technology = get_access_technology;
}

45
plugins/mm-modem-x22x-gsm.h
View File

@@ -1,45 +0,0 @@
/* -*- 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_MODEM_X22X_GSM_H
#define MM_MODEM_X22X_GSM_H
#include "mm-generic-gsm.h"
#define MM_TYPE_MODEM_X22X_GSM (mm_modem_x22x_gsm_get_type ())
#define MM_MODEM_X22X_GSM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MM_TYPE_MODEM_X22X_GSM, MMModemX22xGsm))
#define MM_MODEM_X22X_GSM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MM_TYPE_MODEM_X22X_GSM, MMModemX22xGsmClass))
#define MM_IS_MODEM_X22X_GSM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MM_TYPE_MODEM_X22X_GSM))
#define MM_IS_MODEM_X22X_GSM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MM_TYPE_MODEM_X22X_GSM))
#define MM_MODEM_X22X_GSM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MM_TYPE_MODEM_X22X_GSM, MMModemX22xGsmClass))
typedef struct {
MMGenericGsm parent;
} MMModemX22xGsm;
typedef struct {
MMGenericGsmClass parent;
} MMModemX22xGsmClass;
GType mm_modem_x22x_gsm_get_type (void);
MMModem *mm_modem_x22x_gsm_new (const char *device,
const char *driver,
const char *plugin,
guint32 vendor,
guint32 product);
#endif /* MM_MODEM_X22X_H */

246
plugins/mm-plugin-x22x.c
View File

@@ -1,246 +0,0 @@
/* -*- 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.
*/
#include <string.h>
#include <gmodule.h>
#include "mm-plugin-x22x.h"
#include "mm-modem-x22x-gsm.h"
#include "mm-generic-gsm.h"
#include "mm-modem-helpers.h"
G_DEFINE_TYPE (MMPluginX22x, mm_plugin_x22x, MM_TYPE_PLUGIN_BASE)
int mm_plugin_major_version = MM_PLUGIN_MAJOR_VERSION;
int mm_plugin_minor_version = MM_PLUGIN_MINOR_VERSION;
G_MODULE_EXPORT MMPlugin *
mm_plugin_create (void)
{
return MM_PLUGIN (g_object_new (MM_TYPE_PLUGIN_X22X,
MM_PLUGIN_BASE_NAME, "X22X",
NULL));
}
/*****************************************************************************/
static guint32
get_level_for_capabilities (guint32 capabilities)
{
/* These modems have the same vendor ID as a few of the other
* Alcatel/TCT/T&A modems, and the longcheer plugin will try to claim them
* too. So we provide a higher support level here to make sure this
* plugin tries to grab it's supported devices first.
*/
if (capabilities & MM_PLUGIN_BASE_PORT_CAP_GSM)
return 20;
if (capabilities & MM_PLUGIN_BASE_PORT_CAP_QCDM)
return 20;
return 0;
}
static void
probe_result (MMPluginBase *base,
MMPluginBaseSupportsTask *task,
guint32 capabilities,
gpointer user_data)
{
mm_plugin_base_supports_task_complete (task, get_level_for_capabilities (capabilities));
}
static gboolean
custom_init_response_cb (MMPluginBaseSupportsTask *task,
GString *response,
GError *error,
guint32 tries,
gboolean *out_stop,
guint32 *out_level,
gpointer user_data)
{
const char *p;
if (error)
return tries <= 4 ? TRUE : FALSE;
/* Note the lack of a ':' on the GMR; the X200 doesn't send one */
g_assert (response);
p = mm_strip_tag (response->str, "AT+GMR");
if (*p != 'L') {
/* X200 modems have a GMR firmware revision that starts with 'L', and
* as far as I can tell X060s devices have a revision starting with 'C'.
* So use that to determine if the device is an X200, which this plugin
* does supports.
*/
*out_level = 0;
*out_stop = TRUE;
return FALSE;
}
/* Continue with generic probing */
return FALSE;
}
static MMPluginSupportsResult
supports_port (MMPluginBase *base,
MMModem *existing,
MMPluginBaseSupportsTask *task)
{
GUdevDevice *port;
guint16 vendor = 0, product = 0;
const char *subsys, *name;
/* Can't do anything with non-serial ports */
port = mm_plugin_base_supports_task_get_port (task);
if (strcmp (g_udev_device_get_subsystem (port), "tty"))
return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
subsys = g_udev_device_get_subsystem (port);
name = g_udev_device_get_name (port);
if (!mm_plugin_base_get_device_ids (base, subsys, name, &vendor, &product))
return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
/* Only TCT/T&A for now */
if (vendor != 0x1bbb)
return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
/* If the port wasn't tagged, we don't support it */
if (!g_udev_device_get_property_as_boolean (port, "ID_MM_X22X_TAGGED"))
return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
/* Check if a previous probing was already launched in this port */
if (mm_plugin_base_supports_task_propagate_cached (task)) {
guint32 level;
/* A previous probing was already done, use its results */
level = get_level_for_capabilities (mm_plugin_base_supports_task_get_probed_capabilities (task));
if (level) {
mm_plugin_base_supports_task_complete (task, level);
return MM_PLUGIN_SUPPORTS_PORT_IN_PROGRESS;
}
return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
}
/* TCT/Alcatel in their infinite wisdom assigned the same USB VID/PID to
* the x060s (Longcheer firmware) and the x200 (X22X, this plugin) and thus
* we can't tell them apart via udev rules. Worse, they both report the
* same +GMM and +GMI, so we're left with just +GMR which is a sketchy way
* to tell modems apart. We can't really use X22X-specific commands
* like AT+SSND because we're not sure if they work when the SIM PIN has not
* been entered yet; many modems have a limited command parser before the
* SIM is unlocked.
*/
if (vendor == 0x1bbb && product == 0x0000) {
mm_plugin_base_supports_task_add_custom_init_command (task,
"AT+GMR",
3,
custom_init_response_cb,
NULL);
}
/* Otherwise kick off a probe */
if (mm_plugin_base_probe_port (base, task, 100000, NULL))
return MM_PLUGIN_SUPPORTS_PORT_IN_PROGRESS;
return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
}
static MMModem *
grab_port (MMPluginBase *base,
MMModem *existing,
MMPluginBaseSupportsTask *task,
GError **error)
{
GUdevDevice *port = NULL;
MMModem *modem = NULL;
const char *name, *subsys, *sysfs_path;
guint32 caps;
MMPortType ptype;
guint16 vendor = 0, product = 0;
MMAtPortFlags pflags = MM_AT_PORT_FLAG_NONE;
port = mm_plugin_base_supports_task_get_port (task);
g_assert (port);
/* Look for port type hints; just probing can't distinguish which port should
* be the data/primary port on these devices. We have to tag them based on
* what the Windows .INF files say the port layout should be.
*/
if (g_udev_device_get_property_as_boolean (port, "ID_MM_X22X_PORT_TYPE_MODEM"))
pflags = MM_AT_PORT_FLAG_PRIMARY;
else if (g_udev_device_get_property_as_boolean (port, "ID_MM_X22X_PORT_TYPE_AUX"))
pflags = MM_AT_PORT_FLAG_SECONDARY;
caps = mm_plugin_base_supports_task_get_probed_capabilities (task);
ptype = mm_plugin_base_probed_capabilities_to_port_type (caps);
/* If the port was tagged by the udev rules but isn't a primary or secondary,
* then ignore it to guard against race conditions if a device just happens
* to show up with more than two AT-capable ports.
*/
if ( (pflags == MM_AT_PORT_FLAG_NONE)
&& g_udev_device_get_property_as_boolean (port, "ID_MM_X22X_TAGGED"))
ptype = MM_PORT_TYPE_IGNORED;
subsys = g_udev_device_get_subsystem (port);
name = g_udev_device_get_name (port);
if (!mm_plugin_base_get_device_ids (base, subsys, name, &vendor, &product)) {
g_set_error (error, 0, 0, "Could not get modem product ID.");
return NULL;
}
sysfs_path = mm_plugin_base_supports_task_get_physdev_path (task);
if (!existing) {
if (caps & MM_PLUGIN_BASE_PORT_CAP_GSM) {
modem = mm_modem_x22x_gsm_new (sysfs_path,
mm_plugin_base_supports_task_get_driver (task),
mm_plugin_get_name (MM_PLUGIN (base)),
vendor,
product);
}
if (modem) {
if (!mm_modem_grab_port (modem, subsys, name, ptype, pflags, NULL, error)) {
g_object_unref (modem);
return NULL;
}
}
} else if (get_level_for_capabilities (caps)) {
modem = existing;
if (!mm_modem_grab_port (modem, subsys, name, ptype, pflags, NULL, error))
return NULL;
}
return modem;
}
/*****************************************************************************/
static void
mm_plugin_x22x_init (MMPluginX22x *self)
{
g_signal_connect (self, "probe-result", G_CALLBACK (probe_result), NULL);
}
static void
mm_plugin_x22x_class_init (MMPluginX22xClass *klass)
{
MMPluginBaseClass *pb_class = MM_PLUGIN_BASE_CLASS (klass);
pb_class->supports_port = supports_port;
pb_class->grab_port = grab_port;
}

41
plugins/mm-plugin-x22x.h
View File

@@ -1,41 +0,0 @@
/* -*- 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_PLUGIN_X22X_H
#define MM_PLUGIN_X22X_H
#include "mm-plugin-base.h"
#define MM_TYPE_PLUGIN_X22X (mm_plugin_x22x_get_type ())
#define MM_PLUGIN_X22X(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MM_TYPE_PLUGIN_X22X, MMPluginX22x))
#define MM_PLUGIN_X22X_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MM_TYPE_PLUGIN_X22X, MMPluginX22xClass))
#define MM_IS_PLUGIN_X22X(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MM_TYPE_PLUGIN_X22X))
#define MM_IS_PLUGIN_X22X_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MM_TYPE_PLUGIN_X22X))
#define MM_PLUGIN_X22X_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MM_TYPE_PLUGIN_X22X, MMPluginX22xClass))
typedef struct {
MMPluginBase parent;
} MMPluginX22x;
typedef struct {
MMPluginBaseClass parent;
} MMPluginX22xClass;
GType mm_plugin_x22x_get_type (void);
G_MODULE_EXPORT MMPlugin *mm_plugin_create (void);
#endif /* MM_PLUGIN_X22X_H */