2 * Copyright (c) 2014 Google, Inc
4 * SPDX-License-Identifier: GPL-2.0+
13 #include <dm/device-internal.h>
17 DECLARE_GLOBAL_DATA_PTR;
19 #define I2C_MAX_OFFSET_LEN 4
22 * i2c_setup_offset() - Set up a new message with a chip offset
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.
31 static int i2c_setup_offset(struct dm_i2c_chip *chip, uint offset,
32 uint8_t offset_buf[], struct i2c_msg *msg)
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;
45 *offset_buf++ = offset >> (8 * offset_len);
50 static int i2c_read_bytewise(struct udevice *dev, uint offset,
51 uint8_t *buffer, int len)
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];
61 for (i = 0; i < len; i++) {
62 if (i2c_setup_offset(chip, offset + i, offset_buf, msg))
65 ptr->addr = chip->chip_addr;
66 ptr->flags = msg->flags | I2C_M_RD;
68 ptr->buf = &buffer[i];
71 ret = ops->xfer(bus, msg, ptr - msg);
79 static int i2c_write_bytewise(struct udevice *dev, uint offset,
80 const uint8_t *buffer, int len)
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];
90 for (i = 0; i < len; i++) {
91 if (i2c_setup_offset(chip, offset + i, buf, msg))
93 buf[msg->len++] = buffer[i];
95 ret = ops->xfer(bus, msg, 1);
103 int i2c_read(struct udevice *dev, uint offset, uint8_t *buffer, int len)
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];
114 if (chip->flags & DM_I2C_CHIP_RD_ADDRESS)
115 return i2c_read_bytewise(dev, offset, buffer, len);
117 if (!i2c_setup_offset(chip, offset, offset_buf, ptr))
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;
128 msg_count = ptr - msg;
130 return ops->xfer(bus, msg, msg_count);
133 int i2c_write(struct udevice *dev, uint offset, const uint8_t *buffer, int len)
135 struct dm_i2c_chip *chip = dev_get_parentdata(dev);
136 struct udevice *bus = dev_get_parent(dev);
137 struct dm_i2c_ops *ops = i2c_get_ops(bus);
138 struct i2c_msg msg[1];
143 if (chip->flags & DM_I2C_CHIP_WR_ADDRESS)
144 return i2c_write_bytewise(dev, offset, buffer, len);
146 * The simple approach would be to send two messages here: one to
147 * set the offset and one to write the bytes. However some drivers
148 * will not be expecting this, and some chips won't like how the
149 * driver presents this on the I2C bus.
151 * The API does not support separate offset and data. We could extend
152 * it with a flag indicating that there is data in the next message
153 * that needs to be processed in the same transaction. We could
154 * instead add an additional buffer to each message. For now, handle
155 * this in the uclass since it isn't clear what the impact on drivers
156 * would be with this extra complication. Unfortunately this means
157 * copying the message.
159 * Use the stack for small messages, malloc() for larger ones. We
160 * need to allow space for the offset (up to 4 bytes) and the message
164 uint8_t buf[I2C_MAX_OFFSET_LEN + len];
166 i2c_setup_offset(chip, offset, buf, msg);
168 memcpy(buf + chip->offset_len, buffer, len);
170 return ops->xfer(bus, msg, 1);
175 buf = malloc(I2C_MAX_OFFSET_LEN + len);
178 i2c_setup_offset(chip, offset, buf, msg);
180 memcpy(buf + chip->offset_len, buffer, len);
182 ret = ops->xfer(bus, msg, 1);
189 * i2c_probe_chip() - probe for a chip on a bus
192 * @chip_addr: Chip address to probe
193 * @flags: Flags for the chip
194 * @return 0 if found, -ENOSYS if the driver is invalid, -EREMOTEIO if the chip
195 * does not respond to probe
197 static int i2c_probe_chip(struct udevice *bus, uint chip_addr,
198 enum dm_i2c_chip_flags chip_flags)
200 struct dm_i2c_ops *ops = i2c_get_ops(bus);
201 struct i2c_msg msg[1];
204 if (ops->probe_chip) {
205 ret = ops->probe_chip(bus, chip_addr, chip_flags);
206 if (!ret || ret != -ENOSYS)
213 /* Probe with a zero-length message */
214 msg->addr = chip_addr;
215 msg->flags = chip_flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
219 return ops->xfer(bus, msg, 1);
222 static int i2c_bind_driver(struct udevice *bus, uint chip_addr,
223 struct udevice **devp)
225 struct dm_i2c_chip chip;
230 snprintf(name, sizeof(name), "generic_%x", chip_addr);
232 ret = device_bind_driver(bus, "i2c_generic_chip_drv", str, &dev);
233 debug("%s: device_bind_driver: ret=%d\n", __func__, ret);
237 /* Tell the device what we know about it */
238 memset(&chip, '\0', sizeof(chip));
239 chip.chip_addr = chip_addr;
240 chip.offset_len = 1; /* we assume */
241 ret = device_probe_child(dev, &chip);
242 debug("%s: device_probe_child: ret=%d\n", __func__, ret);
256 int i2c_get_chip(struct udevice *bus, uint chip_addr, struct udevice **devp)
260 debug("%s: Searching bus '%s' for address %02x: ", __func__,
261 bus->name, chip_addr);
262 for (device_find_first_child(bus, &dev); dev;
263 device_find_next_child(&dev)) {
264 struct dm_i2c_chip store;
265 struct dm_i2c_chip *chip = dev_get_parentdata(dev);
270 i2c_chip_ofdata_to_platdata(gd->fdt_blob,
271 dev->of_offset, chip);
273 if (chip->chip_addr == chip_addr) {
274 ret = device_probe(dev);
275 debug("found, ret=%d\n", ret);
282 debug("not found\n");
283 return i2c_bind_driver(bus, chip_addr, devp);
286 int i2c_get_chip_for_busnum(int busnum, int chip_addr, struct udevice **devp)
291 ret = uclass_get_device_by_seq(UCLASS_I2C, busnum, &bus);
293 debug("Cannot find I2C bus %d\n", busnum);
296 ret = i2c_get_chip(bus, chip_addr, devp);
298 debug("Cannot find I2C chip %02x on bus %d\n", chip_addr,
306 int i2c_probe(struct udevice *bus, uint chip_addr, uint chip_flags,
307 struct udevice **devp)
313 /* First probe that chip */
314 ret = i2c_probe_chip(bus, chip_addr, chip_flags);
315 debug("%s: bus='%s', address %02x, ret=%d\n", __func__, bus->name,
320 /* The chip was found, see if we have a driver, and probe it */
321 ret = i2c_get_chip(bus, chip_addr, devp);
322 debug("%s: i2c_get_chip: ret=%d\n", __func__, ret);
327 int i2c_set_bus_speed(struct udevice *bus, unsigned int speed)
329 struct dm_i2c_ops *ops = i2c_get_ops(bus);
330 struct dm_i2c_bus *i2c = bus->uclass_priv;
334 * If we have a method, call it. If not then the driver probably wants
335 * to deal with speed changes on the next transfer. It can easily read
336 * the current speed from this uclass
338 if (ops->set_bus_speed) {
339 ret = ops->set_bus_speed(bus, speed);
343 i2c->speed_hz = speed;
351 * Returns speed of selected I2C bus in Hz
353 int i2c_get_bus_speed(struct udevice *bus)
355 struct dm_i2c_ops *ops = i2c_get_ops(bus);
356 struct dm_i2c_bus *i2c = bus->uclass_priv;
358 if (!ops->get_bus_speed)
359 return i2c->speed_hz;
361 return ops->get_bus_speed(bus);
364 int i2c_set_chip_flags(struct udevice *dev, uint flags)
366 struct udevice *bus = dev->parent;
367 struct dm_i2c_chip *chip = dev_get_parentdata(dev);
368 struct dm_i2c_ops *ops = i2c_get_ops(bus);
371 if (ops->set_flags) {
372 ret = ops->set_flags(dev, flags);
381 int i2c_get_chip_flags(struct udevice *dev, uint *flagsp)
383 struct dm_i2c_chip *chip = dev_get_parentdata(dev);
385 *flagsp = chip->flags;
390 int i2c_set_chip_offset_len(struct udevice *dev, uint offset_len)
392 struct dm_i2c_chip *chip = dev_get_parentdata(dev);
394 if (offset_len > I2C_MAX_OFFSET_LEN)
396 chip->offset_len = offset_len;
401 int i2c_deblock(struct udevice *bus)
403 struct dm_i2c_ops *ops = i2c_get_ops(bus);
406 * We could implement a software deblocking here if we could get
407 * access to the GPIOs used by I2C, and switch them to GPIO mode
408 * and then back to I2C. This is somewhat beyond our powers in
409 * driver model at present, so for now just fail.
411 * See https://patchwork.ozlabs.org/patch/399040/
416 return ops->deblock(bus);
419 int i2c_chip_ofdata_to_platdata(const void *blob, int node,
420 struct dm_i2c_chip *chip)
422 chip->offset_len = 1; /* default */
424 chip->chip_addr = fdtdec_get_int(gd->fdt_blob, node, "reg", -1);
425 if (chip->chip_addr == -1) {
426 debug("%s: I2C Node '%s' has no 'reg' property\n", __func__,
427 fdt_get_name(blob, node, NULL));
434 static int i2c_post_probe(struct udevice *dev)
436 struct dm_i2c_bus *i2c = dev->uclass_priv;
438 i2c->speed_hz = fdtdec_get_int(gd->fdt_blob, dev->of_offset,
439 "clock-frequency", 100000);
441 return i2c_set_bus_speed(dev, i2c->speed_hz);
444 int i2c_post_bind(struct udevice *dev)
446 /* Scan the bus for devices */
447 return dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset, false);
450 UCLASS_DRIVER(i2c) = {
453 .per_device_auto_alloc_size = sizeof(struct dm_i2c_bus),
454 .post_bind = i2c_post_bind,
455 .post_probe = i2c_post_probe,
458 UCLASS_DRIVER(i2c_generic) = {
459 .id = UCLASS_I2C_GENERIC,
460 .name = "i2c_generic",
463 U_BOOT_DRIVER(i2c_generic_chip_drv) = {
464 .name = "i2c_generic_chip_drv",
465 .id = UCLASS_I2C_GENERIC,