/*
 * Copyright (C) 2016 OTA keys S.A.
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */

/**
 * @ingroup     drivers_candev_linux
 * @{
 *
 * @file
 * @brief       Implementation of simulated CAN controller driver using SocketCAN on Linux
 *
 * @author      Hermann Lelong <hermann@otakeys.com>
 * @author      Aurelien Gonce <aurelien.gonce@altran.com>
 * @author      Vincent Dupont <vincent@otakeys.com>
 * @}
 */

#if !defined(__linux__)
#error "MODULE can_linux is only available on Linux"
#else

#include <string.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <net/if.h>

#include <linux/can/raw.h>
#include <linux/can/error.h>

#include "native_internal.h"
#include "can/device.h"
#include "candev_linux.h"
#include "thread.h"
#include "mutex.h"
#include "async_read.h"
#include "sched.h"

#define ENABLE_DEBUG    (0)
#include "debug.h"

static int _init(candev_t *candev);
static int _send(candev_t *candev, const struct can_frame *frame);
static void _isr(candev_t *candev);
static int _set(candev_t *candev, canopt_t opt, void *value, size_t value_len);
static int _get(candev_t *candev, canopt_t opt, void *value, size_t max_len);
static int _abort(candev_t *candev, const struct can_frame *frame);
static int _set_filter(candev_t *candev, const struct can_filter *filter);
static int _remove_filter(candev_t *candev, const struct can_filter *filter);
static int _power_up(candev_t *candev);
static int _power_down(candev_t *candev);

static int _set_bittiming(candev_linux_t *dev, struct can_bittiming *bittiming);

static const candev_driver_t candev_linux_driver = {
    .send = _send,
    .init = _init,
    .isr = _isr,
    .get = _get,
    .set = _set,
    .abort = _abort,
    .set_filter = _set_filter,
    .remove_filter = _remove_filter,
};

static candev_event_t _can_error_to_can_evt(struct can_frame can_frame_err);
static void _callback_can_sigio(int sock, void *arg);

candev_linux_conf_t candev_linux_conf[CAN_DLL_NUMOF] = {
#if CAN_DLL_NUMOF >= 1
   {
        .interface_name = "vcan0",
   },
#endif
#if CAN_DLL_NUMOF >= 2
   {
        .interface_name = "vcan1",
   }
#endif
};

int candev_linux_init(candev_linux_t *dev, const candev_linux_conf_t *conf)
{
    memset(dev, 0, sizeof(candev_linux_t));
    dev->candev.driver = &candev_linux_driver;
    dev->conf = conf;
    dev->candev.bittiming.bitrate = CANDEV_LINUX_DEFAULT_BITRATE;
    dev->candev.bittiming.sample_point = CANDEV_LINUX_DEFAULT_SPT;

    return 0;
}

static candev_event_t _can_error_to_can_evt(struct can_frame can_frame_err)
{
    candev_event_t can_evt = CANDEV_EVENT_NOEVENT;
    can_err_mask_t can_err_type = can_frame_err.can_id & CAN_ERR_MASK;

    if (can_err_type & CAN_ERR_TX_TIMEOUT) {
        can_evt = CANDEV_EVENT_TX_ERROR;
    }
    else if (can_err_type & CAN_ERR_CRTL) {
        switch(can_frame_err.data[1]) {
        case CAN_ERR_CRTL_RX_OVERFLOW:
            can_evt = CANDEV_EVENT_RX_ERROR;
            break;
        case CAN_ERR_CRTL_TX_OVERFLOW:
            can_evt = CANDEV_EVENT_TX_ERROR;
            break;
        case CAN_ERR_CRTL_RX_PASSIVE:
        case CAN_ERR_CRTL_TX_PASSIVE:
            can_evt = CANDEV_EVENT_ERROR_PASSIVE;
            break;
        case CAN_ERR_CRTL_RX_WARNING:
        case CAN_ERR_CRTL_TX_WARNING:
            can_evt = CANDEV_EVENT_ERROR_WARNING;
            break;
        }
    }
    else if (can_err_type & CAN_ERR_BUSOFF) {
        can_evt = CANDEV_EVENT_BUS_OFF;
    }

    return can_evt;
}

static void _callback_can_sigio(int sockfd, void *arg)
{
    (void) sockfd;
    candev_linux_t *dev = (candev_linux_t *) arg;

    if (dev->candev.event_callback) {
        dev->candev.event_callback(&dev->candev, CANDEV_EVENT_ISR, NULL);
    }

    native_async_read_continue(sockfd);

    if (sched_context_switch_request) {
        thread_yield_higher();
    }
}

