1541 lines
58 KiB
C
1541 lines
58 KiB
C
/* -*- 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 <ModemManager.h>
|
|
#include <mm-errors-types.h>
|
|
|
|
#include "mm-plugin.h"
|
|
#include "mm-device.h"
|
|
#include "mm-kernel-device.h"
|
|
#include "mm-kernel-device-generic.h"
|
|
#include "mm-port-serial-at.h"
|
|
#include "mm-port-serial-qcdm.h"
|
|
#include "mm-serial-parsers.h"
|
|
#include "mm-private-boxed-types.h"
|
|
#include "mm-log.h"
|
|
#include "mm-daemon-enums-types.h"
|
|
|
|
G_DEFINE_TYPE (MMPlugin, mm_plugin, G_TYPE_OBJECT)
|
|
|
|
/* Virtual port corresponding to the embedded modem */
|
|
static gchar *virtual_port[] = {"smd0", NULL};
|
|
|
|
#define HAS_POST_PROBING_FILTERS(self) \
|
|
(self->priv->vendor_strings || \
|
|
self->priv->product_strings || \
|
|
self->priv->forbidden_product_strings || \
|
|
self->priv->allowed_icera || \
|
|
self->priv->forbidden_icera || \
|
|
self->priv->allowed_xmm || \
|
|
self->priv->forbidden_xmm || \
|
|
self->priv->custom_init)
|
|
|
|
|
|
struct _MMPluginPrivate {
|
|
gchar *name;
|
|
GHashTable *tasks;
|
|
|
|
/* Pre-probing filters */
|
|
gchar **subsystems;
|
|
gchar **drivers;
|
|
gchar **forbidden_drivers;
|
|
guint16 *vendor_ids;
|
|
mm_uint16_pair *product_ids;
|
|
mm_uint16_pair *forbidden_product_ids;
|
|
gchar **udev_tags;
|
|
|
|
/* Post probing filters */
|
|
gchar **vendor_strings;
|
|
mm_str_pair *product_strings;
|
|
mm_str_pair *forbidden_product_strings;
|
|
gboolean allowed_icera;
|
|
gboolean forbidden_icera;
|
|
gboolean allowed_xmm;
|
|
gboolean forbidden_xmm;
|
|
|
|
/* Probing setup */
|
|
gboolean at;
|
|
gboolean single_at;
|
|
gboolean qcdm;
|
|
gboolean qmi;
|
|
gboolean mbim;
|
|
gboolean icera_probe;
|
|
gboolean xmm_probe;
|
|
MMPortProbeAtCommand *custom_at_probe;
|
|
guint64 send_delay;
|
|
gboolean remove_echo;
|
|
gboolean send_lf;
|
|
|
|
/* Probing setup and/or post-probing filter.
|
|
* Plugins may use this method to decide whether they support a given
|
|
* port or not, so should also be considered kind of post-probing filter. */
|
|
MMAsyncMethod *custom_init;
|
|
};
|
|
|
|
enum {
|
|
PROP_0,
|
|
PROP_NAME,
|
|
PROP_ALLOWED_SUBSYSTEMS,
|
|
PROP_ALLOWED_DRIVERS,
|
|
PROP_FORBIDDEN_DRIVERS,
|
|
PROP_ALLOWED_VENDOR_IDS,
|
|
PROP_ALLOWED_PRODUCT_IDS,
|
|
PROP_FORBIDDEN_PRODUCT_IDS,
|
|
PROP_ALLOWED_VENDOR_STRINGS,
|
|
PROP_ALLOWED_PRODUCT_STRINGS,
|
|
PROP_FORBIDDEN_PRODUCT_STRINGS,
|
|
PROP_ALLOWED_UDEV_TAGS,
|
|
PROP_ALLOWED_AT,
|
|
PROP_ALLOWED_SINGLE_AT,
|
|
PROP_ALLOWED_QCDM,
|
|
PROP_ALLOWED_QMI,
|
|
PROP_ALLOWED_MBIM,
|
|
PROP_ICERA_PROBE,
|
|
PROP_ALLOWED_ICERA,
|
|
PROP_FORBIDDEN_ICERA,
|
|
PROP_XMM_PROBE,
|
|
PROP_ALLOWED_XMM,
|
|
PROP_FORBIDDEN_XMM,
|
|
PROP_CUSTOM_AT_PROBE,
|
|
PROP_CUSTOM_INIT,
|
|
PROP_SEND_DELAY,
|
|
PROP_REMOVE_ECHO,
|
|
PROP_SEND_LF,
|
|
LAST_PROP
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
const gchar *
|
|
mm_plugin_get_name (MMPlugin *self)
|
|
{
|
|
return self->priv->name;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
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_subsystem_filter (MMPlugin *self,
|
|
MMKernelDevice *port)
|
|
{
|
|
if (self->priv->subsystems) {
|
|
const gchar *subsys;
|
|
guint i;
|
|
|
|
subsys = mm_kernel_device_get_subsystem (port);
|
|
for (i = 0; self->priv->subsystems[i]; i++) {
|
|
if (g_str_equal (subsys, self->priv->subsystems[i]))
|
|
break;
|
|
/* New kernels may report as 'usbmisc' the subsystem */
|
|
else if (g_str_equal (self->priv->subsystems[i], "usb") &&
|
|
g_str_equal (subsys, "usbmisc"))
|
|
break;
|
|
}
|
|
|
|
/* If we didn't match any subsystem: unsupported */
|
|
if (!self->priv->subsystems[i])
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/* Returns TRUE if the support check request was filtered out */
|
|
static gboolean
|
|
apply_pre_probing_filters (MMPlugin *self,
|
|
MMDevice *device,
|
|
MMKernelDevice *port,
|
|
gboolean *need_vendor_probing,
|
|
gboolean *need_product_probing)
|
|
{
|
|
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 (apply_subsystem_filter (self, port)) {
|
|
mm_dbg ("(%s) [%s] filtered by subsystem",
|
|
self->priv->name,
|
|
mm_kernel_device_get_name (port));
|
|
return TRUE;
|
|
}
|
|
|
|
/* The plugin may specify that only some drivers are supported, or that some
|
|
* drivers are not supported. If that is the case, filter by driver.
|
|
*
|
|
* The QMI and MBIM *forbidden* drivers filter is implicit. This is, if the
|
|
* plugin doesn't explicitly specify that QMI is allowed and we find a QMI
|
|
* port, the plugin will filter the device. Same for MBIM.
|
|
*
|
|
* The opposite, though, is not applicable. If the plugin specifies that QMI
|
|
* is allowed, we won't take that as a mandatory requirement to look for the
|
|
* QMI driver (as the plugin may handle non-QMI modems as well)
|
|
*/
|
|
if (self->priv->drivers ||
|
|
self->priv->forbidden_drivers ||
|
|
!self->priv->qmi ||
|
|
!self->priv->mbim) {
|
|
static const gchar *virtual_drivers [] = { "virtual", NULL };
|
|
const gchar **drivers;
|
|
|
|
/* Detect any modems accessible through the list of virtual ports */
|
|
drivers = (is_virtual_port (mm_kernel_device_get_name (port)) ?
|
|
virtual_drivers :
|
|
mm_device_get_drivers (device));
|
|
|
|
/* If error retrieving driver: unsupported */
|
|
if (!drivers) {
|
|
mm_dbg ("(%s) [%s] filtered as couldn't retrieve drivers",
|
|
self->priv->name,
|
|
mm_kernel_device_get_name (port));
|
|
return TRUE;
|
|
}
|
|
|
|
/* Filtering by allowed drivers */
|
|
if (self->priv->drivers) {
|
|
gboolean found = FALSE;
|
|
|
|
for (i = 0; self->priv->drivers[i] && !found; i++) {
|
|
guint j;
|
|
|
|
for (j = 0; drivers[j] && !found; j++) {
|
|
if (g_str_equal (drivers[j], self->priv->drivers[i]))
|
|
found = TRUE;
|
|
}
|
|
}
|
|
|
|
/* If we didn't match any driver: unsupported */
|
|
if (!found) {
|
|
mm_dbg ("(%s) [%s] filtered by drivers",
|
|
self->priv->name,
|
|
mm_kernel_device_get_name (port));
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
/* Filtering by forbidden drivers */
|
|
if (self->priv->forbidden_drivers) {
|
|
for (i = 0; self->priv->forbidden_drivers[i]; i++) {
|
|
guint j;
|
|
|
|
for (j = 0; drivers[j]; j++) {
|
|
/* If we match a forbidden driver: unsupported */
|
|
if (g_str_equal (drivers[j], self->priv->forbidden_drivers[i])) {
|
|
mm_dbg ("(%s) [%s] filtered by forbidden drivers",
|
|
self->priv->name,
|
|
mm_kernel_device_get_name (port));
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Implicit filter for forbidden QMI driver */
|
|
if (!self->priv->qmi) {
|
|
guint j;
|
|
|
|
for (j = 0; drivers[j]; j++) {
|
|
/* If we match the QMI driver: unsupported */
|
|
if (g_str_equal (drivers[j], "qmi_wwan")) {
|
|
mm_dbg ("(%s) [%s] filtered by implicit QMI driver",
|
|
self->priv->name,
|
|
mm_kernel_device_get_name (port));
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Implicit filter for forbidden MBIM driver */
|
|
if (!self->priv->mbim) {
|
|
guint j;
|
|
|
|
for (j = 0; drivers[j]; j++) {
|
|
/* If we match the MBIM driver: unsupported */
|
|
if (g_str_equal (drivers[j], "cdc_mbim")) {
|
|
mm_dbg ("(%s) [%s] filtered by implicit MBIM driver",
|
|
self->priv->name,
|
|
mm_kernel_device_get_name (port));
|
|
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 (self->priv->vendor_ids) {
|
|
/* If we didn't get any vendor: filtered */
|
|
if (!vendor)
|
|
vendor_filtered = TRUE;
|
|
else {
|
|
for (i = 0; self->priv->vendor_ids[i]; i++)
|
|
if (vendor == self->priv->vendor_ids[i])
|
|
break;
|
|
|
|
/* If we didn't match any vendor: filtered */
|
|
if (!self->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 (self->priv->product_ids) {
|
|
/* If we didn't get any product: filtered */
|
|
if (!product || !vendor)
|
|
product_filtered = TRUE;
|
|
else {
|
|
for (i = 0; self->priv->product_ids[i].l; i++)
|
|
if (vendor == self->priv->product_ids[i].l &&
|
|
product == self->priv->product_ids[i].r)
|
|
break;
|
|
|
|
/* If we didn't match any product: filtered */
|
|
if (!self->priv->product_ids[i].l)
|
|
product_filtered = TRUE;
|
|
}
|
|
|
|
/* When both vendor ids and product ids are given, it may be the case that
|
|
* we're allowing a full VID1 and only a subset of another VID2, so try to
|
|
* handle that properly. */
|
|
if (vendor_filtered && !product_filtered)
|
|
vendor_filtered = FALSE;
|
|
if (product_filtered && self->priv->vendor_ids && !vendor_filtered)
|
|
product_filtered = FALSE;
|
|
}
|
|
|
|
/* If we got filtered by vendor or product IDs; mark it as unsupported only if:
|
|
* a) we do not have vendor or product strings to compare with (i.e. plugin
|
|
* doesn't have explicit vendor/product strings
|
|
* b) the port is NOT an AT port which we can use for AT probing
|
|
*/
|
|
if ((vendor_filtered || product_filtered) &&
|
|
((!self->priv->vendor_strings &&
|
|
!self->priv->product_strings &&
|
|
!self->priv->forbidden_product_strings) ||
|
|
g_str_equal (mm_kernel_device_get_subsystem (port), "net") ||
|
|
g_str_has_prefix (mm_kernel_device_get_name (port), "cdc-wdm"))) {
|
|
mm_dbg ("(%s) [%s] filtered by vendor/product IDs",
|
|
self->priv->name,
|
|
mm_kernel_device_get_name (port));
|
|
return TRUE;
|
|
}
|
|
|
|
/* The plugin may specify that some product IDs are not supported. If
|
|
* that is the case, filter by forbidden vendor+product ID pair */
|
|
if (self->priv->forbidden_product_ids && product && vendor) {
|
|
for (i = 0; self->priv->forbidden_product_ids[i].l; i++) {
|
|
if (vendor == self->priv->forbidden_product_ids[i].l &&
|
|
product == self->priv->forbidden_product_ids[i].r) {
|
|
mm_dbg ("(%s) [%s] filtered by forbidden vendor/product IDs",
|
|
self->priv->name,
|
|
mm_kernel_device_get_name (port));
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Check if we need vendor/product string probing
|
|
* Only require these probings if the corresponding filters are given, and:
|
|
* 1) if there was no vendor/product ID probing
|
|
* 2) if there was vendor/product ID probing but we got filtered
|
|
*
|
|
* In other words, don't require vendor/product string probing if the plugin
|
|
* already had vendor/product ID filters and we actually passed those. */
|
|
if ((!self->priv->vendor_ids && !self->priv->product_ids) ||
|
|
vendor_filtered ||
|
|
product_filtered) {
|
|
/* If product strings related filters around, we need to probe for both
|
|
* vendor and product strings */
|
|
if (self->priv->product_strings ||
|
|
self->priv->forbidden_product_strings) {
|
|
*need_vendor_probing = TRUE;
|
|
*need_product_probing = TRUE;
|
|
}
|
|
/* If only vendor string filter is needed, only probe for vendor string */
|
|
else if (self->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 (self->priv->udev_tags) {
|
|
for (i = 0; self->priv->udev_tags[i]; i++) {
|
|
/* Check if the port or device was tagged */
|
|
if (mm_kernel_device_get_global_property_as_boolean (port, self->priv->udev_tags[i]))
|
|
break;
|
|
}
|
|
|
|
/* If we didn't match any udev tag: unsupported */
|
|
if (!self->priv->udev_tags[i]) {
|
|
mm_dbg ("(%s) [%s] filtered by udev tags",
|
|
self->priv->name,
|
|
mm_kernel_device_get_name (port));
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/* Returns TRUE if the support check request was filtered out */
|
|
static gboolean
|
|
apply_post_probing_filters (MMPlugin *self,
|
|
MMPortProbeFlag flags,
|
|
MMPortProbe *probe)
|
|
{
|
|
gboolean vendor_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 ((flags & MM_PORT_PROBE_AT_VENDOR) &&
|
|
self->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; self->priv->vendor_strings[i]; i++) {
|
|
gboolean found;
|
|
gchar *casefolded;
|
|
|
|
casefolded = g_utf8_casefold (self->priv->vendor_strings[i], -1);
|
|
found = !!strstr (vendor, casefolded);
|
|
g_free (casefolded);
|
|
if (found)
|
|
break;
|
|
}
|
|
|
|
/* If we didn't match any vendor: filtered */
|
|
if (!self->priv->vendor_strings[i])
|
|
vendor_filtered = TRUE;
|
|
}
|
|
|
|
if (vendor_filtered) {
|
|
if (!self->priv->product_strings) {
|
|
mm_dbg ("(%s) [%s] filtered by vendor strings",
|
|
self->priv->name,
|
|
mm_port_probe_get_port_name (probe));
|
|
return TRUE;
|
|
}
|
|
} else
|
|
/* Vendor matched */
|
|
return FALSE;
|
|
}
|
|
|
|
/* The plugin may specify that only some vendor+product string pairs are
|
|
* supported or unsupported. If that is the case, filter by product
|
|
* string */
|
|
if ((flags & MM_PORT_PROBE_AT_PRODUCT) &&
|
|
(self->priv->product_strings ||
|
|
self->priv->forbidden_product_strings)) {
|
|
const gchar *vendor;
|
|
const gchar *product;
|
|
|
|
vendor = mm_port_probe_get_vendor (probe);
|
|
product = mm_port_probe_get_product (probe);
|
|
|
|
if (self->priv->product_strings) {
|
|
/* If we didn't get any vendor or product: filtered */
|
|
if (!vendor || !product) {
|
|
mm_dbg ("(%s) [%s] filtered as no vendor/product strings given",
|
|
self->priv->name,
|
|
mm_port_probe_get_port_name (probe));
|
|
return TRUE;
|
|
}
|
|
else {
|
|
for (i = 0; self->priv->product_strings[i].l; i++) {
|
|
gboolean found;
|
|
gchar *casefolded_vendor;
|
|
gchar *casefolded_product;
|
|
|
|
casefolded_vendor = g_utf8_casefold (self->priv->product_strings[i].l, -1);
|
|
casefolded_product = g_utf8_casefold (self->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 (!self->priv->product_strings[i].l) {
|
|
mm_dbg ("(%s) [%s] filtered by vendor/product strings",
|
|
self->priv->name,
|
|
mm_port_probe_get_port_name (probe));
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (self->priv->forbidden_product_strings && vendor && product) {
|
|
for (i = 0; self->priv->forbidden_product_strings[i].l; i++) {
|
|
gboolean found;
|
|
gchar *casefolded_vendor;
|
|
gchar *casefolded_product;
|
|
|
|
casefolded_vendor = g_utf8_casefold (self->priv->forbidden_product_strings[i].l, -1);
|
|
casefolded_product = g_utf8_casefold (self->priv->forbidden_product_strings[i].r, -1);
|
|
found = (!!strstr (vendor, casefolded_vendor) &&
|
|
!!strstr (product, casefolded_product));
|
|
g_free (casefolded_vendor);
|
|
g_free (casefolded_product);
|
|
if (found) {
|
|
/* If we match a forbidden product: unsupported */
|
|
mm_dbg ("(%s) [%s] filtered by forbidden vendor/product strings",
|
|
self->priv->name,
|
|
mm_port_probe_get_port_name (probe));
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Keep on with next filters */
|
|
}
|
|
|
|
/* The plugin may specify that only Icera-based modems are supported.
|
|
* If that is the case, filter by allowed Icera support */
|
|
if (self->priv->allowed_icera &&
|
|
!mm_port_probe_is_icera (probe)) {
|
|
/* Unsupported! */
|
|
mm_dbg ("(%s) [%s] filtered as modem is not icera",
|
|
self->priv->name,
|
|
mm_port_probe_get_port_name (probe));
|
|
return TRUE;
|
|
}
|
|
|
|
/* The plugin may specify that Icera-based modems are NOT supported.
|
|
* If that is the case, filter by forbidden Icera support */
|
|
if (self->priv->forbidden_icera &&
|
|
mm_port_probe_is_icera (probe)) {
|
|
/* Unsupported! */
|
|
mm_dbg ("(%s) [%s] filtered as modem is icera",
|
|
self->priv->name,
|
|
mm_port_probe_get_port_name (probe));
|
|
return TRUE;
|
|
}
|
|
|
|
/* The plugin may specify that only Xmm-based modems are supported.
|
|
* If that is the case, filter by allowed Xmm support */
|
|
if (self->priv->allowed_xmm &&
|
|
!mm_port_probe_is_xmm (probe)) {
|
|
/* Unsupported! */
|
|
mm_dbg ("(%s) [%s] filtered as modem is not XMM",
|
|
self->priv->name,
|
|
mm_port_probe_get_port_name (probe));
|
|
return TRUE;
|
|
}
|
|
|
|
/* The plugin may specify that Xmm-based modems are NOT supported.
|
|
* If that is the case, filter by forbidden Xmm support */
|
|
if (self->priv->forbidden_xmm &&
|
|
mm_port_probe_is_xmm (probe)) {
|
|
/* Unsupported! */
|
|
mm_dbg ("(%s) [%s] filtered as modem is XMM",
|
|
self->priv->name,
|
|
mm_port_probe_get_port_name (probe));
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/* Context for the asynchronous probing operation */
|
|
typedef struct {
|
|
MMPlugin *self;
|
|
MMDevice *device;
|
|
MMPortProbeFlag flags;
|
|
} PortProbeRunContext;
|
|
|
|
static void
|
|
port_probe_run_context_free (PortProbeRunContext *ctx)
|
|
{
|
|
g_object_unref (ctx->device);
|
|
g_object_unref (ctx->self);
|
|
g_slice_free (PortProbeRunContext, ctx);
|
|
}
|
|
|
|
static void
|
|
port_probe_run_ready (MMPortProbe *probe,
|
|
GAsyncResult *probe_result,
|
|
GTask *task)
|
|
{
|
|
GError *error = NULL;
|
|
MMPluginSupportsResult result = MM_PLUGIN_SUPPORTS_PORT_UNKNOWN;
|
|
PortProbeRunContext *ctx;
|
|
|
|
if (!mm_port_probe_run_finish (probe, probe_result, &error)) {
|
|
/* Probing failed saying the port is unsupported. This is not to be
|
|
* treated as a generic error, the plugin is just telling us as nicely
|
|
* as it can that the port is not supported, so don't warn these cases.
|
|
*/
|
|
if (g_error_matches (error, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED)) {
|
|
result = MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
|
|
goto out;
|
|
}
|
|
|
|
/* Probing failed but the plugin tells us to retry; so we'll defer the
|
|
* probing a bit */
|
|
if (g_error_matches (error, MM_CORE_ERROR, MM_CORE_ERROR_RETRY)) {
|
|
result = MM_PLUGIN_SUPPORTS_PORT_DEFER;
|
|
goto out;
|
|
}
|
|
|
|
/* For remaining errors, just propagate them */
|
|
g_task_return_error (task, error);
|
|
g_object_unref (task);
|
|
return;
|
|
}
|
|
|
|
/* Probing succeeded, recover context */
|
|
ctx = g_task_get_task_data (task);
|
|
|
|
/* Apply post probing filters */
|
|
if (!apply_post_probing_filters (ctx->self, ctx->flags, probe)) {
|
|
/* Port is supported! */
|
|
result = MM_PLUGIN_SUPPORTS_PORT_SUPPORTED;
|
|
|
|
/* 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 (ctx->self->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
|
|
/* Filtered by post probing filters */
|
|
result = MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
|
|
|
|
out:
|
|
/* Complete action */
|
|
g_clear_error (&error);
|
|
g_task_return_int (task, result);
|
|
g_object_unref (task);
|
|
}
|
|
|
|
G_STATIC_ASSERT (MM_PLUGIN_SUPPORTS_PORT_UNKNOWN == -1);
|
|
|
|
MMPluginSupportsResult
|
|
mm_plugin_supports_port_finish (MMPlugin *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
GError *inner_error = NULL;
|
|
gssize value;
|
|
|
|
g_return_val_if_fail (MM_IS_PLUGIN (self), MM_PLUGIN_SUPPORTS_PORT_UNKNOWN);
|
|
g_return_val_if_fail (G_IS_TASK (result), MM_PLUGIN_SUPPORTS_PORT_UNKNOWN);
|
|
|
|
value = g_task_propagate_int (G_TASK (result), &inner_error);
|
|
if (inner_error) {
|
|
g_propagate_error (error, inner_error);
|
|
return MM_PLUGIN_SUPPORTS_PORT_UNKNOWN;
|
|
}
|
|
return (MMPluginSupportsResult)value;
|
|
}
|
|
|
|
void
|
|
mm_plugin_supports_port (MMPlugin *self,
|
|
MMDevice *device,
|
|
MMKernelDevice *port,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
MMPortProbe *probe = NULL;
|
|
GTask *task;
|
|
PortProbeRunContext *ctx;
|
|
gboolean need_vendor_probing;
|
|
gboolean need_product_probing;
|
|
MMPortProbeFlag probe_run_flags;
|
|
gchar *probe_list_str;
|
|
|
|
g_return_if_fail (MM_IS_PLUGIN (self));
|
|
g_return_if_fail (MM_IS_DEVICE (device));
|
|
g_return_if_fail (MM_IS_KERNEL_DEVICE (port));
|
|
|
|
/* Create new cancellable task */
|
|
task = g_task_new (self, cancellable, callback, user_data);
|
|
|
|
/* Apply filters before launching the probing */
|
|
if (apply_pre_probing_filters (self,
|
|
device,
|
|
port,
|
|
&need_vendor_probing,
|
|
&need_product_probing)) {
|
|
/* Filtered! */
|
|
g_task_return_int (task, MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED);
|
|
g_object_unref (task);
|
|
return;
|
|
}
|
|
|
|
/* Need to launch new probing */
|
|
probe = MM_PORT_PROBE (mm_device_peek_port_probe (device, port));
|
|
if (!probe) {
|
|
/* This may happen if the ports get removed from the device while
|
|
* probing is ongoing */
|
|
g_task_return_new_error (task,
|
|
MM_CORE_ERROR,
|
|
MM_CORE_ERROR_FAILED,
|
|
"(%s) Missing port probe for port (%s/%s)",
|
|
self->priv->name,
|
|
mm_kernel_device_get_subsystem (port),
|
|
mm_kernel_device_get_name (port));
|
|
g_object_unref (task);
|
|
return;
|
|
}
|
|
|
|
/* Before launching any probing, check if the port is a net device. */
|
|
if (g_str_equal (mm_kernel_device_get_subsystem (port), "net")) {
|
|
mm_dbg ("(%s) [%s] probing deferred until result suggested",
|
|
self->priv->name, mm_kernel_device_get_name (port));
|
|
g_task_return_int (task, MM_PLUGIN_SUPPORTS_PORT_DEFER_UNTIL_SUGGESTED);
|
|
g_object_unref (task);
|
|
return;
|
|
}
|
|
|
|
/* Build flags depending on what probing needed */
|
|
probe_run_flags = MM_PORT_PROBE_NONE;
|
|
if (!g_str_has_prefix (mm_kernel_device_get_name (port), "cdc-wdm")) {
|
|
/* Serial ports... */
|
|
if (self->priv->at)
|
|
probe_run_flags |= MM_PORT_PROBE_AT;
|
|
else if (self->priv->single_at)
|
|
probe_run_flags |= MM_PORT_PROBE_AT;
|
|
if (self->priv->qcdm)
|
|
probe_run_flags |= MM_PORT_PROBE_QCDM;
|
|
} else {
|
|
/* cdc-wdm ports... */
|
|
if (self->priv->qmi && !g_strcmp0 (mm_kernel_device_get_driver (port), "qmi_wwan"))
|
|
probe_run_flags |= MM_PORT_PROBE_QMI;
|
|
else if (self->priv->mbim && !g_strcmp0 (mm_kernel_device_get_driver (port), "cdc_mbim"))
|
|
probe_run_flags |= MM_PORT_PROBE_MBIM;
|
|
else
|
|
probe_run_flags |= MM_PORT_PROBE_AT;
|
|
}
|
|
|
|
/* For potential AT ports, check for more things */
|
|
if (probe_run_flags & MM_PORT_PROBE_AT) {
|
|
if (need_vendor_probing)
|
|
probe_run_flags |= MM_PORT_PROBE_AT_VENDOR;
|
|
if (need_product_probing)
|
|
probe_run_flags |= MM_PORT_PROBE_AT_PRODUCT;
|
|
if (self->priv->icera_probe || self->priv->allowed_icera || self->priv->forbidden_icera)
|
|
probe_run_flags |= MM_PORT_PROBE_AT_ICERA;
|
|
if (self->priv->xmm_probe || self->priv->allowed_xmm || self->priv->forbidden_xmm)
|
|
probe_run_flags |= MM_PORT_PROBE_AT_XMM;
|
|
}
|
|
|
|
/* If no explicit probing was required, just request to grab it without probing anything.
|
|
* This may happen, e.g. with cdc-wdm ports which do not need QMI/MBIM probing. */
|
|
if (probe_run_flags == MM_PORT_PROBE_NONE) {
|
|
g_task_return_int (task, MM_PLUGIN_SUPPORTS_PORT_DEFER_UNTIL_SUGGESTED);
|
|
g_object_unref (task);
|
|
return;
|
|
}
|
|
|
|
/* 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 (self->priv->single_at &&
|
|
mm_port_probe_list_has_at_port (mm_device_peek_port_probe_list (device)) &&
|
|
!mm_port_probe_is_at (probe)) {
|
|
mm_dbg ("(%s) [%s] not setting up AT probing tasks: "
|
|
"modem already has the expected single AT port",
|
|
self->priv->name,
|
|
mm_kernel_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_slice_new0 (PortProbeRunContext);
|
|
ctx->self = g_object_ref (self);
|
|
ctx->device = g_object_ref (device);
|
|
ctx->flags = probe_run_flags;
|
|
|
|
/* Store context in task */
|
|
g_task_set_task_data (task, ctx, (GDestroyNotify) port_probe_run_context_free);
|
|
|
|
/* Launch the probe */
|
|
probe_list_str = mm_port_probe_flag_build_string_from_mask (ctx->flags);
|
|
mm_dbg ("(%s) [%s] probe required: '%s'",
|
|
self->priv->name,
|
|
mm_kernel_device_get_name (port),
|
|
probe_list_str);
|
|
g_free (probe_list_str);
|
|
|
|
mm_port_probe_run (probe,
|
|
ctx->flags,
|
|
self->priv->send_delay,
|
|
self->priv->remove_echo,
|
|
self->priv->send_lf,
|
|
self->priv->custom_at_probe,
|
|
self->priv->custom_init,
|
|
cancellable,
|
|
(GAsyncReadyCallback) port_probe_run_ready,
|
|
task);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
MMPluginSupportsHint
|
|
mm_plugin_discard_port_early (MMPlugin *self,
|
|
MMDevice *device,
|
|
MMKernelDevice *port)
|
|
{
|
|
gboolean need_vendor_probing = FALSE;
|
|
gboolean need_product_probing = FALSE;
|
|
|
|
/* If fully filtered by pre-probing filters, port unsupported */
|
|
if (apply_pre_probing_filters (self,
|
|
device,
|
|
port,
|
|
&need_vendor_probing,
|
|
&need_product_probing))
|
|
return MM_PLUGIN_SUPPORTS_HINT_UNSUPPORTED;
|
|
|
|
/* If there are no post-probing filters, this plugin is the only one (except
|
|
* for the generic one) which will grab the port */
|
|
if (!HAS_POST_PROBING_FILTERS (self))
|
|
return MM_PLUGIN_SUPPORTS_HINT_SUPPORTED;
|
|
|
|
/* If no vendor/product probing needed, plugin is likely supported */
|
|
if (!need_vendor_probing && !need_product_probing)
|
|
return MM_PLUGIN_SUPPORTS_HINT_LIKELY;
|
|
|
|
/* If vendor/product probing is needed, plugin may be supported */
|
|
return MM_PLUGIN_SUPPORTS_HINT_MAYBE;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
MMBaseModem *
|
|
mm_plugin_create_modem (MMPlugin *self,
|
|
MMDevice *device,
|
|
GError **error)
|
|
{
|
|
MMBaseModem *modem;
|
|
GList *port_probes = NULL;
|
|
const gchar **virtual_ports = NULL;
|
|
|
|
if (!mm_device_is_virtual (device))
|
|
port_probes = mm_device_peek_port_probe_list (device);
|
|
else
|
|
virtual_ports = mm_device_virtual_peek_ports (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_uid (device),
|
|
mm_device_get_drivers (device),
|
|
mm_device_get_vendor (device),
|
|
mm_device_get_product (device),
|
|
port_probes,
|
|
error);
|
|
if (!modem)
|
|
return NULL;
|
|
|
|
mm_base_modem_set_hotplugged (modem, mm_device_get_hotplugged (device));
|
|
|
|
if (port_probes) {
|
|
GList *l;
|
|
|
|
/* Grab each port */
|
|
for (l = port_probes; l; l = g_list_next (l)) {
|
|
GError *inner_error = NULL;
|
|
MMPortProbe *probe = MM_PORT_PROBE (l->data);
|
|
gboolean grabbed;
|
|
|
|
/* If grabbing a port fails, just warn. We'll decide if the modem is
|
|
* valid or not when all ports get organized */
|
|
|
|
/* We apply again the subsystem filter, as the port may have been
|
|
* probed and accepted by the generic plugin, which is overwritten
|
|
* by the specific one when needed. */
|
|
if (apply_subsystem_filter (self, mm_port_probe_peek_port (probe))) {
|
|
grabbed = FALSE;
|
|
inner_error = g_error_new (MM_CORE_ERROR,
|
|
MM_CORE_ERROR_UNSUPPORTED,
|
|
"unsupported subsystem: '%s'",
|
|
mm_port_probe_get_port_subsys (probe));
|
|
}
|
|
/* Ports that are explicitly blacklisted will be grabbed as ignored */
|
|
else if (mm_port_probe_is_ignored (probe)) {
|
|
mm_dbg ("(%s/%s): port is blacklisted",
|
|
mm_port_probe_get_port_subsys (probe),
|
|
mm_port_probe_get_port_name (probe));
|
|
grabbed = mm_base_modem_grab_port (modem,
|
|
mm_port_probe_peek_port (probe),
|
|
MM_PORT_TYPE_IGNORED,
|
|
MM_PORT_SERIAL_AT_FLAG_NONE,
|
|
&inner_error);
|
|
}
|
|
#if !defined WITH_QMI
|
|
else if (mm_port_probe_get_port_type (probe) == MM_PORT_TYPE_NET &&
|
|
!g_strcmp0 (mm_kernel_device_get_driver (mm_port_probe_peek_port (probe)), "qmi_wwan")) {
|
|
/* Try to generically grab the port, but flagged as ignored */
|
|
grabbed = mm_base_modem_grab_port (modem,
|
|
mm_port_probe_peek_port (probe),
|
|
MM_PORT_TYPE_IGNORED,
|
|
MM_PORT_SERIAL_AT_FLAG_NONE,
|
|
&inner_error);
|
|
}
|
|
#endif
|
|
#if !defined WITH_MBIM
|
|
else if (mm_port_probe_get_port_type (probe) == MM_PORT_TYPE_NET &&
|
|
!g_strcmp0 (mm_kernel_device_get_driver (mm_port_probe_peek_port (probe)), "cdc_mbim")) {
|
|
/* Try to generically grab the port, but flagged as ignored */
|
|
grabbed = mm_base_modem_grab_port (modem,
|
|
mm_port_probe_peek_port (probe),
|
|
MM_PORT_TYPE_IGNORED,
|
|
MM_PORT_SERIAL_AT_FLAG_NONE,
|
|
&inner_error);
|
|
}
|
|
#endif
|
|
else if (MM_PLUGIN_GET_CLASS (self)->grab_port)
|
|
grabbed = MM_PLUGIN_GET_CLASS (self)->grab_port (MM_PLUGIN (self),
|
|
modem,
|
|
probe,
|
|
&inner_error);
|
|
else
|
|
grabbed = mm_base_modem_grab_port (modem,
|
|
mm_port_probe_peek_port (probe),
|
|
mm_port_probe_get_port_type (probe),
|
|
MM_PORT_SERIAL_AT_FLAG_NONE,
|
|
&inner_error);
|
|
if (!grabbed) {
|
|
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);
|
|
}
|
|
}
|
|
} else if (virtual_ports) {
|
|
guint i;
|
|
|
|
for (i = 0; virtual_ports[i]; i++) {
|
|
GError *inner_error = NULL;
|
|
MMKernelDevice *kernel_device;
|
|
MMKernelEventProperties *properties;
|
|
|
|
properties = mm_kernel_event_properties_new ();
|
|
mm_kernel_event_properties_set_action (properties, "add");
|
|
mm_kernel_event_properties_set_subsystem (properties, "virtual");
|
|
mm_kernel_event_properties_set_name (properties, virtual_ports[i]);
|
|
|
|
/* Give an empty set of rules, because we don't want them to be
|
|
* loaded from the udev rules path (as there may not be any
|
|
* installed yet). */
|
|
kernel_device = mm_kernel_device_generic_new_with_rules (properties, NULL, &inner_error);
|
|
if (!kernel_device) {
|
|
mm_warn ("Could not grab port (virtual/%s): '%s'",
|
|
virtual_ports[i],
|
|
inner_error ? inner_error->message : "unknown error");
|
|
g_clear_error (&inner_error);
|
|
} else if (!mm_base_modem_grab_port (modem,
|
|
kernel_device,
|
|
MM_PORT_TYPE_AT,
|
|
MM_PORT_SERIAL_AT_FLAG_NONE,
|
|
&inner_error)) {
|
|
mm_warn ("Could not grab port (virtual/%s): '%s'",
|
|
virtual_ports[i],
|
|
inner_error ? inner_error->message : "unknown error");
|
|
g_clear_error (&inner_error);
|
|
}
|
|
|
|
if (kernel_device)
|
|
g_object_unref (kernel_device);
|
|
g_object_unref (properties);
|
|
}
|
|
}
|
|
|
|
/* If organizing ports fails, consider the modem invalid */
|
|
if (!mm_base_modem_organize_ports (modem, error))
|
|
g_clear_object (&modem);
|
|
|
|
return modem;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
mm_plugin_init (MMPlugin *self)
|
|
{
|
|
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
|
|
MM_TYPE_PLUGIN,
|
|
MMPluginPrivate);
|
|
|
|
/* Defaults */
|
|
self->priv->send_delay = 100000;
|
|
self->priv->remove_echo = TRUE;
|
|
self->priv->send_lf = FALSE;
|
|
}
|
|
|
|
static void
|
|
set_property (GObject *object,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
MMPlugin *self = MM_PLUGIN (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_NAME:
|
|
/* Construct only */
|
|
self->priv->name = g_value_dup_string (value);
|
|
break;
|
|
case PROP_ALLOWED_SUBSYSTEMS:
|
|
/* Construct only */
|
|
self->priv->subsystems = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_ALLOWED_DRIVERS:
|
|
/* Construct only */
|
|
self->priv->drivers = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_FORBIDDEN_DRIVERS:
|
|
/* Construct only */
|
|
self->priv->forbidden_drivers = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_ALLOWED_VENDOR_IDS:
|
|
/* Construct only */
|
|
self->priv->vendor_ids = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_ALLOWED_PRODUCT_IDS:
|
|
/* Construct only */
|
|
self->priv->product_ids = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_FORBIDDEN_PRODUCT_IDS:
|
|
/* Construct only */
|
|
self->priv->forbidden_product_ids = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_ALLOWED_VENDOR_STRINGS:
|
|
/* Construct only */
|
|
self->priv->vendor_strings = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_ALLOWED_PRODUCT_STRINGS:
|
|
/* Construct only */
|
|
self->priv->product_strings = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_FORBIDDEN_PRODUCT_STRINGS:
|
|
/* Construct only */
|
|
self->priv->forbidden_product_strings = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_ALLOWED_UDEV_TAGS:
|
|
/* Construct only */
|
|
self->priv->udev_tags = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_ALLOWED_AT:
|
|
/* Construct only */
|
|
self->priv->at = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_ALLOWED_SINGLE_AT:
|
|
/* Construct only */
|
|
self->priv->single_at = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_ALLOWED_QCDM:
|
|
/* Construct only */
|
|
self->priv->qcdm = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_ALLOWED_QMI:
|
|
/* Construct only */
|
|
self->priv->qmi = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_ALLOWED_MBIM:
|
|
/* Construct only */
|
|
self->priv->mbim = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_ICERA_PROBE:
|
|
/* Construct only */
|
|
self->priv->icera_probe = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_ALLOWED_ICERA:
|
|
/* Construct only */
|
|
self->priv->allowed_icera = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_FORBIDDEN_ICERA:
|
|
/* Construct only */
|
|
self->priv->forbidden_icera = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_XMM_PROBE:
|
|
/* Construct only */
|
|
self->priv->xmm_probe = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_ALLOWED_XMM:
|
|
/* Construct only */
|
|
self->priv->allowed_xmm = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_FORBIDDEN_XMM:
|
|
/* Construct only */
|
|
self->priv->forbidden_xmm = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_CUSTOM_AT_PROBE:
|
|
/* Construct only */
|
|
self->priv->custom_at_probe = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_CUSTOM_INIT:
|
|
/* Construct only */
|
|
self->priv->custom_init = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_SEND_DELAY:
|
|
/* Construct only */
|
|
self->priv->send_delay = (guint64)g_value_get_uint64 (value);
|
|
break;
|
|
case PROP_REMOVE_ECHO:
|
|
/* Construct only */
|
|
self->priv->remove_echo = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_SEND_LF:
|
|
/* Construct only */
|
|
self->priv->send_lf = g_value_get_boolean (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)
|
|
{
|
|
MMPlugin *self = MM_PLUGIN (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_NAME:
|
|
g_value_set_string (value, self->priv->name);
|
|
break;
|
|
case PROP_ALLOWED_SUBSYSTEMS:
|
|
g_value_set_boxed (value, self->priv->subsystems);
|
|
break;
|
|
case PROP_ALLOWED_DRIVERS:
|
|
g_value_set_boxed (value, self->priv->drivers);
|
|
break;
|
|
case PROP_FORBIDDEN_DRIVERS:
|
|
g_value_set_boxed (value, self->priv->forbidden_drivers);
|
|
break;
|
|
case PROP_ALLOWED_VENDOR_IDS:
|
|
g_value_set_boxed (value, self->priv->vendor_ids);
|
|
break;
|
|
case PROP_ALLOWED_PRODUCT_IDS:
|
|
g_value_set_boxed (value, self->priv->product_ids);
|
|
break;
|
|
case PROP_FORBIDDEN_PRODUCT_IDS:
|
|
g_value_set_boxed (value, self->priv->forbidden_product_ids);
|
|
break;
|
|
case PROP_ALLOWED_VENDOR_STRINGS:
|
|
g_value_set_boxed (value, self->priv->vendor_strings);
|
|
break;
|
|
case PROP_ALLOWED_PRODUCT_STRINGS:
|
|
g_value_set_boxed (value, self->priv->product_strings);
|
|
break;
|
|
case PROP_FORBIDDEN_PRODUCT_STRINGS:
|
|
g_value_set_boxed (value, self->priv->forbidden_product_strings);
|
|
break;
|
|
case PROP_ALLOWED_AT:
|
|
g_value_set_boolean (value, self->priv->at);
|
|
break;
|
|
case PROP_ALLOWED_SINGLE_AT:
|
|
g_value_set_boolean (value, self->priv->single_at);
|
|
break;
|
|
case PROP_ALLOWED_QCDM:
|
|
g_value_set_boolean (value, self->priv->qcdm);
|
|
break;
|
|
case PROP_ALLOWED_QMI:
|
|
g_value_set_boolean (value, self->priv->qmi);
|
|
break;
|
|
case PROP_ALLOWED_MBIM:
|
|
g_value_set_boolean (value, self->priv->mbim);
|
|
break;
|
|
case PROP_ALLOWED_UDEV_TAGS:
|
|
g_value_set_boxed (value, self->priv->udev_tags);
|
|
break;
|
|
case PROP_ICERA_PROBE:
|
|
g_value_set_boolean (value, self->priv->icera_probe);
|
|
break;
|
|
case PROP_ALLOWED_ICERA:
|
|
g_value_set_boolean (value, self->priv->allowed_icera);
|
|
break;
|
|
case PROP_FORBIDDEN_ICERA:
|
|
g_value_set_boolean (value, self->priv->forbidden_icera);
|
|
break;
|
|
case PROP_XMM_PROBE:
|
|
g_value_set_boolean (value, self->priv->xmm_probe);
|
|
break;
|
|
case PROP_ALLOWED_XMM:
|
|
g_value_set_boolean (value, self->priv->allowed_xmm);
|
|
break;
|
|
case PROP_FORBIDDEN_XMM:
|
|
g_value_set_boolean (value, self->priv->forbidden_xmm);
|
|
break;
|
|
case PROP_CUSTOM_AT_PROBE:
|
|
g_value_set_boxed (value, self->priv->custom_at_probe);
|
|
break;
|
|
case PROP_CUSTOM_INIT:
|
|
g_value_set_boxed (value, self->priv->custom_init);
|
|
break;
|
|
case PROP_SEND_DELAY:
|
|
g_value_set_uint64 (value, self->priv->send_delay);
|
|
break;
|
|
case PROP_REMOVE_ECHO:
|
|
g_value_set_boolean (value, self->priv->remove_echo);
|
|
break;
|
|
case PROP_SEND_LF:
|
|
g_value_set_boolean (value, self->priv->send_lf);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
finalize (GObject *object)
|
|
{
|
|
MMPlugin *self = MM_PLUGIN (object);
|
|
|
|
g_free (self->priv->name);
|
|
|
|
#define _g_boxed_free0(t,p) if (p) g_boxed_free (t, p)
|
|
|
|
_g_boxed_free0 (G_TYPE_STRV, self->priv->subsystems);
|
|
_g_boxed_free0 (G_TYPE_STRV, self->priv->drivers);
|
|
_g_boxed_free0 (G_TYPE_STRV, self->priv->forbidden_drivers);
|
|
_g_boxed_free0 (MM_TYPE_UINT16_ARRAY, self->priv->vendor_ids);
|
|
_g_boxed_free0 (MM_TYPE_UINT16_PAIR_ARRAY, self->priv->product_ids);
|
|
_g_boxed_free0 (MM_TYPE_UINT16_PAIR_ARRAY, self->priv->forbidden_product_ids);
|
|
_g_boxed_free0 (G_TYPE_STRV, self->priv->udev_tags);
|
|
_g_boxed_free0 (G_TYPE_STRV, self->priv->vendor_strings);
|
|
_g_boxed_free0 (MM_TYPE_STR_PAIR_ARRAY, self->priv->product_strings);
|
|
_g_boxed_free0 (MM_TYPE_STR_PAIR_ARRAY, self->priv->forbidden_product_strings);
|
|
_g_boxed_free0 (MM_TYPE_POINTER_ARRAY, self->priv->custom_at_probe);
|
|
_g_boxed_free0 (MM_TYPE_ASYNC_METHOD, self->priv->custom_init);
|
|
|
|
#undef _g_boxed_free0
|
|
|
|
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_FORBIDDEN_DRIVERS,
|
|
g_param_spec_boxed (MM_PLUGIN_FORBIDDEN_DRIVERS,
|
|
"Forbidden drivers",
|
|
"List of drivers this plugin cannot 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_FORBIDDEN_PRODUCT_IDS,
|
|
g_param_spec_boxed (MM_PLUGIN_FORBIDDEN_PRODUCT_IDS,
|
|
"Forbidden product IDs",
|
|
"List of vendor+product ID pairs this plugin cannot 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_FORBIDDEN_PRODUCT_STRINGS,
|
|
g_param_spec_boxed (MM_PLUGIN_FORBIDDEN_PRODUCT_STRINGS,
|
|
"Forbidden product strings",
|
|
"List of vendor+product string pairs this plugin cannot 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_ALLOWED_QMI,
|
|
g_param_spec_boolean (MM_PLUGIN_ALLOWED_QMI,
|
|
"Allowed QMI",
|
|
"Whether QMI ports are allowed in this plugin",
|
|
FALSE,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
|
|
|
|
g_object_class_install_property
|
|
(object_class, PROP_ALLOWED_MBIM,
|
|
g_param_spec_boolean (MM_PLUGIN_ALLOWED_MBIM,
|
|
"Allowed MBIM",
|
|
"Whether MBIM ports are allowed in this plugin",
|
|
FALSE,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
|
|
|
|
g_object_class_install_property
|
|
(object_class, PROP_ICERA_PROBE,
|
|
g_param_spec_boolean (MM_PLUGIN_ICERA_PROBE,
|
|
"Icera probe",
|
|
"Request to probe for Icera support.",
|
|
FALSE,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
|
|
|
|
g_object_class_install_property
|
|
(object_class, PROP_ALLOWED_ICERA,
|
|
g_param_spec_boolean (MM_PLUGIN_ALLOWED_ICERA,
|
|
"Allowed Icera",
|
|
"Whether Icera support is allowed in this plugin.",
|
|
FALSE,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
|
|
|
|
g_object_class_install_property
|
|
(object_class, PROP_FORBIDDEN_ICERA,
|
|
g_param_spec_boolean (MM_PLUGIN_FORBIDDEN_ICERA,
|
|
"Allowed Icera",
|
|
"Whether Icera support is forbidden in this plugin.",
|
|
FALSE,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
|
|
|
|
g_object_class_install_property
|
|
(object_class, PROP_XMM_PROBE,
|
|
g_param_spec_boolean (MM_PLUGIN_XMM_PROBE,
|
|
"XMM probe",
|
|
"Request to probe for XMM support.",
|
|
FALSE,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
|
|
|
|
g_object_class_install_property
|
|
(object_class, PROP_ALLOWED_XMM,
|
|
g_param_spec_boolean (MM_PLUGIN_ALLOWED_XMM,
|
|
"Allowed XMM",
|
|
"Whether XMM support is allowed in this plugin.",
|
|
FALSE,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
|
|
|
|
g_object_class_install_property
|
|
(object_class, PROP_FORBIDDEN_XMM,
|
|
g_param_spec_boolean (MM_PLUGIN_FORBIDDEN_XMM,
|
|
"Allowed XMM",
|
|
"Whether XMM support is forbidden in this plugin.",
|
|
FALSE,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
|
|
|
|
g_object_class_install_property
|
|
(object_class, PROP_CUSTOM_AT_PROBE,
|
|
g_param_spec_boxed (MM_PLUGIN_CUSTOM_AT_PROBE,
|
|
"Custom AT Probe",
|
|
"Custom set of commands to probe for AT support, "
|
|
"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_CUSTOM_INIT,
|
|
g_param_spec_boxed (MM_PLUGIN_CUSTOM_INIT,
|
|
"Custom initialization",
|
|
"Asynchronous method setup which contains the "
|
|
"custom initializations this plugin needs.",
|
|
MM_TYPE_ASYNC_METHOD,
|
|
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));
|
|
|
|
g_object_class_install_property
|
|
(object_class, PROP_REMOVE_ECHO,
|
|
g_param_spec_boolean (MM_PLUGIN_REMOVE_ECHO,
|
|
"Remove echo",
|
|
"Remove echo out of the AT responses",
|
|
TRUE,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
|
|
|
|
g_object_class_install_property
|
|
(object_class, PROP_SEND_LF,
|
|
g_param_spec_boolean (MM_PLUGIN_SEND_LF,
|
|
"Send LF",
|
|
"Send line-feed at the end of each AT command sent",
|
|
FALSE,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
|
|
}
|