// SPDX-License-Identifier: GPL-2.0+

/*
 * EEPROM driver for RAVE SP
 *
 * Copyright (C) 2018 Zodiac Inflight Innovations
 *
 */
#include <linux/kernel.h>
#include <linux/mfd/rave-sp.h>
#include <linux/module.h>
#include <linux/nvmem-provider.h>
#include <linux/of_device.h>
#include <linux/platform_device.h>
#include <linux/sizes.h>

/**
 * enum rave_sp_eeprom_access_type - Supported types of EEPROM access
 *
 * @RAVE_SP_EEPROM_WRITE:       EEPROM write
 * @RAVE_SP_EEPROM_READ:        EEPROM read
 */
enum rave_sp_eeprom_access_type {
        RAVE_SP_EEPROM_WRITE = 0,
        RAVE_SP_EEPROM_READ  = 1,
};

/**
 * enum rave_sp_eeprom_header_size - EEPROM command header sizes
 *
 * @RAVE_SP_EEPROM_HEADER_SMALL: EEPROM header size for "small" devices (< 8K)
 * @RAVE_SP_EEPROM_HEADER_BIG:   EEPROM header size for "big" devices (> 8K)
 */
enum rave_sp_eeprom_header_size {
        RAVE_SP_EEPROM_HEADER_SMALL = 4U,
        RAVE_SP_EEPROM_HEADER_BIG   = 5U,
};
#define RAVE_SP_EEPROM_HEADER_MAX       RAVE_SP_EEPROM_HEADER_BIG

#define RAVE_SP_EEPROM_PAGE_SIZE        32U

/**
 * struct rave_sp_eeprom_page - RAVE SP EEPROM page
 *
 * @type:       Access type (see enum rave_sp_eeprom_access_type)
 * @success:    Success flag (Success = 1, Failure = 0)
 * @data:       Read data

 * Note this structure corresponds to RSP_*_EEPROM payload from RAVE
 * SP ICD
 */
struct rave_sp_eeprom_page {
        u8  type;
        u8  success;
        u8  data[RAVE_SP_EEPROM_PAGE_SIZE];
} __packed;

/**
 * struct rave_sp_eeprom - RAVE SP EEPROM device
 *
 * @sp:                 Pointer to parent RAVE SP device
 * @mutex:              Lock protecting access to EEPROM
 * @address:            EEPROM device address
 * @header_size:        Size of EEPROM command header for this device
 * @dev:                Pointer to corresponding struct device used for logging
 */
struct rave_sp_eeprom {
        struct rave_sp *sp;
        struct mutex mutex;
        u8 address;
        unsigned int header_size;
        struct device *dev;
};

/**
 * rave_sp_eeprom_io - Low-level part of EEPROM page access
 *
 * @eeprom:     EEPROM device to write to
 * @type:       EEPROM access type (read or write)
 * @idx:        number of the EEPROM page
 * @page:       Data to write or buffer to store result (via page->data)
 *
 * This function does all of the low-level work required to perform a
 * EEPROM access. This includes formatting correct command payload,
 * sending it and checking received results.
 *
 * Returns zero in case of success or negative error code in
 * case of failure.
 */
static int rave_sp_eeprom_io(struct rave_sp_eeprom *eeprom,
                             enum rave_sp_eeprom_access_type type,
                             u16 idx,
                             struct rave_sp_eeprom_page *page)
{
        const bool is_write = type == RAVE_SP_EEPROM_WRITE;
        const unsigned int data_size = is_write ? sizeof(page->data) : 0;
        const unsigned int cmd_size = eeprom->header_size + data_size;
        const unsigned int rsp_size =
                is_write ? sizeof(*page) - sizeof(page->data) : sizeof(*page);
        unsigned int offset = 0;
        u8 cmd[RAVE_SP_EEPROM_HEADER_MAX + sizeof(page->data)];
        int ret;

        if (WARN_ON(cmd_size > sizeof(cmd)))
                return -EINVAL;

        cmd[offset++] = eeprom->address;
        cmd[offset++] = 0;
        cmd[offset++] = type;
        cmd[offset++] = idx;

