[people/ms/u-boot.git] / drivers / misc / i2c_eeprom_emul.c

/*
 * Simulate an I2C eeprom
 *
 * Copyright (c) 2014 Google, Inc
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <dm.h>
#include <errno.h>
#include <fdtdec.h>
#include <i2c.h>
#include <malloc.h>
#include <asm/test.h>

#ifdef DEBUG
#define debug_buffer print_buffer
#else
#define debug_buffer(x, ...)
#endif

DECLARE_GLOBAL_DATA_PTR;

struct sandbox_i2c_flash_plat_data {
	enum sandbox_i2c_eeprom_test_mode test_mode;
	const char *filename;
	int offset_len;		/* Length of an offset in bytes */
	int size;		/* Size of data buffer */
};

struct sandbox_i2c_flash {
	uint8_t *data;
};

void sandbox_i2c_eeprom_set_test_mode(struct udevice *dev,
				      enum sandbox_i2c_eeprom_test_mode mode)
{
	struct sandbox_i2c_flash_plat_data *plat = dev_get_platdata(dev);

	plat->test_mode = mode;
}

void sandbox_i2c_eeprom_set_offset_len(struct udevice *dev, int offset_len)
{
	struct sandbox_i2c_flash_plat_data *plat = dev_get_platdata(dev);

	plat->offset_len = offset_len;
}

static int sandbox_i2c_eeprom_xfer(struct udevice *emul, struct i2c_msg *msg,
				  int nmsgs)
{
	struct sandbox_i2c_flash *priv = dev_get_priv(emul);
	uint offset = 0;

	debug("\n%s\n", __func__);
	debug_buffer(0, priv->data, 1, 16, 0);
	for (; nmsgs > 0; nmsgs--, msg++) {
		struct sandbox_i2c_flash_plat_data *plat =
				dev_get_platdata(emul);
		int len;
		u8 *ptr;

		if (!plat->size)
			return -ENODEV;
		if (msg->addr + msg->len > plat->size) {
			debug("%s: Address %x, len %x is outside range 0..%x\n",
			      __func__, msg->addr, msg->len, plat->size);
			return -EINVAL;
		}
		len = msg->len;
		debug("   %s: msg->len=%d",
		      msg->flags & I2C_M_RD ? "read" : "write",
		      msg->len);
		if (msg->flags & I2C_M_RD) {
			if (plat->test_mode == SIE_TEST_MODE_SINGLE_BYTE)
				len = 1;
			debug(", offset %x, len %x: ", offset, len);
			memcpy(msg->buf, priv->data + offset, len);
			memset(msg->buf + len, '\xff', msg->len - len);
			debug_buffer(0, msg->buf, 1, msg->len, 0);
		} else if (len >= plat->offset_len) {
			int i;

			ptr = msg->buf;
			for (i = 0; i < plat->offset_len; i++, len--)
				offset = (offset << 8) | *ptr++;
			debug(", set offset %x: ", offset);
			debug_buffer(0, msg->buf, 1, msg->len, 0);
			if (plat->test_mode == SIE_TEST_MODE_SINGLE_BYTE)
				len = min(len, 1);

			/* For testing, map offsets into our limited buffer */
			for (i = 24; i > 0; i -= 8) {
				if (offset > (1 << i)) {
					offset = (offset >> i) |
						(offset & ((1 << i) - 1));
					offset += i;
				}
			}
			memcpy(priv->data + offset, ptr, len);
		}
	}
	debug_buffer(0, priv->data, 1, 16, 0);

	return 0;
}

struct dm_i2c_ops sandbox_i2c_emul_ops = {
	.xfer = sandbox_i2c_eeprom_xfer,
};

static int sandbox_i2c_eeprom_ofdata_to_platdata(struct udevice *dev)
{
	struct sandbox_i2c_flash_plat_data *plat = dev_get_platdata(dev);

	plat->size = fdtdec_get_int(gd->fdt_blob, dev_of_offset(dev),
				    "sandbox,size", 32);
	plat->filename = fdt_getprop(gd->fdt_blob, dev_of_offset(dev),
				     "sandbox,filename", NULL);
	if (!plat->filename) {
		debug("%s: No filename for device '%s'\n", __func__,
		      dev->name);
		return -EINVAL;
	}
	plat->test_mode = SIE_TEST_MODE_NONE;
	plat->offset_len = 1;

	return 0;
}

