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 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 port_probe_run_task_free (PortProbeRunTask *task) { if (task->source_id) g_source_remove (task->source_id); if (task->buffer_full_id) g_source_remove (task->buffer_full_id); if (task->serial) { if (mm_serial_port_is_open (task->serial)) mm_serial_port_close (task->serial); g_object_unref (task->serial); } #if defined WITH_QMI if (task->qmi_port) { if (mm_qmi_port_is_open (task->qmi_port)) mm_qmi_port_close (task->qmi_port); g_object_unref (task->qmi_port); } #endif if (task->cancellable) g_object_unref (task->cancellable); if (task->at_probing_cancellable) g_object_unref (task->at_probing_cancellable); g_object_unref (task->result); g_free (task); }
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 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 serial_buffer_full (MMSerialPort *serial, GByteArray *buffer, PortProbeRunTask *task) { const gchar **iter; size_t iter_len; int i; /* Some devices (observed on a ZTE branded "QUALCOMM INCORPORATED" model * "154") spew NULLs from some ports. */ if ( (buffer->len >= sizeof (zerobuf)) && (memcmp (buffer->data, zerobuf, sizeof (zerobuf)) == 0)) { mm_serial_port_close (serial); port_probe_run_task_complete (task, FALSE, NULL); return; } /* 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 */ mm_serial_port_close (serial); port_probe_run_task_complete (task, FALSE, NULL); return; } } } }
static void serial_buffer_full (MMSerialPort *serial, GByteArray *buffer, MMPortProbe *self) { if (is_non_at_response (buffer->data, buffer->len)) { mm_serial_port_close (serial); mm_port_probe_set_result_at (self, FALSE); serial_probe_schedule (self); } }
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); }
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; }