usb_moded-udev.c

Go to the documentation of this file.

 
#include "usb_moded-udev.h"
 
#include "usb_moded.h"
#include "usb_moded-config-private.h"
#include "usb_moded-control.h"
#include "usb_moded-dbus-private.h"
#include "usb_moded-log.h"
 
#include <libudev.h>
 
/* ========================================================================= *
 * Prototypes
 * ========================================================================= */
 
/* ------------------------------------------------------------------------- *
 * UMUDEV
 * ------------------------------------------------------------------------- */
 
static gboolean      umudev_cable_state_timer_cb   (gpointer aptr);
static void          umudev_cable_state_stop_timer (void);
static void          umudev_cable_state_start_timer(gint delay);
static bool          umudev_cable_state_connected  (void);
static cable_state_t umudev_cable_state_get        (void);
static void          umudev_cable_state_set        (cable_state_t state);
static void          umudev_cable_state_changed    (void);
static void          umudev_cable_state_from_udev  (cable_state_t curr);
static void          umudev_io_error_cb            (gpointer data);
static gboolean      umudev_io_input_cb            (GIOChannel *iochannel, GIOCondition cond, gpointer data);
static void          umudev_parse_properties       (struct udev_device *dev, bool initial);
static int           umudev_score_as_power_supply  (const char *syspath);
gboolean             umudev_init                   (void);
void                 umudev_quit                   (void);
 
/* ========================================================================= *
 * Data
 * ========================================================================= */
 
/* global variables */
static struct udev         *umudev_object     = 0;
static struct udev_monitor *umudev_monitor    = 0;
static gchar               *umudev_sysname    = 0;
static guint                umudev_watch_id   = 0;
static bool                 umudev_in_cleanup = false;

static cable_state_t umudev_cable_state_current  = CABLE_STATE_UNKNOWN;

static cable_state_t umudev_cable_state_active   = CABLE_STATE_UNKNOWN;

static cable_state_t umudev_cable_state_previous = CABLE_STATE_UNKNOWN;

static guint umudev_cable_state_timer_id = 0;
static gint  umudev_cable_state_timer_delay = -1;
 
/* ========================================================================= *
 * cable state
 * ========================================================================= */
 
static gboolean umudev_cable_state_timer_cb(gpointer aptr)
{
    LOG_REGISTER_CONTEXT;
 
    (void)aptr;
    umudev_cable_state_timer_id = 0;
    umudev_cable_state_timer_delay = -1;
 
    log_debug("trigger delayed transfer to: %s",
              cable_state_repr(umudev_cable_state_current));
    umudev_cable_state_set(umudev_cable_state_current);
    return FALSE;
}
 
static void umudev_cable_state_stop_timer(void)
{
    LOG_REGISTER_CONTEXT;
 
    if( umudev_cable_state_timer_id ) {
        log_debug("cancel delayed transfer to: %s",
                  cable_state_repr(umudev_cable_state_current));
        g_source_remove(umudev_cable_state_timer_id),
            umudev_cable_state_timer_id = 0;
        umudev_cable_state_timer_delay = -1;
    }
}
 
static void umudev_cable_state_start_timer(gint delay)
{
    LOG_REGISTER_CONTEXT;
 
    if( umudev_cable_state_timer_delay != delay ) {
        umudev_cable_state_stop_timer();
    }
 
    if( !umudev_cable_state_timer_id ) {
        log_debug("schedule delayed transfer to: %s",
                  cable_state_repr(umudev_cable_state_current));
        umudev_cable_state_timer_id =
            g_timeout_add(delay,
                          umudev_cable_state_timer_cb, 0);
        umudev_cable_state_timer_delay = delay;
    }
}
 
static bool
umudev_cable_state_connected(void)
{
    LOG_REGISTER_CONTEXT;
 
    bool connected = false;
    switch( umudev_cable_state_get() ) {
    default:
        break;
    case CABLE_STATE_CHARGER_CONNECTED:
    case CABLE_STATE_PC_CONNECTED:
        connected = true;
        break;
    }
    return connected;
}
 