static int sandbox_i2c_eeprom_probe(struct udevice *dev)
{
	struct sandbox_i2c_flash_plat_data *plat = dev_get_platdata(dev);
	struct sandbox_i2c_flash *priv = dev_get_priv(dev);

	priv->data = calloc(1, plat->size);
	if (!priv->data)
		return -ENOMEM;

	return 0;
}

static int sandbox_i2c_eeprom_remove(struct udevice *dev)
{
	struct sandbox_i2c_flash *priv = dev_get_priv(dev);

	free(priv->data);

	return 0;
}

static const struct udevice_id sandbox_i2c_ids[] = {
	{ .compatible = "sandbox,i2c-eeprom" },
	{ }
};

U_BOOT_DRIVER(sandbox_i2c_emul) = {
	.name		= "sandbox_i2c_eeprom_emul",
	.id		= UCLASS_I2C_EMUL,
	.of_match	= sandbox_i2c_ids,
	.ofdata_to_platdata = sandbox_i2c_eeprom_ofdata_to_platdata,
	.probe		= sandbox_i2c_eeprom_probe,
	.remove		= sandbox_i2c_eeprom_remove,
	.priv_auto_alloc_size = sizeof(struct sandbox_i2c_flash),
	.platdata_auto_alloc_size = sizeof(struct sandbox_i2c_flash_plat_data),
	.ops		= &sandbox_i2c_emul_ops,
};
Commit	Line	Data
6ec1b753 SG	1	/*
	2	* Simulate an I2C eeprom
	3	*
	4	* Copyright (c) 2014 Google, Inc
	5	*
	6	* SPDX-License-Identifier: GPL-2.0+
	7	*/
	8
	9	#include <common.h>
	10	#include <dm.h>
