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 void
telit_custom_init (MMPortProbe *probe,
MMPortSerialAt *port,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
MMDevice *device;
GUdevDevice *udevDevice;
TelitCustomInitContext *ctx;
device = mm_port_probe_peek_device (probe);
udevDevice = mm_port_probe_peek_port (probe);
ctx = g_slice_new (TelitCustomInitContext);
ctx->result = g_simple_async_result_new (G_OBJECT (probe),
callback,
user_data,
telit_custom_init);
ctx->probe = g_object_ref (probe);
ctx->port = g_object_ref (port);
ctx->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
ctx->getportcfg_done = FALSE;
ctx->getportcfg_retries = 3;
/* If the device is tagged for supporting #PORTCFG do the custom init */
if (g_udev_device_get_property_as_boolean (udevDevice, "ID_MM_TELIT_PORTS_TAGGED")) {
telit_custom_init_step (ctx);
return;
}
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
telit_custom_init_context_complete_and_free (ctx);
}
static void
getportmode_ready (MMPortSerialAt *port,
GAsyncResult *res,
HuaweiCustomInitContext *ctx)
{
const gchar *response;
GError *error = NULL;
response = mm_port_serial_at_command_finish (port, res, &error);
if (error) {
mm_dbg ("(Huawei) couldn't get port mode: '%s'",
error->message);
/* If any error occurred that was not ERROR or COMMAND NOT SUPPORT then
* retry the command.
*/
if (!g_error_matches (error,
MM_MOBILE_EQUIPMENT_ERROR,
MM_MOBILE_EQUIPMENT_ERROR_UNKNOWN))
goto out;
/* Port mode not supported */
} else {
MMDevice *device;
mm_dbg ("(Huawei) port mode layout retrieved");
/* Results are cached in the parent device object */
device = mm_port_probe_peek_device (ctx->probe);
cache_port_mode (device, response, "PCUI:", TAG_HUAWEI_PCUI_PORT);
cache_port_mode (device, response, "MDM:", TAG_HUAWEI_MODEM_PORT);
cache_port_mode (device, response, "NDIS:", TAG_HUAWEI_NDIS_PORT);
cache_port_mode (device, response, "DIAG:", TAG_HUAWEI_DIAG_PORT);
/* GETPORTMODE response format in newer devices... (e.g. E3372) */
cache_port_mode (device, response, "pcui:", TAG_HUAWEI_PCUI_PORT);
cache_port_mode (device, response, "modem:", TAG_HUAWEI_MODEM_PORT);
g_object_set_data (G_OBJECT (device), TAG_GETPORTMODE_SUPPORTED, GUINT_TO_POINTER (TRUE));
/* Mark port as being AT already */
mm_port_probe_set_result_at (ctx->probe, TRUE);
}
ctx->getportmode_done = TRUE;
out:
if (error)
g_error_free (error);
huawei_custom_init_step (ctx);
}
static void
custom_init_step (CustomInitContext *ctx)
{
/* If cancelled, end */
if (g_cancellable_is_cancelled (ctx->cancellable)) {
mm_dbg ("(Novatel) no need to keep on running custom init in (%s)",
mm_port_get_device (MM_PORT (ctx->port)));
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
custom_init_context_complete_and_free (ctx);
return;
}
/* If device has a QMI port, don't run $NWDMAT */
if (mm_port_probe_list_has_qmi_port (mm_device_peek_port_probe_list (mm_port_probe_peek_device (ctx->probe)))) {
mm_dbg ("(Novatel) no need to run custom init in (%s): device has QMI port",
mm_port_get_device (MM_PORT (ctx->port)));
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
custom_init_context_complete_and_free (ctx);
return;
}
if (ctx->wait_time > 0) {
ctx->wait_time--;
g_timeout_add_seconds (1, (GSourceFunc)custom_init_wait_cb, ctx);
return;
}
if (ctx->nwdmat_retries > 0) {
ctx->nwdmat_retries--;
mm_port_serial_at_command (ctx->port,
"$NWDMAT=1",
3,
FALSE, /* raw */
FALSE, /* allow_cached */
ctx->cancellable,
(GAsyncReadyCallback)nwdmat_ready,
ctx);
return;
}
/* Finish custom_init */
mm_dbg ("(Novatel) couldn't flip secondary port to AT in (%s): all retries consumed",
mm_port_get_device (MM_PORT (ctx->port)));
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
custom_init_context_complete_and_free (ctx);
}
static void
getportcfg_ready (MMPortSerialAt *port,
GAsyncResult *res,
TelitCustomInitContext *ctx)
{
const gchar *response;
GError *error = NULL;
response = mm_port_serial_at_command_finish (port, res, &error);
if (error) {
mm_dbg ("telit: couldn't get port mode: '%s'",
error->message);
/* If ERROR or COMMAND NOT SUPPORT occur then do not retry the
* command.
*/
if (g_error_matches (error,
MM_MOBILE_EQUIPMENT_ERROR,
MM_MOBILE_EQUIPMENT_ERROR_UNKNOWN))
ctx->getportcfg_done = TRUE;
} else {
MMDevice *device;
device = mm_port_probe_peek_device (ctx->probe);
/* Results are cached in the parent device object */
if (g_object_get_data (G_OBJECT (device), TAG_GETPORTCFG_SUPPORTED) == NULL) {
mm_dbg ("telit: retrieving port mode layout");
if (cache_port_mode (device, response)) {
g_object_set_data (G_OBJECT (device), TAG_GETPORTCFG_SUPPORTED, GUINT_TO_POINTER (TRUE));
ctx->getportcfg_done = TRUE;
}
}
/* Port answered to #PORTCFG, so mark it as being AT already */
mm_port_probe_set_result_at (ctx->probe, TRUE);
}
if (error)
g_error_free (error);
telit_custom_init_step (ctx);
}
static void
getportmode_ready (MMAtSerialPort *port,
GString *response,
GError *error,
HuaweiCustomInitContext *ctx)
{
if (error) {
mm_dbg ("(Huawei) couldn't get port mode: '%s'",
error->message);
/* If any error occurred that was not ERROR or COMMAND NOT SUPPORT then
* retry the command.
*/
if (!g_error_matches (error,
MM_MOBILE_EQUIPMENT_ERROR,
MM_MOBILE_EQUIPMENT_ERROR_UNKNOWN)) {
/* Retry */
huawei_custom_init_step (ctx);
return;
}
/* Port mode not supported */
} else {
MMDevice *device;
mm_dbg ("(Huawei) port mode layout retrieved");
/* Results are cached in the parent device object */
device = mm_port_probe_peek_device (ctx->probe);
cache_port_mode (device, response->str, "PCUI:", TAG_HUAWEI_PCUI_PORT);
cache_port_mode (device, response->str, "MDM:", TAG_HUAWEI_MODEM_PORT);
cache_port_mode (device, response->str, "NDIS:", TAG_HUAWEI_NDIS_PORT);
cache_port_mode (device, response->str, "DIAG:", TAG_HUAWEI_DIAG_PORT);
g_object_set_data (G_OBJECT (device), TAG_GETPORTMODE_SUPPORTED, GUINT_TO_POINTER (TRUE));
/* Mark port as being AT already */
mm_port_probe_set_result_at (ctx->probe, TRUE);
}
ctx->getportmode_done = TRUE;
huawei_custom_init_step (ctx);
}
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 void
huawei_custom_init (MMPortProbe *probe,
MMAtSerialPort *port,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
MMDevice *device;
FirstInterfaceContext *fi_ctx;
HuaweiCustomInitContext *ctx;
device = mm_port_probe_peek_device (probe);
/* The primary port (called the "modem" port in the Windows drivers) is
* always USB interface 0, and we need to detect that interface first for
* two reasons: (1) to disable unsolicited messages on other ports that
* may fill up the buffer and crash the device, and (2) to attempt to get
* the port layout for hints about what the secondary port is (called the
* "pcui" port in Windows). Thus we probe USB interface 0 first and defer
* probing other interfaces until we've got if0, at which point we allow
* the other ports to be probed too.
*/
fi_ctx = g_object_get_data (G_OBJECT (device), TAG_FIRST_INTERFACE_CONTEXT);
if (!fi_ctx) {
/* This is the first time we ask for the context. Set it up. */
fi_ctx = g_slice_new0 (FirstInterfaceContext);
g_object_set_data_full (G_OBJECT (device),
TAG_FIRST_INTERFACE_CONTEXT,
fi_ctx,
(GDestroyNotify)first_interface_context_free);
/* The timeout is controlled in the data set in 'device', and therefore
* it should be safe to assume that the timeout will not get fired after
* having disposed 'device' */
fi_ctx->timeout_id = g_timeout_add_seconds (MAX_WAIT_TIME,
(GSourceFunc)first_interface_missing_timeout_cb,
device);
/* By default, we'll ask the Huawei plugin to start probing usbif 0 */
fi_ctx->first_usbif = 0;
/* Custom init of the Huawei plugin is to be run only in the first
* interface. We'll control here whether we did run it already or not. */
fi_ctx->custom_init_run = FALSE;
}
ctx = g_slice_new (HuaweiCustomInitContext);
ctx->result = g_simple_async_result_new (G_OBJECT (probe),
callback,
user_data,
huawei_custom_init);
ctx->probe = g_object_ref (probe);
ctx->port = g_object_ref (port);
ctx->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
ctx->curc_done = FALSE;
ctx->curc_retries = 3;
ctx->getportmode_done = FALSE;
ctx->getportmode_retries = 3;
/* Custom init only to be run in the first interface */
if (g_udev_device_get_property_as_int (mm_port_probe_peek_port (probe),
"ID_USB_INTERFACE_NUM") != fi_ctx->first_usbif) {
if (fi_ctx->custom_init_run)
/* If custom init was run already, we can consider this as successfully run */
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
else
/* Otherwise, we'll need to defer the probing a bit more */
g_simple_async_result_set_error (ctx->result,
MM_CORE_ERROR,
MM_CORE_ERROR_RETRY,
"Defer needed");
huawei_custom_init_context_complete_and_free (ctx);
return;
}
/* We can run custom init in the first interface! clear the timeout as it is no longer needed */
g_source_remove (fi_ctx->timeout_id);
fi_ctx->timeout_id = 0;
huawei_custom_init_step (ctx);
}
static void
huawei_custom_init_step (HuaweiCustomInitContext *ctx)
{
FirstInterfaceContext *fi_ctx;
/* If cancelled, end */
if (g_cancellable_is_cancelled (ctx->cancellable)) {
mm_dbg ("(Huawei) no need to keep on running custom init in (%s)",
mm_port_get_device (MM_PORT (ctx->port)));
g_simple_async_result_set_error (ctx->result,
MM_CORE_ERROR,
MM_CORE_ERROR_CANCELLED,
"Custom initialization cancelled");
huawei_custom_init_context_complete_and_free (ctx);
return;
}
if (!ctx->curc_done) {
if (ctx->curc_retries == 0) {
/* All retries consumed, probably not an AT port */
mm_port_probe_set_result_at (ctx->probe, FALSE);
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
/* Try with next */
try_next_usbif (mm_port_probe_peek_device (ctx->probe));
huawei_custom_init_context_complete_and_free (ctx);
return;
}
ctx->curc_retries--;
/* Turn off unsolicited messages on secondary ports until needed */
mm_at_serial_port_queue_command (
ctx->port,
"AT^CURC=0",
3,
FALSE, /* raw */
ctx->cancellable,
(MMAtSerialResponseFn)curc_ready,
ctx);
return;
}
/* Try to get a port map from the modem */
if (!ctx->getportmode_done) {
if (ctx->getportmode_retries == 0) {
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
huawei_custom_init_context_complete_and_free (ctx);
return;
}
ctx->getportmode_retries--;
mm_at_serial_port_queue_command (
ctx->port,
"AT^GETPORTMODE",
3,
FALSE, /* raw */
ctx->cancellable,
(MMAtSerialResponseFn)getportmode_ready,
ctx);
return;
}
/* All done it seems */
fi_ctx = g_object_get_data (G_OBJECT (mm_port_probe_peek_device (ctx->probe)), TAG_FIRST_INTERFACE_CONTEXT);
g_assert (fi_ctx != NULL);
fi_ctx->custom_init_run = TRUE;
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
huawei_custom_init_context_complete_and_free (ctx);
}
static gboolean
grab_port (MMPlugin *self,
MMBaseModem *modem,
MMPortProbe *probe,
GError **error)
{
GUdevDevice *port;
MMDevice *device;
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);
device = mm_port_probe_peek_device (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 no udev rules are found, AT#PORTCFG (if supported) can be used for
* identifying the port layout
*/
if (g_udev_device_get_property_as_boolean (port, TAG_TELIT_MODEM_PORT)) {
mm_dbg ("telit: 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, TAG_TELIT_AUX_PORT)) {
mm_dbg ("telit: 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;
} else if (g_udev_device_get_property_as_boolean (port, TAG_TELIT_NMEA_PORT)) {
mm_dbg ("telit: port '%s/%s' flagged as NMEA",
mm_port_probe_get_port_subsys (probe),
mm_port_probe_get_port_name (probe));
ptype = MM_PORT_TYPE_GPS;
} else if (g_object_get_data (G_OBJECT (device), TAG_GETPORTCFG_SUPPORTED) != NULL) {
if (g_strcmp0 (g_udev_device_get_property (port, "ID_USB_INTERFACE_NUM"), g_object_get_data (G_OBJECT (device), TAG_TELIT_MODEM_PORT)) == 0) {
mm_dbg ("telit: 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_strcmp0 (g_udev_device_get_property (port, "ID_USB_INTERFACE_NUM"), g_object_get_data (G_OBJECT (device), TAG_TELIT_AUX_PORT)) == 0) {
mm_dbg ("telit: 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;
} else if (g_strcmp0 (g_udev_device_get_property (port, "ID_USB_INTERFACE_NUM"), g_object_get_data (G_OBJECT (device), TAG_TELIT_NMEA_PORT)) == 0) {
mm_dbg ("telit: port '%s/%s' flagged as NMEA",
mm_port_probe_get_port_subsys (probe),
mm_port_probe_get_port_name (probe));
ptype = MM_PORT_TYPE_GPS;
} else
ptype = MM_PORT_TYPE_IGNORED;
} else {
/* 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.
*/
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
custom_init_step (CustomInitContext *ctx)
{
/* If cancelled, end */
if (g_cancellable_is_cancelled (ctx->cancellable)) {
mm_dbg ("(Dell) no need to keep on running custom init in (%s)",
mm_port_get_device (MM_PORT (ctx->port)));
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
custom_init_context_complete_and_free (ctx);
return;
}
#if defined WITH_QMI
/* If device has a QMI port, don't run anything else, as we don't care */
if (mm_port_probe_list_has_qmi_port (mm_device_peek_port_probe_list (mm_port_probe_peek_device (ctx->probe)))) {
mm_dbg ("(Dell) no need to run custom init in (%s): device has QMI port",
mm_port_get_device (MM_PORT (ctx->port)));
mm_port_probe_set_result_at (ctx->probe, FALSE);
mm_port_probe_set_result_qcdm (ctx->probe, FALSE);
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
custom_init_context_complete_and_free (ctx);
return;
}
#endif
#if defined WITH_MBIM
/* If device has a MBIM port, don't run anything else, as we don't care */
if (mm_port_probe_list_has_mbim_port (mm_device_peek_port_probe_list (mm_port_probe_peek_device (ctx->probe)))) {
mm_dbg ("(Dell) no need to run custom init in (%s): device has MBIM port",
mm_port_get_device (MM_PORT (ctx->port)));
mm_port_probe_set_result_at (ctx->probe, FALSE);
mm_port_probe_set_result_qcdm (ctx->probe, FALSE);
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
custom_init_context_complete_and_free (ctx);
return;
}
#endif
if (ctx->gmi_retries > 0) {
ctx->gmi_retries--;
mm_port_serial_at_command (ctx->port,
"AT+GMI",
3,
FALSE, /* raw */
FALSE, /* allow_cached */
ctx->cancellable,
(GAsyncReadyCallback)response_ready,
ctx);
return;
}
if (ctx->cgmi_retries > 0) {
ctx->cgmi_retries--;
mm_port_serial_at_command (ctx->port,
"AT+CGMI",
3,
FALSE, /* raw */
FALSE, /* allow_cached */
ctx->cancellable,
(GAsyncReadyCallback)response_ready,
ctx);
return;
}
if (ctx->ati_retries > 0) {
ctx->ati_retries--;
/* Note: in Ericsson devices, ATI3 seems to reply the vendor string */
mm_port_serial_at_command (ctx->port,
"ATI1I2I3",
3,
FALSE, /* raw */
FALSE, /* allow_cached */
ctx->cancellable,
(GAsyncReadyCallback)response_ready,
ctx);
return;
}
/* Finish custom_init */
mm_dbg ("(Dell) couldn't flip secondary port to AT in (%s): all retries consumed",
mm_port_get_device (MM_PORT (ctx->port)));
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
custom_init_context_complete_and_free (ctx);
}
static void
huawei_custom_init_step (HuaweiCustomInitContext *ctx)
{
FirstInterfaceContext *fi_ctx;
GUdevDevice *port;
/* If cancelled, end */
if (g_cancellable_is_cancelled (ctx->cancellable)) {
mm_dbg ("(Huawei) no need to keep on running custom init in (%s)",
mm_port_get_device (MM_PORT (ctx->port)));
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
huawei_custom_init_context_complete_and_free (ctx);
return;
}
if (!ctx->curc_done) {
if (ctx->curc_retries == 0) {
/* All retries consumed, probably not an AT port */
mm_port_probe_set_result_at (ctx->probe, FALSE);
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
/* Try with next */
try_next_usbif (mm_port_probe_peek_device (ctx->probe));
huawei_custom_init_context_complete_and_free (ctx);
return;
}
ctx->curc_retries--;
/* Turn off unsolicited messages on secondary ports until needed */
mm_port_serial_at_command (
ctx->port,
"AT^CURC=0",
3,
FALSE, /* raw */
FALSE, /* allow_cached */
ctx->cancellable,
(GAsyncReadyCallback)curc_ready,
ctx);
return;
}
/* Try to get a port map from the modem */
port = mm_port_probe_peek_port (ctx->probe);
if (!ctx->getportmode_done && !g_udev_device_get_property_as_boolean (port, "ID_MM_HUAWEI_DISABLE_GETPORTMODE")) {
if (ctx->getportmode_retries == 0) {
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
huawei_custom_init_context_complete_and_free (ctx);
return;
}
ctx->getportmode_retries--;
mm_port_serial_at_command (
ctx->port,
"AT^GETPORTMODE",
3,
FALSE, /* raw */
FALSE, /* allow_cached */
ctx->cancellable,
(GAsyncReadyCallback)getportmode_ready,
ctx);
return;
}
/* All done it seems */
fi_ctx = g_object_get_data (G_OBJECT (mm_port_probe_peek_device (ctx->probe)), TAG_FIRST_INTERFACE_CONTEXT);
g_assert (fi_ctx != NULL);
fi_ctx->custom_init_run = TRUE;
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
huawei_custom_init_context_complete_and_free (ctx);
}
