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

/*
 * 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 <dm/device-internal.h>
#include <dm/lists.h>
#include <dm/root.h>

DECLARE_GLOBAL_DATA_PTR;

#define I2C_MAX_OFFSET_LEN	4

/**
 * i2c_setup_offset() - Set up a new message with a chip offset
 *
 * @chip:	Chip to use
 * @offset:	Byte offset within chip
 * @offset_buf:	Place to put byte offset
 * @msg:	Message buffer
 * @return 0 if OK, -EADDRNOTAVAIL if the offset length is 0. In that case the
 * message is still set up but will not contain an offset.
 */
static int i2c_setup_offset(struct dm_i2c_chip *chip, uint offset,
			    uint8_t offset_buf[], struct i2c_msg *msg)
{
	int offset_len;

	msg->addr = chip->chip_addr;
	msg->flags = chip->flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
	msg->len = chip->offset_len;
	msg->buf = offset_buf;
	if (!chip->offset_len)
		return -EADDRNOTAVAIL;
	assert(chip->offset_len <= I2C_MAX_OFFSET_LEN);
	offset_len = chip->offset_len;
	while (offset_len--)
		*offset_buf++ = offset >> (8 * offset_len);

	return 0;
}

static int i2c_read_bytewise(struct udevice *dev, uint offset,
			     uint8_t *buffer, int len)
{
	struct dm_i2c_chip *chip = dev_get_parentdata(dev);
	struct udevice *bus = dev_get_parent(dev);
	struct dm_i2c_ops *ops = i2c_get_ops(bus);
	struct i2c_msg msg[2], *ptr;
	uint8_t offset_buf[I2C_MAX_OFFSET_LEN];
	int ret;
	int i;

	for (i = 0; i < len; i++) {
		if (i2c_setup_offset(chip, offset + i, offset_buf, msg))
			return -EINVAL;
		ptr = msg + 1;
		ptr->addr = chip->chip_addr;
		ptr->flags = msg->flags | I2C_M_RD;
		ptr->len = 1;
		ptr->buf = &buffer[i];
		ptr++;

		ret = ops->xfer(bus, msg, ptr - msg);
		if (ret)
			return ret;
	}

	return 0;
}

static int i2c_write_bytewise(struct udevice *dev, uint offset,
			     const uint8_t *buffer, int len)
{
	struct dm_i2c_chip *chip = dev_get_parentdata(dev);
	struct udevice *bus = dev_get_parent(dev);
	struct dm_i2c_ops *ops = i2c_get_ops(bus);
	struct i2c_msg msg[1];
	uint8_t buf[I2C_MAX_OFFSET_LEN + 1];
	int ret;
	int i;

	for (i = 0; i < len; i++) {
		if (i2c_setup_offset(chip, offset + i, buf, msg))
			return -EINVAL;
		buf[msg->len++] = buffer[i];

		ret = ops->xfer(bus, msg, 1);
		if (ret)
			return ret;
	}

	return 0;
}

int dm_i2c_read(struct udevice *dev, uint offset, uint8_t *buffer, int len)
{
	struct dm_i2c_chip *chip = dev_get_parentdata(dev);
	struct udevice *bus = dev_get_parent(dev);
	struct dm_i2c_ops *ops = i2c_get_ops(bus);
	struct i2c_msg msg[2], *ptr;
	uint8_t offset_buf[I2C_MAX_OFFSET_LEN];
	int msg_count;

	if (!ops->xfer)
		return -ENOSYS;
	if (chip->flags & DM_I2C_CHIP_RD_ADDRESS)
		return i2c_read_bytewise(dev, offset, buffer, len);
	ptr = msg;
	if (!i2c_setup_offset(chip, offset, offset_buf, ptr))
		ptr++;

	if (len) {
		ptr->addr = chip->chip_addr;
		ptr->flags = chip->flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
		ptr->flags |= I2C_M_RD;
		ptr->len = len;
		ptr->buf = buffer;
		ptr++;
	}
	msg_count = ptr - msg;

	return ops->xfer(bus, msg, msg_count);
}

