// SPDX-License-Identifier: GPL-2.0+
/*
 * (C) Copyright 2017
 * Mario Six,  Guntermann & Drunck GmbH, mario.six@gdsys.cc
 *
 * based on the cmd_ioloop driver/command, which is
 *
 * (C) Copyright 2014
 * Dirk Eibach, Guntermann & Drunck GmbH, dirk.eibach@gdsys.cc
 *
 * SPDX-License-Identifier:     GPL-2.0+
 */

#include <common.h>
#include <dm.h>
#include <log.h>
#include <misc.h>
#include <regmap.h>

#include "gdsys_ioep.h"

/**
 * struct gdsys_ioep_priv - Private data structure for IOEP devices
 * @map:   Register map to be used for the device
 * @state: Flag to keep the current status of the RX control (enabled/disabled)
 */
struct gdsys_ioep_priv {
        struct regmap *map;
        bool state;
};

/**
 * enum last_spec - Convenience enum for read data sanity check
 * @READ_DATA_IS_LAST:     The data to be read should be the final data of the
 *                         current packet
 * @READ_DATA_IS_NOT_LAST: The data to be read should not be the final data of
 *                         the current packet
 */
enum last_spec {
        READ_DATA_IS_LAST,
        READ_DATA_IS_NOT_LAST,
};

static int gdsys_ioep_set_receive(struct udevice *dev, bool val)
{
        struct gdsys_ioep_priv *priv = dev_get_priv(dev);
        u16 state;

        priv->state = !priv->state;

        if (val)
                state = CTRL_PROC_RECEIVE_ENABLE;
        else
                state = ~CTRL_PROC_RECEIVE_ENABLE;

        gdsys_ioep_set(priv->map, tx_control, state);

        if (val) {
                /* Set device address to dummy 1 */
                gdsys_ioep_set(priv->map, device_address, 1);
        }

        return !priv->state;
}

static int gdsys_ioep_send(struct udevice *dev, int offset,
                           const void *buf, int size)
{
        struct gdsys_ioep_priv *priv = dev_get_priv(dev);
        int k;
        u16 *p = (u16 *)buf;

        for (k = 0; k < size; ++k)
                gdsys_ioep_set(priv->map, transmit_data, *(p++));

        gdsys_ioep_set(priv->map, tx_control, CTRL_PROC_RECEIVE_ENABLE |
                                              CTRL_FLUSH_TRANSMIT_BUFFER);

        return 0;
}

/**
 * receive_byte_buffer() - Read data from a IOEP device
 * @dev:       The IOEP device to read data from
 * @len:       The length of the data to read
 * @buffer:    The buffer to read the data into
 * @last_spec: Flag to indicate if the data to be read in this call should be
 *             the final data of the current packet (i.e. it should be empty
 *             after this read)
 *
 * Return: 0 if OK, -ve on error
 */
static int receive_byte_buffer(struct udevice *dev, uint len,
                               u16 *buffer, enum last_spec last_spec)
{
        struct gdsys_ioep_priv *priv = dev_get_priv(dev);
        int k;
        int ret = -EIO;

        for (k = 0; k < len; ++k) {
                u16 rx_tx_status;

                gdsys_ioep_get(priv->map, receive_data, buffer++);

                gdsys_ioep_get(priv->map, rx_tx_status, &rx_tx_status);
                /*
                 * Sanity check: If the data read should have been the last,
                 * but wasn't, something is wrong
                 */
                if (k == (len - 1) && (last_spec == READ_DATA_IS_NOT_LAST ||
                                       rx_tx_status & STATE_RX_DATA_LAST))
                        ret = 0;
        }

        if (ret)
                debug("%s: Error while receiving bufer (err = %d)\n",
                      dev->name, ret);

        return ret;
}

static int gdsys_ioep_receive(struct udevice *dev, int offset, void *buf,
                              int size)
{
        int ret;
        struct io_generic_packet header;
        u16 *p = (u16 *)buf;
        const int header_words = sizeof(struct io_generic_packet) / sizeof(u16);
        uint len;

        /* Read the packet header */
        ret = receive_byte_buffer(dev, header_words, p, READ_DATA_IS_NOT_LAST);
        if (ret) {
                debug("%s: Failed to read header data (err = %d)\n",
                      dev->name, ret);
                return ret;
        }

        memcpy(&header, p, header_words * sizeof(u16));
        p += header_words;

        /* Get payload data length */
        len = (header.packet_length + 1) / sizeof(u16);

        /* Read the packet payload */
        ret = receive_byte_buffer(dev, len, p, READ_DATA_IS_LAST);
        if (ret) {
                debug("%s: Failed to read payload data (err = %d)\n",
                      dev->name, ret);
                return ret;
        }

        return 0;
}

static int gdsys_ioep_get_and_reset_status(struct udevice *dev, int msgid,
                                           void *tx_msg, int tx_size,
                                           void *rx_msg, int rx_size)
{
        struct gdsys_ioep_priv *priv = dev_get_priv(dev);
        const u16 mask = STATE_RX_DIST_ERR | STATE_RX_LENGTH_ERR |
                         STATE_RX_FRAME_CTR_ERR | STATE_RX_FCS_ERR |
                         STATE_RX_PACKET_DROPPED | STATE_TX_ERR;
        u16 *status = rx_msg;

        gdsys_ioep_get(priv->map, rx_tx_status, status);

        gdsys_ioep_set(priv->map, rx_tx_status, *status);

        return (*status & mask) ? 1 : 0;
}

static const struct misc_ops gdsys_ioep_ops = {
        .set_enabled = gdsys_ioep_set_receive,
        .write = gdsys_ioep_send,
        .read = gdsys_ioep_receive,
        .call = gdsys_ioep_get_and_reset_status,
};

static int gdsys_ioep_probe(struct udevice *dev)
{
        struct gdsys_ioep_priv *priv = dev_get_priv(dev);
        int ret;

        ret = regmap_init_mem(dev_ofnode(dev), &priv->map);
        if (ret) {
                debug("%s: Could not initialize regmap (err = %d)",
                      dev->name, ret);
                return ret;
        }

        priv->state = false;

        return 0;
}

static const struct udevice_id gdsys_ioep_ids[] = {
        { .compatible = "gdsys,io-endpoint" },
        { }
};

U_BOOT_DRIVER(gdsys_ioep) = {
        .name           = "gdsys_ioep",
        .id             = UCLASS_MISC,
        .ops            = &gdsys_ioep_ops,
        .flags          = DM_UC_FLAG_SEQ_ALIAS,
        .of_match       = gdsys_ioep_ids,
        .probe          = gdsys_ioep_probe,
        .priv_auto      = sizeof(struct gdsys_ioep_priv),
};