static cable_state_t umudev_cable_state_get(void)
{
    LOG_REGISTER_CONTEXT;
 
    return umudev_cable_state_active;
}
 
static void umudev_cable_state_set(cable_state_t state)
{
    LOG_REGISTER_CONTEXT;
 
    umudev_cable_state_stop_timer();
 
    if( umudev_cable_state_active == state )
        goto EXIT;
 
    umudev_cable_state_previous = umudev_cable_state_active;
    umudev_cable_state_active   = state;
 
    log_debug("cable_state: %s -> %s",
              cable_state_repr(umudev_cable_state_previous),
              cable_state_repr(umudev_cable_state_active));
 
    umudev_cable_state_changed();
 
EXIT:
    return;
}
 
static void umudev_cable_state_changed(void)
{
    LOG_REGISTER_CONTEXT;
 
    /* The rest of usb-moded separates charger
     * and pc connection states... make single
     * state tracking compatible with that. */
 
    /* First handle pc/charger disconnect based
     * on previous state.
     */
    switch( umudev_cable_state_previous ) {
    default:
    case CABLE_STATE_DISCONNECTED:
        /* dontcare */
        break;
    case CABLE_STATE_CHARGER_CONNECTED:
        umdbus_send_event_signal(CHARGER_DISCONNECTED);
        break;
    case CABLE_STATE_PC_CONNECTED:
        umdbus_send_event_signal(USB_DISCONNECTED);
        break;
    }
 
    /* Then handle pc/charger connect based
     * on current state.
     */
 
    switch( umudev_cable_state_active ) {
    default:
    case CABLE_STATE_DISCONNECTED:
        /* dontcare */
        break;
    case CABLE_STATE_CHARGER_CONNECTED:
        umdbus_send_event_signal(CHARGER_CONNECTED);
        break;
    case CABLE_STATE_PC_CONNECTED:
        umdbus_send_event_signal(USB_CONNECTED);
        break;
    }
 
    /* Then act on usb mode */
    control_set_cable_state(umudev_cable_state_active);
}
 
static void umudev_cable_state_from_udev(cable_state_t curr)
{
    LOG_REGISTER_CONTEXT;
 
    cable_state_t prev = umudev_cable_state_current;
    umudev_cable_state_current = curr;
 
    if( prev == curr )
        goto EXIT;
 
    log_debug("reported cable state: %s -> %s",
              cable_state_repr(prev),
              cable_state_repr(curr));
 
    /* Because mode transitions are handled synchronously and can thus
     * block the usb-moded mainloop, we might end up receiving a bursts
     * of stale udev events after returning from mode switch - including
     * multiple cable connect / disconnect events due to user replugging
     * the cable in frustration of things taking too long.
     */
 
    if( curr == CABLE_STATE_DISCONNECTED ) {
        /* If we see any disconnect events, those must be acted on
         * immediately to get the 1st disconnect handled.
         */
        umudev_cable_state_set(curr);
    }
    else {
        /* All other transitions are handled with at least 100 ms delay.
         * This should compress multiple stale disconnect + connect
         * pairs into single action.
         */
        gint delay = 100;
 
        if( curr == CABLE_STATE_PC_CONNECTED && prev != CABLE_STATE_UNKNOWN ) {
            if( delay < usbmoded_get_cable_connection_delay() )
                delay = usbmoded_get_cable_connection_delay();
        }
 
        umudev_cable_state_start_timer(delay);
    }
 
EXIT:
    return;
}
 
/* ========================================================================= *
 * legacy code
 * ========================================================================= */
 
static void umudev_io_error_cb(gpointer data)
{
    LOG_REGISTER_CONTEXT;
 
    (void)data;
 
    /* we do not want to restart when we try to clean up */
    if( !umudev_in_cleanup ) {
        log_debug("USB connection watch destroyed, restarting it\n!");
        /* restart trigger */
        umudev_quit();
        umudev_init();
    }
}
 