int dm_i2c_write(struct udevice *dev, uint offset, const uint8_t *buffer,
		 int len)
{
	struct dm_i2c_chip *chip = dev_get_parentdata(dev);
	struct udevice *bus = dev_get_parent(dev);
	struct dm_i2c_ops *ops = i2c_get_ops(bus);
	struct i2c_msg msg[1];

	if (!ops->xfer)
		return -ENOSYS;

	if (chip->flags & DM_I2C_CHIP_WR_ADDRESS)
		return i2c_write_bytewise(dev, offset, buffer, len);
	/*
	 * The simple approach would be to send two messages here: one to
	 * set the offset and one to write the bytes. However some drivers
	 * will not be expecting this, and some chips won't like how the
	 * driver presents this on the I2C bus.
	 *
	 * The API does not support separate offset and data. We could extend
	 * it with a flag indicating that there is data in the next message
	 * that needs to be processed in the same transaction. We could
	 * instead add an additional buffer to each message. For now, handle
	 * this in the uclass since it isn't clear what the impact on drivers
	 * would be with this extra complication. Unfortunately this means
	 * copying the message.
	 *
	 * Use the stack for small messages, malloc() for larger ones. We
	 * need to allow space for the offset (up to 4 bytes) and the message
	 * itself.
	 */
	if (len < 64) {
		uint8_t buf[I2C_MAX_OFFSET_LEN + len];

		i2c_setup_offset(chip, offset, buf, msg);
		msg->len += len;
		memcpy(buf + chip->offset_len, buffer, len);

		return ops->xfer(bus, msg, 1);
	} else {
		uint8_t *buf;
		int ret;

		buf = malloc(I2C_MAX_OFFSET_LEN + len);
		if (!buf)
			return -ENOMEM;
		i2c_setup_offset(chip, offset, buf, msg);
		msg->len += len;
		memcpy(buf + chip->offset_len, buffer, len);

		ret = ops->xfer(bus, msg, 1);
		free(buf);
		return ret;
	}
}

/**
 * i2c_probe_chip() - probe for a chip on a bus
 *
 * @bus:	Bus to probe
 * @chip_addr:	Chip address to probe
 * @flags:	Flags for the chip
 * @return 0 if found, -ENOSYS if the driver is invalid, -EREMOTEIO if the chip
 * does not respond to probe
 */
static int i2c_probe_chip(struct udevice *bus, uint chip_addr,
			  enum dm_i2c_chip_flags chip_flags)
{
	struct dm_i2c_ops *ops = i2c_get_ops(bus);
	struct i2c_msg msg[1];
	int ret;

	if (ops->probe_chip) {
		ret = ops->probe_chip(bus, chip_addr, chip_flags);
		if (!ret || ret != -ENOSYS)
			return ret;
	}

	if (!ops->xfer)
		return -ENOSYS;

	/* Probe with a zero-length message */
	msg->addr = chip_addr;
	msg->flags = chip_flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
	msg->len = 0;
	msg->buf = NULL;

	return ops->xfer(bus, msg, 1);
}

static int i2c_bind_driver(struct udevice *bus, uint chip_addr,
			   struct udevice **devp)
{
	struct dm_i2c_chip chip;
	char name[30], *str;
	struct udevice *dev;
	int ret;

	snprintf(name, sizeof(name), "generic_%x", chip_addr);
	str = strdup(name);
	ret = device_bind_driver(bus, "i2c_generic_chip_drv", str, &dev);
	debug("%s:  device_bind_driver: ret=%d\n", __func__, ret);
	if (ret)
		goto err_bind;

	/* Tell the device what we know about it */
	memset(&chip, '\0', sizeof(chip));
	chip.chip_addr = chip_addr;
	chip.offset_len = 1;	/* we assume */
	ret = device_probe_child(dev, &chip);
	debug("%s:  device_probe_child: ret=%d\n", __func__, ret);
	if (ret)
		goto err_probe;

