colin/ModemManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

port-serial: use GIO Async API like method for reopen()

Browse Source
This commit is contained in:
Aleksander Morgado
2013-11-17 14:13:50 +01:00
parent d4dfd661b9
commit 6e35f0a888
3 changed files with 117 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/mm-broadband-bearer.c
View File

@@ -1362,12 +1362,14 @@ data_flash_cdma_ready (MMPortSerial *data,
static void static void
data_reopen_cdma_ready (MMPortSerial *data, data_reopen_cdma_ready (MMPortSerial *data,
GError *error, GAsyncResult *res,
DetailedDisconnectContext *ctx) DetailedDisconnectContext *ctx)
{ {
if (error) { GError *error = NULL;
if (!mm_port_serial_reopen_finish (data, res, &error)) {
/* Fatal */ /* Fatal */
g_simple_async_result_set_from_error (ctx->result, error); g_simple_async_result_take_error (ctx->result, error);
detailed_disconnect_context_complete_and_free (ctx); detailed_disconnect_context_complete_and_free (ctx);
return; return;
} }
@@ -1409,7 +1411,7 @@ disconnect_cdma (MMBroadbandBearer *self,
mm_dbg ("Reopening data port (%s)...", mm_port_get_device (MM_PORT (ctx->data))); mm_dbg ("Reopening data port (%s)...", mm_port_get_device (MM_PORT (ctx->data)));
mm_port_serial_reopen (MM_PORT_SERIAL (ctx->data), mm_port_serial_reopen (MM_PORT_SERIAL (ctx->data),
1000, 1000,
(MMSerialReopenFn)data_reopen_cdma_ready, (GAsyncReadyCallback)data_reopen_cdma_ready,
ctx); ctx);
} }
@@ -1490,12 +1492,14 @@ data_flash_3gpp_ready (MMPortSerial *data,
static void static void
data_reopen_3gpp_ready (MMPortSerial *data, data_reopen_3gpp_ready (MMPortSerial *data,
GError *error, GAsyncResult *res,
DetailedDisconnectContext *ctx) DetailedDisconnectContext *ctx)
{ {
if (error) { GError *error = NULL;
if (!mm_port_serial_reopen_finish (data, res, &error)) {
/* Fatal */ /* Fatal */
g_simple_async_result_set_from_error (ctx->result, error); g_simple_async_result_take_error (ctx->result, error);
detailed_disconnect_context_complete_and_free (ctx); detailed_disconnect_context_complete_and_free (ctx);
return; return;
} }
@@ -1516,7 +1520,7 @@ data_reopen_3gpp (DetailedDisconnectContext *ctx)
mm_dbg ("Reopening data port (%s)...", mm_port_get_device (MM_PORT (ctx->data))); mm_dbg ("Reopening data port (%s)...", mm_port_get_device (MM_PORT (ctx->data)));
mm_port_serial_reopen (MM_PORT_SERIAL (ctx->data), mm_port_serial_reopen (MM_PORT_SERIAL (ctx->data),
1000, 1000,
(MMSerialReopenFn)data_reopen_3gpp_ready, (GAsyncReadyCallback)data_reopen_3gpp_ready,
ctx); ctx);
} }

161
src/mm-port-serial.c
View File

@@ -35,7 +35,8 @@
#include "mm-log.h" #include "mm-log.h"
static gboolean mm_port_serial_queue_process (gpointer data); static gboolean mm_port_serial_queue_process (gpointer data);
static void mm_port_serial_close_force (MMPortSerial *self); static void port_serial_close_force (MMPortSerial *self);
static void port_serial_reopen_cancel (MMPortSerial *self);
G_DEFINE_TYPE (MMPortSerial, mm_port_serial, MM_TYPE_PORT) G_DEFINE_TYPE (MMPortSerial, mm_port_serial, MM_TYPE_PORT)
@@ -98,8 +99,9 @@ typedef struct {
guint n_consecutive_timeouts; guint n_consecutive_timeouts;
guint flash_id; guint flash_id;
guint reopen_id;
guint connected_id; guint connected_id;
gpointer reopen_ctx;
} MMPortSerialPrivate; } MMPortSerialPrivate;
typedef struct { typedef struct {
@@ -753,7 +755,7 @@ data_available (GIOChannel *source,
if (priv->response->len) if (priv->response->len)
g_byte_array_remove_range (priv->response, 0, priv->response->len); g_byte_array_remove_range (priv->response, 0, priv->response->len);
mm_port_serial_close_force (self); port_serial_close_force (self);
return FALSE; return FALSE;
} }
@@ -884,7 +886,7 @@ mm_port_serial_open (MMPortSerial *self, GError **error)
return FALSE; return FALSE;
} }
if (priv->reopen_id) { if (priv->reopen_ctx) {
g_set_error (error, g_set_error (error,
MM_SERIAL_ERROR, MM_SERIAL_ERROR,
MM_SERIAL_ERROR_OPEN_FAILED, MM_SERIAL_ERROR_OPEN_FAILED,
@@ -1132,7 +1134,7 @@ mm_port_serial_close (MMPortSerial *self)
} }
static void static void
mm_port_serial_close_force (MMPortSerial *self) port_serial_close_force (MMPortSerial *self)
{ {
MMPortSerialPrivate *priv; MMPortSerialPrivate *priv;
@@ -1148,9 +1150,12 @@ mm_port_serial_close_force (MMPortSerial *self)
mm_dbg ("(%s) forced to close port", mm_port_get_device (MM_PORT (self))); mm_dbg ("(%s) forced to close port", mm_port_get_device (MM_PORT (self)));
/* If already closed, done */ /* If already closed, done */
if (!priv->open_count) if (!priv->open_count && !priv->reopen_ctx)
return; return;
/* Cancel port reopening if one is running */
port_serial_reopen_cancel (self);
/* Force the port to close */ /* Force the port to close */
priv->open_count = 1; priv->open_count = 1;
mm_port_serial_close (self); mm_port_serial_close (self);
@@ -1243,108 +1248,142 @@ mm_port_serial_queue_command_cached (MMPortSerial *self,
internal_queue_command (self, command, take_command, TRUE, timeout_seconds, cancellable, callback, user_data); internal_queue_command (self, command, take_command, TRUE, timeout_seconds, cancellable, callback, user_data);
} }
/*****************************************************************************/
/* Reopen */
typedef struct { typedef struct {
MMPortSerial *port; MMPortSerial *self;
GSimpleAsyncResult *result;
guint initial_open_count; guint initial_open_count;
MMSerialReopenFn callback; guint reopen_id;
gpointer user_data; } ReopenContext;
} ReopenInfo;
static void
reopen_context_complete_and_free (ReopenContext *ctx)
{
if (ctx->reopen_id)
g_source_remove (ctx->reopen_id);
g_simple_async_result_complete_in_idle (ctx->result);
g_object_unref (ctx->result);
g_object_unref (ctx->self);
g_slice_free (ReopenContext, ctx);
}
gboolean
mm_port_serial_reopen_finish (MMPortSerial *port,
GAsyncResult *res,
GError **error)
{
return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error);
}
static void static void
port_serial_reopen_cancel (MMPortSerial *self) port_serial_reopen_cancel (MMPortSerial *self)
{ {
MMPortSerialPrivate *priv; MMPortSerialPrivate *priv;
ReopenContext *ctx;
g_return_if_fail (MM_IS_PORT_SERIAL (self));
priv = MM_PORT_SERIAL_GET_PRIVATE (self); priv = MM_PORT_SERIAL_GET_PRIVATE (self);
if (!priv->reopen_ctx)
return;
if (priv->reopen_id > 0) { /* Recover context */
g_source_remove (priv->reopen_id); ctx = (ReopenContext *)priv->reopen_ctx;
priv->reopen_id = 0; priv->reopen_ctx = NULL;
}
g_simple_async_result_set_error (ctx->result,
MM_CORE_ERROR,
MM_CORE_ERROR_CANCELLED,
"Reopen cancelled");
reopen_context_complete_and_free (ctx);
} }
static gboolean static gboolean
reopen_do (gpointer data) reopen_do (MMPortSerial *self)
{ {
ReopenInfo *info = (ReopenInfo *) data; MMPortSerialPrivate *priv = MM_PORT_SERIAL_GET_PRIVATE (self);
MMPortSerialPrivate *priv = MM_PORT_SERIAL_GET_PRIVATE (info->port); ReopenContext *ctx;
GError *error = NULL; GError *error = NULL;
guint i; guint i;
priv->reopen_id = 0; /* Recover context */
g_assert (priv->reopen_ctx != NULL);
ctx = (ReopenContext *)priv->reopen_ctx;
priv->reopen_ctx = NULL;
for (i = 0; i < info->initial_open_count; i++) { ctx->reopen_id = 0;
if (!mm_port_serial_open (info->port, &error)) {
for (i = 0; i < ctx->initial_open_count; i++) {
if (!mm_port_serial_open (ctx->self, &error)) {
g_prefix_error (&error, "Couldn't reopen port (%u): ", i); g_prefix_error (&error, "Couldn't reopen port (%u): ", i);
break; break;
} }
} }
info->callback (info->port, error, info->user_data);
if (error) if (error)
g_error_free (error); g_simple_async_result_take_error (ctx->result, error);
g_slice_free (ReopenInfo, info); else
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
reopen_context_complete_and_free (ctx);
return FALSE; return FALSE;
} }
gboolean void
mm_port_serial_reopen (MMPortSerial *self, mm_port_serial_reopen (MMPortSerial *self,
guint32 reopen_time, guint32 reopen_time,
MMSerialReopenFn callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
ReopenInfo *info; ReopenContext *ctx;
MMPortSerialPrivate *priv; MMPortSerialPrivate *priv;
guint i; guint i;
g_return_val_if_fail (MM_IS_PORT_SERIAL (self), FALSE); g_return_if_fail (MM_IS_PORT_SERIAL (self));
priv = MM_PORT_SERIAL_GET_PRIVATE (self); priv = MM_PORT_SERIAL_GET_PRIVATE (self);
/* Setup context */
ctx = g_slice_new0 (ReopenContext);
ctx->self = g_object_ref (self);
ctx->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
mm_port_serial_reopen);
ctx->initial_open_count = priv->open_count;
if (priv->forced_close) { if (priv->forced_close) {
GError *error; g_simple_async_result_set_error (ctx->result,
MM_CORE_ERROR,
error = g_error_new_literal (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
MM_CORE_ERROR_FAILED, "Serial port has been forced close.");
"Serial port has been forced close."); reopen_context_complete_and_free (ctx);
callback (self, error, user_data); return;
g_error_free (error);
return FALSE;
} }
if (priv->reopen_id > 0) { /* If already reopening, halt */
GError *error; if (priv->reopen_ctx) {
g_simple_async_result_set_error (ctx->result,
error = g_error_new_literal (MM_CORE_ERROR, MM_CORE_ERROR,
MM_CORE_ERROR_IN_PROGRESS, MM_CORE_ERROR_IN_PROGRESS,
"Modem is already being reopened."); "Modem is already being reopened");
callback (self, error, user_data); reopen_context_complete_and_free (ctx);
g_error_free (error); return;
return FALSE;
} }
info = g_slice_new0 (ReopenInfo);
info->port = self;
info->callback = callback;
info->user_data = user_data;
priv = MM_PORT_SERIAL_GET_PRIVATE (self);
info->initial_open_count = priv->open_count;
mm_dbg ("(%s) reopening port (%u)", mm_dbg ("(%s) reopening port (%u)",
mm_port_get_device (MM_PORT (self)), mm_port_get_device (MM_PORT (self)),
info->initial_open_count); ctx->initial_open_count);
for (i = 0; i < info->initial_open_count; i++) for (i = 0; i < ctx->initial_open_count; i++)
mm_port_serial_close (self); mm_port_serial_close (self);
if (reopen_time > 0) if (reopen_time > 0)
priv->reopen_id = g_timeout_add (reopen_time, reopen_do, info); ctx->reopen_id = g_timeout_add (reopen_time, (GSourceFunc)reopen_do, self);
else else
priv->reopen_id = g_idle_add (reopen_do, info); ctx->reopen_id = g_idle_add ((GSourceFunc)reopen_do, self);
return TRUE; /* Store context in private info */
priv->reopen_ctx = ctx;
} }
static gboolean static gboolean
@@ -1706,9 +1745,7 @@ dispose (GObject *object)
priv->timeout_id = 0; priv->timeout_id = 0;
} }
mm_port_serial_close_force (MM_PORT_SERIAL (object)); port_serial_close_force (MM_PORT_SERIAL (object));
port_serial_reopen_cancel (MM_PORT_SERIAL (object));
mm_port_serial_flash_cancel (MM_PORT_SERIAL (object)); mm_port_serial_flash_cancel (MM_PORT_SERIAL (object));
G_OBJECT_CLASS (mm_port_serial_parent_class)->dispose (object); G_OBJECT_CLASS (mm_port_serial_parent_class)->dispose (object);

