[people/ms/u-boot.git] / drivers / i2c / sandbox_i2c.c

/*
 * Simulate an I2C port
 *
 * 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 <asm/test.h>
#include <dm/lists.h>
#include <dm/device-internal.h>
#include <dm/root.h>

DECLARE_GLOBAL_DATA_PTR;

struct sandbox_i2c_priv {
	bool test_mode;
};

static int get_emul(struct udevice *dev, struct udevice **devp,
		    struct dm_i2c_ops **opsp)
{
	struct dm_i2c_chip *plat;
	struct udevice *child;
	int ret;

	*devp = NULL;
	*opsp = NULL;
	plat = dev_get_parent_platdata(dev);
	if (!plat->emul) {
		ret = dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset,
				       false);
		if (ret)
			return ret;

		for (device_find_first_child(dev, &child); child;
		     device_find_next_child(&child)) {
			if (device_get_uclass_id(child) != UCLASS_I2C_EMUL)
				continue;

			ret = device_probe(child);
			if (ret)
				return ret;

			break;
		}

		if (child)
			plat->emul = child;
		else
			return -ENODEV;
	}
	*devp = plat->emul;
	*opsp = i2c_get_ops(plat->emul);

	return 0;
}

void sandbox_i2c_set_test_mode(struct udevice *bus, bool test_mode)
{
	struct sandbox_i2c_priv *priv = dev_get_priv(bus);

	priv->test_mode = test_mode;
}

static int sandbox_i2c_xfer(struct udevice *bus, struct i2c_msg *msg,
			    int nmsgs)
{
	struct dm_i2c_bus *i2c = dev_get_uclass_priv(bus);
	struct sandbox_i2c_priv *priv = dev_get_priv(bus);
	struct dm_i2c_ops *ops;
	struct udevice *emul, *dev;
	bool is_read;
	int ret;

	/* Special test code to return success but with no emulation */
	if (priv->test_mode && msg->addr == SANDBOX_I2C_TEST_ADDR)
		return 0;

	ret = i2c_get_chip(bus, msg->addr, 1, &dev);
	if (ret)
		return ret;

	ret = get_emul(dev, &emul, &ops);
	if (ret)
		return ret;

	if (priv->test_mode) {
		/*
		* For testing, don't allow writing above 100KHz for writes and
		* 400KHz for reads.
		*/
		is_read = nmsgs > 1;
		if (i2c->speed_hz > (is_read ? 400000 : 100000)) {
			debug("%s: Max speed exceeded\n", __func__);
			return -EINVAL;
		}
	}

	return ops->xfer(emul, msg, nmsgs);
}

static const struct dm_i2c_ops sandbox_i2c_ops = {
	.xfer		= sandbox_i2c_xfer,
};

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

U_BOOT_DRIVER(i2c_sandbox) = {
	.name	= "i2c_sandbox",
	.id	= UCLASS_I2C,
	.of_match = sandbox_i2c_ids,
	.ops	= &sandbox_i2c_ops,
	.priv_auto_alloc_size = sizeof(struct sandbox_i2c_priv),
};
Commit	Line	Data
d19de0d3 SG	1	/*
	2	* Simulate an I2C port
	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>
	11	#include <errno.h>
	12	#include <fdtdec.h>
	13	#include <i2c.h>
	14	#include <asm/test.h>
	15	#include <dm/lists.h>
	16	#include <dm/device-internal.h>
	17	#include <dm/root.h>
	18
	19	DECLARE_GLOBAL_DATA_PTR;
	20
182bf92d SG	21	struct sandbox_i2c_priv {
182bf92d SG	22	bool test_mode;
d19de0d3 SG	23	};
	24
	25	static int get_emul(struct udevice dev, struct udevice *devp,
	26	struct dm_i2c_ops **opsp)
	27	{
e6f66ec0	28	struct dm_i2c_chip *plat;
a989ec8d	29	struct udevice *child;
d19de0d3 SG	30	int ret;
	31
	32	*devp = NULL;
	33	*opsp = NULL;
e6f66ec0 SG	34	plat = dev_get_parent_platdata(dev);
e6f66ec0 SG	35	if (!plat->emul) {
d19de0d3 SG	36	ret = dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset,
	37	false);
	38	if (ret)
	39	return ret;
	40
a989ec8d PM	41	for (device_find_first_child(dev, &child); child;
	42	device_find_next_child(&child)) {
	43	if (device_get_uclass_id(child) != UCLASS_I2C_EMUL)
	44	continue;
	45
	46	ret = device_probe(child);
	47	if (ret)
	48	return ret;
	49
	50	break;
	51	}
	52
	53	if (child)
	54	plat->emul = child;
	55	else
	56	return -ENODEV;
d19de0d3	57	}
e6f66ec0 SG	58	*devp = plat->emul;
e6f66ec0 SG	59	*opsp = i2c_get_ops(plat->emul);
d19de0d3 SG	60
	61	return 0;
	62	}
	63
182bf92d SG	64	void sandbox_i2c_set_test_mode(struct udevice *bus, bool test_mode)
	65	{
	66	struct sandbox_i2c_priv *priv = dev_get_priv(bus);
	67
	68	priv->test_mode = test_mode;
	69	}
	70
d19de0d3 SG	71	static int sandbox_i2c_xfer(struct udevice bus, struct i2c_msg msg,
	72	int nmsgs)
	73	{
e564f054	74	struct dm_i2c_bus *i2c = dev_get_uclass_priv(bus);
182bf92d	75	struct sandbox_i2c_priv *priv = dev_get_priv(bus);
d19de0d3 SG	76	struct dm_i2c_ops *ops;
	77	struct udevice emul, dev;
	78	bool is_read;
	79	int ret;
	80
	81	/* Special test code to return success but with no emulation */
182bf92d	82	if (priv->test_mode && msg->addr == SANDBOX_I2C_TEST_ADDR)
d19de0d3 SG	83	return 0;
d19de0d3 SG	84
25ab4b03	85	ret = i2c_get_chip(bus, msg->addr, 1, &dev);
d19de0d3 SG	86	if (ret)
	87	return ret;
	88
	89	ret = get_emul(dev, &emul, &ops);
	90	if (ret)
	91	return ret;
	92
182bf92d SG	93	if (priv->test_mode) {
	94	/*
	95	* For testing, don't allow writing above 100KHz for writes and
	96	* 400KHz for reads.
	97	*/
	98	is_read = nmsgs > 1;
	99	if (i2c->speed_hz > (is_read ? 400000 : 100000)) {
	100	debug("%s: Max speed exceeded\n", __func__);
	101	return -EINVAL;
	102	}
1bde67b1	103	}
182bf92d	104
d19de0d3 SG	105	return ops->xfer(emul, msg, nmsgs);
	106	}
	107
	108	static const struct dm_i2c_ops sandbox_i2c_ops = {
	109	.xfer = sandbox_i2c_xfer,
	110	};
	111
d19de0d3 SG	112	static const struct udevice_id sandbox_i2c_ids[] = {
	113	{ .compatible = "sandbox,i2c" },
	114	{ }
	115	};
	116
	117	U_BOOT_DRIVER(i2c_sandbox) = {
	118	.name = "i2c_sandbox",
	119	.id = UCLASS_I2C,
	120	.of_match = sandbox_i2c_ids,
d19de0d3	121	.ops = &sandbox_i2c_ops,
182bf92d	122	.priv_auto_alloc_size = sizeof(struct sandbox_i2c_priv),
d19de0d3	123	};