static int _init(candev_t *candev)
{
    struct sockaddr_can addr;
    struct ifreq ifr;
    int ret;

    DEBUG("Will start linux CAN init\n");
    candev_linux_t *dev = (candev_linux_t *)candev;

    if ((strlen(dev->conf->interface_name) == 0)
            || (strlen(dev->conf->interface_name) > CAN_MAX_SIZE_INTERFACE_NAME)) {
        real_printf("Error: Invalid can iface, too short or too long \n");
        return -1;
    }

    dev->sock = real_socket(PF_CAN, SOCK_RAW, CAN_RAW);

    if (dev->sock < 0) {
        real_printf("CAN config KO, socket nr = %i \n", dev->sock);
        return -1;
    }

    can_err_mask_t err_mask = CAN_ERR_TX_TIMEOUT |
                              CAN_ERR_BUSOFF |
                              CAN_ERR_CRTL;
    ret = real_setsockopt(dev->sock, SOL_CAN_RAW, CAN_RAW_ERR_FILTER,
                          &err_mask, sizeof(err_mask));

    if (ret < 0) {
        real_printf("Error: setsockopt failed\n");
        real_close(dev->sock);
        return -1;
    }

    strcpy(ifr.ifr_name, dev->conf->interface_name);
    ret = real_ioctl(dev->sock, SIOCGIFINDEX, &ifr);

    if (ret < 0) {
        real_printf("Error: Invalid can iface %s\n", dev->conf->interface_name);
        real_close(dev->sock);
        return -1;
    }

    native_async_read_setup();
    /* This func will also automatically configure socket to be asynchronous */
    /* and to activate SIGIO */
    native_async_read_add_handler(dev->sock, (void *) dev, _callback_can_sigio);

    addr.can_family = AF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;

    real_bind(dev->sock, (struct sockaddr *)&addr, sizeof(addr));

    _set_bittiming(dev, &candev->bittiming);

    DEBUG("CAN linux device ready\n");

    return 0;
}

static int _send(candev_t *candev, const struct can_frame *frame)
{
    int nbytes;
    candev_linux_t *dev = (candev_linux_t *)candev;

    nbytes = real_write(dev->sock, frame, sizeof(struct can_frame));

    if (nbytes < frame->can_dlc) {
        real_printf("CAN write op failed, nbytes=%i\n", nbytes);
        return -1;
    }

    if (dev->candev.event_callback) {
        dev->candev.event_callback(&dev->candev, CANDEV_EVENT_TX_CONFIRMATION, (void *)frame);
    }

    return 0;
}

static void _isr(candev_t *candev)
{
    int nbytes;
    struct can_frame rcv_frame;
    candev_linux_t *dev = (candev_linux_t *)candev;

    if (dev == NULL) {
        return;
    }

    DEBUG("candev_native _isr: CAN SIGIO interrupt received, sock = %i\n", dev->sock);
    nbytes = real_read(dev->sock, &rcv_frame, sizeof(struct can_frame));

    if (nbytes < 0) {   /* SIGIO signal was probably due to an error with the socket */
        DEBUG("candev_native _isr: read: error during read\n");
        return;
    }

    if (nbytes < (int)sizeof(struct can_frame)) {
        DEBUG("candev_native _isr: read: incomplete CAN frame\n");
        return;
    }

    if (rcv_frame.can_id & CAN_ERR_FLAG) {
        DEBUG("candev_native _isr: error frame\n");
        candev_event_t evt = _can_error_to_can_evt(rcv_frame);
        if ((evt != CANDEV_EVENT_NOEVENT) && (dev->candev.event_callback)) {
            dev->candev.event_callback(&dev->candev, evt, NULL);
        }
        return;
    }

    if (rcv_frame.can_id & CAN_RTR_FLAG) {
        DEBUG("candev_native _isr: rtr frame\n");
        return;
    }

    if (dev->candev.event_callback) {
        DEBUG("candev_native _isr: calling event callback\n");
        dev->candev.event_callback(&dev->candev, CANDEV_EVENT_RX_INDICATION, &rcv_frame);
    }

}