static gboolean umudev_io_input_cb(GIOChannel *iochannel, GIOCondition cond, gpointer data)
{
    LOG_REGISTER_CONTEXT;
 
    (void)iochannel;
    (void)data;
 
    gboolean continue_watching = TRUE;
 
    /* No code paths are allowed to bypass the common_release_wakelock() call below */
    common_acquire_wakelock(USB_MODED_WAKELOCK_PROCESS_INPUT);
 
    if( cond & G_IO_IN )
    {
        /* This normally blocks but G_IO_IN indicates that we can read */
        struct udev_device *dev = udev_monitor_receive_device(umudev_monitor);
        if( !dev )
        {
            /* if we get something else something bad happened stop watching to avoid busylooping */
            continue_watching = FALSE;
        }
        else
        {
            /* check if it is the actual device we want to check */
            if( !strcmp(umudev_sysname, udev_device_get_sysname(dev)) )
            {
                if( !strcmp(udev_device_get_action(dev), "change") )
                {
                    umudev_parse_properties(dev, false);
                }
            }
 
            udev_device_unref(dev);
        }
    }
 
    if( cond & (G_IO_ERR | G_IO_HUP | G_IO_NVAL) )
    {
        /* Unhandled errors turn io watch to virtual busyloop too */
        continue_watching = FALSE;
    }
 
    if( !continue_watching && umudev_watch_id )
    {
        umudev_watch_id = 0;
        log_crit("udev io watch disabled");
    }
 
    common_release_wakelock(USB_MODED_WAKELOCK_PROCESS_INPUT);
 
    return continue_watching;
}
 
static void umudev_parse_properties(struct udev_device *dev, bool initial)
{
    LOG_REGISTER_CONTEXT;
 
    (void)initial;
 
    /* udev properties we are interested in */
    const char *power_supply_present = 0;
    const char *power_supply_online  = 0;
    const char *power_supply_type    = 0;
 
    /* Assume there is no usb connection until proven otherwise */
    bool connected  = false;
 
    /* Unless debug logging has been request via command line,
     * suppress warnings about potential property issues and/or
     * fallback strategies applied (to avoid spamming due to the
     * code below seeing the same property values over and over
     * again also in stable states).
     */
    bool warnings = log_p(LOG_DEBUG);
 
    /*
     * Check for present first as some drivers use online for when charging
     * is enabled
     */
    power_supply_present = udev_device_get_property_value(dev, "POWER_SUPPLY_PRESENT");
    if( !power_supply_present ) {
        power_supply_present =
            power_supply_online = udev_device_get_property_value(dev, "POWER_SUPPLY_ONLINE");
    }
 
    if( power_supply_present && !strcmp(power_supply_present, "1") )
        connected = true;
 
    /* Transition period = Connection status derived from udev
     * events disagrees with usb-moded side bookkeeping. */
    if( connected != control_get_connection_state() ) {
        /* Enable udev property diagnostic logging */
        warnings = true;
        /* Block suspend briefly */
        usbmoded_delay_suspend();
    }
 
    if( !connected ) {
        /* Handle: Disconnected */
 
        if( warnings && !power_supply_present )
            log_err("No usable power supply indicator\n");
        umudev_cable_state_from_udev(CABLE_STATE_DISCONNECTED);
    }
    else {
        if( warnings && power_supply_online )
            log_warning("Using online property\n");
 
        /* At least h4113 i.e. "Xperia XA2 - Dual SIM" seem to have
         * POWER_SUPPLY_REAL_TYPE udev property with information
         * that usb-moded expects to be in POWER_SUPPLY_TYPE prop.
         */
        power_supply_type = udev_device_get_property_value(dev, "POWER_SUPPLY_REAL_TYPE");
        if( !power_supply_type )
            power_supply_type = udev_device_get_property_value(dev, "POWER_SUPPLY_TYPE");
        /*
         * Power supply type might not exist also :(
         * Send connected event but this will not be able
         * to discriminate between charger/cable.
         */
        if( !power_supply_type ) {
            if( warnings )
                log_warning("Fallback since cable detection might not be accurate. "
                            "Will connect on any voltage on charger.\n");
            umudev_cable_state_from_udev(CABLE_STATE_PC_CONNECTED);
            goto cleanup;
        }
 
        log_debug("CONNECTED - POWER_SUPPLY_TYPE = %s", power_supply_type);
 
        if( !strcmp(power_supply_type, "USB") ||
            !strcmp(power_supply_type, "USB_CDP") ) {
            umudev_cable_state_from_udev(CABLE_STATE_PC_CONNECTED);
        }
        else if( !strcmp(power_supply_type, "USB_DCP") ||
                 !strcmp(power_supply_type, "USB_HVDCP") ||
                 !strcmp(power_supply_type, "USB_HVDCP_3") ) {
            umudev_cable_state_from_udev(CABLE_STATE_CHARGER_CONNECTED);
        }
        else if( !strcmp(power_supply_type, "USB_FLOAT")) {
            if( !umudev_cable_state_connected() )
                log_warning("connection type detection failed, assuming charger");
            umudev_cable_state_from_udev(CABLE_STATE_CHARGER_CONNECTED);
        }
        else if( !strcmp(power_supply_type, "Unknown")) {
            // nop
            log_warning("unknown connection type reported, assuming disconnected");
            umudev_cable_state_from_udev(CABLE_STATE_DISCONNECTED);
        }
        else {
            if( warnings )
                log_warning("unhandled power supply type: %s", power_supply_type);
            umudev_cable_state_from_udev(CABLE_STATE_DISCONNECTED);
        }
    }
 
cleanup:
    return;
}
 