	*devp = dev;
	return 0;

err_probe:
	device_unbind(dev);
err_bind:
	free(str);
	return ret;
}

int i2c_get_chip(struct udevice *bus, uint chip_addr, struct udevice **devp)
{
	struct udevice *dev;

	debug("%s: Searching bus '%s' for address %02x: ", __func__,
	      bus->name, chip_addr);
	for (device_find_first_child(bus, &dev); dev;
			device_find_next_child(&dev)) {
		struct dm_i2c_chip store;
		struct dm_i2c_chip *chip = dev_get_parentdata(dev);
		int ret;

		if (!chip) {
			chip = &store;
			i2c_chip_ofdata_to_platdata(gd->fdt_blob,
						    dev->of_offset, chip);
		}
		if (chip->chip_addr == chip_addr) {
			ret = device_probe(dev);
			debug("found, ret=%d\n", ret);
			if (ret)
				return ret;
			*devp = dev;
			return 0;
		}
	}
	debug("not found\n");
	return i2c_bind_driver(bus, chip_addr, devp);
}

int i2c_get_chip_for_busnum(int busnum, int chip_addr, struct udevice **devp)
{
	struct udevice *bus;
	int ret;

	ret = uclass_get_device_by_seq(UCLASS_I2C, busnum, &bus);
	if (ret) {
		debug("Cannot find I2C bus %d\n", busnum);
		return ret;
	}
	ret = i2c_get_chip(bus, chip_addr, devp);
	if (ret) {
		debug("Cannot find I2C chip %02x on bus %d\n", chip_addr,
		      busnum);
		return ret;
	}

	return 0;
}

int dm_i2c_probe(struct udevice *bus, uint chip_addr, uint chip_flags,
		 struct udevice **devp)
{
	int ret;

	*devp = NULL;

	/* First probe that chip */
	ret = i2c_probe_chip(bus, chip_addr, chip_flags);
	debug("%s: bus='%s', address %02x, ret=%d\n", __func__, bus->name,
	      chip_addr, ret);
	if (ret)
		return ret;

	/* The chip was found, see if we have a driver, and probe it */
	ret = i2c_get_chip(bus, chip_addr, devp);
	debug("%s:  i2c_get_chip: ret=%d\n", __func__, ret);

	return ret;
}

int i2c_set_bus_speed(struct udevice *bus, unsigned int speed)
{
	struct dm_i2c_ops *ops = i2c_get_ops(bus);
	struct dm_i2c_bus *i2c = bus->uclass_priv;
	int ret;

	/*
	 * If we have a method, call it. If not then the driver probably wants
	 * to deal with speed changes on the next transfer. It can easily read
	 * the current speed from this uclass
	 */
	if (ops->set_bus_speed) {
		ret = ops->set_bus_speed(bus, speed);
		if (ret)
			return ret;
	}
	i2c->speed_hz = speed;

	return 0;
}

/*
 * i2c_get_bus_speed:
 *
 *  Returns speed of selected I2C bus in Hz
 */
int i2c_get_bus_speed(struct udevice *bus)
{
	struct dm_i2c_ops *ops = i2c_get_ops(bus);
	struct dm_i2c_bus *i2c = bus->uclass_priv;

	if (!ops->get_bus_speed)
		return i2c->speed_hz;

	return ops->get_bus_speed(bus);
}

int i2c_set_chip_flags(struct udevice *dev, uint flags)
{
	struct udevice *bus = dev->parent;
	struct dm_i2c_chip *chip = dev_get_parentdata(dev);
	struct dm_i2c_ops *ops = i2c_get_ops(bus);
	int ret;

	if (ops->set_flags) {
		ret = ops->set_flags(dev, flags);
		if (ret)
			return ret;
	}
	chip->flags = flags;

	return 0;
}