static int _set_bittiming(candev_linux_t *dev, struct can_bittiming *bittiming)
{
    int res;

    dev->candev.bittiming = *bittiming;

    DEBUG("bitrate = %d, brp= %d, phase_seg1 = %d, phase_seg2 = %d, sjw = %d\n",
          dev->candev.bittiming.bitrate, dev->candev.bittiming.brp,
          dev->candev.bittiming.phase_seg1, dev->candev.bittiming.phase_seg2,
          dev->candev.bittiming.sjw);

    /* bitrate setting */
    DEBUG("_set: setting %s down\n", dev->conf->interface_name);
    res = can_do_stop(dev->conf->interface_name);
    if (res < 0) {
        return res;
    }
    DEBUG("_set: setting bittiming to %s\n", dev->conf->interface_name);
    res = can_set_bitrate(dev->conf->interface_name, dev->candev.bittiming.bitrate);
    can_get_bittiming(dev->conf->interface_name, &dev->candev.bittiming);
    DEBUG("_set: setting %s up\n", dev->conf->interface_name);
    can_do_start(dev->conf->interface_name);

    return res;
}

static int _set(candev_t *candev, canopt_t opt, void *value, size_t value_len)
{
    candev_linux_t *dev = (candev_linux_t *) candev;
    int res = 0;

    switch (opt) {
    case CANOPT_BITTIMING:
        DEBUG("candev_linux: CANOPT_BITTIMING\n");

        if (strncmp(dev->conf->interface_name, "can", strlen("can"))) {
            DEBUG("candev_native: _set: error interface is not real can\n");
            return -EINVAL;
        }

        if (value == NULL) {
            DEBUG("candev_native: _set: error value NULL\n");
            return -EOVERFLOW;
        }

        if (value_len < sizeof(struct can_bittiming)) {
            DEBUG("candev_native: _set: error size of bittiming\n");
            return -EOVERFLOW;
        }

        res = _set_bittiming(dev, value);

        break;
    case CANOPT_STATE:
        switch (*((canopt_state_t *)value)) {
            case CANOPT_STATE_SLEEP:
            case CANOPT_STATE_OFF:
                _power_down(candev);
                break;
            default:
                _power_up(candev);
                break;
        }
        break;
    default:
        DEBUG("CAN set, not supported opt\n");
        res = -ENOTSUP;
        break;
    }

    return res;
}

static int _get(candev_t *candev, canopt_t opt, void *value, size_t max_len)
{
    candev_linux_t *dev = (candev_linux_t *) candev;
    int res = 0;

    switch (opt) {
    case CANOPT_BITTIMING:
        if (max_len < sizeof(struct can_bittiming)) {
            res = -EOVERFLOW;
            break;
        }
        if (value == NULL) {
            res = -EINVAL;
            break;
        }
        if (can_get_bittiming(dev->conf->interface_name, value) == 0) {
            res = sizeof(struct can_bittiming);
        }
        else {
            res = -ENOTSUP;
        }
        break;
    case CANOPT_BITTIMING_CONST:
        if (max_len < sizeof(struct can_bittiming_const)) {
            res = -EOVERFLOW;
            break;
        }
        if (value == NULL) {
            res = -EINVAL;
            break;
        }
        if (can_get_bittiming_const(dev->conf->interface_name, value) == 0) {
            res = sizeof(struct can_bittiming_const);
        }
        else {
            res = -ENOTSUP;
        }
        break;
    case CANOPT_CLOCK:
        if (max_len < sizeof(uint32_t)) {
            res = -EOVERFLOW;
            break;
        }
        if (value == NULL) {
            res = -EINVAL;
            break;
        }
        {
        struct can_clock clock;
        if (can_get_clock(dev->conf->interface_name, &clock) == 0) {
            *((uint32_t *)value) = clock.freq;
            res = sizeof(uint32_t);
        }
        else {
            res = -ENOTSUP;
        }
        }
        break;
    case CANOPT_TEC:
    case CANOPT_REC:
        if (max_len < sizeof(uint16_t)) {
            res = -EOVERFLOW;
            break;
        }
        if (value == NULL) {
            res = -EINVAL;
            break;
        }
        {
        struct can_berr_counter bc;
        if (can_get_berr_counter(dev->conf->interface_name, &bc) == 0) {
            if (opt == CANOPT_TEC) {
                *((uint16_t *)value) = bc.txerr;
            }
            else {
                *((uint16_t *)value) = bc.rxerr;
            }
            res = sizeof(uint16_t);
        }
        else {
            res = -ENOTSUP;
        }
        }
        break;
    case CANOPT_RX_FILTERS: {
        if (max_len % sizeof(struct can_filter) != 0) {
            res = -EOVERFLOW;
            break;
        }
        struct can_filter *list = value;
        size_t i;
        for (i = 0; (i < CANDEV_LINUX_MAX_FILTERS_RX)
             && (dev->filters[i].can_id != 0)
             && (i < (max_len / sizeof(struct can_filter))); i++) {
            list[i] = dev->filters[i];
        }
        res = i * sizeof(struct can_filter);
        break; }
    default:
        DEBUG("CAN get, not supported op\n");
        res = -ENOTSUP;
        break;
    }

    return res;
}