static int umudev_score_as_power_supply(const char *syspath)
{
    LOG_REGISTER_CONTEXT;
 
    int                 score   = 0;
    struct udev_device *dev     = 0;
    const char         *sysname = 0;
 
    if( !umudev_object )
        goto EXIT;
 
    if( !(dev = udev_device_new_from_syspath(umudev_object, syspath)) )
        goto EXIT;
 
    if( !(sysname = udev_device_get_sysname(dev)) )
        goto EXIT;
 
    /* try to assign a weighed score */
 
    /* check that it is not a battery */
    if(strstr(sysname, "battery") || strstr(sysname, "BAT"))
        goto EXIT;
 
    /* if it contains usb in the name it very likely is good */
    if(strstr(sysname, "usb"))
        score = score + 10;
 
    /* often charger is also mentioned in the name */
    if(strstr(sysname, "charger"))
        score = score + 5;
 
    /* present property is used to detect activity, however online is better */
    if(udev_device_get_property_value(dev, "POWER_SUPPLY_PRESENT"))
        score = score + 5;
 
    if(udev_device_get_property_value(dev, "POWER_SUPPLY_ONLINE"))
        score = score + 10;
 
    /* type is used to detect if it is a cable or dedicated charger.
     * Bonus points if it is there. */
    if(udev_device_get_property_value(dev, "POWER_SUPPLY_TYPE"))
        score = score + 10;
 
EXIT:
    /* clean up */
    if( dev )
        udev_device_unref(dev);
 
    return score;
}
 
