// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2013 Intel Corporation. All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 as published by the Free Software Foundation.
 *
 * This program 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 General Public License for more details.
 *
 *
 */
#include <linux/i2c.h>
#include <linux/firmware.h>
#include <linux/device.h>
#include <linux/export.h>
#include "../include/linux/libmsrlisthelper.h"
#include <linux/module.h>
#include <linux/slab.h>

/* Tagged binary data container structure definitions. */
struct tbd_header {
        u32 tag;          /*!< Tag identifier, also checks endianness */
        u32 size;         /*!< Container size including this header */
        u32 version;      /*!< Version, format 0xYYMMDDVV */
        u32 revision;     /*!< Revision, format 0xYYMMDDVV */
        u32 config_bits;  /*!< Configuration flag bits set */
        u32 checksum;     /*!< Global checksum, header included */
} __packed;

struct tbd_record_header {
        u32 size;        /*!< Size of record including header */
        u8 format_id;    /*!< tbd_format_t enumeration values used */
        u8 packing_key;  /*!< Packing method; 0 = no packing */
        u16 class_id;    /*!< tbd_class_t enumeration values used */
} __packed;

struct tbd_data_record_header {
        u16 next_offset;
        u16 flags;
        u16 data_offset;
        u16 data_size;
} __packed;

#define TBD_CLASS_DRV_ID 2

static int set_msr_configuration(struct i2c_client *client, uint8_t *bufptr,
                                 unsigned int size)
{
        /*
         * The configuration data contains any number of sequences where
         * the first byte (that is, uint8_t) that marks the number of bytes
         * in the sequence to follow, is indeed followed by the indicated
         * number of bytes of actual data to be written to sensor.
         * By convention, the first two bytes of actual data should be
         * understood as an address in the sensor address space (hibyte
         * followed by lobyte) where the remaining data in the sequence
         * will be written.
         */

        u8 *ptr = bufptr;

        while (ptr < bufptr + size) {
                struct i2c_msg msg = {
                        .addr = client->addr,
                        .flags = 0,
                };
                int ret;

                /* How many bytes */
                msg.len = *ptr++;
                /* Where the bytes are located */
                msg.buf = ptr;
                ptr += msg.len;

                if (ptr > bufptr + size)
                        /* Accessing data beyond bounds is not tolerated */
                        return -EINVAL;

                ret = i2c_transfer(client->adapter, &msg, 1);
                if (ret < 0) {
                        dev_err(&client->dev, "i2c write error: %d", ret);
                        return ret;
                }
        }
        return 0;
}

static int parse_and_apply(struct i2c_client *client, uint8_t *buffer,
                           unsigned int size)
{
        u8 *endptr8 = buffer + size;
        struct tbd_data_record_header *header =
            (struct tbd_data_record_header *)buffer;

        /* There may be any number of datasets present */
        unsigned int dataset = 0;

        do {
                /* In below, four variables are read from buffer */
                if ((uint8_t *)header + sizeof(*header) > endptr8)
                        return -EINVAL;

                /* All data should be located within given buffer */
                if ((uint8_t *)header + header->data_offset +
                    header->data_size > endptr8)
                        return -EINVAL;

                /* We have a new valid dataset */
                dataset++;
                /* See whether there is MSR data */
                /* If yes, update the reg info */
                if (header->data_size && (header->flags & 1)) {
                        int ret;

                        dev_info(&client->dev,
                                 "New MSR data for sensor driver (dataset %02d) size:%d\n",
                                 dataset, header->data_size);
                        ret = set_msr_configuration(client,
                                                    buffer + header->data_offset,
                                                    header->data_size);
                        if (ret)
                                return ret;
                }
                header = (struct tbd_data_record_header *)(buffer +
                         header->next_offset);
        } while (header->next_offset);

        return 0;
}

int apply_msr_data(struct i2c_client *client, const struct firmware *fw)
{
        struct tbd_header *header;
        struct tbd_record_header *record;

        if (!fw) {
                dev_warn(&client->dev, "Drv data is not loaded.\n");
                return -EINVAL;
        }

        if (sizeof(*header) > fw->size)
                return -EINVAL;

        header = (struct tbd_header *)fw->data;
        /* Check that we have drvb block. */
        if (memcmp(&header->tag, "DRVB", 4))
                return -EINVAL;

        /* Check the size */
        if (header->size != fw->size)
                return -EINVAL;

        if (sizeof(*header) + sizeof(*record) > fw->size)
                return -EINVAL;

        record = (struct tbd_record_header *)(header + 1);
        /* Check that class id mathes tbd's drv id. */
        if (record->class_id != TBD_CLASS_DRV_ID)
                return -EINVAL;

        /* Size 0 shall not be treated as an error */
        if (!record->size)
                return 0;

        return parse_and_apply(client, (uint8_t *)(record + 1), record->size);
}
EXPORT_SYMBOL_GPL(apply_msr_data);

int load_msr_list(struct i2c_client *client, char *name,
                  const struct firmware **fw)
{
        int ret = request_firmware(fw, name, &client->dev);

        if (ret) {
                dev_err(&client->dev,
                        "Error %d while requesting firmware %s\n",
                        ret, name);
                return ret;
        }
        dev_info(&client->dev, "Received %lu bytes drv data\n",
                 (unsigned long)(*fw)->size);

        return 0;
}
EXPORT_SYMBOL_GPL(load_msr_list);

void release_msr_list(struct i2c_client *client, const struct firmware *fw)
{
        release_firmware(fw);
}
EXPORT_SYMBOL_GPL(release_msr_list);

static int init_msrlisthelper(void)
{
        return 0;
}

static void exit_msrlisthelper(void)
{
}

module_init(init_msrlisthelper);
module_exit(exit_msrlisthelper);

MODULE_AUTHOR("Jukka Kaartinen <jukka.o.kaartinen@intel.com>");
MODULE_LICENSE("GPL");