static int _set_filter(candev_t *candev, const struct can_filter *filter)
{
    candev_linux_t *dev = (candev_linux_t *)candev;

    if (filter == NULL) {
        DEBUG("candev_native: _set_filter: error filter NULL\n");
        return -EOVERFLOW;
    }

    DEBUG("candev_native: _set_filter: candev=%p, filter: f=%x m=%x on sock: %i\n",
          (void *)candev, filter->can_id, filter->can_mask, dev->sock
    );
    uint32_t i;
    for (i = 0; i < CANDEV_LINUX_MAX_FILTERS_RX; i++) {
        if (dev->filters[i].can_id == filter->can_id) {
            DEBUG("candev_native: _set_filter: filter already set\n");
            return 0;
        }
        else if (dev->filters[i].can_id == 0) {
            break;
        }
    }
    if (i == CANDEV_LINUX_MAX_FILTERS_RX) {
        DEBUG("candev_native: _set_filter: no more filters available\n");
        return -EOVERFLOW;
    }
    for (i = 0; i < CANDEV_LINUX_MAX_FILTERS_RX; i++) {
        if (dev->filters[i].can_id == 0) {
            /* Only 29 bits must be used for masks in SocketCAN */
            dev->filters[i] = *filter;
            dev->filters[i].can_mask &= CAN_EFF_MASK;
            DEBUG("candev_native: _set_filter: filter:ID=0x%x\n", filter->can_id);
            DEBUG("candev_native: _set_filter: mask=0x%x\n", filter->can_mask);
            break;
        }
    }
    i++;
    DEBUG("%" PRIu32 " filters will be set\n", i);
    real_setsockopt(dev->sock, SOL_CAN_RAW, CAN_RAW_FILTER, dev->filters,
                    sizeof(struct can_filter) * i);

    return i;
}

static int _remove_filter(candev_t *candev, const struct can_filter *filter)
{
    candev_linux_t *dev = (candev_linux_t *)candev;

    if (filter == NULL) {
        DEBUG("candev_native: _remove_filter: error filter NULL\n");
        return -EOVERFLOW;
    }

    uint32_t i;
    for (i = 0; i < CANDEV_LINUX_MAX_FILTERS_RX; i++) {
        if ((dev->filters[i].can_id == filter->can_id )
                && (dev->filters[i].can_mask == (filter->can_mask & CAN_EFF_MASK))) {
            if (i < CANDEV_LINUX_MAX_FILTERS_RX - 1) {
                memmove(&dev->filters[i], &dev->filters[i + 1],
                        sizeof(dev->filters[i]) * (CANDEV_LINUX_MAX_FILTERS_RX - i - 1));
            }
            dev->filters[CANDEV_LINUX_MAX_FILTERS_RX - 1].can_id = 0;
            break;

        }
        else if (dev->filters[i].can_id == 0) {
            DEBUG("candev_native: _remove_filter: error filter not found\n");
            return -EOVERFLOW;
        }
    }

    if (i == CANDEV_LINUX_MAX_FILTERS_RX) {
        DEBUG("candev_native: _remove_filter: error filter not found\n");
        return -EOVERFLOW;
    }

    for (i = 0; i < CANDEV_LINUX_MAX_FILTERS_RX; i++) {
        if (dev->filters[i].can_id == 0) {
            break;
        }
    }

    DEBUG("%" PRIu32 " filters will be set\n", i);
    real_setsockopt(dev->sock, SOL_CAN_RAW, CAN_RAW_FILTER, dev->filters,
                    sizeof(struct can_filter) * i);

    return 0;
}

static int _abort(candev_t *candev, const struct can_frame *frame)
{
    (void)frame;
    (void)candev;

    return 0;
}

static int _power_down(candev_t *candev)
{
    (void)candev;

    return 0;
}

static int _power_up(candev_t *candev)
{
    (void)candev;

    return 0;
}
#endif   /* defined(__linux__) */