38068820	11	#include <errno.h>
6ec1b753 SG	12	#include <fdtdec.h>
	13	#include <i2c.h>
	14	#include <malloc.h>
	15	#include <asm/test.h>
	16
	17	#ifdef DEBUG
	18	#define debug_buffer print_buffer
	19	#else
	20	#define debug_buffer(x, ...)
	21	#endif
	22
	23	DECLARE_GLOBAL_DATA_PTR;
	24
	25	struct sandbox_i2c_flash_plat_data {
	26	enum sandbox_i2c_eeprom_test_mode test_mode;
	27	const char *filename;
	28	int offset_len; /* Length of an offset in bytes */
	29	int size; /* Size of data buffer */
	30	};
	31
	32	struct sandbox_i2c_flash {
	33	uint8_t *data;
	34	};
	35
	36	void sandbox_i2c_eeprom_set_test_mode(struct udevice *dev,
	37	enum sandbox_i2c_eeprom_test_mode mode)
	38	{
	39	struct sandbox_i2c_flash_plat_data *plat = dev_get_platdata(dev);
	40
	41	plat->test_mode = mode;
	42	}
	43
	44	void sandbox_i2c_eeprom_set_offset_len(struct udevice *dev, int offset_len)
	45	{
	46	struct sandbox_i2c_flash_plat_data *plat = dev_get_platdata(dev);
	47
	48	plat->offset_len = offset_len;
	49	}
	50
	51	static int sandbox_i2c_eeprom_xfer(struct udevice emul, struct i2c_msg msg,
	52	int nmsgs)
	53	{
	54	struct sandbox_i2c_flash *priv = dev_get_priv(emul);
	55	uint offset = 0;
	56
	57	debug("\n%s\n", __func__);
	58	debug_buffer(0, priv->data, 1, 16, 0);
	59	for (; nmsgs > 0; nmsgs--, msg++) {
	60	struct sandbox_i2c_flash_plat_data *plat =
	61	dev_get_platdata(emul);
	62	int len;
	63	u8 *ptr;
	64
	65	if (!plat->size)
	66	return -ENODEV;
	67	if (msg->addr + msg->len > plat->size) {
	68	debug("%s: Address %x, len %x is outside range 0..%x\n",
	69	__func__, msg->addr, msg->len, plat->size);
	70	return -EINVAL;
	71	}
	72	len = msg->len;
	73	debug(" %s: msg->len=%d",
	74	msg->flags & I2C_M_RD ? "read" : "write",
	75	msg->len);
76	if (msg->flags & I2C_M_RD) {
77	if (plat->test_mode == SIE_TEST_MODE_SINGLE_BYTE)
78	len = 1;
79	debug(", offset %x, len %x: ", offset, len);
80	memcpy(msg->buf, priv->data + offset, len);
81	memset(msg->buf + len, '\xff', msg->len - len);
82	debug_buffer(0, msg->buf, 1, msg->len, 0);
83	} else if (len >= plat->offset_len) {
84	int i;
85
86	ptr = msg->buf;
87	for (i = 0; i < plat->offset_len; i++, len--)
88	offset = (offset << 8) \| *ptr++;
89	debug(", set offset %x: ", offset);
90	debug_buffer(0, msg->buf, 1, msg->len, 0);
91	if (plat->test_mode == SIE_TEST_MODE_SINGLE_BYTE)
92	len = min(len, 1);
93
94	/* For testing, map offsets into our limited buffer */
95	for (i = 24; i > 0; i -= 8) {
96	if (offset > (1 << i)) {
97	offset = (offset >> i) \|
98	(offset & ((1 << i) - 1));
99	offset += i;
100	}
101	}
102	memcpy(priv->data + offset, ptr, len);
103	}
104	}
105	debug_buffer(0, priv->data, 1, 16, 0);
106
107	return 0;
108	}
109
110	struct dm_i2c_ops sandbox_i2c_emul_ops = {
111	.xfer = sandbox_i2c_eeprom_xfer,
112	};
113
114	static int sandbox_i2c_eeprom_ofdata_to_platdata(struct udevice *dev)
115	{
116	struct sandbox_i2c_flash_plat_data *plat = dev_get_platdata(dev);
117
e160f7d4	118	plat->size = fdtdec_get_int(gd->fdt_blob, dev_of_offset(dev),
6ec1b753	119	"sandbox,size", 32);
e160f7d4	120	plat->filename = fdt_getprop(gd->fdt_blob, dev_of_offset(dev),
6ec1b753 SG	121	"sandbox,filename", NULL);
	122	if (!plat->filename) {
	123	debug("%s: No filename for device '%s'\n", __func__,
	124	dev->name);
	125	return -EINVAL;
	126	}
	127	plat->test_mode = SIE_TEST_MODE_NONE;
	128	plat->offset_len = 1;
	129
	130	return 0;
	131	}
	132
	133	static int sandbox_i2c_eeprom_probe(struct udevice *dev)
	134	{
	135	struct sandbox_i2c_flash_plat_data *plat = dev_get_platdata(dev);
	136	struct sandbox_i2c_flash *priv = dev_get_priv(dev);
	137
	138	priv->data = calloc(1, plat->size);
	139	if (!priv->data)
	140	return -ENOMEM;
	141
	142	return 0;
	143	}
	144
	145	static int sandbox_i2c_eeprom_remove(struct udevice *dev)
	146	{
	147	struct sandbox_i2c_flash *priv = dev_get_priv(dev);
	148
	149	free(priv->data);
	150
	151	return 0;
	152	}
	153
	154	static const struct udevice_id sandbox_i2c_ids[] = {
	155	{ .compatible = "sandbox,i2c-eeprom" },
	156	{ }
	157	};
	158
	159	U_BOOT_DRIVER(sandbox_i2c_emul) = {
	160	.name = "sandbox_i2c_eeprom_emul",
	161	.id = UCLASS_I2C_EMUL,
	162	.of_match = sandbox_i2c_ids,
	163	.ofdata_to_platdata = sandbox_i2c_eeprom_ofdata_to_platdata,
	164	.probe = sandbox_i2c_eeprom_probe,
	165	.remove = sandbox_i2c_eeprom_remove,
	166	.priv_auto_alloc_size = sizeof(struct sandbox_i2c_flash),
	167	.platdata_auto_alloc_size = sizeof(struct sandbox_i2c_flash_plat_data),
	168	.ops = &sandbox_i2c_emul_ops,
	169	};