blob: 2aa3efe8aaa01e7fa8f1b86109e917fd32056535 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glassc6202d82014-12-10 08:55:47 -07002/*
3 * Copyright (c) 2014 Google, Inc
Simon Glassc6202d82014-12-10 08:55:47 -07004 */
5
6#include <common.h>
7#include <dm.h>
8#include <errno.h>
Simon Glassc6202d82014-12-10 08:55:47 -07009#include <i2c.h>
10#include <malloc.h>
11#include <dm/device-internal.h>
12#include <dm/lists.h>
Alexander Kochetkovaa541922018-03-27 17:52:27 +030013#include <dm/pinctrl.h>
Simon Glassbcee8d62019-12-06 21:41:35 -070014#if CONFIG_IS_ENABLED(DM_GPIO)
Alexander Kochetkovaa541922018-03-27 17:52:27 +030015#include <asm/gpio.h>
16#endif
Simon Glassc6202d82014-12-10 08:55:47 -070017
Simon Glassc6202d82014-12-10 08:55:47 -070018#define I2C_MAX_OFFSET_LEN 4
19
Alexander Kochetkovaa541922018-03-27 17:52:27 +030020enum {
21 PIN_SDA = 0,
22 PIN_SCL,
23 PIN_COUNT,
24};
25
Simon Glass7d7db222015-07-02 18:15:39 -060026/* Useful debugging function */
27void i2c_dump_msgs(struct i2c_msg *msg, int nmsgs)
28{
29 int i;
30
31 for (i = 0; i < nmsgs; i++) {
32 struct i2c_msg *m = &msg[i];
33
34 printf(" %s %x len=%x", m->flags & I2C_M_RD ? "R" : "W",
35 msg->addr, msg->len);
36 if (!(m->flags & I2C_M_RD))
37 printf(": %x", m->buf[0]);
38 printf("\n");
39 }
40}
41
Simon Glassc6202d82014-12-10 08:55:47 -070042/**
43 * i2c_setup_offset() - Set up a new message with a chip offset
44 *
45 * @chip: Chip to use
46 * @offset: Byte offset within chip
47 * @offset_buf: Place to put byte offset
48 * @msg: Message buffer
49 * @return 0 if OK, -EADDRNOTAVAIL if the offset length is 0. In that case the
50 * message is still set up but will not contain an offset.
51 */
52static int i2c_setup_offset(struct dm_i2c_chip *chip, uint offset,
53 uint8_t offset_buf[], struct i2c_msg *msg)
54{
Robert Beckett85968522019-10-28 17:44:57 +000055 int offset_len = chip->offset_len;
Simon Glassc6202d82014-12-10 08:55:47 -070056
57 msg->addr = chip->chip_addr;
Robert Beckett85968522019-10-28 17:44:57 +000058 if (chip->chip_addr_offset_mask)
59 msg->addr |= (offset >> (8 * offset_len)) &
60 chip->chip_addr_offset_mask;
Simon Glassc6202d82014-12-10 08:55:47 -070061 msg->flags = chip->flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
62 msg->len = chip->offset_len;
63 msg->buf = offset_buf;
Robert Beckett85968522019-10-28 17:44:57 +000064 if (!offset_len)
Simon Glassc6202d82014-12-10 08:55:47 -070065 return -EADDRNOTAVAIL;
Robert Beckett85968522019-10-28 17:44:57 +000066 assert(offset_len <= I2C_MAX_OFFSET_LEN);
67
Simon Glassc6202d82014-12-10 08:55:47 -070068 while (offset_len--)
69 *offset_buf++ = offset >> (8 * offset_len);
70
71 return 0;
72}
73
74static int i2c_read_bytewise(struct udevice *dev, uint offset,
75 uint8_t *buffer, int len)
76{
Simon Glasse6f66ec2015-01-25 08:27:13 -070077 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -070078 struct udevice *bus = dev_get_parent(dev);
79 struct dm_i2c_ops *ops = i2c_get_ops(bus);
80 struct i2c_msg msg[2], *ptr;
81 uint8_t offset_buf[I2C_MAX_OFFSET_LEN];
82 int ret;
83 int i;
84
85 for (i = 0; i < len; i++) {
86 if (i2c_setup_offset(chip, offset + i, offset_buf, msg))
87 return -EINVAL;
88 ptr = msg + 1;
Robert Beckett85968522019-10-28 17:44:57 +000089 ptr->addr = msg->addr;
Simon Glassc6202d82014-12-10 08:55:47 -070090 ptr->flags = msg->flags | I2C_M_RD;
91 ptr->len = 1;
92 ptr->buf = &buffer[i];
93 ptr++;
94
95 ret = ops->xfer(bus, msg, ptr - msg);
96 if (ret)
97 return ret;
98 }
99
100 return 0;
101}
102
103static int i2c_write_bytewise(struct udevice *dev, uint offset,
104 const uint8_t *buffer, int len)
105{
Simon Glasse6f66ec2015-01-25 08:27:13 -0700106 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700107 struct udevice *bus = dev_get_parent(dev);
108 struct dm_i2c_ops *ops = i2c_get_ops(bus);
109 struct i2c_msg msg[1];
110 uint8_t buf[I2C_MAX_OFFSET_LEN + 1];
111 int ret;
112 int i;
113
114 for (i = 0; i < len; i++) {
115 if (i2c_setup_offset(chip, offset + i, buf, msg))
116 return -EINVAL;
117 buf[msg->len++] = buffer[i];
118
119 ret = ops->xfer(bus, msg, 1);
120 if (ret)
121 return ret;
122 }
123
124 return 0;
125}
126
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700127int dm_i2c_read(struct udevice *dev, uint offset, uint8_t *buffer, int len)
Simon Glassc6202d82014-12-10 08:55:47 -0700128{
Simon Glasse6f66ec2015-01-25 08:27:13 -0700129 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700130 struct udevice *bus = dev_get_parent(dev);
131 struct dm_i2c_ops *ops = i2c_get_ops(bus);
132 struct i2c_msg msg[2], *ptr;
133 uint8_t offset_buf[I2C_MAX_OFFSET_LEN];
134 int msg_count;
135
136 if (!ops->xfer)
137 return -ENOSYS;
138 if (chip->flags & DM_I2C_CHIP_RD_ADDRESS)
139 return i2c_read_bytewise(dev, offset, buffer, len);
140 ptr = msg;
141 if (!i2c_setup_offset(chip, offset, offset_buf, ptr))
142 ptr++;
143
144 if (len) {
Robert Beckett85968522019-10-28 17:44:57 +0000145 ptr->addr = msg->addr;
Simon Glassc6202d82014-12-10 08:55:47 -0700146 ptr->flags = chip->flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
147 ptr->flags |= I2C_M_RD;
148 ptr->len = len;
149 ptr->buf = buffer;
150 ptr++;
151 }
152 msg_count = ptr - msg;
153
154 return ops->xfer(bus, msg, msg_count);
155}
156
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700157int dm_i2c_write(struct udevice *dev, uint offset, const uint8_t *buffer,
158 int len)
Simon Glassc6202d82014-12-10 08:55:47 -0700159{
Simon Glasse6f66ec2015-01-25 08:27:13 -0700160 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700161 struct udevice *bus = dev_get_parent(dev);
162 struct dm_i2c_ops *ops = i2c_get_ops(bus);
163 struct i2c_msg msg[1];
164
165 if (!ops->xfer)
166 return -ENOSYS;
167
168 if (chip->flags & DM_I2C_CHIP_WR_ADDRESS)
169 return i2c_write_bytewise(dev, offset, buffer, len);
170 /*
171 * The simple approach would be to send two messages here: one to
172 * set the offset and one to write the bytes. However some drivers
173 * will not be expecting this, and some chips won't like how the
174 * driver presents this on the I2C bus.
175 *
176 * The API does not support separate offset and data. We could extend
177 * it with a flag indicating that there is data in the next message
178 * that needs to be processed in the same transaction. We could
179 * instead add an additional buffer to each message. For now, handle
180 * this in the uclass since it isn't clear what the impact on drivers
181 * would be with this extra complication. Unfortunately this means
182 * copying the message.
183 *
184 * Use the stack for small messages, malloc() for larger ones. We
185 * need to allow space for the offset (up to 4 bytes) and the message
186 * itself.
187 */
188 if (len < 64) {
189 uint8_t buf[I2C_MAX_OFFSET_LEN + len];
190
191 i2c_setup_offset(chip, offset, buf, msg);
192 msg->len += len;
193 memcpy(buf + chip->offset_len, buffer, len);
194
195 return ops->xfer(bus, msg, 1);
196 } else {
197 uint8_t *buf;
198 int ret;
199
200 buf = malloc(I2C_MAX_OFFSET_LEN + len);
201 if (!buf)
202 return -ENOMEM;
203 i2c_setup_offset(chip, offset, buf, msg);
204 msg->len += len;
205 memcpy(buf + chip->offset_len, buffer, len);
206
207 ret = ops->xfer(bus, msg, 1);
208 free(buf);
209 return ret;
210 }
211}
212
Simon Glassdf358c62015-07-02 18:15:42 -0600213int dm_i2c_xfer(struct udevice *dev, struct i2c_msg *msg, int nmsgs)
214{
215 struct udevice *bus = dev_get_parent(dev);
216 struct dm_i2c_ops *ops = i2c_get_ops(bus);
217
218 if (!ops->xfer)
219 return -ENOSYS;
220
221 return ops->xfer(bus, msg, nmsgs);
222}
223
Simon Glassba3864f2015-04-20 12:37:14 -0600224int dm_i2c_reg_read(struct udevice *dev, uint offset)
225{
226 uint8_t val;
227 int ret;
228
229 ret = dm_i2c_read(dev, offset, &val, 1);
230 if (ret < 0)
231 return ret;
232
233 return val;
234}
235
236int dm_i2c_reg_write(struct udevice *dev, uint offset, uint value)
237{
238 uint8_t val = value;
239
240 return dm_i2c_write(dev, offset, &val, 1);
241}
242
Simon Glassc6202d82014-12-10 08:55:47 -0700243/**
244 * i2c_probe_chip() - probe for a chip on a bus
245 *
246 * @bus: Bus to probe
247 * @chip_addr: Chip address to probe
248 * @flags: Flags for the chip
249 * @return 0 if found, -ENOSYS if the driver is invalid, -EREMOTEIO if the chip
250 * does not respond to probe
251 */
252static int i2c_probe_chip(struct udevice *bus, uint chip_addr,
253 enum dm_i2c_chip_flags chip_flags)
254{
255 struct dm_i2c_ops *ops = i2c_get_ops(bus);
256 struct i2c_msg msg[1];
257 int ret;
258
259 if (ops->probe_chip) {
260 ret = ops->probe_chip(bus, chip_addr, chip_flags);
261 if (!ret || ret != -ENOSYS)
262 return ret;
263 }
264
265 if (!ops->xfer)
266 return -ENOSYS;
267
268 /* Probe with a zero-length message */
269 msg->addr = chip_addr;
270 msg->flags = chip_flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
271 msg->len = 0;
272 msg->buf = NULL;
273
274 return ops->xfer(bus, msg, 1);
275}
276
Simon Glass25ab4b02015-01-25 08:26:55 -0700277static int i2c_bind_driver(struct udevice *bus, uint chip_addr, uint offset_len,
Simon Glassc6202d82014-12-10 08:55:47 -0700278 struct udevice **devp)
279{
Simon Glasse6f66ec2015-01-25 08:27:13 -0700280 struct dm_i2c_chip *chip;
Simon Glassc6202d82014-12-10 08:55:47 -0700281 char name[30], *str;
282 struct udevice *dev;
283 int ret;
284
285 snprintf(name, sizeof(name), "generic_%x", chip_addr);
286 str = strdup(name);
Simon Glass5c2d23b2015-02-18 14:10:28 -0700287 if (!str)
288 return -ENOMEM;
Simon Glassc6202d82014-12-10 08:55:47 -0700289 ret = device_bind_driver(bus, "i2c_generic_chip_drv", str, &dev);
290 debug("%s: device_bind_driver: ret=%d\n", __func__, ret);
291 if (ret)
292 goto err_bind;
293
294 /* Tell the device what we know about it */
Simon Glasse6f66ec2015-01-25 08:27:13 -0700295 chip = dev_get_parent_platdata(dev);
296 chip->chip_addr = chip_addr;
297 chip->offset_len = offset_len;
298 ret = device_probe(dev);
299 debug("%s: device_probe: ret=%d\n", __func__, ret);
Simon Glassc6202d82014-12-10 08:55:47 -0700300 if (ret)
301 goto err_probe;
302
303 *devp = dev;
304 return 0;
305
306err_probe:
Simon Glasse6f66ec2015-01-25 08:27:13 -0700307 /*
308 * If the device failed to probe, unbind it. There is nothing there
309 * on the bus so we don't want to leave it lying around
310 */
Simon Glassc6202d82014-12-10 08:55:47 -0700311 device_unbind(dev);
312err_bind:
313 free(str);
314 return ret;
315}
316
Simon Glass25ab4b02015-01-25 08:26:55 -0700317int i2c_get_chip(struct udevice *bus, uint chip_addr, uint offset_len,
318 struct udevice **devp)
Simon Glassc6202d82014-12-10 08:55:47 -0700319{
320 struct udevice *dev;
321
322 debug("%s: Searching bus '%s' for address %02x: ", __func__,
323 bus->name, chip_addr);
324 for (device_find_first_child(bus, &dev); dev;
325 device_find_next_child(&dev)) {
Simon Glasse6f66ec2015-01-25 08:27:13 -0700326 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700327 int ret;
328
Robert Beckett85968522019-10-28 17:44:57 +0000329 if (chip->chip_addr == (chip_addr &
330 ~chip->chip_addr_offset_mask)) {
Simon Glassc6202d82014-12-10 08:55:47 -0700331 ret = device_probe(dev);
332 debug("found, ret=%d\n", ret);
333 if (ret)
334 return ret;
335 *devp = dev;
336 return 0;
337 }
338 }
339 debug("not found\n");
Simon Glass25ab4b02015-01-25 08:26:55 -0700340 return i2c_bind_driver(bus, chip_addr, offset_len, devp);
Simon Glassc6202d82014-12-10 08:55:47 -0700341}
342
Simon Glass25ab4b02015-01-25 08:26:55 -0700343int i2c_get_chip_for_busnum(int busnum, int chip_addr, uint offset_len,
344 struct udevice **devp)
Simon Glassc6202d82014-12-10 08:55:47 -0700345{
346 struct udevice *bus;
347 int ret;
348
349 ret = uclass_get_device_by_seq(UCLASS_I2C, busnum, &bus);
350 if (ret) {
351 debug("Cannot find I2C bus %d\n", busnum);
352 return ret;
353 }
Jean-Jacques Hiblotf32a8002018-12-07 14:50:38 +0100354
355 /* detect the presence of the chip on the bus */
356 ret = i2c_probe_chip(bus, chip_addr, 0);
357 debug("%s: bus='%s', address %02x, ret=%d\n", __func__, bus->name,
358 chip_addr, ret);
359 if (ret) {
360 debug("Cannot detect I2C chip %02x on bus %d\n", chip_addr,
361 busnum);
362 return ret;
363 }
364
Simon Glass25ab4b02015-01-25 08:26:55 -0700365 ret = i2c_get_chip(bus, chip_addr, offset_len, devp);
Simon Glassc6202d82014-12-10 08:55:47 -0700366 if (ret) {
367 debug("Cannot find I2C chip %02x on bus %d\n", chip_addr,
368 busnum);
369 return ret;
370 }
371
372 return 0;
373}
374
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700375int dm_i2c_probe(struct udevice *bus, uint chip_addr, uint chip_flags,
376 struct udevice **devp)
Simon Glassc6202d82014-12-10 08:55:47 -0700377{
378 int ret;
379
380 *devp = NULL;
381
382 /* First probe that chip */
383 ret = i2c_probe_chip(bus, chip_addr, chip_flags);
384 debug("%s: bus='%s', address %02x, ret=%d\n", __func__, bus->name,
385 chip_addr, ret);
386 if (ret)
387 return ret;
388
389 /* The chip was found, see if we have a driver, and probe it */
Simon Glass25ab4b02015-01-25 08:26:55 -0700390 ret = i2c_get_chip(bus, chip_addr, 1, devp);
Simon Glassc6202d82014-12-10 08:55:47 -0700391 debug("%s: i2c_get_chip: ret=%d\n", __func__, ret);
392
393 return ret;
394}
395
Simon Glassca88b9b2015-02-05 21:41:32 -0700396int dm_i2c_set_bus_speed(struct udevice *bus, unsigned int speed)
Simon Glassc6202d82014-12-10 08:55:47 -0700397{
398 struct dm_i2c_ops *ops = i2c_get_ops(bus);
Simon Glasse564f052015-03-05 12:25:20 -0700399 struct dm_i2c_bus *i2c = dev_get_uclass_priv(bus);
Simon Glassc6202d82014-12-10 08:55:47 -0700400 int ret;
401
402 /*
403 * If we have a method, call it. If not then the driver probably wants
404 * to deal with speed changes on the next transfer. It can easily read
405 * the current speed from this uclass
406 */
407 if (ops->set_bus_speed) {
408 ret = ops->set_bus_speed(bus, speed);
409 if (ret)
410 return ret;
411 }
412 i2c->speed_hz = speed;
413
414 return 0;
415}
416
Simon Glassca88b9b2015-02-05 21:41:32 -0700417int dm_i2c_get_bus_speed(struct udevice *bus)
Simon Glassc6202d82014-12-10 08:55:47 -0700418{
419 struct dm_i2c_ops *ops = i2c_get_ops(bus);
Simon Glasse564f052015-03-05 12:25:20 -0700420 struct dm_i2c_bus *i2c = dev_get_uclass_priv(bus);
Simon Glassc6202d82014-12-10 08:55:47 -0700421
422 if (!ops->get_bus_speed)
423 return i2c->speed_hz;
424
425 return ops->get_bus_speed(bus);
426}
427
428int i2c_set_chip_flags(struct udevice *dev, uint flags)
429{
430 struct udevice *bus = dev->parent;
Simon Glasse6f66ec2015-01-25 08:27:13 -0700431 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700432 struct dm_i2c_ops *ops = i2c_get_ops(bus);
433 int ret;
434
435 if (ops->set_flags) {
436 ret = ops->set_flags(dev, flags);
437 if (ret)
438 return ret;
439 }
440 chip->flags = flags;
441
442 return 0;
443}
444
445int i2c_get_chip_flags(struct udevice *dev, uint *flagsp)
446{
Simon Glasse6f66ec2015-01-25 08:27:13 -0700447 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700448
449 *flagsp = chip->flags;
450
451 return 0;
452}
453
454int i2c_set_chip_offset_len(struct udevice *dev, uint offset_len)
455{
Simon Glasse6f66ec2015-01-25 08:27:13 -0700456 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700457
458 if (offset_len > I2C_MAX_OFFSET_LEN)
459 return -EINVAL;
460 chip->offset_len = offset_len;
461
462 return 0;
463}
464
Simon Glass01501802015-05-04 11:30:58 -0600465int i2c_get_chip_offset_len(struct udevice *dev)
466{
467 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
468
469 return chip->offset_len;
470}
471
Robert Beckett85968522019-10-28 17:44:57 +0000472int i2c_set_chip_addr_offset_mask(struct udevice *dev, uint mask)
473{
474 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
475
476 chip->chip_addr_offset_mask = mask;
477
478 return 0;
479}
480
481uint i2c_get_chip_addr_offset_mask(struct udevice *dev)
482{
483 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
484
485 return chip->chip_addr_offset_mask;
486}
487
Simon Glassbcee8d62019-12-06 21:41:35 -0700488#if CONFIG_IS_ENABLED(DM_GPIO)
Alexander Kochetkovaa541922018-03-27 17:52:27 +0300489static void i2c_gpio_set_pin(struct gpio_desc *pin, int bit)
490{
491 if (bit)
492 dm_gpio_set_dir_flags(pin, GPIOD_IS_IN);
493 else
494 dm_gpio_set_dir_flags(pin, GPIOD_IS_OUT |
495 GPIOD_ACTIVE_LOW |
496 GPIOD_IS_OUT_ACTIVE);
497}
498
499static int i2c_gpio_get_pin(struct gpio_desc *pin)
500{
501 return dm_gpio_get_value(pin);
502}
503
504static int i2c_deblock_gpio_loop(struct gpio_desc *sda_pin,
505 struct gpio_desc *scl_pin)
506{
507 int counter = 9;
508 int ret = 0;
509
510 i2c_gpio_set_pin(sda_pin, 1);
511 i2c_gpio_set_pin(scl_pin, 1);
512 udelay(5);
513
514 /* Toggle SCL until slave release SDA */
515 while (counter-- >= 0) {
516 i2c_gpio_set_pin(scl_pin, 1);
517 udelay(5);
518 i2c_gpio_set_pin(scl_pin, 0);
519 udelay(5);
520 if (i2c_gpio_get_pin(sda_pin))
521 break;
522 }
523
524 /* Then, send I2C stop */
525 i2c_gpio_set_pin(sda_pin, 0);
526 udelay(5);
527
528 i2c_gpio_set_pin(scl_pin, 1);
529 udelay(5);
530
531 i2c_gpio_set_pin(sda_pin, 1);
532 udelay(5);
533
534 if (!i2c_gpio_get_pin(sda_pin) || !i2c_gpio_get_pin(scl_pin))
535 ret = -EREMOTEIO;
536
537 return ret;
538}
539
540static int i2c_deblock_gpio(struct udevice *bus)
541{
542 struct gpio_desc gpios[PIN_COUNT];
543 int ret, ret0;
544
545 ret = gpio_request_list_by_name(bus, "gpios", gpios,
546 ARRAY_SIZE(gpios), GPIOD_IS_IN);
547 if (ret != ARRAY_SIZE(gpios)) {
548 debug("%s: I2C Node '%s' has no 'gpios' property %s\n",
549 __func__, dev_read_name(bus), bus->name);
550 if (ret >= 0) {
551 gpio_free_list(bus, gpios, ret);
552 ret = -ENOENT;
553 }
554 goto out;
555 }
556
557 ret = pinctrl_select_state(bus, "gpio");
558 if (ret) {
559 debug("%s: I2C Node '%s' has no 'gpio' pinctrl state. %s\n",
560 __func__, dev_read_name(bus), bus->name);
561 goto out_no_pinctrl;
562 }
563
564 ret0 = i2c_deblock_gpio_loop(&gpios[PIN_SDA], &gpios[PIN_SCL]);
565
566 ret = pinctrl_select_state(bus, "default");
567 if (ret) {
568 debug("%s: I2C Node '%s' has no 'default' pinctrl state. %s\n",
569 __func__, dev_read_name(bus), bus->name);
570 }
571
572 ret = !ret ? ret0 : ret;
573
574out_no_pinctrl:
575 gpio_free_list(bus, gpios, ARRAY_SIZE(gpios));
576out:
577 return ret;
578}
579#else
580static int i2c_deblock_gpio(struct udevice *bus)
581{
582 return -ENOSYS;
583}
Simon Glassbcee8d62019-12-06 21:41:35 -0700584#endif /* DM_GPIO */
Alexander Kochetkovaa541922018-03-27 17:52:27 +0300585
Simon Glassc6202d82014-12-10 08:55:47 -0700586int i2c_deblock(struct udevice *bus)
587{
588 struct dm_i2c_ops *ops = i2c_get_ops(bus);
589
Simon Glassc6202d82014-12-10 08:55:47 -0700590 if (!ops->deblock)
Alexander Kochetkovaa541922018-03-27 17:52:27 +0300591 return i2c_deblock_gpio(bus);
Simon Glassc6202d82014-12-10 08:55:47 -0700592
593 return ops->deblock(bus);
594}
595
Adam Fordafa8cdd2018-08-20 20:24:34 -0500596#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
Simon Glass17043082017-05-18 20:09:30 -0600597int i2c_chip_ofdata_to_platdata(struct udevice *dev, struct dm_i2c_chip *chip)
Simon Glassc6202d82014-12-10 08:55:47 -0700598{
Simon Glass17043082017-05-18 20:09:30 -0600599 int addr;
600
601 chip->offset_len = dev_read_u32_default(dev, "u-boot,i2c-offset-len",
602 1);
Simon Glassc6202d82014-12-10 08:55:47 -0700603 chip->flags = 0;
Simon Glass17043082017-05-18 20:09:30 -0600604 addr = dev_read_u32_default(dev, "reg", -1);
605 if (addr == -1) {
606 debug("%s: I2C Node '%s' has no 'reg' property %s\n", __func__,
607 dev_read_name(dev), dev->name);
Simon Glassc6202d82014-12-10 08:55:47 -0700608 return -EINVAL;
609 }
Simon Glass17043082017-05-18 20:09:30 -0600610 chip->chip_addr = addr;
Simon Glassc6202d82014-12-10 08:55:47 -0700611
612 return 0;
613}
Mugunthan V N5142ac72016-07-18 15:10:58 +0530614#endif
Simon Glassc6202d82014-12-10 08:55:47 -0700615
Lukasz Majewskia40fe212019-04-04 12:35:34 +0200616static int i2c_pre_probe(struct udevice *dev)
617{
618#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
619 struct dm_i2c_bus *i2c = dev_get_uclass_priv(dev);
620 unsigned int max = 0;
621 ofnode node;
622 int ret;
623
624 i2c->max_transaction_bytes = 0;
625 dev_for_each_subnode(node, dev) {
626 ret = ofnode_read_u32(node,
627 "u-boot,i2c-transaction-bytes",
628 &max);
629 if (!ret && max > i2c->max_transaction_bytes)
630 i2c->max_transaction_bytes = max;
631 }
632
633 debug("%s: I2C bus: %s max transaction bytes: %d\n", __func__,
634 dev->name, i2c->max_transaction_bytes);
635#endif
636 return 0;
637}
638
Simon Glassc6202d82014-12-10 08:55:47 -0700639static int i2c_post_probe(struct udevice *dev)
640{
Adam Fordafa8cdd2018-08-20 20:24:34 -0500641#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
Simon Glasse564f052015-03-05 12:25:20 -0700642 struct dm_i2c_bus *i2c = dev_get_uclass_priv(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700643
Simon Glassf3d46152020-01-23 11:48:22 -0700644 i2c->speed_hz = dev_read_u32_default(dev, "clock-frequency",
645 I2C_SPEED_STANDARD_RATE);
Simon Glassc6202d82014-12-10 08:55:47 -0700646
Simon Glassca88b9b2015-02-05 21:41:32 -0700647 return dm_i2c_set_bus_speed(dev, i2c->speed_hz);
Mugunthan V N5142ac72016-07-18 15:10:58 +0530648#else
649 return 0;
650#endif
Simon Glassc6202d82014-12-10 08:55:47 -0700651}
652
Simon Glasse6f66ec2015-01-25 08:27:13 -0700653static int i2c_child_post_bind(struct udevice *dev)
654{
Adam Fordafa8cdd2018-08-20 20:24:34 -0500655#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
Simon Glasse6f66ec2015-01-25 08:27:13 -0700656 struct dm_i2c_chip *plat = dev_get_parent_platdata(dev);
657
Simon Glass17043082017-05-18 20:09:30 -0600658 if (!dev_of_valid(dev))
Simon Glasse6f66ec2015-01-25 08:27:13 -0700659 return 0;
Simon Glass17043082017-05-18 20:09:30 -0600660 return i2c_chip_ofdata_to_platdata(dev, plat);
Mugunthan V N5142ac72016-07-18 15:10:58 +0530661#else
662 return 0;
663#endif
Simon Glasse6f66ec2015-01-25 08:27:13 -0700664}
665
Michal Simek6bfacc82019-01-31 16:31:01 +0100666struct i2c_priv {
667 int max_id;
668};
669
Michal Simek61607222019-01-31 16:31:02 +0100670static int i2c_post_bind(struct udevice *dev)
671{
672 struct uclass *class = dev->uclass;
673 struct i2c_priv *priv = class->priv;
674 int ret = 0;
675
676 /* Just for sure */
677 if (!priv)
678 return -ENOMEM;
679
680 debug("%s: %s, req_seq=%d\n", __func__, dev->name, dev->req_seq);
681
682 /* if there is no alias ID, use the first free */
683 if (dev->req_seq == -1)
684 dev->req_seq = ++priv->max_id;
685
686 debug("%s: %s, new req_seq=%d\n", __func__, dev->name, dev->req_seq);
687
688#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
689 ret = dm_scan_fdt_dev(dev);
690#endif
691 return ret;
692}
693
Michal Simek6bfacc82019-01-31 16:31:01 +0100694int i2c_uclass_init(struct uclass *class)
695{
696 struct i2c_priv *priv = class->priv;
697
698 /* Just for sure */
699 if (!priv)
700 return -ENOMEM;
701
702 /* Get the last allocated alias. */
Simon Glassf3d46152020-01-23 11:48:22 -0700703 if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA))
704 priv->max_id = dev_read_alias_highest_id("i2c");
705 else
706 priv->max_id = -1;
Michal Simek6bfacc82019-01-31 16:31:01 +0100707
708 debug("%s: highest alias id is %d\n", __func__, priv->max_id);
709
710 return 0;
711}
712
Simon Glassc6202d82014-12-10 08:55:47 -0700713UCLASS_DRIVER(i2c) = {
714 .id = UCLASS_I2C,
715 .name = "i2c",
Simon Glass9cc36a22015-01-25 08:27:05 -0700716 .flags = DM_UC_FLAG_SEQ_ALIAS,
Michal Simek61607222019-01-31 16:31:02 +0100717 .post_bind = i2c_post_bind,
Michal Simek6bfacc82019-01-31 16:31:01 +0100718 .init = i2c_uclass_init,
719 .priv_auto_alloc_size = sizeof(struct i2c_priv),
Lukasz Majewskia40fe212019-04-04 12:35:34 +0200720 .pre_probe = i2c_pre_probe,
Simon Glassc6202d82014-12-10 08:55:47 -0700721 .post_probe = i2c_post_probe,
Simon Glasse6f66ec2015-01-25 08:27:13 -0700722 .per_device_auto_alloc_size = sizeof(struct dm_i2c_bus),
723 .per_child_platdata_auto_alloc_size = sizeof(struct dm_i2c_chip),
724 .child_post_bind = i2c_child_post_bind,
Simon Glassc6202d82014-12-10 08:55:47 -0700725};
726
727UCLASS_DRIVER(i2c_generic) = {
728 .id = UCLASS_I2C_GENERIC,
729 .name = "i2c_generic",
730};
731
732U_BOOT_DRIVER(i2c_generic_chip_drv) = {
733 .name = "i2c_generic_chip_drv",
734 .id = UCLASS_I2C_GENERIC,
735};