static void
propagate_port_mode_results (GList *probes)
{
MMDevice *device;
GList *l;
gboolean primary_flagged = FALSE;
g_assert (probes != NULL);
device = mm_port_probe_peek_device (MM_PORT_PROBE (probes->data));
/* Now we propagate the tags to the specific port probes */
for (l = probes; l; l = g_list_next (l)) {
MMPortSerialAtFlag at_port_flags = MM_PORT_SERIAL_AT_FLAG_NONE;
gint usbif;
usbif = g_udev_device_get_property_as_int (mm_port_probe_peek_port (MM_PORT_PROBE (l->data)), "ID_USB_INTERFACE_NUM");
if (GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (device), TAG_GETPORTMODE_SUPPORTED))) {
if (usbif + 1 == GPOINTER_TO_INT (g_object_get_data (G_OBJECT (device), TAG_HUAWEI_PCUI_PORT))) {
at_port_flags = MM_PORT_SERIAL_AT_FLAG_PRIMARY;
primary_flagged = TRUE;
} else if (usbif + 1 == GPOINTER_TO_INT (g_object_get_data (G_OBJECT (device), TAG_HUAWEI_MODEM_PORT)))
at_port_flags = MM_PORT_SERIAL_AT_FLAG_PPP;
else if (!g_object_get_data (G_OBJECT (device), TAG_HUAWEI_MODEM_PORT) &&
usbif + 1 == GPOINTER_TO_INT (g_object_get_data (G_OBJECT (device), TAG_HUAWEI_NDIS_PORT)))
/* If NDIS reported only instead of MDM, use it */
at_port_flags = MM_PORT_SERIAL_AT_FLAG_PPP;
} else if (usbif == 0 &&
mm_port_probe_is_at (MM_PORT_PROBE (l->data))) {
/* If GETPORTMODE is not supported, we assume usbif 0 is the modem port */
at_port_flags = MM_PORT_SERIAL_AT_FLAG_PPP;
/* /\* TODO. */
/* * For CDMA modems we assume usbif0 is both primary and PPP, since */
/* * they don't have problems with talking on secondary ports. */
/* *\/ */
/* if (caps & CAP_CDMA) */
/* pflags |= MM_PORT_SERIAL_AT_FLAG_PRIMARY; */
}
g_object_set_data (G_OBJECT (l->data), TAG_AT_PORT_FLAGS, GUINT_TO_POINTER (at_port_flags));
}
if (primary_flagged)
return;
/* For devices exposing a cdc-wdm port, make sure it gets flagged as primary, if there is none
* already */
for (l = probes; l; l = g_list_next (l)) {
MMPortProbe *probe = MM_PORT_PROBE (l->data);
if (mm_port_probe_is_at (probe) &&
g_str_has_prefix (mm_port_probe_get_port_subsys (probe), "usb") &&
g_str_has_prefix (mm_port_probe_get_port_name (probe), "cdc-wdm")) {
/* Flag as PRIMARY and do nothing else */
g_object_set_data (G_OBJECT (probe), TAG_AT_PORT_FLAGS, GUINT_TO_POINTER (MM_PORT_SERIAL_AT_FLAG_PRIMARY));
break;
}
}
}
static MMBaseModem *
grab_port (MMPluginBase *base,
MMBaseModem *existing,
MMPortProbe *probe,
GError **error)
{
MMBaseModem *modem = NULL;
const gchar *name, *subsys;
guint16 vendor = 0, product = 0;
/* The Motorola plugin cannot do anything with non-AT ports */
if (!mm_port_probe_is_at (probe)) {
g_set_error_literal (error,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Ignoring non-AT port");
return NULL;
}
subsys = mm_port_probe_get_port_subsys (probe);
name = mm_port_probe_get_port_name (probe);
if (!mm_plugin_base_get_device_ids (base, subsys, name, &vendor, &product)) {
g_set_error_literal (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Could not get modem product ID");
return NULL;
}
/* If this is the first port being grabbed, create a new modem object */
if (!existing)
modem = MM_BASE_MODEM (mm_broadband_modem_motorola_new (
mm_port_probe_get_port_physdev (probe),
mm_port_probe_get_port_driver (probe),
mm_plugin_get_name (MM_PLUGIN (base)),
vendor,
product));
if (!mm_base_modem_grab_port (existing ? existing : modem,
subsys,
name,
MM_PORT_TYPE_AT, /* we only allow AT ports here */
MM_AT_PORT_FLAG_NONE,
error)) {
if (modem)
g_object_unref (modem);
return NULL;
}
return existing ? existing : modem;
}
static MMBaseModem *
grab_port (MMPluginBase *base,
MMBaseModem *existing,
MMPortProbe *probe,
GError **error)
{
MMBaseModem *modem = NULL;
const gchar *name, *subsys, *driver;
guint16 vendor = 0, product = 0;
/* The Gobi plugin only handles AT and QCDM ports (for now) */
if (!mm_port_probe_is_at (probe) && !mm_port_probe_is_qcdm (probe)) {
g_set_error_literal (error,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Ignoring non-AT/non-QCDM port");
return NULL;
}
subsys = mm_port_probe_get_port_subsys (probe);
name = mm_port_probe_get_port_name (probe);
driver = mm_port_probe_get_port_driver (probe);
if (!mm_plugin_base_get_device_ids (base, subsys, name, &vendor, &product)) {
g_set_error_literal (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Could not get modem product ID");
return NULL;
}
/* If this is the first port being grabbed, create a new modem object */
if (!existing)
modem = MM_BASE_MODEM (mm_broadband_modem_gobi_new (mm_port_probe_get_port_physdev (probe),
driver,
mm_plugin_get_name (MM_PLUGIN (base)),
vendor,
product));
if (!mm_base_modem_grab_port (existing ? existing : modem,
subsys,
name,
mm_port_probe_get_port_type (probe),
MM_AT_PORT_FLAG_NONE,
error)) {
if (modem)
g_object_unref (modem);
return NULL;
}
return existing ? existing : modem;
}
static MMBaseModem *
grab_port (MMPluginBase *base,
MMBaseModem *existing,
MMPortProbe *probe,
GError **error)
{
MMBaseModem *modem = NULL;
const gchar *name, *subsys, *driver;
guint16 vendor = 0, product = 0;
/* The Iridium plugin cannot do anything with non-AT ports */
if (!mm_port_probe_is_at (probe)) {
g_set_error_literal (error,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Ignoring non-AT port");
return NULL;
}
subsys = mm_port_probe_get_port_subsys (probe);
name = mm_port_probe_get_port_name (probe);
driver = mm_port_probe_get_port_driver (probe);
/* Try to get Product IDs from udev. Note that it is not an error
* if we can't get them in our case, as we also support serial
* modems. */
mm_plugin_base_get_device_ids (base, subsys, name, &vendor, &product);
/* If this is the first port being grabbed, create a new modem object */
if (!existing)
modem = MM_BASE_MODEM (mm_broadband_modem_iridium_new (
mm_port_probe_get_port_physdev (probe),
driver,
mm_plugin_get_name (MM_PLUGIN (base)),
vendor,
product));
if (!mm_base_modem_grab_port (existing ? existing : modem,
subsys,
name,
MM_PORT_TYPE_AT, /* we only allow AT ports here */
MM_AT_PORT_FLAG_NONE,
error)) {
if (modem)
g_object_unref (modem);
return NULL;
}
return existing ? existing : modem;
}
static gboolean
grab_port (MMPlugin *self,
MMBaseModem *modem,
MMPortProbe *probe,
GError **error)
{
GUdevDevice *port;
MMPortType ptype;
MMPortSerialAtFlag pflags = MM_PORT_SERIAL_AT_FLAG_NONE;
port = mm_port_probe_peek_port (probe);
ptype = mm_port_probe_get_port_type (probe);
if (mm_port_probe_is_at (probe)) {
/* 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_SIMTECH_PORT_TYPE_MODEM")) {
mm_dbg ("Simtech: AT port '%s/%s' flagged as primary",
mm_port_probe_get_port_subsys (probe),
mm_port_probe_get_port_name (probe));
pflags = MM_PORT_SERIAL_AT_FLAG_PRIMARY;
} else if (g_udev_device_get_property_as_boolean (port, "ID_MM_SIMTECH_PORT_TYPE_AUX")) {
mm_dbg ("Simtech: AT port '%s/%s' flagged as secondary",
mm_port_probe_get_port_subsys (probe),
mm_port_probe_get_port_name (probe));
pflags = MM_PORT_SERIAL_AT_FLAG_SECONDARY;
}
/* 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_PORT_SERIAL_AT_FLAG_NONE &&
g_udev_device_get_property_as_boolean (port, "ID_MM_SIMTECH_TAGGED"))
ptype = MM_PORT_TYPE_IGNORED;
}
return mm_base_modem_grab_port (modem,
mm_port_probe_get_port_subsys (probe),
mm_port_probe_get_port_name (probe),
mm_port_probe_get_parent_path (probe),
ptype,
pflags,
error);
}
static void
propagate_port_mode_results (GList *probes)
{
MMDevice *device;
GList *l;
g_assert (probes != NULL);
device = mm_port_probe_peek_device (MM_PORT_PROBE (probes->data));
/* Now we propagate the tags to the specific port probes */
for (l = probes; l; l = g_list_next (l)) {
MMAtPortFlag at_port_flags = MM_AT_PORT_FLAG_NONE;
gint usbif;
usbif = g_udev_device_get_property_as_int (mm_port_probe_peek_port (MM_PORT_PROBE (l->data)), "ID_USB_INTERFACE_NUM");
if (GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (device), TAG_GETPORTMODE_SUPPORTED))) {
if (usbif + 1 == GPOINTER_TO_INT (g_object_get_data (G_OBJECT (device), TAG_HUAWEI_PCUI_PORT)))
at_port_flags = MM_AT_PORT_FLAG_PRIMARY;
else if (usbif + 1 == GPOINTER_TO_INT (g_object_get_data (G_OBJECT (device), TAG_HUAWEI_MODEM_PORT)))
at_port_flags = MM_AT_PORT_FLAG_PPP;
else if (!g_object_get_data (G_OBJECT (device), TAG_HUAWEI_MODEM_PORT) &&
usbif + 1 == GPOINTER_TO_INT (g_object_get_data (G_OBJECT (device), TAG_HUAWEI_NDIS_PORT)))
/* If NDIS reported only instead of MDM, use it */
at_port_flags = MM_AT_PORT_FLAG_PPP;
} else if (usbif == 0 &&
mm_port_probe_is_at (MM_PORT_PROBE (l->data))) {
/* If GETPORTMODE is not supported, we assume usbif 0 is the modem port */
at_port_flags = MM_AT_PORT_FLAG_PPP;
/* /\* TODO. */
/* * For CDMA modems we assume usbif0 is both primary and PPP, since */
/* * they don't have problems with talking on secondary ports. */
/* *\/ */
/* if (caps & CAP_CDMA) */
/* pflags |= MM_AT_PORT_FLAG_PRIMARY; */
}
g_object_set_data (G_OBJECT (l->data), TAG_AT_PORT_FLAGS, GUINT_TO_POINTER (at_port_flags));
}
}
static MMBaseModem *
grab_port (MMPluginBase *base,
MMBaseModem *existing,
MMPortProbe *probe,
GError **error)
{
MMBaseModem *modem = NULL;
GUdevDevice *port;
MMPortType ptype;
const gchar *name, *subsys;
guint16 vendor = 0, product = 0;
MMAtPortFlag pflags = MM_AT_PORT_FLAG_NONE;
/* The Simtech plugin cannot do anything with non-AT non-QCDM ports */
if (!mm_port_probe_is_at (probe) &&
!mm_port_probe_is_qcdm (probe)) {
g_set_error_literal (error,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Ignoring non-AT non-QCDM port");
return NULL;
}
port = mm_port_probe_get_port (probe); /* transfer none */
subsys = mm_port_probe_get_port_subsys (probe);
name = mm_port_probe_get_port_name (probe);
if (!mm_plugin_base_get_device_ids (base, subsys, name, &vendor, &product)) {
g_set_error_literal (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Could not get modem product ID");
return NULL;
}
/* 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_SIMTECH_PORT_TYPE_MODEM"))
pflags = MM_AT_PORT_FLAG_PRIMARY;
else if (g_udev_device_get_property_as_boolean (port, "ID_MM_SIMTECH_PORT_TYPE_AUX"))
pflags = MM_AT_PORT_FLAG_SECONDARY;
/* 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_SIMTECH_TAGGED"))
ptype = MM_PORT_TYPE_IGNORED;
else
ptype = mm_port_probe_get_port_type (probe);
/* If this is the first port being grabbed, create a new modem object */
if (!existing)
modem = MM_BASE_MODEM (mm_broadband_modem_simtech_new (mm_port_probe_get_port_physdev (probe),
mm_port_probe_get_port_driver (probe),
mm_plugin_get_name (MM_PLUGIN (base)),
vendor,
product));
if (!mm_base_modem_grab_port (existing ? existing : modem,
subsys,
name,
ptype,
pflags,
error)) {
if (modem)
g_object_unref (modem);
return NULL;
}
return existing ? existing : modem;
}
void
mm_plugin_supports_port (MMPlugin *self,
MMDevice *device,
GUdevDevice *port,
GAsyncReadyCallback callback,
gpointer user_data)
{
MMPortProbe *probe;
GSimpleAsyncResult *async_result;
PortProbeRunContext *ctx;
gboolean need_vendor_probing;
gboolean need_product_probing;
MMPortProbeFlag probe_run_flags;
gchar *probe_list_str;
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;
}
/* Need to launch new probing */
probe = MM_PORT_PROBE (mm_device_get_port_probe (device, port));
if (!probe) {
/* This may happen if the ports get removed from the device while
* probing is ongoing */
g_simple_async_result_set_error (async_result,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"(%s) Missing port probe for port (%s/%s)",
self->priv->name,
g_udev_device_get_subsystem (port),
g_udev_device_get_name (port));
g_simple_async_result_complete_in_idle (async_result);
goto out;
}
/* Before launching any probing, check if the port is a net device. */
if (g_str_equal (g_udev_device_get_subsystem (port), "net")) {
mm_dbg ("(%s) [%s] probing deferred until result suggested",
self->priv->name,
g_udev_device_get_name (port));
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 */
if (!g_str_has_prefix (g_udev_device_get_name (port), "cdc-wdm")) {
/* Serial ports... */
probe_run_flags = MM_PORT_PROBE_NONE;
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 (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 (self->priv->qcdm)
probe_run_flags |= MM_PORT_PROBE_QCDM;
if (self->priv->icera_probe || self->priv->allowed_icera || self->priv->forbidden_icera)
probe_run_flags |= (MM_PORT_PROBE_AT | MM_PORT_PROBE_AT_ICERA);
} else {
/* cdc-wdm ports... */
probe_run_flags = MM_PORT_PROBE_QMI;
}
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 (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,
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->self = 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 */
probe_list_str = mm_port_probe_flag_build_string_from_mask (ctx->flags);
mm_dbg ("(%s) [%s] probe required: '%s'",
self->priv->name,
g_udev_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->custom_at_probe,
self->priv->custom_init,
(GAsyncReadyCallback)port_probe_run_ready,
ctx);
out:
g_object_unref (async_result);
}
static void
port_probe_run_ready (MMPortProbe *probe,
GAsyncResult *probe_result,
PortProbeRunContext *ctx)
{
GError *error = NULL;
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)) {
g_simple_async_result_set_op_res_gpointer (ctx->result,
GUINT_TO_POINTER (MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED),
NULL);
}
/* Probing failed but the plugin tells us to retry; so we'll defer the
* probing a bit */
else if (g_error_matches (error,
MM_CORE_ERROR,
MM_CORE_ERROR_RETRY)) {
g_simple_async_result_set_op_res_gpointer (ctx->result,
GUINT_TO_POINTER (MM_PLUGIN_SUPPORTS_PORT_DEFER),
NULL);
}
/* For remaining errors, just propagate them */
else {
g_simple_async_result_take_error (ctx->result, error);
}
} else {
/* Probing succeeded */
MMPluginSupportsResult supports_result;
if (!apply_post_probing_filters (ctx->self, ctx->flags, probe)) {
/* Port is supported! */
supports_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 {
/* 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);
g_object_unref (ctx->device);
g_object_unref (ctx->result);
g_object_unref (ctx->self);
g_free (ctx);
}