int i2c_get_chip_flags(struct udevice *dev, uint *flagsp)
{
	struct dm_i2c_chip *chip = dev_get_parentdata(dev);

	*flagsp = chip->flags;

	return 0;
}

int i2c_set_chip_offset_len(struct udevice *dev, uint offset_len)
{
	struct dm_i2c_chip *chip = dev_get_parentdata(dev);

	if (offset_len > I2C_MAX_OFFSET_LEN)
		return -EINVAL;
	chip->offset_len = offset_len;

	return 0;
}

int i2c_deblock(struct udevice *bus)
{
	struct dm_i2c_ops *ops = i2c_get_ops(bus);

	/*
	 * We could implement a software deblocking here if we could get
	 * access to the GPIOs used by I2C, and switch them to GPIO mode
	 * and then back to I2C. This is somewhat beyond our powers in
	 * driver model at present, so for now just fail.
	 *
	 * See https://patchwork.ozlabs.org/patch/399040/
	 */
	if (!ops->deblock)
		return -ENOSYS;

	return ops->deblock(bus);
}

int i2c_chip_ofdata_to_platdata(const void *blob, int node,
				struct dm_i2c_chip *chip)
{
	chip->offset_len = 1;	/* default */
	chip->flags = 0;
	chip->chip_addr = fdtdec_get_int(gd->fdt_blob, node, "reg", -1);
	if (chip->chip_addr == -1) {
		debug("%s: I2C Node '%s' has no 'reg' property\n", __func__,
		      fdt_get_name(blob, node, NULL));
		return -EINVAL;
	}

	return 0;
}

static int i2c_post_probe(struct udevice *dev)
{
	struct dm_i2c_bus *i2c = dev->uclass_priv;

	i2c->speed_hz = fdtdec_get_int(gd->fdt_blob, dev->of_offset,
				     "clock-frequency", 100000);

	return i2c_set_bus_speed(dev, i2c->speed_hz);
}

int i2c_post_bind(struct udevice *dev)
{
	/* Scan the bus for devices */
	return dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset, false);
}

UCLASS_DRIVER(i2c) = {
	.id		= UCLASS_I2C,
	.name		= "i2c",
	.per_device_auto_alloc_size = sizeof(struct dm_i2c_bus),
	.post_bind	= i2c_post_bind,
	.post_probe	= i2c_post_probe,
};

UCLASS_DRIVER(i2c_generic) = {
	.id		= UCLASS_I2C_GENERIC,
	.name		= "i2c_generic",
};