        /*
         * If there's still room in this command's header it means we
         * are talkin to EEPROM that uses 16-bit page numbers and we
         * have to specify index's MSB in payload as well.
         */
        if (offset < eeprom->header_size)
                cmd[offset++] = idx >> 8;
        /*
         * Copy our data to write to command buffer first. In case of
         * a read data_size should be zero and memcpy would become a
         * no-op
         */
        memcpy(&cmd[offset], page->data, data_size);

        ret = rave_sp_exec(eeprom->sp, cmd, cmd_size, page, rsp_size);
        if (ret)
                return ret;

        if (page->type != type)
                return -EPROTO;

        if (!page->success)
                return -EIO;

        return 0;
}

/**
 * rave_sp_eeprom_page_access - Access single EEPROM page
 *
 * @eeprom:     EEPROM device to access
 * @type:       Access type to perform (read or write)
 * @offset:     Offset within EEPROM to access
 * @data:       Data buffer
 * @data_len:   Size of the data buffer
 *
 * This function performs a generic access to a single page or a
 * portion thereof. Requested access MUST NOT cross the EEPROM page
 * boundary.
 *
 * Returns zero in case of success or negative error code in
 * case of failure.
 */
static int
rave_sp_eeprom_page_access(struct rave_sp_eeprom *eeprom,
                           enum rave_sp_eeprom_access_type type,
                           unsigned int offset, u8 *data,
                           size_t data_len)
{
        const unsigned int page_offset = offset % RAVE_SP_EEPROM_PAGE_SIZE;
        const unsigned int page_nr     = offset / RAVE_SP_EEPROM_PAGE_SIZE;
        struct rave_sp_eeprom_page page;
        int ret;

        /*
         * This function will not work if data access we've been asked
         * to do is crossing EEPROM page boundary. Normally this
         * should never happen and getting here would indicate a bug
         * in the code.
         */
        if (WARN_ON(data_len > sizeof(page.data) - page_offset))
                return -EINVAL;

        if (type == RAVE_SP_EEPROM_WRITE) {
                /*
                 * If doing a partial write we need to do a read first
                 * to fill the rest of the page with correct data.
                 */
                if (data_len < RAVE_SP_EEPROM_PAGE_SIZE) {
                        ret = rave_sp_eeprom_io(eeprom, RAVE_SP_EEPROM_READ,
                                                page_nr, &page);
                        if (ret)
                                return ret;
                }

                memcpy(&page.data[page_offset], data, data_len);
        }

        ret = rave_sp_eeprom_io(eeprom, type, page_nr, &page);
        if (ret)
                return ret;

        /*
         * Since we receive the result of the read via 'page.data'
         * buffer we need to copy that to 'data'
         */
        if (type == RAVE_SP_EEPROM_READ)
                memcpy(data, &page.data[page_offset], data_len);

        return 0;
}

/**
 * rave_sp_eeprom_access - Access EEPROM data
 *
 * @eeprom:     EEPROM device to access
 * @type:       Access type to perform (read or write)
 * @offset:     Offset within EEPROM to access
 * @data:       Data buffer
 * @data_len:   Size of the data buffer
 *
 * This function performs a generic access (either read or write) at
 * arbitrary offset (not necessary page aligned) of arbitrary length
 * (is not constrained by EEPROM page size).
 *
 * Returns zero in case of success or negative error code in case of
 * failure.
 */
