SymbX/ModemManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
cf48d3daa790a57bd003e6488baf936ec186caee
ModemManager/src/mm-plugin.c
T
Aleksander Morgado cf48d3daa7 plugin: don't provide an additional method to cancel the probing 
We'll do it with a GCancellable.
2012-08-06 20:06:45 +02:00

916 lines
31 KiB
C
Raw Blame History

/* -*- 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 - 2012 Red Hat, Inc.
* Copyright (C) 2012 Google, Inc.
*/
#define _GNU_SOURCE /* for strcasestr */
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <gudev/gudev.h>
#include <ModemManager.h>
#include <mm-errors-types.h>
#include "mm-plugin.h"
#include "mm-device.h"
#include "mm-at-serial-port.h"
#include "mm-qcdm-serial-port.h"
#include "mm-serial-parsers.h"
#include "mm-marshal.h"
#include "mm-private-boxed-types.h"
#include "libqcdm/src/commands.h"
#include "libqcdm/src/utils.h"
#include "libqcdm/src/errors.h"
#include "mm-log.h"
G_DEFINE_TYPE (MMPlugin, mm_plugin, G_TYPE_OBJECT)
#define MM_PLUGIN_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MM_TYPE_PLUGIN, MMPluginPrivate))
/* Virtual port corresponding to the embeded modem */
static gchar *virtual_port[] = {"smd0", NULL};
typedef struct {
gchar *name;
GUdevClient *client;
GHashTable *tasks;
/* Plugin-specific setups */
gchar **subsystems;
gchar **drivers;
guint16 *vendor_ids;
mm_uint16_pair *product_ids;
gchar **vendor_strings;
mm_str_pair *product_strings;
gchar **udev_tags;
gboolean at;
gboolean single_at;
gboolean qcdm;
MMPortProbeAtCommand *custom_init;
guint64 send_delay;
} MMPluginPrivate;
enum {
PROP_0,
PROP_NAME,
PROP_ALLOWED_SUBSYSTEMS,
PROP_ALLOWED_DRIVERS,
PROP_ALLOWED_VENDOR_IDS,
PROP_ALLOWED_PRODUCT_IDS,
PROP_ALLOWED_VENDOR_STRINGS,
PROP_ALLOWED_PRODUCT_STRINGS,
PROP_ALLOWED_UDEV_TAGS,
PROP_ALLOWED_AT,
PROP_ALLOWED_SINGLE_AT,
PROP_ALLOWED_QCDM,
PROP_CUSTOM_INIT,
PROP_SEND_DELAY,
LAST_PROP
};
/*****************************************************************************/
static char *
get_key (const char *subsys, const char *name)
{
return g_strdup_printf ("%s%s", subsys, name);
}
const char *
mm_plugin_get_name (MMPlugin *plugin)
{
return MM_PLUGIN_GET_PRIVATE (plugin)->name;
}
gboolean
mm_plugin_get_sort_last (const MMPlugin *plugin)
{
MMPluginPrivate *priv = MM_PLUGIN_GET_PRIVATE (plugin);
/* If we have any post-probing filter, we need to sort the plugin last */
return (priv->vendor_strings || priv->product_strings);
}
static gboolean
device_file_exists (const char *name)
{
char *devfile;
struct stat s;
int result;
devfile = g_strdup_printf ("/dev/%s", name);
result = stat (devfile, &s);
g_free (devfile);
return (0 == result) ? TRUE : FALSE;
}
static gboolean
is_virtual_port (const gchar *device_name)
{
guint idx;
/* Detect any modems accessible through the list of virtual ports */
for (idx = 0; virtual_port[idx]; idx++) {
if (strcmp (device_name, virtual_port[idx]))
continue;
if (!device_file_exists (virtual_port[idx]))
continue;
return TRUE;
}
return FALSE;
}
/* Returns TRUE if the support check request was filtered out */
static gboolean
apply_pre_probing_filters (MMPlugin *self,
MMDevice *device,
GUdevDevice *port,
gboolean *need_vendor_probing,
gboolean *need_product_probing)
{
MMPluginPrivate *priv = MM_PLUGIN_GET_PRIVATE (self);
guint16 vendor;
guint16 product;
gboolean product_filtered = FALSE;
gboolean vendor_filtered = FALSE;
guint i;
*need_vendor_probing = FALSE;
*need_product_probing = FALSE;
/* The plugin may specify that only some subsystems are supported. If that
* is the case, filter by subsystem */
if (priv->subsystems) {
const gchar *subsys;
subsys = g_udev_device_get_subsystem (port);
for (i = 0; priv->subsystems[i]; i++) {
if (g_str_equal (subsys, priv->subsystems[i]))
break;
}
/* If we didn't match any subsystem: unsupported */
if (!priv->subsystems[i])
return TRUE;
}
/* The plugin may specify that only some drivers are supported. If that
* is the case, filter by driver */
if (priv->drivers) {
const gchar *driver;
/* Detect any modems accessible through the list of virtual ports */
driver = (is_virtual_port (g_udev_device_get_name (port)) ?
"virtual" :
mm_device_get_driver (device));
/* If error retrieving driver: unsupported */
if (!driver)
return TRUE;
for (i = 0; priv->drivers[i]; i++) {
if (g_str_equal (driver, priv->drivers[i]))
break;
}
/* If we didn't match any driver: unsupported */
if (!priv->drivers[i])
return TRUE;
}
vendor = mm_device_get_vendor (device);
product = mm_device_get_product (device);
/* The plugin may specify that only some vendor IDs are supported. If that
* is the case, filter by vendor ID. */
if (priv->vendor_ids) {
/* If we didn't get any vendor: filtered */
if (!vendor)
vendor_filtered = TRUE;
else {
for (i = 0; priv->vendor_ids[i]; i++)
if (vendor == priv->vendor_ids[i])
break;
/* If we didn't match any vendor: filtered */
if (!priv->vendor_ids[i])
vendor_filtered = TRUE;
}
}
/* The plugin may specify that only some product IDs are supported. If
* that is the case, filter by vendor+product ID pair */
if (priv->product_ids) {
/* If we didn't get any product: filtered */
if (!product)
product_filtered = TRUE;
else {
for (i = 0; priv->product_ids[i].l; i++)
if (vendor == priv->product_ids[i].l &&
product == priv->product_ids[i].r)
break;
/* If we didn't match any product: filtered */
if (!priv->product_ids[i].l)
product_filtered = TRUE;
}
}
/* If we got filtered by vendor or product IDs and we do not have vendor
* or product strings to compare with: unsupported */
if ((vendor_filtered || product_filtered) &&
!priv->vendor_strings &&
!priv->product_strings)
return TRUE;
/* If we need to filter by vendor/product strings, need to probe for both.
* This covers the case where a RS232 modem is connected via a USB<->RS232
* adaptor, and we get in udev the vendor ID of the adaptor */
if (priv->product_strings) {
*need_vendor_probing = TRUE;
*need_product_probing = TRUE;
} else if (priv->vendor_strings)
*need_vendor_probing = TRUE;
/* The plugin may specify that only ports with some given udev tags are
* supported. If that is the case, filter by udev tag */
if (priv->udev_tags) {
for (i = 0; priv->udev_tags[i]; i++) {
/* Check if the port was tagged */
if (g_udev_device_get_property_as_boolean (port,
priv->udev_tags[i]))
break;
}
/* If we didn't match any udev tag: unsupported */
if (!priv->udev_tags[i])
return TRUE;
}
return FALSE;
}
/* Returns TRUE if the support check request was filtered out */
static gboolean
apply_post_probing_filters (MMPlugin *self,
MMPortProbe *probe)
{
MMPluginPrivate *priv = MM_PLUGIN_GET_PRIVATE (self);
gboolean vendor_filtered = FALSE;
gboolean product_filtered = FALSE;
guint i;
/* The plugin may specify that only some vendor strings are supported. If
* that is the case, filter by vendor string. */
if (priv->vendor_strings) {
const gchar *vendor;
vendor = mm_port_probe_get_vendor (probe);
/* If we didn't get any vendor: filtered */
if (!vendor)
vendor_filtered = TRUE;
else {
for (i = 0; priv->vendor_strings[i]; i++) {
gboolean found;
gchar *casefolded;
casefolded = g_utf8_casefold (priv->vendor_strings[i], -1);
found = !!strstr (vendor, casefolded);
g_free (casefolded);
if (found)
break;
}
/* If we didn't match any vendor: filtered */
if (!priv->vendor_strings[i])
vendor_filtered = TRUE;
}
if (vendor_filtered) {
if (!priv->product_strings)
return TRUE;
} else
/* Vendor matched */
return FALSE;
}
/* The plugin may specify that only some vendor+product string pairs are
* supported. If that is the case, filter by product string */
if (priv->product_strings) {
const gchar *vendor;
const gchar *product;
vendor = mm_port_probe_get_vendor (probe);
product = mm_port_probe_get_product (probe);
/* If we didn't get any vendor or product: filtered */
if (!vendor || !product)
product_filtered = TRUE;
else {
for (i = 0; priv->product_strings[i].l; i++) {
gboolean found;
gchar *casefolded_vendor;
gchar *casefolded_product;
casefolded_vendor = g_utf8_casefold (priv->product_strings[i].l, -1);
casefolded_product = g_utf8_casefold (priv->product_strings[i].r, -1);
found = (!!strstr (vendor, casefolded_vendor) &&
!!strstr (product, casefolded_product));
g_free (casefolded_vendor);
g_free (casefolded_product);
if (found)
break;
}
/* If we didn't match any product: unsupported */
if (!priv->product_strings[i].l)
product_filtered = TRUE;
}
return product_filtered;
}
return FALSE;
}
/* Context for the asynchronous probing operation */
typedef struct {
GSimpleAsyncResult *result;
MMPlugin *plugin;
MMPortProbeFlag flags;
MMDevice *device;
} PortProbeRunContext;
static void
port_probe_run_ready (MMPortProbe *probe,
GAsyncResult *probe_result,
PortProbeRunContext *ctx)
{
MMPluginPrivate *priv = MM_PLUGIN_GET_PRIVATE (ctx->plugin);
GError *error = NULL;
gboolean keep_probe = FALSE;
if (!mm_port_probe_run_finish (probe, probe_result, &error)) {
/* Probing failed */
g_simple_async_result_take_error (ctx->result, error);
} else {
/* Probing succeeded */
MMPluginSupportsResult supports_result;
if (!apply_post_probing_filters (ctx->plugin, probe)) {
/* Port is supported! Leave it in the internal HT until port gets
* grabbed. */
supports_result = MM_PLUGIN_SUPPORTS_PORT_SUPPORTED;
keep_probe = TRUE;
/* If we were looking for AT ports, and the port is AT,
* and we were told that only one AT port is expected, cancel AT
* probings in the other available support tasks of the SAME
* device. */
if (priv->single_at &&
ctx->flags & MM_PORT_PROBE_AT &&
mm_port_probe_is_at (probe)) {
GList *l;
for (l = mm_device_peek_port_probe_list (ctx->device); l; l = g_list_next (l)) {
if (l->data != probe) {
mm_port_probe_run_cancel_at_probing (MM_PORT_PROBE (l->data));
}
}
}
} else {
/* Unsupported port, remove from internal tracking HT */
supports_result = MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
}
g_simple_async_result_set_op_res_gpointer (ctx->result,
GUINT_TO_POINTER (supports_result),
NULL);
}
/* Complete the async supports port request */
g_simple_async_result_complete_in_idle (ctx->result);
/* If no longer needed, Remove probe from internal HT */
if (!keep_probe) {
gchar *key;
key = get_key (mm_port_probe_get_port_subsys (probe),
mm_port_probe_get_port_name (probe));
g_hash_table_remove (priv->tasks, key);
g_free (key);
}
g_object_unref (ctx->device);
g_object_unref (ctx->result);
g_object_unref (ctx->plugin);
g_free (ctx);
}
MMPluginSupportsResult
mm_plugin_supports_port_finish (MMPlugin *self,
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (MM_IS_PLUGIN (self),
MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED);
g_return_val_if_fail (G_IS_ASYNC_RESULT (result),
MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED);
/* Propagate error, if any */
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
error)) {
return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
}
return (MMPluginSupportsResult) GPOINTER_TO_UINT (g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result)));
}
void
mm_plugin_supports_port (MMPlugin *self,
GObject *device_o,
GUdevDevice *port,
GAsyncReadyCallback callback,
gpointer user_data)
{
MMDevice *device = MM_DEVICE (device_o);
MMPluginPrivate *priv = MM_PLUGIN_GET_PRIVATE (self);
gchar *key = NULL;
MMPortProbe *probe;
GSimpleAsyncResult *async_result;
PortProbeRunContext *ctx;
gboolean need_vendor_probing;
gboolean need_product_probing;
MMPortProbeFlag probe_run_flags;
/* Setup key */
key = get_key (g_udev_device_get_subsystem (port),
g_udev_device_get_name (port));
async_result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
mm_plugin_supports_port);
/* Apply filters before launching the probing */
if (apply_pre_probing_filters (self,
device,
port,
&need_vendor_probing,
&need_product_probing)) {
/* Filtered! */
g_simple_async_result_set_op_res_gpointer (async_result,
GUINT_TO_POINTER (MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED),
NULL);
g_simple_async_result_complete_in_idle (async_result);
goto out;
}
mm_dbg ("(%s) checking port support (%s,%s)",
priv->name,
g_udev_device_get_subsystem (port),
g_udev_device_get_name (port));
/* Need to launch new probing */
probe = mm_device_get_port_probe (device, port);
g_assert (probe);
/* Before launching any probing, check if the port is a net device (which
* cannot be probed).
* TODO: With the new defer-until-suggested we probably don't need the modem
* object being passed down here just for this. */
if (g_str_equal (g_udev_device_get_subsystem (port), "net")) {
/* Keep track of the probe object, which is considered finished */
if (!g_hash_table_lookup (priv->tasks, key))
g_hash_table_insert (priv->tasks,
g_strdup (key),
g_object_ref (probe));
g_simple_async_result_set_op_res_gpointer (
async_result,
GUINT_TO_POINTER (MM_PLUGIN_SUPPORTS_PORT_DEFER_UNTIL_SUGGESTED),
NULL);
g_simple_async_result_complete_in_idle (async_result);
goto out;
}
/* Build flags depending on what probing needed */
probe_run_flags = MM_PORT_PROBE_NONE;
if (priv->at)
probe_run_flags |= MM_PORT_PROBE_AT;
else if (priv->single_at)
probe_run_flags |= MM_PORT_PROBE_AT;
if (need_vendor_probing)
probe_run_flags |= (MM_PORT_PROBE_AT | MM_PORT_PROBE_AT_VENDOR);
if (need_product_probing)
probe_run_flags |= (MM_PORT_PROBE_AT | MM_PORT_PROBE_AT_PRODUCT);
if (priv->qcdm)
probe_run_flags |= MM_PORT_PROBE_QCDM;
g_assert (probe_run_flags != MM_PORT_PROBE_NONE);
/* If a modem is already available and the plugin says that only one AT port is
* expected, check if we alredy got the single AT port. And if so, we know this
* port being probed won't be AT. */
if (priv->single_at &&
mm_port_probe_list_has_at_port (mm_device_peek_port_probe_list (device))) {
mm_dbg ("(%s) not setting up AT probing tasks for (%s,%s): "
"modem already has the expected single AT port",
priv->name,
g_udev_device_get_subsystem (port),
g_udev_device_get_name (port));
/* Assuming it won't be an AT port. We still run the probe anyway, in
* case we need to check for other port types (e.g. QCDM) */
mm_port_probe_set_result_at (probe, FALSE);
}
/* Setup async call context */
ctx = g_new (PortProbeRunContext, 1);
ctx->plugin = g_object_ref (self);
ctx->device = g_object_ref (device);
ctx->result = g_object_ref (async_result);
ctx->flags = probe_run_flags;
/* Launch the probe */
mm_dbg ("(%s) launching probe for (%s,%s)",
priv->name,
g_udev_device_get_subsystem (port),
g_udev_device_get_name (port));
mm_port_probe_run (probe,
ctx->flags,
priv->send_delay,
priv->custom_init,
(GAsyncReadyCallback)port_probe_run_ready,
ctx);
/* Keep track of the probe. Note that we got a new reference already */
g_hash_table_insert (priv->tasks,
g_strdup (key),
probe);
out:
g_free (key);
g_object_unref (async_result);
}
/*****************************************************************************/
MMBaseModem *
mm_plugin_create_modem (MMPlugin *self,
GObject *device_o,
GError **error)
{
MMDevice *device = MM_DEVICE (device_o);
MMPluginPrivate *priv = MM_PLUGIN_GET_PRIVATE (self);
MMBaseModem *modem = NULL;
GList *port_probes, *l;
port_probes = mm_device_peek_port_probe_list (device);
/* Let the plugin create the modem from the port probe results */
modem = MM_PLUGIN_GET_CLASS (self)->create_modem (MM_PLUGIN (self),
mm_device_get_path (device),
mm_device_get_driver (device),
mm_device_get_vendor (device),
mm_device_get_product (device),
port_probes,
error);
if (modem) {
/* Grab each port */
for (l = port_probes; l; l = g_list_next (l)) {
GError *inner_error = NULL;
/* If grabbing a port fails, just warn. We'll decide if the modem is
* valid or not when all ports get organized */
if (!MM_PLUGIN_GET_CLASS (self)->grab_port (MM_PLUGIN (self),
modem,
MM_PORT_PROBE (l->data),
&inner_error)) {
mm_warn ("Could not grab port (%s/%s): '%s'",
mm_port_probe_get_port_subsys (MM_PORT_PROBE (l->data)),
mm_port_probe_get_port_name (MM_PORT_PROBE (l->data)),
inner_error ? inner_error->message : "unknown error");
g_clear_error (&inner_error);
}
}
/* If organizing ports fails, consider the modem invalid */
if (!mm_base_modem_organize_ports (modem, error))
g_clear_object (&modem);
}
for (l = port_probes; l; l = g_list_next (l)) {
gchar *key;
key = get_key (mm_port_probe_get_port_subsys (l->data),
mm_port_probe_get_port_name (l->data));
g_hash_table_remove (priv->tasks, key);
g_free (key);
}
return modem;
}
/*****************************************************************************/
static void
mm_plugin_init (MMPlugin *self)
{
MMPluginPrivate *priv = MM_PLUGIN_GET_PRIVATE (self);
/* We pass NULL as we won't need to get notified about uevents,
* we just use this client for sync queries. */
priv->client = g_udev_client_new (NULL);
priv->tasks = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
(GDestroyNotify) g_object_unref);
/* Defaults */
priv->send_delay = 100000;
}
static void
set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
MMPluginPrivate *priv = MM_PLUGIN_GET_PRIVATE (object);
switch (prop_id) {
case PROP_NAME:
/* Construct only */
priv->name = g_value_dup_string (value);
break;
case PROP_ALLOWED_SUBSYSTEMS:
/* Construct only */
priv->subsystems = g_value_dup_boxed (value);
break;
case PROP_ALLOWED_DRIVERS:
/* Construct only */
priv->drivers = g_value_dup_boxed (value);
break;
case PROP_ALLOWED_VENDOR_IDS:
/* Construct only */
priv->vendor_ids = g_value_dup_boxed (value);
break;
case PROP_ALLOWED_PRODUCT_IDS:
/* Construct only */
priv->product_ids = g_value_dup_boxed (value);
break;
case PROP_ALLOWED_VENDOR_STRINGS:
/* Construct only */
priv->vendor_strings = g_value_dup_boxed (value);
break;
case PROP_ALLOWED_PRODUCT_STRINGS:
/* Construct only */
priv->product_strings = g_value_dup_boxed (value);
break;
case PROP_ALLOWED_UDEV_TAGS:
/* Construct only */
priv->udev_tags = g_value_dup_boxed (value);
break;
case PROP_ALLOWED_AT:
/* Construct only */
priv->at = g_value_get_boolean (value);
break;
case PROP_ALLOWED_SINGLE_AT:
/* Construct only */
priv->single_at = g_value_get_boolean (value);
break;
case PROP_ALLOWED_QCDM:
/* Construct only */
priv->qcdm = g_value_get_boolean (value);
break;
case PROP_CUSTOM_INIT:
/* Construct only */
priv->custom_init = g_value_dup_boxed (value);
break;
case PROP_SEND_DELAY:
/* Construct only */
priv->send_delay = (guint64)g_value_get_uint64 (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
MMPluginPrivate *priv = MM_PLUGIN_GET_PRIVATE (object);
switch (prop_id) {
case PROP_NAME:
g_value_set_string (value, priv->name);
break;
case PROP_ALLOWED_SUBSYSTEMS:
g_value_set_boxed (value, priv->subsystems);
break;
case PROP_ALLOWED_DRIVERS:
g_value_set_boxed (value, priv->drivers);
break;
case PROP_ALLOWED_VENDOR_IDS:
g_value_set_boxed (value, priv->vendor_ids);
break;
case PROP_ALLOWED_PRODUCT_IDS:
g_value_set_boxed (value, priv->product_ids);
break;
case PROP_ALLOWED_VENDOR_STRINGS:
g_value_set_boxed (value, priv->vendor_strings);
break;
case PROP_ALLOWED_PRODUCT_STRINGS:
g_value_set_boxed (value, priv->product_strings);
break;
case PROP_ALLOWED_AT:
g_value_set_boolean (value, priv->at);
break;
case PROP_ALLOWED_SINGLE_AT:
g_value_set_boolean (value, priv->single_at);
break;
case PROP_ALLOWED_QCDM:
g_value_set_boolean (value, priv->qcdm);
break;
case PROP_ALLOWED_UDEV_TAGS:
g_value_set_boxed (value, priv->udev_tags);
break;
case PROP_CUSTOM_INIT:
g_value_set_boxed (value, priv->custom_init);
break;
case PROP_SEND_DELAY:
g_value_set_uint64 (value, priv->send_delay);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
finalize (GObject *object)
{
MMPluginPrivate *priv = MM_PLUGIN_GET_PRIVATE (object);
g_free (priv->name);
g_object_unref (priv->client);
g_hash_table_destroy (priv->tasks);
G_OBJECT_CLASS (mm_plugin_parent_class)->finalize (object);
}
static void
mm_plugin_class_init (MMPluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (object_class, sizeof (MMPluginPrivate));
/* Virtual methods */
object_class->get_property = get_property;
object_class->set_property = set_property;
object_class->finalize = finalize;
g_object_class_install_property
(object_class, PROP_NAME,
g_param_spec_string (MM_PLUGIN_NAME,
"Name",
"Name",
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(object_class, PROP_ALLOWED_SUBSYSTEMS,
g_param_spec_boxed (MM_PLUGIN_ALLOWED_SUBSYSTEMS,
"Allowed subsystems",
"List of subsystems this plugin can support, "
"should be an array of strings finished with 'NULL'",
G_TYPE_STRV,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(object_class, PROP_ALLOWED_DRIVERS,
g_param_spec_boxed (MM_PLUGIN_ALLOWED_DRIVERS,
"Allowed drivers",
"List of drivers this plugin can support, "
"should be an array of strings finished with 'NULL'",
G_TYPE_STRV,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(object_class, PROP_ALLOWED_VENDOR_IDS,
g_param_spec_boxed (MM_PLUGIN_ALLOWED_VENDOR_IDS,
"Allowed vendor IDs",
"List of vendor IDs this plugin can support, "
"should be an array of guint16 finished with '0'",
MM_TYPE_UINT16_ARRAY,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(object_class, PROP_ALLOWED_PRODUCT_IDS,
g_param_spec_boxed (MM_PLUGIN_ALLOWED_PRODUCT_IDS,
"Allowed product IDs",
"List of vendor+product ID pairs this plugin can support, "
"should be an array of mm_uint16_pair finished with '0,0'",
MM_TYPE_UINT16_PAIR_ARRAY,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(object_class, PROP_ALLOWED_VENDOR_STRINGS,
g_param_spec_boxed (MM_PLUGIN_ALLOWED_VENDOR_STRINGS,
"Allowed vendor strings",
"List of vendor strings this plugin can support, "
"should be an array of strings finished with 'NULL'",
G_TYPE_STRV,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(object_class, PROP_ALLOWED_PRODUCT_STRINGS,
g_param_spec_boxed (MM_PLUGIN_ALLOWED_PRODUCT_STRINGS,
"Allowed product strings",
"List of vendor+product string pairs this plugin can support, "
"should be an array of mm_str_pair finished with 'NULL,NULL'",
MM_TYPE_STR_PAIR_ARRAY,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(object_class, PROP_ALLOWED_UDEV_TAGS,
g_param_spec_boxed (MM_PLUGIN_ALLOWED_UDEV_TAGS,
"Allowed Udev tags",
"List of udev tags this plugin may expect, "
"should be an array of strings finished with 'NULL'",
G_TYPE_STRV,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(object_class, PROP_ALLOWED_AT,
g_param_spec_boolean (MM_PLUGIN_ALLOWED_AT,
"Allowed AT",
"Whether AT ports are allowed in this plugin",
FALSE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(object_class, PROP_ALLOWED_SINGLE_AT,
g_param_spec_boolean (MM_PLUGIN_ALLOWED_SINGLE_AT,
"Allowed single AT",
"Whether just a single AT port is allowed in this plugin. ",
FALSE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(object_class, PROP_ALLOWED_QCDM,
g_param_spec_boolean (MM_PLUGIN_ALLOWED_QCDM,
"Allowed QCDM",
"Whether QCDM ports are allowed in this plugin",
FALSE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(object_class, PROP_CUSTOM_INIT,
g_param_spec_boxed (MM_PLUGIN_CUSTOM_INIT,
"Custom initialization",
"List of custom initializations this plugin needs, "
"should be an array of MMPortProbeAtCommand structs "
"finished with 'NULL'",
MM_TYPE_POINTER_ARRAY,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(object_class, PROP_SEND_DELAY,
g_param_spec_uint64 (MM_PLUGIN_SEND_DELAY,
"Send delay",
"Send delay for characters in the AT port, "
"in microseconds",
0, G_MAXUINT64, 100000,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
}
Reference in New Issue View Git Blame Copy Permalink