U_BOOT_DRIVER(i2c_generic_chip_drv) = {
	.name		= "i2c_generic_chip_drv",
	.id		= UCLASS_I2C_GENERIC,
};
Commit	Line	Data
c6202d85 SG	1	/*
	2	* Copyright (c) 2014 Google, Inc
	3	*
	4	* SPDX-License-Identifier: GPL-2.0+
	5	*/
	6
	7	#include <common.h>
	8	#include <dm.h>
	9	#include <errno.h>
	10	#include <fdtdec.h>
	11	#include <i2c.h>
	12	#include <malloc.h>
	13	#include <dm/device-internal.h>
	14	#include <dm/lists.h>
	15	#include <dm/root.h>
	16
	17	DECLARE_GLOBAL_DATA_PTR;
	18
	19	#define I2C_MAX_OFFSET_LEN 4
	20
	21	/**
	22	* i2c_setup_offset() - Set up a new message with a chip offset
	23	*
	24	* @chip: Chip to use
	25	* @offset: Byte offset within chip
	26	* @offset_buf: Place to put byte offset
	27	* @msg: Message buffer
	28	* @return 0 if OK, -EADDRNOTAVAIL if the offset length is 0. In that case the
	29	* message is still set up but will not contain an offset.
	30	*/
	31	static int i2c_setup_offset(struct dm_i2c_chip *chip, uint offset,
	32	uint8_t offset_buf[], struct i2c_msg *msg)
	33	{
	34	int offset_len;
	35
	36	msg->addr = chip->chip_addr;
	37	msg->flags = chip->flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
	38	msg->len = chip->offset_len;
	39	msg->buf = offset_buf;
	40	if (!chip->offset_len)
	41	return -EADDRNOTAVAIL;
	42	assert(chip->offset_len <= I2C_MAX_OFFSET_LEN);
	43	offset_len = chip->offset_len;
	44	while (offset_len--)
	45	offset_buf++ = offset >> (8 offset_len);
	46
	47	return 0;
	48	}
	49
	50	static int i2c_read_bytewise(struct udevice *dev, uint offset,
	51	uint8_t *buffer, int len)
	52	{
	53	struct dm_i2c_chip *chip = dev_get_parentdata(dev);
	54	struct udevice *bus = dev_get_parent(dev);
	55	struct dm_i2c_ops *ops = i2c_get_ops(bus);
	56	struct i2c_msg msg[2], *ptr;
	57	uint8_t offset_buf[I2C_MAX_OFFSET_LEN];
	58	int ret;
	59	int i;
	60
	61	for (i = 0; i < len; i++) {
	62	if (i2c_setup_offset(chip, offset + i, offset_buf, msg))
	63	return -EINVAL;
	64	ptr = msg + 1;
65	ptr->addr = chip->chip_addr;
66	ptr->flags = msg->flags \| I2C_M_RD;
67	ptr->len = 1;
68	ptr->buf = &buffer[i];
69	ptr++;
70
71	ret = ops->xfer(bus, msg, ptr - msg);
72	if (ret)
73	return ret;
74	}
75
76	return 0;
77	}
78
79	static int i2c_write_bytewise(struct udevice *dev, uint offset,
80	const uint8_t *buffer, int len)
81	{
82	struct dm_i2c_chip *chip = dev_get_parentdata(dev);
83	struct udevice *bus = dev_get_parent(dev);
84	struct dm_i2c_ops *ops = i2c_get_ops(bus);
85	struct i2c_msg msg[1];
86	uint8_t buf[I2C_MAX_OFFSET_LEN + 1];
87	int ret;
88	int i;
89
90	for (i = 0; i < len; i++) {
91	if (i2c_setup_offset(chip, offset + i, buf, msg))
92	return -EINVAL;
93	buf[msg->len++] = buffer[i];
94
95	ret = ops->xfer(bus, msg, 1);
96	if (ret)
97	return ret;
98	}
99
100	return 0;
101	}
102
f9a4c2da	103	int dm_i2c_read(struct udevice dev, uint offset, uint8_t buffer, int len)
c6202d85 SG	104	{
	105	struct dm_i2c_chip *chip = dev_get_parentdata(dev);
	106	struct udevice *bus = dev_get_parent(dev);
	107	struct dm_i2c_ops *ops = i2c_get_ops(bus);
	108	struct i2c_msg msg[2], *ptr;
	109	uint8_t offset_buf[I2C_MAX_OFFSET_LEN];
	110	int msg_count;
	111
	112	if (!ops->xfer)
	113	return -ENOSYS;
	114	if (chip->flags & DM_I2C_CHIP_RD_ADDRESS)
	115	return i2c_read_bytewise(dev, offset, buffer, len);
	116	ptr = msg;
	117	if (!i2c_setup_offset(chip, offset, offset_buf, ptr))
	118	ptr++;
	119
	120	if (len) {
	121	ptr->addr = chip->chip_addr;
	122	ptr->flags = chip->flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
	123	ptr->flags \|= I2C_M_RD;
	124	ptr->len = len;
	125	ptr->buf = buffer;
	126	ptr++;
	127	}
	128	msg_count = ptr - msg;
	129
	130	return ops->xfer(bus, msg, msg_count);
	131	}
	132
