static void
supports_task_dispose (GObject *object)
{
MMPluginBaseSupportsTaskPrivate *priv = MM_PLUGIN_BASE_SUPPORTS_TASK_GET_PRIVATE (object);
if (MM_IS_SERIAL_PORT (priv->probe_port))
mm_serial_port_flash_cancel (MM_SERIAL_PORT (priv->probe_port));
g_object_unref (priv->port);
g_free (priv->physdev_path);
g_free (priv->driver);
g_free (priv->probe_resp);
g_clear_error (&(priv->probe_error));
g_free (priv->custom_init);
if (priv->open_id)
g_source_remove (priv->open_id);
if (priv->full_id)
g_source_remove (priv->full_id);
if (priv->probe_id)
g_source_remove (priv->probe_id);
if (priv->probe_port) {
mm_serial_port_close (MM_SERIAL_PORT (priv->probe_port));
g_object_unref (priv->probe_port);
}
if (priv->qcdm_port) {
mm_serial_port_close (MM_SERIAL_PORT (priv->qcdm_port));
g_object_unref (priv->qcdm_port);
}
G_OBJECT_CLASS (mm_plugin_base_supports_task_parent_class)->dispose (object);
}
static void
try_qcdm_probe (MMPluginBaseSupportsTask *task)
{
MMPluginBaseSupportsTaskPrivate *priv = MM_PLUGIN_BASE_SUPPORTS_TASK_GET_PRIVATE (task);
const char *name;
GError *error = NULL;
GByteArray *verinfo = NULL, *verinfo2;
gint len;
/* Close the AT port */
if (priv->probe_port) {
mm_serial_port_close (MM_SERIAL_PORT (priv->probe_port));
g_object_unref (priv->probe_port);
priv->probe_port = NULL;
}
/* Open the QCDM port */
name = g_udev_device_get_name (priv->port);
g_assert (name);
priv->qcdm_port = mm_qcdm_serial_port_new (name, MM_PORT_TYPE_PRIMARY);
if (priv->qcdm_port == NULL) {
g_warning ("(%s) failed to create new QCDM serial port.", name);
probe_complete (task);
return;
}
if (!mm_serial_port_open (MM_SERIAL_PORT (priv->qcdm_port), &error)) {
g_warning ("(%s) failed to open new QCDM serial port: (%d) %s.",
name,
error ? error->code : -1,
error && error->message ? error->message : "(unknown)");
g_clear_error (&error);
probe_complete (task);
return;
}
/* Build up the probe command */
verinfo = g_byte_array_sized_new (50);
len = qcdm_cmd_version_info_new ((char *) verinfo->data, 50, &error);
if (len <= 0) {
g_byte_array_free (verinfo, TRUE);
g_warning ("(%s) failed to create QCDM version info command: (%d) %s.",
name,
error ? error->code : -1,
error && error->message ? error->message : "(unknown)");
g_clear_error (&error);
probe_complete (task);
return;
}
verinfo->len = len;
/* Queuing the command takes ownership over it; copy it for the second try */
verinfo2 = g_byte_array_sized_new (verinfo->len);
g_byte_array_append (verinfo2, verinfo->data, verinfo->len);
/* Send the command twice; the ports often need to be woken up */
mm_qcdm_serial_port_queue_command (priv->qcdm_port, verinfo, 3, qcdm_verinfo_cb, NULL);
mm_qcdm_serial_port_queue_command (priv->qcdm_port, verinfo2, 3, qcdm_verinfo_cb, task);
}
static void
at_sequence_context_free (AtSequenceContext *ctx)
{
mm_serial_port_close (MM_SERIAL_PORT (ctx->port));
g_object_unref (ctx->port);
g_object_unref (ctx->self);
if (ctx->response_processor_context &&
ctx->response_processor_context_free)
ctx->response_processor_context_free (ctx->response_processor_context);
if (ctx->cancelled_id)
g_cancellable_disconnect (ctx->modem_cancellable,
ctx->cancelled_id);
if (ctx->user_cancellable)
g_object_unref (ctx->user_cancellable);
g_object_unref (ctx->modem_cancellable);
g_object_unref (ctx->cancellable);
if (ctx->result)
g_variant_unref (ctx->result);
if (ctx->simple)
g_object_unref (ctx->simple);
g_free (ctx);
}
static void
custom_init_response (MMAtSerialPort *port,
GString *response,
GError *error,
gpointer user_data)
{
MMPluginBaseSupportsTask *task = MM_PLUGIN_BASE_SUPPORTS_TASK (user_data);
MMPluginBaseSupportsTaskPrivate *task_priv = MM_PLUGIN_BASE_SUPPORTS_TASK_GET_PRIVATE (task);
if (error) {
task_priv->custom_init_tries++;
if (task_priv->custom_init_tries < task_priv->custom_init_max_tries) {
/* Try the custom command again */
flash_done (MM_SERIAL_PORT (port), NULL, user_data);
return;
} else if (task_priv->custom_init_fail_if_timeout) {
/* Fail the probe if the plugin wanted it and the command timed out */
if (g_error_matches (error, MM_SERIAL_ERROR, MM_SERIAL_ERROR_RESPONSE_TIMEOUT)) {
probe_complete (task);
return;
}
}
}
/* Otherwise proceed to probing */
mm_at_serial_port_queue_command (port, "+GCAP", 3, parse_response, user_data);
}
static void
port_buffer_full (MMSerialPort *port, GByteArray *buffer, gpointer user_data)
{
MMPluginBaseSupportsTask *task = MM_PLUGIN_BASE_SUPPORTS_TASK (user_data);
MMPluginBaseSupportsTaskPrivate *priv = MM_PLUGIN_BASE_SUPPORTS_TASK_GET_PRIVATE (user_data);
const char **iter;
size_t iter_len;
int i;
/* Check for an immediate disqualification response. There are some
* ports (Option Icera-based chipsets have them, as do Qualcomm Gobi
* devices before their firmware is loaded) that just shouldn't be
* probed if we get a certain response because we know they can't be
* used. Kernel bugs (at least with 2.6.31 and 2.6.32) also trigger port
* flow control kernel oopses if we read too much data for these ports.
*/
for (iter = &dq_strings[0]; iter && *iter; iter++) {
/* Search in the response for the item; the response could have embedded
* nulls so we can't use memcmp() or strstr() on the whole response.
*/
iter_len = strlen (*iter);
for (i = 0; i < buffer->len - iter_len; i++) {
if (!memcmp (&buffer->data[i], *iter, iter_len)) {
/* Immediately close the port and complete probing */
priv->probed_caps = 0;
mm_serial_port_close (MM_SERIAL_PORT (priv->probe_port));
probe_complete (task);
return;
}
}
}
}
static gboolean
try_open (gpointer user_data)
{
MMPluginBaseSupportsTask *task = MM_PLUGIN_BASE_SUPPORTS_TASK (user_data);
MMPluginBaseSupportsTaskPrivate *task_priv = MM_PLUGIN_BASE_SUPPORTS_TASK_GET_PRIVATE (task);
GError *error = NULL;
task_priv->open_id = 0;
if (!mm_serial_port_open (MM_SERIAL_PORT (task_priv->probe_port), &error)) {
if (++task_priv->open_tries > 4) {
/* took too long to open the port; give up */
g_warning ("(%s): failed to open after 4 tries.",
mm_port_get_device (MM_PORT (task_priv->probe_port)));
probe_complete (task);
} else if (g_error_matches (error,
MM_SERIAL_ERROR,
MM_SERIAL_ERROR_OPEN_FAILED_NO_DEVICE)) {
/* this is nozomi being dumb; try again */
task_priv->open_id = g_timeout_add_seconds (1, try_open, task);
} else {
/* some other hard error */
probe_complete (task);
}
g_clear_error (&error);
} else {
/* success, start probing */
GUdevDevice *port;
port = mm_plugin_base_supports_task_get_port (task);
g_assert (port);
task_priv->full_id = g_signal_connect (task_priv->probe_port, "buffer-full",
G_CALLBACK (port_buffer_full), task);
g_debug ("(%s): probe requested by plugin '%s'",
g_udev_device_get_name (port),
mm_plugin_get_name (MM_PLUGIN (task_priv->plugin)));
mm_serial_port_flash (MM_SERIAL_PORT (task_priv->probe_port), 100, TRUE, flash_done, task);
}
return FALSE;
}
static gboolean
abort_async_if_port_unusable (MMBaseModem *self,
MMAtSerialPort *port,
GAsyncReadyCallback callback,
gpointer user_data)
{
GError *error = NULL;
/* If no port given, probably the port dissapeared */
if (!port) {
g_simple_async_report_error_in_idle (
G_OBJECT (self),
callback,
user_data,
MM_CORE_ERROR,
MM_CORE_ERROR_NOT_FOUND,
"Cannot run sequence: port not given");
return FALSE;
}
/* Ensure we don't try to use a connected port */
if (mm_port_get_connected (MM_PORT (port))) {
g_simple_async_report_error_in_idle (
G_OBJECT (self),
callback,
user_data,
MM_CORE_ERROR,
MM_CORE_ERROR_CONNECTED,
"Cannot run sequence: port is connected");
return FALSE;
}
/* Ensure we have a port open during the sequence */
if (!mm_serial_port_open (MM_SERIAL_PORT (port), &error)) {
g_simple_async_report_error_in_idle (
G_OBJECT (self),
callback,
user_data,
MM_CORE_ERROR,
MM_CORE_ERROR_CONNECTED,
"Cannot run sequence: '%s'",
error->message);
g_error_free (error);
return FALSE;
}
return TRUE;
}
static void
at_command_context_free (AtCommandContext *ctx)
{
mm_serial_port_close (MM_SERIAL_PORT (ctx->port));
if (ctx->cancelled_id)
g_cancellable_disconnect (ctx->modem_cancellable,
ctx->cancelled_id);
if (ctx->user_cancellable)
g_object_unref (ctx->user_cancellable);
g_object_unref (ctx->modem_cancellable);
g_object_unref (ctx->cancellable);
g_object_unref (ctx->port);
g_object_unref (ctx->result);
g_object_unref (ctx->self);
g_free (ctx);
}
void
mm_at_serial_port_queue_command_cached (MMAtSerialPort *self,
const char *command,
guint32 timeout_seconds,
MMAtSerialResponseFn callback,
gpointer user_data)
{
GByteArray *buf;
g_return_if_fail (self != NULL);
g_return_if_fail (MM_IS_AT_SERIAL_PORT (self));
g_return_if_fail (command != NULL);
buf = at_command_to_byte_array (command);
g_return_if_fail (buf != NULL);
mm_serial_port_queue_command_cached (MM_SERIAL_PORT (self),
buf,
TRUE,
timeout_seconds,
(MMSerialResponseFn) callback,
user_data);
}
static gboolean
serial_open_at (MMPortProbe *self)
{
PortProbeRunTask *task = self->priv->task;
GError *error = NULL;
task->source_id = 0;
/* If already cancelled, do nothing else */
if (port_probe_run_is_cancelled (self))
return FALSE;
/* Create AT serial port if not done before */
if (!task->serial) {
task->serial = MM_SERIAL_PORT (mm_at_serial_port_new (self->priv->name));
if (!task->serial) {
port_probe_run_task_complete (
task,
FALSE,
g_error_new (MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"(%s) couldn't create AT port",
self->priv->name));
return FALSE;
}
g_object_set (task->serial,
MM_SERIAL_PORT_SEND_DELAY, task->at_send_delay,
MM_PORT_CARRIER_DETECT, FALSE,
MM_SERIAL_PORT_SPEW_CONTROL, TRUE,
NULL);
mm_at_serial_port_set_response_parser (MM_AT_SERIAL_PORT (task->serial),
mm_serial_parser_v1_parse,
mm_serial_parser_v1_new (),
mm_serial_parser_v1_destroy);
}
/* Try to open the port */
if (!mm_serial_port_open (task->serial, &error)) {
/* Abort if maximum number of open tries reached */
if (++task->at_open_tries > 4) {
/* took too long to open the port; give up */
port_probe_run_task_complete (
task,
FALSE,
g_error_new (MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"(%s) failed to open port after 4 tries",
self->priv->name));
} else if (g_error_matches (error,
MM_SERIAL_ERROR,
MM_SERIAL_ERROR_OPEN_FAILED_NO_DEVICE)) {
/* this is nozomi being dumb; try again */
task->source_id = g_timeout_add_seconds (1,
(GSourceFunc)serial_open_at,
self);
} else {
port_probe_run_task_complete (
task,
FALSE,
g_error_new (MM_SERIAL_ERROR,
MM_SERIAL_ERROR_OPEN_FAILED,
"(%s) failed to open port: %s",
self->priv->name,
(error ? error->message : "unknown error")));
}
g_clear_error (&error);
return FALSE;
}
/* success, start probing */
task->buffer_full_id = g_signal_connect (task->serial,
"buffer-full",
G_CALLBACK (serial_buffer_full),
self);
mm_serial_port_flash (MM_SERIAL_PORT (task->serial),
100,
TRUE,
(MMSerialFlashFn)serial_flash_done,
self);
return FALSE;
}
static gboolean
serial_probe_qcdm (MMPortProbe *self)
{
PortProbeRunTask *task = self->priv->task;
GError *error = NULL;
GByteArray *verinfo = NULL;
GByteArray *verinfo2;
gint len;
task->source_id = 0;
/* If already cancelled, do nothing else */
if (port_probe_run_is_cancelled (self))
return FALSE;
mm_dbg ("(%s) probing QCDM...", self->priv->name);
/* If open, close the AT port */
if (task->serial) {
mm_serial_port_close (task->serial);
g_object_unref (task->serial);
}
/* Open the QCDM port */
task->serial = MM_SERIAL_PORT (mm_qcdm_serial_port_new (self->priv->name));
if (!task->serial) {
port_probe_run_task_complete (
task,
FALSE,
g_error_new (MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"(%s) Couldn't create QCDM port",
self->priv->name));
return FALSE;
}
/* Try to open the port */
if (!mm_serial_port_open (task->serial, &error)) {
port_probe_run_task_complete (
task,
FALSE,
g_error_new (MM_SERIAL_ERROR,
MM_SERIAL_ERROR_OPEN_FAILED,
"(%s) Failed to open QCDM port: %s",
self->priv->name,
(error ? error->message : "unknown error")));
g_clear_error (&error);
return FALSE;
}
/* Build up the probe command */
verinfo = g_byte_array_sized_new (50);
len = qcdm_cmd_version_info_new ((gchar *) verinfo->data, 50);
if (len <= 0) {
g_byte_array_free (verinfo, TRUE);
port_probe_run_task_complete (
task,
FALSE,
g_error_new (MM_SERIAL_ERROR,
MM_SERIAL_ERROR_OPEN_FAILED,
"(%s) Failed to create QCDM versin info command",
self->priv->name));
return FALSE;
}
verinfo->len = len;
/* Queuing the command takes ownership over it; dup it for the second try */
verinfo2 = g_byte_array_sized_new (verinfo->len);
g_byte_array_append (verinfo2, verinfo->data, verinfo->len);
/* Send the command twice; the ports often need to be woken up */
mm_qcdm_serial_port_queue_command (MM_QCDM_SERIAL_PORT (task->serial),
verinfo,
3,
NULL,
(MMQcdmSerialResponseFn)serial_probe_qcdm_parse_response,
NULL);
mm_qcdm_serial_port_queue_command (MM_QCDM_SERIAL_PORT (task->serial),
verinfo2,
3,
NULL,
(MMQcdmSerialResponseFn)serial_probe_qcdm_parse_response,
self);
return FALSE;
}
static gboolean
serial_probe_qcdm (MMPortProbe *self)
{
PortProbeRunTask *task = self->priv->task;
GError *error = NULL;
GByteArray *verinfo = NULL;
GByteArray *verinfo2;
gint len;
guint8 marker = 0x7E;
task->source_id = 0;
/* If already cancelled, do nothing else */
if (port_probe_run_is_cancelled (self))
return FALSE;
mm_dbg ("(%s/%s) probing QCDM...",
g_udev_device_get_subsystem (self->priv->port),
g_udev_device_get_name (self->priv->port));
/* If open, close the AT port */
if (task->serial) {
mm_serial_port_close (task->serial);
g_object_unref (task->serial);
}
/* Open the QCDM port */
task->serial = MM_SERIAL_PORT (mm_qcdm_serial_port_new (g_udev_device_get_name (self->priv->port)));
if (!task->serial) {
port_probe_run_task_complete (
task,
FALSE,
g_error_new (MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"(%s/%s) Couldn't create QCDM port",
g_udev_device_get_subsystem (self->priv->port),
g_udev_device_get_name (self->priv->port)));
return FALSE;
}
/* Try to open the port */
if (!mm_serial_port_open (task->serial, &error)) {
port_probe_run_task_complete (
task,
FALSE,
g_error_new (MM_SERIAL_ERROR,
MM_SERIAL_ERROR_OPEN_FAILED,
"(%s/%s) Failed to open QCDM port: %s",
g_udev_device_get_subsystem (self->priv->port),
g_udev_device_get_name (self->priv->port),
(error ? error->message : "unknown error")));
g_clear_error (&error);
return FALSE;
}
/* Build up the probe command; 0x7E is the frame marker, so put one at the
* beginning of the buffer to ensure that the device discards any AT
* commands that probing might have sent earlier. Should help devices
* respond more quickly and speed up QCDM probing.
*/
verinfo = g_byte_array_sized_new (10);
g_byte_array_append (verinfo, &marker, 1);
len = qcdm_cmd_version_info_new ((char *) (verinfo->data + 1), 9);
if (len <= 0) {
g_byte_array_free (verinfo, TRUE);
port_probe_run_task_complete (
task,
FALSE,
g_error_new (MM_SERIAL_ERROR,
MM_SERIAL_ERROR_OPEN_FAILED,
"(%s/%s) Failed to create QCDM versin info command",
g_udev_device_get_subsystem (self->priv->port),
g_udev_device_get_name (self->priv->port)));
return FALSE;
}
verinfo->len = len + 1;
/* Queuing the command takes ownership over it; save it for the second try */
verinfo2 = g_byte_array_sized_new (verinfo->len);
g_byte_array_append (verinfo2, verinfo->data, verinfo->len);
g_object_set_data_full (G_OBJECT (self), "cmd2", verinfo2, (GDestroyNotify) g_byte_array_unref);
mm_qcdm_serial_port_queue_command (MM_QCDM_SERIAL_PORT (task->serial),
verinfo,
3,
NULL,
(MMQcdmSerialResponseFn)serial_probe_qcdm_parse_response,
self);
return FALSE;
}
