path: root/src/libembim/embim-device.c

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * libembim -- Library to control MBIM devices
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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 this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 * Copyright (C) 2015 Aleksander Morgado <aleksander@aleksander.es>
 */

#include <config.h>

#include <stdio.h>
#include <stdint.h>
#include <errno.h>
#include <assert.h>
#include <malloc.h>
#include <string.h>
#include <pthread.h>
#include <fcntl.h>
#include <unistd.h>

#include <sys/ioctl.h>
#define IOCTL_WDM_MAX_COMMAND _IOR('H', 0xA0, uint16_t)
#define FALLBACK_MAX_CONTROL_TRANSFER 4096

#include "embim-device.h"

/*****************************************************************************/

struct indication_s;
struct embim_device_s {
    /* The MBIM device path */
    char *path;
    /* Open device FD */
    int fd;
    /* Transaction ID */
    uint32_t transaction_id;
    /* Registered indication callbacks */
    struct indication_s *indications;
    size_t               indications_n;
    size_t               indications_size;
    pthread_mutex_t      indications_mutex;
};

static void cleanup_indications (embim_device_t *self);
static void notify_indication   (embim_device_t *self,
                                 const uint8_t  *indication);

/*****************************************************************************/
/* Basic device creation/destruction */

embim_device_t *
embim_device_new (const char *path)
{
    embim_device_t *self;

    assert (path);

    self = malloc (sizeof (struct embim_device_s));
    if (self) {
        self->path = strdup (path);
        if (!self->path) {
            free (self);
            self = NULL;
        }

        self->fd = -1;

        pthread_mutex_init (&self->indications_mutex, NULL);
        self->indications_n    = 0;
        self->indications_size = 0;
        self->indications      = NULL;
    }

    return self;
}

void
embim_device_free (embim_device_t *self)
{
    if (!self)
        return;

    embim_device_close (self);

    cleanup_indications (self);
    pthread_mutex_destroy (&self->indications_mutex);

    free (self->path);
    free (self);
}

/*****************************************************************************/
/* MBIM write */

embim_status_e
embim_device_write (embim_device_t *self,
                    const uint8_t  *message,
                    size_t          message_size)
{


}

/*****************************************************************************/
/* MBIM open */

embim_status_e
embim_device_open (embim_device_t *self)
{
    /* If already open, we're done */
    if (!(self->fd < 0))
        return EMBIM_STATUS_SUCCESS;

    self->fd = open (self->path, O_RDWR | FD_CLOEXEC);
    if (self->fd < 0) {
        /* Not having enough privileges is a very common error here. */
        if (errno == EACCESS)
            return EMBIM_STATUS_ERROR_UNAUTHORIZED;
        return EMBIM_STATUS_ERROR_GENERIC;
    }

    /* Query message size */
    if (ioctl (self->fd, IOCTL_WDM_MAX_COMMAND, &self->max_control_transfer) < 0)
        /* Fallback to a default value */
        self->max_control_transfer = FALLBACK_MAX_CONTROL_TRANSFER;

    notify_indication (self, NULL);

    return EMBIM_STATUS_SUCCESS;
}

int
embim_device_get_fd (embim_device_t *self)
{
    return self->fd;
}

uint16_t
embim_device_get_max_control_transfer (embim_device_t *self)
{
    return self->max_control_transfer;
}

/*****************************************************************************/
/* MBIM close */

embim_status_e
embim_device_close (embim_device_t *self)
{
    if (!(self->fd < 0)) {
        close (self->fd);
        self->fd = -1;
    }

    return EMBIM_STATUS_SUCCESS;
}

/*****************************************************************************/
/* Transaction ID management */

static uint32_t
get_next_transaction_id (embim_device_t *self)
{
    uint32_t next;

    next = self->transaction_id;

    if (self->transaction_id == (uint32_t) 0xFFFFFFFF)
        /* Reset! */
        self->priv->transaction_id = 0x01;
    else
        self->priv->transaction_id++;

    return next;
}

/*****************************************************************************/
/* Registered callbacks for indications */

struct indication_s {
    embim_device_indication_cb  cb;
    void                       *user_data;
};

static void
notify_indication (embim_device_t *self,
                   const uint8_t  *indication)
{
    size_t i;

    for (i = 0; i < self->indications_size; i++) {
        /* Notify if there is a callback registered */
        if (self->indications[i].cb)
            self->indications[i].cb (self, indication, self->indications[i].user_data);
    }
}

static void
cleanup_indications (embim_device_t *self)
{
    pthread_mutex_lock (&self->indications_mutex);
    {
        free (self->indications);
        self->indications      = NULL;
        self->indications_size = 0;
        self->indications_n    = 0;
    }
    pthread_mutex_unlock (&self->indications_mutex);
}

embim_status_e
embim_device_unregister_indication_cb (embim_device_t             *self,
                                       embim_device_indication_cb  indication_cb,
                                       void                       *indication_user_data)
{
    embim_status_e st = EMBIM_STATUS_ERROR_NOT_FOUND;

    pthread_mutex_lock (&self->indications_mutex);
    {
        size_t i;

        /* Look for the slot in the indications array */
        for (i = 0; i < self->indications_size; i++) {
            if ((self->indications[i].cb == indication_cb) &&
                (self->indications[i].user_data == indication_user_data)) {
                /* Found! */
                self->indications[i].cb        = NULL;
                self->indications[i].user_data = NULL;
                st = EMBIM_STATUS_SUCCESS;
                assert (self->indications_n > 0);
                self->indications_n--;
                break;
            }
        }
    }
    pthread_mutex_unlock (&self->indications_mutex);

    return st;
}

embim_status_e
embim_device_register_indication_cb (embim_device_t             *self,
                                     embim_device_indication_cb  indication_cb,
                                     void                       *indication_user_data)
{
    embim_status_e st = EMBIM_STATUS_SUCCESS;

    pthread_mutex_lock (&self->indications_mutex);
    {
        size_t  i;
        ssize_t empty_slot = -1;

        /* Iterate all the array, looking both for a free slot and for a duplicate */
        for (i = 0; i < self->indications_size; i++) {
            /* Error out if it already exists */
            if ((self->indications[i].cb == indication_cb) &&
                (self->indications[i].user_data == indication_user_data)) {
                st = EMBIM_STATUS_ERROR_EXISTS;
                goto err;
            }

            /* Register empty slot when first found */
            if (!self->indications[i].cb && empty_slot < 0)
                empty_slot = i;
        }

        /* Need more slots, resize */
        if (empty_slot < 0) {
            struct indication_s *resized;
            size_t               resized_size;

            resized_size = self->indications_size ? (self->indications_size * 2) : 1;
            resized = (struct indication_s *) realloc (self->indications, resized_size * sizeof (struct indication_s));
            if (!resized) {
                st = EMBIM_STATUS_ERROR_NO_MEMORY;
                goto err;
            }

            memset (&resized[self->indications_size], 0, (resized_size - self->indications_size) * sizeof (struct indication_s));

            /* Empty slot will be the first one in the resized chunk */
            empty_slot = self->indications_size;

            self->indications      = resized;
            self->indications_size = resized_size;
        }

        /* Register it */
        self->indications[empty_slot].cb        = indication_cb;
        self->indications[empty_slot].user_data = indication_user_data;
        self->indications_n++;
    }

err:
    pthread_mutex_unlock (&self->indications_mutex);
    return st;
}