f9a4c2da SG	133	int dm_i2c_write(struct udevice dev, uint offset, const uint8_t buffer,
f9a4c2da SG	134	int len)
c6202d85 SG	135	{
	136	struct dm_i2c_chip *chip = dev_get_parentdata(dev);
	137	struct udevice *bus = dev_get_parent(dev);
	138	struct dm_i2c_ops *ops = i2c_get_ops(bus);
	139	struct i2c_msg msg[1];
	140
	141	if (!ops->xfer)
	142	return -ENOSYS;
	143
	144	if (chip->flags & DM_I2C_CHIP_WR_ADDRESS)
	145	return i2c_write_bytewise(dev, offset, buffer, len);
	146	/*
	147	* The simple approach would be to send two messages here: one to
	148	* set the offset and one to write the bytes. However some drivers
	149	* will not be expecting this, and some chips won't like how the
	150	* driver presents this on the I2C bus.
	151	*
	152	* The API does not support separate offset and data. We could extend
	153	* it with a flag indicating that there is data in the next message
	154	* that needs to be processed in the same transaction. We could
	155	* instead add an additional buffer to each message. For now, handle
	156	* this in the uclass since it isn't clear what the impact on drivers
	157	* would be with this extra complication. Unfortunately this means
	158	* copying the message.
	159	*
	160	* Use the stack for small messages, malloc() for larger ones. We
	161	* need to allow space for the offset (up to 4 bytes) and the message
	162	* itself.
	163	*/
	164	if (len < 64) {
	165	uint8_t buf[I2C_MAX_OFFSET_LEN + len];
	166
	167	i2c_setup_offset(chip, offset, buf, msg);
	168	msg->len += len;
	169	memcpy(buf + chip->offset_len, buffer, len);
	170
	171	return ops->xfer(bus, msg, 1);
	172	} else {
	173	uint8_t *buf;
	174	int ret;
	175
	176	buf = malloc(I2C_MAX_OFFSET_LEN + len);
	177	if (!buf)
	178	return -ENOMEM;
	179	i2c_setup_offset(chip, offset, buf, msg);
	180	msg->len += len;
	181	memcpy(buf + chip->offset_len, buffer, len);
	182
	183	ret = ops->xfer(bus, msg, 1);
	184	free(buf);
	185	return ret;
	186	}
	187	}
	188
	189	/**
	190	* i2c_probe_chip() - probe for a chip on a bus
	191	*
	192	* @bus: Bus to probe
	193	* @chip_addr: Chip address to probe
	194	* @flags: Flags for the chip
	195	* @return 0 if found, -ENOSYS if the driver is invalid, -EREMOTEIO if the chip
	196	* does not respond to probe
	197	*/
	198	static int i2c_probe_chip(struct udevice *bus, uint chip_addr,
199	enum dm_i2c_chip_flags chip_flags)
200	{
201	struct dm_i2c_ops *ops = i2c_get_ops(bus);
202	struct i2c_msg msg[1];
203	int ret;
204
205	if (ops->probe_chip) {
206	ret = ops->probe_chip(bus, chip_addr, chip_flags);
207	if (!ret \|\| ret != -ENOSYS)
208	return ret;
209	}
210
211	if (!ops->xfer)
212	return -ENOSYS;
213
214	/* Probe with a zero-length message */
215	msg->addr = chip_addr;
216	msg->flags = chip_flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
217	msg->len = 0;
218	msg->buf = NULL;
219
220	return ops->xfer(bus, msg, 1);
221	}
222
223	static int i2c_bind_driver(struct udevice *bus, uint chip_addr,
224	struct udevice **devp)
225	{
226	struct dm_i2c_chip chip;
227	char name[30], *str;
228	struct udevice *dev;
229	int ret;
230
231	snprintf(name, sizeof(name), "generic_%x", chip_addr);
232	str = strdup(name);
233	ret = device_bind_driver(bus, "i2c_generic_chip_drv", str, &dev);
234	debug("%s: device_bind_driver: ret=%d\n", __func__, ret);
235	if (ret)
236	goto err_bind;
237
238	/* Tell the device what we know about it */
239	memset(&chip, '\0', sizeof(chip));
240	chip.chip_addr = chip_addr;
241	chip.offset_len = 1; /* we assume */
242	ret = device_probe_child(dev, &chip);
243	debug("%s: device_probe_child: ret=%d\n", __func__, ret);
244	if (ret)
245	goto err_probe;
246
247	*devp = dev;
248	return 0;
249
250	err_probe:
251	device_unbind(dev);
252	err_bind:
253	free(str);
254	return ret;
255	}
256
257	int i2c_get_chip(struct udevice bus, uint chip_addr, struct udevice *devp)
258	{
259	struct udevice *dev;
260
261	debug("%s: Searching bus '%s' for address %02x: ", __func__,
262	bus->name, chip_addr);
263	for (device_find_first_child(bus, &dev); dev;
264	device_find_next_child(&dev)) {
265	struct dm_i2c_chip store;
266	struct dm_i2c_chip *chip = dev_get_parentdata(dev);
267	int ret;
268
269	if (!chip) {
270	chip = &store;
271	i2c_chip_ofdata_to_platdata(gd->fdt_blob,
272	dev->of_offset, chip);
273	}
274	if (chip->chip_addr == chip_addr) {
275	ret = device_probe(dev);
276	debug("found, ret=%d\n", ret);
277	if (ret)
278	return ret;
279	*devp = dev;
280	return 0;
281	}
282	}
283	debug("not found\n");
284	return i2c_bind_driver(bus, chip_addr, devp);
285	}
286
287	int i2c_get_chip_for_busnum(int busnum, int chip_addr, struct udevice **devp)
288	{
289	struct udevice *bus;
290	int ret;
291
292	ret = uclass_get_device_by_seq(UCLASS_I2C, busnum, &bus);
293	if (ret) {
294	debug("Cannot find I2C bus %d\n", busnum);
295	return ret;
296	}
297	ret = i2c_get_chip(bus, chip_addr, devp);
298	if (ret) {
299	debug("Cannot find I2C chip %02x on bus %d\n", chip_addr,
300	busnum);
301	return ret;
302	}
303
304	return 0;
305	}
306
f9a4c2da SG	307	int dm_i2c_probe(struct udevice *bus, uint chip_addr, uint chip_flags,
f9a4c2da SG	308	struct udevice **devp)
c6202d85 SG	309	{
	310	int ret;
	311
	312	*devp = NULL;
	313
	314	/* First probe that chip */
	315	ret = i2c_probe_chip(bus, chip_addr, chip_flags);
	316	debug("%s: bus='%s', address %02x, ret=%d\n", __func__, bus->name,
	317	chip_addr, ret);
	318	if (ret)
	319	return ret;
	320
	321	/* The chip was found, see if we have a driver, and probe it */
	322	ret = i2c_get_chip(bus, chip_addr, devp);
	323	debug("%s: i2c_get_chip: ret=%d\n", __func__, ret);
	324
	325	return ret;
	326	}
	327
	328	int i2c_set_bus_speed(struct udevice *bus, unsigned int speed)
	329	{
	330	struct dm_i2c_ops *ops = i2c_get_ops(bus);
	331	struct dm_i2c_bus *i2c = bus->uclass_priv;
	332	int ret;
	333
	334	/*
	335	* If we have a method, call it. If not then the driver probably wants
	336	* to deal with speed changes on the next transfer. It can easily read
	337	* the current speed from this uclass
	338	*/
	339	if (ops->set_bus_speed) {
	340	ret = ops->set_bus_speed(bus, speed);
	341	if (ret)
	342	return ret;
	343	}
	344	i2c->speed_hz = speed;
	345
	346	return 0;
	347	}
	348
	349	/*
	350	* i2c_get_bus_speed:
	351	*
	352	* Returns speed of selected I2C bus in Hz
	353	*/
	354	int i2c_get_bus_speed(struct udevice *bus)
	355	{
	356	struct dm_i2c_ops *ops = i2c_get_ops(bus);
	357	struct dm_i2c_bus *i2c = bus->uclass_priv;
	358
	359	if (!ops->get_bus_speed)
	360	return i2c->speed_hz;
	361
	362	return ops->get_bus_speed(bus);
	363	}
	364
	365	int i2c_set_chip_flags(struct udevice *dev, uint flags)
	366	{
	367	struct udevice *bus = dev->parent;
	368	struct dm_i2c_chip *chip = dev_get_parentdata(dev);
	369	struct dm_i2c_ops *ops = i2c_get_ops(bus);
	370	int ret;
	371
	372	if (ops->set_flags) {
373	ret = ops->set_flags(dev, flags);
374	if (ret)
375	return ret;
376	}
377	chip->flags = flags;
378
379	return 0;
380	}
381
382	int i2c_get_chip_flags(struct udevice dev, uint flagsp)
383	{
384	struct dm_i2c_chip *chip = dev_get_parentdata(dev);
385
386	*flagsp = chip->flags;
387
388	return 0;
389	}
390
391	int i2c_set_chip_offset_len(struct udevice *dev, uint offset_len)
392	{
393	struct dm_i2c_chip *chip = dev_get_parentdata(dev);
394
395	if (offset_len > I2C_MAX_OFFSET_LEN)
396	return -EINVAL;
397	chip->offset_len = offset_len;
398
399	return 0;
400	}
401
402	int i2c_deblock(struct udevice *bus)
403	{
404	struct dm_i2c_ops *ops = i2c_get_ops(bus);
405
406	/*
407	* We could implement a software deblocking here if we could get
408	* access to the GPIOs used by I2C, and switch them to GPIO mode
409	* and then back to I2C. This is somewhat beyond our powers in
410	* driver model at present, so for now just fail.
411	*
412	* See https://patchwork.ozlabs.org/patch/399040/
413	*/
414	if (!ops->deblock)
415	return -ENOSYS;
416
417	return ops->deblock(bus);
418	}
419
420	int i2c_chip_ofdata_to_platdata(const void *blob, int node,
421	struct dm_i2c_chip *chip)
422	{
423	chip->offset_len = 1; /* default */
424	chip->flags = 0;
425	chip->chip_addr = fdtdec_get_int(gd->fdt_blob, node, "reg", -1);
426	if (chip->chip_addr == -1) {
427	debug("%s: I2C Node '%s' has no 'reg' property\n", __func__,
428	fdt_get_name(blob, node, NULL));
429	return -EINVAL;
430	}
431
432	return 0;
433	}
434
435	static int i2c_post_probe(struct udevice *dev)
436	{
437	struct dm_i2c_bus *i2c = dev->uclass_priv;
438
439	i2c->speed_hz = fdtdec_get_int(gd->fdt_blob, dev->of_offset,
440	"clock-frequency", 100000);
441
442	return i2c_set_bus_speed(dev, i2c->speed_hz);
443	}
444
445	int i2c_post_bind(struct udevice *dev)
446	{
447	/* Scan the bus for devices */
448	return dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset, false);
449	}
450
451	UCLASS_DRIVER(i2c) = {
452	.id = UCLASS_I2C,
453	.name = "i2c",
454	.per_device_auto_alloc_size = sizeof(struct dm_i2c_bus),
455	.post_bind = i2c_post_bind,
456	.post_probe = i2c_post_probe,
457	};
458
459	UCLASS_DRIVER(i2c_generic) = {
460	.id = UCLASS_I2C_GENERIC,
461	.name = "i2c_generic",
462	};
463
464	U_BOOT_DRIVER(i2c_generic_chip_drv) = {
465	.name = "i2c_generic_chip_drv",
466	.id = UCLASS_I2C_GENERIC,
467	};