Skip to content
Permalink
master
Switch branches/tags
Go to file
 
 
Cannot retrieve contributors at this time
/**
* @file mce-hbtimer.c
*
* Mode Control Entity - Suspend proof timer functionality
*
* <p>
*
* Copyright (C) 2014-2015 Jolla Ltd.
*
* <p>
*
* @author Simo Piiroinen <simo.piiroinen@jollamobile.com>
*
* mce is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License
* version 2.1 as published by the Free Software Foundation.
*
* mce is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with mce. If not, see <http://www.gnu.org/licenses/>.
*/
#include "mce-hbtimer.h"
#include "mce.h"
#include "mce-log.h"
#include "mce-lib.h"
#ifdef ENABLE_WAKELOCKS
# include "libwakelock.h"
#endif
#include <sys/socket.h>
#include <stdlib.h>
#include <inttypes.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <iphbd/libiphb.h>
/* ========================================================================= *
* Types and functions
* ========================================================================= */
/* ------------------------------------------------------------------------- *
* TIMER_METHODS
* ------------------------------------------------------------------------- */
/** State data for mce heartbeat timers */
struct mce_hbtimer_t
{
/** Timer name, used for debug logging purposes */
char *hbt_name;
/** Trigger time, milliseconds in CLOCK_BOOTTIME base */
int64_t hbt_trigger;
/** Timer callback function */
GSourceFunc hbt_notify;
/** Timer delay in milliseconds */
int hbt_period;
/** Flag for: control within hbt_notify() */
bool hbt_in_notify;
/** User data to pass to hbt_notify() */
void *hbt_user_data;
};
mce_hbtimer_t * mce_hbtimer_create (const char *name, int period, GSourceFunc notify, void *user_data);
void mce_hbtimer_delete (mce_hbtimer_t *self);
bool mce_hbtimer_is_active (const mce_hbtimer_t *self);
const char *mce_hbtimer_get_name (const mce_hbtimer_t *self);
void mce_hbtimer_set_period (mce_hbtimer_t *self, int period);
void mce_hbtimer_start (mce_hbtimer_t *self);
void mce_hbtimer_stop (mce_hbtimer_t *self);
static void mce_hbtimer_notify (mce_hbtimer_t *self);
static void mce_hbtimer_set_trigger (mce_hbtimer_t *self, int64_t trigger);
/* ------------------------------------------------------------------------- *
* GENERIC_UTILITIES
* ------------------------------------------------------------------------- */
/** Monotonic tick value used to signify "not-set" */
#define NO_TICK INT64_MAX
static guint mht_add_iowatch (int fd, bool close_on_unref, GIOCondition cnd, GIOFunc io_cb, gpointer aptr);
/* ------------------------------------------------------------------------- *
* QUEUE_MANAGEMENT
* ------------------------------------------------------------------------- */
/** List of registered timers */
static GSList *mht_queue_timer_list = 0;
void mht_queue_dispatch_timers (void);
static void mht_queue_schedule_wakeups (void);
static void mht_queue_garbage_collect (void);
static void mht_queue_add_timer (mce_hbtimer_t *self);
static void mht_queue_remove_timer (mce_hbtimer_t *self);
static bool mht_queue_has_timer (const mce_hbtimer_t *self);
/* ------------------------------------------------------------------------- *
* GLIB_WAKEUPS
* ------------------------------------------------------------------------- */
/** Source ID for currently active glib timer wakeup */
static guint mce_hbtimer_glib_wait_id = 0;
static gboolean mht_glib_wakeup_cb (gpointer aptr);
static void mht_glib_set_wakeup (int64_t trigger, int64_t now);
/* ------------------------------------------------------------------------- *
* IPHB_WAKEUPS
* ------------------------------------------------------------------------- */
/** How much wakeups from suspend can be delayed [s]
*
* To increase changes of aligning with other iphb wakeups this
* should be >= heartbeat period (=12 seconds) */
#define MHT_IPHB_WAKEUP_MAX_DELAY_S 12
/** Cached timestamp of last requested iphb wakeup */
static int64_t mht_iphb_wakeup_tick = NO_TICK;
/** Source id for iphb wakeup input watch */
static guint mht_iphb_wakeup_watch_id = 0;
static gboolean mht_iphb_wakeup_cb (GIOChannel *chn, GIOCondition cnd, gpointer data);
static void mht_iphb_set_wakeup (int64_t trigger, int64_t now);
/* ------------------------------------------------------------------------- *
* IPHB_CONNECTION
* ------------------------------------------------------------------------- */
/** Number of times iphb connect is attempted after dsme startup */
#define MHT_CONNECTION_MAX_RETRIES 5
/** Delay between iphb connect attempts [ms] */
#define MHT_CONNECTION_RETRY_DELAY_MS 5000
/** Timer ID for: iphb connection attempts */
static guint mht_connection_timer_id = 0;
/** Number of connection attempts so far */
static gint mht_connection_retry_no = 0;
/** Handle for iphb connection */
static iphb_t mht_connection_handle = 0;
static bool mht_connection_try_to_open (void);
static gboolean mht_connection_timer_cb (gpointer aptr);
static bool mht_connection_is_pending (void);
static void mht_connection_start_timer (void);
static void mht_connection_stop_timer (void);
static void mht_connection_open (void);
static void mht_connection_close (void);
/* ------------------------------------------------------------------------- *
* DATAPIPE_HANDLERS
* ------------------------------------------------------------------------- */
/** Availability of dsme; from dsme_service_state_pipe */
static service_state_t dsme_service_state = SERVICE_STATE_UNDEF;
/** Device is shutting down; assume false */
static bool shutting_down = false;
static void mht_datapipe_dsme_service_state_cb (gconstpointer data);
static void mht_datapipe_resume_detected_event_cb (gconstpointer data);
static void mht_datapipe_shutting_down_cb (gconstpointer data);
static void mht_datapipe_init(void);
static void mht_datapipe_quit(void);
/* ------------------------------------------------------------------------- *
* MODULE_INIT
* ------------------------------------------------------------------------- */
/** Flag for: mce_hbtimer_init() has been called */
static bool mce_hbtimer_initialized = false;
void mce_hbtimer_init (void);
void mce_hbtimer_quit (void);
/* ========================================================================= *
* GENERIC_UTILITIES
* ========================================================================= */
/** Helper for creating I/O watch for file descriptor
*/
static guint
mht_add_iowatch(int fd, bool close_on_unref,
GIOCondition cnd, GIOFunc io_cb, gpointer aptr)
{
guint wid = 0;
GIOChannel *chn = 0;
if( !(chn = g_io_channel_unix_new(fd)) )
goto cleanup;
g_io_channel_set_close_on_unref(chn, close_on_unref);
cnd |= G_IO_ERR | G_IO_HUP | G_IO_NVAL;
if( !(wid = g_io_add_watch(chn, cnd, io_cb, aptr)) )
goto cleanup;
cleanup:
if( chn != 0 ) g_io_channel_unref(chn);
return wid;
}
/* ========================================================================= *
* TIMER_METHODS
* ========================================================================= */
/** Create heatbeat timer
*
* @param name timer name
* @param period timer delay [ms]
* @param notify function to be called when triggered
* @param user_data pointer to be passed to notify function
*
* @return heartbeat timer object
*/
mce_hbtimer_t *
mce_hbtimer_create(const char *name,
int period,
GSourceFunc notify,
void *user_data)
{
mce_hbtimer_t *self = calloc(1, sizeof *self);
self->hbt_name = name ? strdup(name) : 0;
self->hbt_notify = notify;
self->hbt_period = period;
self->hbt_user_data = user_data;
self->hbt_trigger = NO_TICK;
self->hbt_in_notify = false;
mht_queue_add_timer(self);
return self;
}
/** Delete heatbeat timer
*
* @param self heartbeat timer object, or NULL
*/
void
mce_hbtimer_delete(mce_hbtimer_t *self)
{
if( !self )
goto EXIT;
mht_queue_remove_timer(self);
mht_queue_schedule_wakeups();
free(self->hbt_name),
self->hbt_name = 0;
free(self);
EXIT:
return;
}
/** Predicate for: heatbeat timer has been started
*
* @param self heartbeat timer object, or NULL
*
* @return true if heartbeat timer has been started, false otherwise
*/
bool
mce_hbtimer_is_active(const mce_hbtimer_t *self)
{
bool active = false;
if( self )
active = (self->hbt_trigger < NO_TICK);
return active;
}
/** Get heatbeat timer name
*
* @param self heartbeat timer object, or NULL
*
* @return "invalid" if object is not valid,
* "unknown" if object has no name, or
* object name
*/
const char *
mce_hbtimer_get_name(const mce_hbtimer_t *self)
{
const char *name = "invalid";
if( self )
name = self->hbt_name;
return name ?: "unknown";
}
/** Set heatbeat timer period
*
* @param self heartbeat timer object, or NULL
* @param period timer delay [ms]
*/
void
mce_hbtimer_set_period(mce_hbtimer_t *self, int period)
{
if( self )
self->hbt_period = period;
}
/** Call heatbeat timer notification functiom
*
* @param self heartbeat timer object, or NULL
*/
static void
mce_hbtimer_notify(mce_hbtimer_t *self)
{
if( !self )
goto EXIT;
if( self->hbt_in_notify )
goto EXIT;
if( !self->hbt_notify )
goto EXIT;
self->hbt_in_notify = true;
self->hbt_trigger = NO_TICK;
bool again = self->hbt_notify(self->hbt_user_data);
/* Check that notify callback did not delete the timer */
if( !mht_queue_has_timer(self) )
goto EXIT;
self->hbt_in_notify = false;
if( again )
mce_hbtimer_start(self);
EXIT:
return;
}
/** Set heatbeat timer trigger time stamp
*
* @param self heartbeat timer object, or NULL
* @param trigger trigger time
*/
static void
mce_hbtimer_set_trigger(mce_hbtimer_t *self, int64_t trigger)
{
if( !self )
goto EXIT;
if( self->hbt_trigger == trigger )
goto EXIT;
self->hbt_trigger = trigger;
mht_queue_schedule_wakeups();
EXIT:
return;
}
/** Start heatbeat timer
*
* @param self heartbeat timer object, or NULL
*/
void
mce_hbtimer_start(mce_hbtimer_t *self)
{
if( !self )
goto EXIT;
mce_log(LL_DEBUG, "start %s %d", mce_hbtimer_get_name(self),
self->hbt_period);
int64_t now = mce_lib_get_boot_tick();
int64_t trigger = now + self->hbt_period;
mce_hbtimer_set_trigger(self, trigger);
EXIT:
return;
}
/** Stop heatbeat timer
*
* @param self heartbeat timer object, or NULL
*/
void
mce_hbtimer_stop(mce_hbtimer_t *self)
{
if( !self )
goto EXIT;
mce_log(LL_DEBUG, "stop %s", mce_hbtimer_get_name(self));
mce_hbtimer_set_trigger(self, NO_TICK);
mht_queue_schedule_wakeups();
EXIT:
return;
}
/* ========================================================================= *
* QUEUE_MANAGEMENT
* ========================================================================= */
/** Clean up unused timer list slots
*
* When timers are deleted, the associated node in mht_queue_timer_list
* is left in place with data pointer set to zero.
*
* This function can be used to remove such stale entries in suitable
* point outside the dispatch iteration loop.
*/
static void
mht_queue_garbage_collect(void)
{
GSList **tail = &mht_queue_timer_list;
GSList *item;
while( (item = *tail) ) {
if( item->data ) {
tail = &item->next;
}
else {
*tail = item->next;
item->next = 0;
g_slist_free(item);
}
}
}
/** Predicate for: heartbeat timer is registered
*
* @param self heartbeat timer object, or NULL
*
* return true if timer is registered, false otherwise
*/
static bool
mht_queue_has_timer(const mce_hbtimer_t *self)
{
bool has_timer = false;
if( !self )
goto EXIT;
has_timer = g_slist_find(mht_queue_timer_list, self) != 0;
EXIT:
return has_timer;
}
/** Register heartbeat timer
*
* @param self heartbeat timer object, or NULL
*/
static void
mht_queue_add_timer(mce_hbtimer_t *self)
{
if( !self )
goto EXIT;
/* Try to find recyclable vacated timer slot */
GSList *item = g_slist_find(mht_queue_timer_list, 0);
if( item )
item->data = self;
else
mht_queue_timer_list = g_slist_prepend(mht_queue_timer_list, self);
EXIT:
return;
}
/** Unregister heartbeat timer
*
* @param self heartbeat timer object, or NULL
*/
static void
mht_queue_remove_timer(mce_hbtimer_t *self)
{
if( !self )
goto EXIT;
GSList *item = g_slist_find(mht_queue_timer_list, self);
/* Vacate the slot by clearing the data link */
if( item )
item->data = 0;
EXIT:
return;
}
/** Scan registered heartbeat timers and schdule nearest wakeup
*/
static void
mht_queue_schedule_wakeups(void)
{
if( !mce_hbtimer_initialized )
goto EXIT;
int64_t trigger = NO_TICK;
bool compact = false;
for( GSList *item = mht_queue_timer_list; item; item = item->next ) {
mce_hbtimer_t *timer = item->data;
if( !timer )
compact = true;
else if( trigger > timer->hbt_trigger )
trigger = timer->hbt_trigger;
}
if( compact )
mht_queue_garbage_collect();
int64_t now = mce_lib_get_boot_tick();
if( trigger < now )
trigger = now;
mht_glib_set_wakeup(trigger, now);
mht_iphb_set_wakeup(trigger, now);
EXIT:
return;
}
/** Scan registered heartbeat timers and notify triggered ones
*/
void
mht_queue_dispatch_timers(void)
{
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
if( !mce_hbtimer_initialized )
goto EXIT;
/* We need to be sure that actions resulting from
* timer notifications do not cause recursive dispatching
* to take place. */
if( pthread_mutex_trylock(&mutex) != 0 )
goto EXIT;
/* Block suspend during dispatching */
#ifdef ENABLE_WAKELOCKS
wakelock_lock("mce_hbtimer_dispatch", -1);
#endif
int64_t now = mce_lib_get_boot_tick();
for( GSList *item = mht_queue_timer_list; item; item = item->next ) {
mce_hbtimer_t *timer = item->data;
if( !timer )
continue;
if( timer->hbt_trigger == NO_TICK )
continue;
mce_log(LL_DEBUG, "%s T%+"PRId64" ms",
mce_hbtimer_get_name(timer),
now - timer->hbt_trigger);
if( now < timer->hbt_trigger )
continue;
mce_hbtimer_notify(timer);
}
/* Check the next timer to trigger */
mht_queue_schedule_wakeups();
#ifdef ENABLE_WAKELOCKS
wakelock_unlock("mce_hbtimer_dispatch");
#endif
pthread_mutex_unlock(&mutex);
EXIT:
return;
}
/* ========================================================================= *
* GLIB_WAKEUPS
* ========================================================================= */
/** Glib timeout callback for dispatching heartbeat timers
*
* @param aptr (not used)
*
* @return FALSE to stop timeout from repeating
*/
static gboolean
mht_glib_wakeup_cb(gpointer aptr)
{
(void) aptr;
if( !mce_hbtimer_glib_wait_id )
goto EXIT;
mce_hbtimer_glib_wait_id = 0;
mce_log(LL_DEBUG, "glib wakeup; dispatch hbtimers");
mht_queue_dispatch_timers();
EXIT:
return FALSE;
}
/** Reprogram glib timeout for dispatching heartbeat timers
*
* @param trigger when to trigger
* @param now current time
*/
static void
mht_glib_set_wakeup(int64_t trigger, int64_t now)
{
static int64_t prev = NO_TICK;
int delay = -1;
/* The glib timers use CLOCK_MONOTONIC while we need to evaluate
* triggering in CLOCK_BOOTTIME.
*
* Assume glib reprogramming is cheap enough so that we do not need
* to try to avoid it.
*/
if( mce_hbtimer_glib_wait_id ) {
g_source_remove(mce_hbtimer_glib_wait_id),
mce_hbtimer_glib_wait_id = 0;
}
if( trigger != NO_TICK ) {
delay = (int)(trigger - now);
mce_hbtimer_glib_wait_id =
g_timeout_add(delay, mht_glib_wakeup_cb, 0);
}
if( prev != trigger ) {
prev = trigger;
mce_log(LL_DEBUG, "glib wakeup in %d ms", delay);
}
}
/* ========================================================================= *
* IPHB_WAKEUPS
* ========================================================================= */
/** iphb wakeup callback for dispatching heartbeat timers
*
* @param chn io channel
* @param cnd io condition
* @param data (unused)
*
* @return TRUE to keep io watch alive, or FALSE to disable it
*/
static gboolean
mht_iphb_wakeup_cb(GIOChannel *chn, GIOCondition cnd, gpointer data)
{
(void)data;
gboolean keep_going = FALSE;
if( !mht_iphb_wakeup_watch_id )
goto cleanup_nak;
int fd = g_io_channel_unix_get_fd(chn);
if( fd < 0 )
goto cleanup_nak;
if( cnd & ~G_IO_IN )
goto cleanup_nak;
if( !(cnd & G_IO_IN) )
goto cleanup_ack;
char buf[256];
int rc = recv(fd, buf, sizeof buf, MSG_DONTWAIT);
if( rc == 0 ) {
if( !shutting_down )
mce_log(LL_ERR, "unexpected eof");
goto cleanup_nak;
}
if( rc == -1 ) {
if( errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK )
goto cleanup_ack;
mce_log(LL_ERR, "read error: %m");
goto cleanup_nak;
}
if( mht_iphb_wakeup_tick == NO_TICK )
goto cleanup_ack;
/* clear programmed state */
mht_iphb_wakeup_tick = NO_TICK;
/* notify */
mce_log(LL_DEBUG, "iphb wakeup; dispatch hbtimers");
mht_queue_dispatch_timers();
cleanup_ack:
keep_going = TRUE;
cleanup_nak:
if( !keep_going ) {
mht_iphb_wakeup_watch_id = 0;
mht_connection_close();
}
return keep_going;
}
/** Reprogram iphb timeout for dispatching heartbeat timers
*
* @param trigger when to trigger
* @param now current time
*/
static void
mht_iphb_set_wakeup(int64_t trigger, int64_t now)
{
/* Assume: iphb timer should be stopped */
int lo = 0;
int hi = 0;
int64_t tick = NO_TICK;
if( mht_connection_handle && trigger != NO_TICK) {
/* Calculate the iphb wakeup range to be used. */
int64_t delay = (trigger - now + 999) / 1000;
lo = (int)delay;
hi = lo + MHT_IPHB_WAKEUP_MAX_DELAY_S;
/* Calculate the next full BOOTTIME second after low bound
* of iphb wakeup. This is used for avoiding constant iphb
* ipc when wakeups get re-evaluated.
*
* There might be up to one second jitter in actual wakeup
* vs cached time stamp, but it does not matter since:
* 1) the wide iphb range means the wake ups from suspend
* are going to be off by several seconds on average
* anyway
* 2) if the device does not get suspended, the higher
* resolution glib timeout gets triggered on time
*/
tick = now + delay * 1000;
tick += 999;
tick -= tick % 1000;
}
if( mht_iphb_wakeup_tick != tick ) {
mht_iphb_wakeup_tick = tick;
if( mht_connection_handle )
iphb_wait2(mht_connection_handle, lo, hi, 0, 1);
mce_log(LL_DEBUG, "iphb wakeup in [%d, %d] s", lo, hi);
}
}
/* ========================================================================= *
* IPHB_CONNECTION
* ========================================================================= */
/** Try to establish iphb socket connection
*
* Note: This is a helper function meant to be called only from
* mht_connection_open() and mht_connection_timer_cb()
* functions.
*
* @return true if connection is made, false otherwise
*/
static bool
mht_connection_try_to_open(void)
{
iphb_t handle = 0;
if( mht_connection_handle )
goto cleanup;
if( !(handle = iphb_open(0)) ) {
mce_log(LL_WARN, "iphb_open: %m");
goto cleanup;
}
int fd = iphb_get_fd(handle);
if( fd == -1 ) {
mce_log(LL_WARN, "iphb_get_fd: %m");
goto cleanup;
}
/* set up io watch */
mht_iphb_wakeup_watch_id =
mht_add_iowatch(fd, false, G_IO_IN, mht_iphb_wakeup_cb, 0);
if( !mht_iphb_wakeup_watch_id )
goto cleanup;
/* cache the handle */
mht_connection_handle = handle, handle = 0;
mce_log(LL_DEBUG, "iphb connected; dispatch hbtimers");
mht_queue_dispatch_timers();
cleanup:
if( handle ) iphb_close(handle);
return mht_connection_handle != 0;
}
/** Callback for connect reattempt timer
*
* @param aptr (unused)
*
* @return TRUE to keep timer repeating, or FALSE to stop it
*/
static gboolean
mht_connection_timer_cb(gpointer aptr)
{
(void)aptr;
if( !mht_connection_timer_id )
goto cleanup;
++mht_connection_retry_no;
if( !mht_connection_try_to_open() ) {
if( mht_connection_retry_no < MHT_CONNECTION_MAX_RETRIES )
goto cleanup;
mce_log(LL_WARN, "connect failed %d times; giving up",
mht_connection_retry_no);
}
else {
mce_log(LL_DEBUG, "connected after %d retries",
mht_connection_retry_no);
}
mht_connection_timer_id = 0;
cleanup:
return mht_connection_timer_id != 0;
}
/** Start connect reattempt timer
*/
static void
mht_connection_start_timer(void)
{
if( !mht_connection_timer_id && mce_hbtimer_initialized ) {
mht_connection_retry_no = 0;
mht_connection_timer_id =
g_timeout_add(MHT_CONNECTION_RETRY_DELAY_MS,
mht_connection_timer_cb, 0);
}
}
/** Cancel connect reattempt timer
*/
static void
mht_connection_stop_timer(void)
{
if( mht_connection_timer_id ) {
g_source_remove(mht_connection_timer_id),
mht_connection_timer_id = 0;
}
}
/** Predicate for: Connect reattempt timer is active
*/
static bool
mht_connection_is_pending(void)
{
return mht_connection_timer_id != 0;
}
/** Start connecting to iphb socket
*
* If the connection cant be made immediately it
* will be reattempted few times via timer callback.
*/
static void
mht_connection_open(void)
{
if( mht_connection_is_pending() ) {
// Retry timer already set up
}
else if( !mht_connection_try_to_open() ) {
// Could not connect now - start retry timer
mht_connection_start_timer();
}
}
/** Close connection to iphb socket
*/
static void
mht_connection_close(void)
{
/* stop pending connect attempts */
mht_connection_stop_timer();
/* remove io watch */
if( mht_iphb_wakeup_watch_id ) {
g_source_remove(mht_iphb_wakeup_watch_id),
mht_iphb_wakeup_watch_id = 0;
}
/* close handle */
if( mht_connection_handle ) {
iphb_close(mht_connection_handle),
mht_connection_handle = 0;
mce_log(LL_DEBUG, "iphb disconnected");
/* reset last programmed wakeup */
mht_iphb_set_wakeup(NO_TICK, NO_TICK);
}
}
/* ========================================================================= *
* DATAPIPE_HANDLERS
* ========================================================================= */
/** Resumed from suspend notification */
static void mht_datapipe_resume_detected_event_cb(gconstpointer data)
{
(void) data;
/* Check triggers & update glib wakeup after resume */
mce_log(LL_DEBUG, "resumed; dispatch hbtimers");
mht_queue_dispatch_timers();
}
/** Datapipe trigger for dsme availability
*/
static void mht_datapipe_dsme_service_state_cb(gconstpointer const data)
{
service_state_t prev = dsme_service_state;
dsme_service_state = GPOINTER_TO_INT(data);
if( dsme_service_state == prev )
goto EXIT;
mce_log(LL_DEBUG, "DSME dbus service: %s -> %s",
service_state_repr(prev),
service_state_repr(dsme_service_state));
if( dsme_service_state == SERVICE_STATE_RUNNING )
mht_connection_open();
else
mht_connection_close();
EXIT:
return;
}
/** Change notifications for shutting_down
*/
static void mht_datapipe_shutting_down_cb(gconstpointer data)
{
bool prev = shutting_down;
shutting_down = GPOINTER_TO_INT(data);
if( shutting_down == prev )
goto EXIT;
mce_log(LL_DEBUG, "shutting_down = %d -> %d",
prev, shutting_down);
/* Loss of iphb connection is expected during shutdown */
EXIT:
return;
}
/** Array of datapipe handlers */
static datapipe_handler_t mht_datapipe_handlers[] =
{
// output triggers
{
.datapipe = &resume_detected_event_pipe,
.output_cb = mht_datapipe_resume_detected_event_cb,
},
{
.datapipe = &dsme_service_state_pipe,
.output_cb = mht_datapipe_dsme_service_state_cb,
},
{
.datapipe = &shutting_down_pipe,
.output_cb = mht_datapipe_shutting_down_cb,
},
// sentinel
{
.datapipe = 0,
}
};
static datapipe_bindings_t mht_datapipe_bindings =
{
.module = "mce_hbtimer",
.handlers = mht_datapipe_handlers,
};
/** Append triggers/filters to datapipes
*/
static void mht_datapipe_init(void)
{
mce_datapipe_init_bindings(&mht_datapipe_bindings);
}
/** Remove triggers/filters from datapipes
*/
static void mht_datapipe_quit(void)
{
mce_datapipe_quit_bindings(&mht_datapipe_bindings);
}
/* ========================================================================= *
* MODULE_INIT
* ========================================================================= */
void
mce_hbtimer_init(void)
{
/* Connect to datapipes */
mht_datapipe_init();
/* Mark as initialized */
mce_hbtimer_initialized = true;
/* Schedule timers that have been created
* before initialization took place */
mht_queue_schedule_wakeups();
}
void
mce_hbtimer_quit(void)
{
/* Mark as de-initialized */
mce_hbtimer_initialized = false;
/* Disconnect from datapipes */
mht_datapipe_quit();
/* Remove wakeups */
mht_glib_set_wakeup(NO_TICK, NO_TICK);
mht_iphb_set_wakeup(NO_TICK, NO_TICK);
/* close iphb connection */
mht_connection_close();
}