gboolean umudev_init(void)
{
    LOG_REGISTER_CONTEXT;
 
    gboolean                success = FALSE;
 
    char                   *configured_device = NULL;
    char                   *configured_subsystem = NULL;
    struct udev_device     *dev = 0;
    GIOChannel             *iochannel = 0;
 
    int ret = 0;
 
    /* Clear in-cleanup in case of restart */
    umudev_in_cleanup = false;
 
    /* Create the udev object */
    if( !(umudev_object = udev_new()) ) {
        log_err("Can't create umudev_object\n");
        goto EXIT;
    }
 
    if( !(configured_device = config_find_udev_path()) )
        configured_device = g_strdup("/sys/class/power_supply/usb");
 
    if( !(configured_subsystem = config_find_udev_subsystem()) )
        configured_subsystem = g_strdup("power_supply");
 
    /* Try with configured / default device */
    dev = udev_device_new_from_syspath(umudev_object, configured_device);
 
    /* If needed, try heuristics */
    if( !dev ) {
        log_debug("Trying to guess $power_supply device.\n");
 
        int    current_score = 0;
        gchar *current_name  = 0;
 
        struct udev_enumerate  *list;
        struct udev_list_entry *list_entry;
        struct udev_list_entry *first_entry;
 
        list = udev_enumerate_new(umudev_object);
        udev_enumerate_add_match_subsystem(list, "power_supply");
        udev_enumerate_scan_devices(list);
        first_entry = udev_enumerate_get_list_entry(list);
        udev_list_entry_foreach(list_entry, first_entry) {
            const char *name = udev_list_entry_get_name(list_entry);
            int score = umudev_score_as_power_supply(name);
            if( current_score < score ) {
                g_free(current_name);
                current_name = g_strdup(name);
                current_score = score;
            }
        }
        /* check if we found anything with some kind of score */
        if(current_score > 0) {
            dev = udev_device_new_from_syspath(umudev_object, current_name);
        }
        g_free(current_name);
    }
 
    /* Give up if no power supply device was found */
    if( !dev ) {
        log_err("Unable to find $power_supply device.");
        /* communicate failure, mainloop will exit and call appropriate clean-up */
        goto EXIT;
    }
 
    /* Cache device name */
    umudev_sysname = g_strdup(udev_device_get_sysname(dev));
    log_debug("device name = %s\n", umudev_sysname);
 
    /* Start monitoring for changes */
    umudev_monitor = udev_monitor_new_from_netlink(umudev_object, "udev");
    if( !umudev_monitor )
    {
        log_err("Unable to monitor the netlink\n");
        /* communicate failure, mainloop will exit and call appropriate clean-up */
        goto EXIT;
    }
 
    ret = udev_monitor_filter_add_match_subsystem_devtype(umudev_monitor,
                                                          configured_subsystem,
                                                          NULL);
    if(ret != 0)
    {
        log_err("Udev match failed.\n");
        goto EXIT;
    }
 
    ret = udev_monitor_enable_receiving(umudev_monitor);
    if(ret != 0)
    {
        log_err("Failed to enable monitor recieving.\n");
        goto EXIT;
    }
 
    iochannel = g_io_channel_unix_new(udev_monitor_get_fd(umudev_monitor));
    if( !iochannel )
        goto EXIT;
 
    umudev_watch_id = g_io_add_watch_full(iochannel, 0, G_IO_IN, umudev_io_input_cb, NULL, umudev_io_error_cb);
    if( !umudev_watch_id )
        goto EXIT;
 
    /* everything went well */
    success = TRUE;
 
    /* check initial status */
    umudev_parse_properties(dev, true);
 
EXIT:
    /* Cleanup local resources */
    if( iochannel )
        g_io_channel_unref(iochannel);
 
    if( dev )
        udev_device_unref(dev);
 
    g_free(configured_subsystem);
    g_free(configured_device);
 
    /* All or nothing */
    if( !success )
        umudev_quit();
 
    return success;
}
 
void umudev_quit(void)
{
    LOG_REGISTER_CONTEXT;
 
    umudev_in_cleanup = true;
 
    log_debug("HWhal cleanup\n");
 
    if( umudev_watch_id )
    {
        g_source_remove(umudev_watch_id),
            umudev_watch_id = 0;
    }
 
    if( umudev_monitor ) {
        udev_monitor_unref(umudev_monitor),
            umudev_monitor = 0;
    }
 
    if( umudev_object ) {
        udev_unref(umudev_object),
            umudev_object =0 ;
    }
 
    g_free(umudev_sysname),
        umudev_sysname = 0;
 
    umudev_cable_state_stop_timer();
}