12
src/mm-port-serial.h
View File

@@ -43,10 +43,6 @@
typedef struct _MMPortSerial MMPortSerial; typedef struct _MMPortSerial MMPortSerial;
typedef struct _MMPortSerialClass MMPortSerialClass; typedef struct _MMPortSerialClass MMPortSerialClass;
typedef void (*MMSerialReopenFn) (MMPortSerial *port,
GError *error,
gpointer user_data);
typedef void (*MMSerialFlashFn) (MMPortSerial *port, typedef void (*MMSerialFlashFn) (MMPortSerial *port,
GError *error, GError *error,
gpointer user_data); gpointer user_data);
@@ -126,10 +122,14 @@ gboolean mm_port_serial_open (MMPortSerial *self,
void mm_port_serial_close (MMPortSerial *self); void mm_port_serial_close (MMPortSerial *self);
gboolean mm_port_serial_reopen (MMPortSerial *self, /* Reopen(), async */
void mm_port_serial_reopen (MMPortSerial *self,
guint32 reopen_time, guint32 reopen_time,
MMSerialReopenFn callback, GAsyncReadyCallback callback,
gpointer user_data); gpointer user_data);
gboolean mm_port_serial_reopen_finish (MMPortSerial *port,
GAsyncResult *res,
GError **error);
gboolean mm_port_serial_flash (MMPortSerial *self, gboolean mm_port_serial_flash (MMPortSerial *self,
guint32 flash_time, guint32 flash_time,