// 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");