static int rave_sp_eeprom_access(struct rave_sp_eeprom *eeprom,
                                 enum rave_sp_eeprom_access_type type,
                                 unsigned int offset, u8 *data,
                                 unsigned int data_len)
{
        unsigned int residue;
        unsigned int chunk;
        unsigned int head;
        int ret;

        mutex_lock(&eeprom->mutex);

        head    = offset % RAVE_SP_EEPROM_PAGE_SIZE;
        residue = data_len;

        do {
                /*
                 * First iteration, if we are doing an access that is
                 * not 32-byte aligned, we need to access only data up
                 * to a page boundary to avoid corssing it in
                 * rave_sp_eeprom_page_access()
                 */
                if (unlikely(head)) {
                        chunk = RAVE_SP_EEPROM_PAGE_SIZE - head;
                        /*
                         * This can only happen once per
                         * rave_sp_eeprom_access() call, so we set
                         * head to zero to process all the other
                         * iterations normally.
                         */
                        head  = 0;
                } else {
                        chunk = RAVE_SP_EEPROM_PAGE_SIZE;
                }

                /*
                 * We should never read more that 'residue' bytes
                 */
                chunk = min(chunk, residue);
                ret = rave_sp_eeprom_page_access(eeprom, type, offset,
                                                 data, chunk);
                if (ret)
                        goto out;

                residue -= chunk;
                offset  += chunk;
                data    += chunk;
        } while (residue);
out:
        mutex_unlock(&eeprom->mutex);
        return ret;
}

static int rave_sp_eeprom_reg_read(void *eeprom, unsigned int offset,
                                   void *val, size_t bytes)
{
        return rave_sp_eeprom_access(eeprom, RAVE_SP_EEPROM_READ,
                                     offset, val, bytes);
}

static int rave_sp_eeprom_reg_write(void *eeprom, unsigned int offset,
                                    void *val, size_t bytes)
{
        return rave_sp_eeprom_access(eeprom, RAVE_SP_EEPROM_WRITE,
                                     offset, val, bytes);
}

static int rave_sp_eeprom_probe(struct platform_device *pdev)
{
        struct device *dev = &pdev->dev;
        struct rave_sp *sp = dev_get_drvdata(dev->parent);
        struct device_node *np = dev->of_node;
        struct nvmem_config config = { 0 };
        struct rave_sp_eeprom *eeprom;
        struct nvmem_device *nvmem;
        u32 reg[2], size;

        if (of_property_read_u32_array(np, "reg", reg, ARRAY_SIZE(reg))) {
                dev_err(dev, "Failed to parse \"reg\" property\n");
                return -EINVAL;
        }

        size = reg[1];
        /*
         * Per ICD, we have no more than 2 bytes to specify EEPROM
         * page.
         */
        if (size > U16_MAX * RAVE_SP_EEPROM_PAGE_SIZE) {
                dev_err(dev, "Specified size is too big\n");
                return -EINVAL;
        }

        eeprom = devm_kzalloc(dev, sizeof(*eeprom), GFP_KERNEL);
        if (!eeprom)
                return -ENOMEM;

        eeprom->address = reg[0];
        eeprom->sp      = sp;
        eeprom->dev     = dev;

        if (size > SZ_8K)
                eeprom->header_size = RAVE_SP_EEPROM_HEADER_BIG;
        else
                eeprom->header_size = RAVE_SP_EEPROM_HEADER_SMALL;

        mutex_init(&eeprom->mutex);

        config.id               = -1;
        of_property_read_string(np, "zii,eeprom-name", &config.name);
        config.priv             = eeprom;
        config.dev              = dev;
        config.size             = size;
        config.reg_read         = rave_sp_eeprom_reg_read;
        config.reg_write        = rave_sp_eeprom_reg_write;
        config.word_size        = 1;
        config.stride           = 1;

        nvmem = devm_nvmem_register(dev, &config);

        return PTR_ERR_OR_ZERO(nvmem);
}

static const struct of_device_id rave_sp_eeprom_of_match[] = {
        { .compatible = "zii,rave-sp-eeprom" },
        {}
};
MODULE_DEVICE_TABLE(of, rave_sp_eeprom_of_match);

static struct platform_driver rave_sp_eeprom_driver = {
        .probe = rave_sp_eeprom_probe,
        .driver = {
                .name = KBUILD_MODNAME,
                .of_match_table = rave_sp_eeprom_of_match,
        },
};
module_platform_driver(rave_sp_eeprom_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Andrey Vostrikov <andrey.vostrikov@cogentembedded.com>");
MODULE_AUTHOR("Nikita Yushchenko <nikita.yoush@cogentembedded.com>");
MODULE_AUTHOR("Andrey Smirnov <andrew.smirnov@gmail.com>");
MODULE_DESCRIPTION("RAVE SP EEPROM driver");