blob: c5a3c4e2016e80d2c31c254c264f97fd80ff06f8 [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>
14#ifdef CONFIG_DM_GPIO
15#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{
55 int offset_len;
56
57 msg->addr = chip->chip_addr;
58 msg->flags = chip->flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
59 msg->len = chip->offset_len;
60 msg->buf = offset_buf;
61 if (!chip->offset_len)
62 return -EADDRNOTAVAIL;
63 assert(chip->offset_len <= I2C_MAX_OFFSET_LEN);
64 offset_len = chip->offset_len;
65 while (offset_len--)
66 *offset_buf++ = offset >> (8 * offset_len);
67
68 return 0;
69}
70
71static int i2c_read_bytewise(struct udevice *dev, uint offset,
72 uint8_t *buffer, int len)
73{
Simon Glasse6f66ec2015-01-25 08:27:13 -070074 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -070075 struct udevice *bus = dev_get_parent(dev);
76 struct dm_i2c_ops *ops = i2c_get_ops(bus);
77 struct i2c_msg msg[2], *ptr;
78 uint8_t offset_buf[I2C_MAX_OFFSET_LEN];
79 int ret;
80 int i;
81
82 for (i = 0; i < len; i++) {
83 if (i2c_setup_offset(chip, offset + i, offset_buf, msg))
84 return -EINVAL;
85 ptr = msg + 1;
86 ptr->addr = chip->chip_addr;
87 ptr->flags = msg->flags | I2C_M_RD;
88 ptr->len = 1;
89 ptr->buf = &buffer[i];
90 ptr++;
91
92 ret = ops->xfer(bus, msg, ptr - msg);
93 if (ret)
94 return ret;
95 }
96
97 return 0;
98}
99
100static int i2c_write_bytewise(struct udevice *dev, uint offset,
101 const uint8_t *buffer, int len)
102{
Simon Glasse6f66ec2015-01-25 08:27:13 -0700103 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700104 struct udevice *bus = dev_get_parent(dev);
105 struct dm_i2c_ops *ops = i2c_get_ops(bus);
106 struct i2c_msg msg[1];
107 uint8_t buf[I2C_MAX_OFFSET_LEN + 1];
108 int ret;
109 int i;
110
111 for (i = 0; i < len; i++) {
112 if (i2c_setup_offset(chip, offset + i, buf, msg))
113 return -EINVAL;
114 buf[msg->len++] = buffer[i];
115
116 ret = ops->xfer(bus, msg, 1);
117 if (ret)
118 return ret;
119 }
120
121 return 0;
122}
123
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700124int dm_i2c_read(struct udevice *dev, uint offset, uint8_t *buffer, int len)
Simon Glassc6202d82014-12-10 08:55:47 -0700125{
Simon Glasse6f66ec2015-01-25 08:27:13 -0700126 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700127 struct udevice *bus = dev_get_parent(dev);
128 struct dm_i2c_ops *ops = i2c_get_ops(bus);
129 struct i2c_msg msg[2], *ptr;
130 uint8_t offset_buf[I2C_MAX_OFFSET_LEN];
131 int msg_count;
132
133 if (!ops->xfer)
134 return -ENOSYS;
135 if (chip->flags & DM_I2C_CHIP_RD_ADDRESS)
136 return i2c_read_bytewise(dev, offset, buffer, len);
137 ptr = msg;
138 if (!i2c_setup_offset(chip, offset, offset_buf, ptr))
139 ptr++;
140
141 if (len) {
142 ptr->addr = chip->chip_addr;
143 ptr->flags = chip->flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
144 ptr->flags |= I2C_M_RD;
145 ptr->len = len;
146 ptr->buf = buffer;
147 ptr++;
148 }
149 msg_count = ptr - msg;
150
151 return ops->xfer(bus, msg, msg_count);
152}
153
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700154int dm_i2c_write(struct udevice *dev, uint offset, const uint8_t *buffer,
155 int len)
Simon Glassc6202d82014-12-10 08:55:47 -0700156{
Simon Glasse6f66ec2015-01-25 08:27:13 -0700157 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700158 struct udevice *bus = dev_get_parent(dev);
159 struct dm_i2c_ops *ops = i2c_get_ops(bus);
160 struct i2c_msg msg[1];
161
162 if (!ops->xfer)
163 return -ENOSYS;
164
165 if (chip->flags & DM_I2C_CHIP_WR_ADDRESS)
166 return i2c_write_bytewise(dev, offset, buffer, len);
167 /*
168 * The simple approach would be to send two messages here: one to
169 * set the offset and one to write the bytes. However some drivers
170 * will not be expecting this, and some chips won't like how the
171 * driver presents this on the I2C bus.
172 *
173 * The API does not support separate offset and data. We could extend
174 * it with a flag indicating that there is data in the next message
175 * that needs to be processed in the same transaction. We could
176 * instead add an additional buffer to each message. For now, handle
177 * this in the uclass since it isn't clear what the impact on drivers
178 * would be with this extra complication. Unfortunately this means
179 * copying the message.
180 *
181 * Use the stack for small messages, malloc() for larger ones. We
182 * need to allow space for the offset (up to 4 bytes) and the message
183 * itself.
184 */
185 if (len < 64) {
186 uint8_t buf[I2C_MAX_OFFSET_LEN + len];
187
188 i2c_setup_offset(chip, offset, buf, msg);
189 msg->len += len;
190 memcpy(buf + chip->offset_len, buffer, len);
191
192 return ops->xfer(bus, msg, 1);
193 } else {
194 uint8_t *buf;
195 int ret;
196
197 buf = malloc(I2C_MAX_OFFSET_LEN + len);
198 if (!buf)
199 return -ENOMEM;
200 i2c_setup_offset(chip, offset, buf, msg);
201 msg->len += len;
202 memcpy(buf + chip->offset_len, buffer, len);
203
204 ret = ops->xfer(bus, msg, 1);
205 free(buf);
206 return ret;
207 }
208}
209
Simon Glassdf358c62015-07-02 18:15:42 -0600210int dm_i2c_xfer(struct udevice *dev, struct i2c_msg *msg, int nmsgs)
211{
212 struct udevice *bus = dev_get_parent(dev);
213 struct dm_i2c_ops *ops = i2c_get_ops(bus);
214
215 if (!ops->xfer)
216 return -ENOSYS;
217
218 return ops->xfer(bus, msg, nmsgs);
219}
220
Simon Glassba3864f2015-04-20 12:37:14 -0600221int dm_i2c_reg_read(struct udevice *dev, uint offset)
222{
223 uint8_t val;
224 int ret;
225
226 ret = dm_i2c_read(dev, offset, &val, 1);
227 if (ret < 0)
228 return ret;
229
230 return val;
231}
232
233int dm_i2c_reg_write(struct udevice *dev, uint offset, uint value)
234{
235 uint8_t val = value;
236
237 return dm_i2c_write(dev, offset, &val, 1);
238}
239
Simon Glassc6202d82014-12-10 08:55:47 -0700240/**
241 * i2c_probe_chip() - probe for a chip on a bus
242 *
243 * @bus: Bus to probe
244 * @chip_addr: Chip address to probe
245 * @flags: Flags for the chip
246 * @return 0 if found, -ENOSYS if the driver is invalid, -EREMOTEIO if the chip
247 * does not respond to probe
248 */
249static int i2c_probe_chip(struct udevice *bus, uint chip_addr,
250 enum dm_i2c_chip_flags chip_flags)
251{
252 struct dm_i2c_ops *ops = i2c_get_ops(bus);
253 struct i2c_msg msg[1];
254 int ret;
255
256 if (ops->probe_chip) {
257 ret = ops->probe_chip(bus, chip_addr, chip_flags);
258 if (!ret || ret != -ENOSYS)
259 return ret;
260 }
261
262 if (!ops->xfer)
263 return -ENOSYS;
264
265 /* Probe with a zero-length message */
266 msg->addr = chip_addr;
267 msg->flags = chip_flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
268 msg->len = 0;
269 msg->buf = NULL;
270
271 return ops->xfer(bus, msg, 1);
272}
273
Simon Glass25ab4b02015-01-25 08:26:55 -0700274static int i2c_bind_driver(struct udevice *bus, uint chip_addr, uint offset_len,
Simon Glassc6202d82014-12-10 08:55:47 -0700275 struct udevice **devp)
276{
Simon Glasse6f66ec2015-01-25 08:27:13 -0700277 struct dm_i2c_chip *chip;
Simon Glassc6202d82014-12-10 08:55:47 -0700278 char name[30], *str;
279 struct udevice *dev;
280 int ret;
281
282 snprintf(name, sizeof(name), "generic_%x", chip_addr);
283 str = strdup(name);
Simon Glass5c2d23b2015-02-18 14:10:28 -0700284 if (!str)
285 return -ENOMEM;
Simon Glassc6202d82014-12-10 08:55:47 -0700286 ret = device_bind_driver(bus, "i2c_generic_chip_drv", str, &dev);
287 debug("%s: device_bind_driver: ret=%d\n", __func__, ret);
288 if (ret)
289 goto err_bind;
290
291 /* Tell the device what we know about it */
Simon Glasse6f66ec2015-01-25 08:27:13 -0700292 chip = dev_get_parent_platdata(dev);
293 chip->chip_addr = chip_addr;
294 chip->offset_len = offset_len;
295 ret = device_probe(dev);
296 debug("%s: device_probe: ret=%d\n", __func__, ret);
Simon Glassc6202d82014-12-10 08:55:47 -0700297 if (ret)
298 goto err_probe;
299
300 *devp = dev;
301 return 0;
302
303err_probe:
Simon Glasse6f66ec2015-01-25 08:27:13 -0700304 /*
305 * If the device failed to probe, unbind it. There is nothing there
306 * on the bus so we don't want to leave it lying around
307 */
Simon Glassc6202d82014-12-10 08:55:47 -0700308 device_unbind(dev);
309err_bind:
310 free(str);
311 return ret;
312}
313
Simon Glass25ab4b02015-01-25 08:26:55 -0700314int i2c_get_chip(struct udevice *bus, uint chip_addr, uint offset_len,
315 struct udevice **devp)
Simon Glassc6202d82014-12-10 08:55:47 -0700316{
317 struct udevice *dev;
318
319 debug("%s: Searching bus '%s' for address %02x: ", __func__,
320 bus->name, chip_addr);
321 for (device_find_first_child(bus, &dev); dev;
322 device_find_next_child(&dev)) {
Simon Glasse6f66ec2015-01-25 08:27:13 -0700323 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700324 int ret;
325
Simon Glassc6202d82014-12-10 08:55:47 -0700326 if (chip->chip_addr == chip_addr) {
327 ret = device_probe(dev);
328 debug("found, ret=%d\n", ret);
329 if (ret)
330 return ret;
331 *devp = dev;
332 return 0;
333 }
334 }
335 debug("not found\n");
Simon Glass25ab4b02015-01-25 08:26:55 -0700336 return i2c_bind_driver(bus, chip_addr, offset_len, devp);
Simon Glassc6202d82014-12-10 08:55:47 -0700337}
338
Simon Glass25ab4b02015-01-25 08:26:55 -0700339int i2c_get_chip_for_busnum(int busnum, int chip_addr, uint offset_len,
340 struct udevice **devp)
Simon Glassc6202d82014-12-10 08:55:47 -0700341{
342 struct udevice *bus;
343 int ret;
344
345 ret = uclass_get_device_by_seq(UCLASS_I2C, busnum, &bus);
346 if (ret) {
347 debug("Cannot find I2C bus %d\n", busnum);
348 return ret;
349 }
Simon Glass25ab4b02015-01-25 08:26:55 -0700350 ret = i2c_get_chip(bus, chip_addr, offset_len, devp);
Simon Glassc6202d82014-12-10 08:55:47 -0700351 if (ret) {
352 debug("Cannot find I2C chip %02x on bus %d\n", chip_addr,
353 busnum);
354 return ret;
355 }
356
357 return 0;
358}
359
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700360int dm_i2c_probe(struct udevice *bus, uint chip_addr, uint chip_flags,
361 struct udevice **devp)
Simon Glassc6202d82014-12-10 08:55:47 -0700362{
363 int ret;
364
365 *devp = NULL;
366
367 /* First probe that chip */
368 ret = i2c_probe_chip(bus, chip_addr, chip_flags);
369 debug("%s: bus='%s', address %02x, ret=%d\n", __func__, bus->name,
370 chip_addr, ret);
371 if (ret)
372 return ret;
373
374 /* The chip was found, see if we have a driver, and probe it */
Simon Glass25ab4b02015-01-25 08:26:55 -0700375 ret = i2c_get_chip(bus, chip_addr, 1, devp);
Simon Glassc6202d82014-12-10 08:55:47 -0700376 debug("%s: i2c_get_chip: ret=%d\n", __func__, ret);
377
378 return ret;
379}
380
Simon Glassca88b9b2015-02-05 21:41:32 -0700381int dm_i2c_set_bus_speed(struct udevice *bus, unsigned int speed)
Simon Glassc6202d82014-12-10 08:55:47 -0700382{
383 struct dm_i2c_ops *ops = i2c_get_ops(bus);
Simon Glasse564f052015-03-05 12:25:20 -0700384 struct dm_i2c_bus *i2c = dev_get_uclass_priv(bus);
Simon Glassc6202d82014-12-10 08:55:47 -0700385 int ret;
386
387 /*
388 * If we have a method, call it. If not then the driver probably wants
389 * to deal with speed changes on the next transfer. It can easily read
390 * the current speed from this uclass
391 */
392 if (ops->set_bus_speed) {
393 ret = ops->set_bus_speed(bus, speed);
394 if (ret)
395 return ret;
396 }
397 i2c->speed_hz = speed;
398
399 return 0;
400}
401
Simon Glassca88b9b2015-02-05 21:41:32 -0700402int dm_i2c_get_bus_speed(struct udevice *bus)
Simon Glassc6202d82014-12-10 08:55:47 -0700403{
404 struct dm_i2c_ops *ops = i2c_get_ops(bus);
Simon Glasse564f052015-03-05 12:25:20 -0700405 struct dm_i2c_bus *i2c = dev_get_uclass_priv(bus);
Simon Glassc6202d82014-12-10 08:55:47 -0700406
407 if (!ops->get_bus_speed)
408 return i2c->speed_hz;
409
410 return ops->get_bus_speed(bus);
411}
412
413int i2c_set_chip_flags(struct udevice *dev, uint flags)
414{
415 struct udevice *bus = dev->parent;
Simon Glasse6f66ec2015-01-25 08:27:13 -0700416 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700417 struct dm_i2c_ops *ops = i2c_get_ops(bus);
418 int ret;
419
420 if (ops->set_flags) {
421 ret = ops->set_flags(dev, flags);
422 if (ret)
423 return ret;
424 }
425 chip->flags = flags;
426
427 return 0;
428}
429
430int i2c_get_chip_flags(struct udevice *dev, uint *flagsp)
431{
Simon Glasse6f66ec2015-01-25 08:27:13 -0700432 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700433
434 *flagsp = chip->flags;
435
436 return 0;
437}
438
439int i2c_set_chip_offset_len(struct udevice *dev, uint offset_len)
440{
Simon Glasse6f66ec2015-01-25 08:27:13 -0700441 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700442
443 if (offset_len > I2C_MAX_OFFSET_LEN)
444 return -EINVAL;
445 chip->offset_len = offset_len;
446
447 return 0;
448}
449
Simon Glass01501802015-05-04 11:30:58 -0600450int i2c_get_chip_offset_len(struct udevice *dev)
451{
452 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
453
454 return chip->offset_len;
455}
456
Alexander Kochetkovaa541922018-03-27 17:52:27 +0300457#ifdef CONFIG_DM_GPIO
458static void i2c_gpio_set_pin(struct gpio_desc *pin, int bit)
459{
460 if (bit)
461 dm_gpio_set_dir_flags(pin, GPIOD_IS_IN);
462 else
463 dm_gpio_set_dir_flags(pin, GPIOD_IS_OUT |
464 GPIOD_ACTIVE_LOW |
465 GPIOD_IS_OUT_ACTIVE);
466}
467
468static int i2c_gpio_get_pin(struct gpio_desc *pin)
469{
470 return dm_gpio_get_value(pin);
471}
472
473static int i2c_deblock_gpio_loop(struct gpio_desc *sda_pin,
474 struct gpio_desc *scl_pin)
475{
476 int counter = 9;
477 int ret = 0;
478
479 i2c_gpio_set_pin(sda_pin, 1);
480 i2c_gpio_set_pin(scl_pin, 1);
481 udelay(5);
482
483 /* Toggle SCL until slave release SDA */
484 while (counter-- >= 0) {
485 i2c_gpio_set_pin(scl_pin, 1);
486 udelay(5);
487 i2c_gpio_set_pin(scl_pin, 0);
488 udelay(5);
489 if (i2c_gpio_get_pin(sda_pin))
490 break;
491 }
492
493 /* Then, send I2C stop */
494 i2c_gpio_set_pin(sda_pin, 0);
495 udelay(5);
496
497 i2c_gpio_set_pin(scl_pin, 1);
498 udelay(5);
499
500 i2c_gpio_set_pin(sda_pin, 1);
501 udelay(5);
502
503 if (!i2c_gpio_get_pin(sda_pin) || !i2c_gpio_get_pin(scl_pin))
504 ret = -EREMOTEIO;
505
506 return ret;
507}
508
509static int i2c_deblock_gpio(struct udevice *bus)
510{
511 struct gpio_desc gpios[PIN_COUNT];
512 int ret, ret0;
513
514 ret = gpio_request_list_by_name(bus, "gpios", gpios,
515 ARRAY_SIZE(gpios), GPIOD_IS_IN);
516 if (ret != ARRAY_SIZE(gpios)) {
517 debug("%s: I2C Node '%s' has no 'gpios' property %s\n",
518 __func__, dev_read_name(bus), bus->name);
519 if (ret >= 0) {
520 gpio_free_list(bus, gpios, ret);
521 ret = -ENOENT;
522 }
523 goto out;
524 }
525
526 ret = pinctrl_select_state(bus, "gpio");
527 if (ret) {
528 debug("%s: I2C Node '%s' has no 'gpio' pinctrl state. %s\n",
529 __func__, dev_read_name(bus), bus->name);
530 goto out_no_pinctrl;
531 }
532
533 ret0 = i2c_deblock_gpio_loop(&gpios[PIN_SDA], &gpios[PIN_SCL]);
534
535 ret = pinctrl_select_state(bus, "default");
536 if (ret) {
537 debug("%s: I2C Node '%s' has no 'default' pinctrl state. %s\n",
538 __func__, dev_read_name(bus), bus->name);
539 }
540
541 ret = !ret ? ret0 : ret;
542
543out_no_pinctrl:
544 gpio_free_list(bus, gpios, ARRAY_SIZE(gpios));
545out:
546 return ret;
547}
548#else
549static int i2c_deblock_gpio(struct udevice *bus)
550{
551 return -ENOSYS;
552}
553#endif // CONFIG_DM_GPIO
554
Simon Glassc6202d82014-12-10 08:55:47 -0700555int i2c_deblock(struct udevice *bus)
556{
557 struct dm_i2c_ops *ops = i2c_get_ops(bus);
558
Simon Glassc6202d82014-12-10 08:55:47 -0700559 if (!ops->deblock)
Alexander Kochetkovaa541922018-03-27 17:52:27 +0300560 return i2c_deblock_gpio(bus);
Simon Glassc6202d82014-12-10 08:55:47 -0700561
562 return ops->deblock(bus);
563}
564
Adam Fordafa8cdd2018-08-20 20:24:34 -0500565#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
Simon Glass17043082017-05-18 20:09:30 -0600566int i2c_chip_ofdata_to_platdata(struct udevice *dev, struct dm_i2c_chip *chip)
Simon Glassc6202d82014-12-10 08:55:47 -0700567{
Simon Glass17043082017-05-18 20:09:30 -0600568 int addr;
569
570 chip->offset_len = dev_read_u32_default(dev, "u-boot,i2c-offset-len",
571 1);
Simon Glassc6202d82014-12-10 08:55:47 -0700572 chip->flags = 0;
Simon Glass17043082017-05-18 20:09:30 -0600573 addr = dev_read_u32_default(dev, "reg", -1);
574 if (addr == -1) {
575 debug("%s: I2C Node '%s' has no 'reg' property %s\n", __func__,
576 dev_read_name(dev), dev->name);
Simon Glassc6202d82014-12-10 08:55:47 -0700577 return -EINVAL;
578 }
Simon Glass17043082017-05-18 20:09:30 -0600579 chip->chip_addr = addr;
Simon Glassc6202d82014-12-10 08:55:47 -0700580
581 return 0;
582}
Mugunthan V N5142ac72016-07-18 15:10:58 +0530583#endif
Simon Glassc6202d82014-12-10 08:55:47 -0700584
585static int i2c_post_probe(struct udevice *dev)
586{
Adam Fordafa8cdd2018-08-20 20:24:34 -0500587#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
Simon Glasse564f052015-03-05 12:25:20 -0700588 struct dm_i2c_bus *i2c = dev_get_uclass_priv(dev);
Simon Glassc6202d82014-12-10 08:55:47 -0700589
Simon Glass17043082017-05-18 20:09:30 -0600590 i2c->speed_hz = dev_read_u32_default(dev, "clock-frequency", 100000);
Simon Glassc6202d82014-12-10 08:55:47 -0700591
Simon Glassca88b9b2015-02-05 21:41:32 -0700592 return dm_i2c_set_bus_speed(dev, i2c->speed_hz);
Mugunthan V N5142ac72016-07-18 15:10:58 +0530593#else
594 return 0;
595#endif
Simon Glassc6202d82014-12-10 08:55:47 -0700596}
597
Simon Glasse6f66ec2015-01-25 08:27:13 -0700598static int i2c_child_post_bind(struct udevice *dev)
599{
Adam Fordafa8cdd2018-08-20 20:24:34 -0500600#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
Simon Glasse6f66ec2015-01-25 08:27:13 -0700601 struct dm_i2c_chip *plat = dev_get_parent_platdata(dev);
602
Simon Glass17043082017-05-18 20:09:30 -0600603 if (!dev_of_valid(dev))
Simon Glasse6f66ec2015-01-25 08:27:13 -0700604 return 0;
Simon Glass17043082017-05-18 20:09:30 -0600605 return i2c_chip_ofdata_to_platdata(dev, plat);
Mugunthan V N5142ac72016-07-18 15:10:58 +0530606#else
607 return 0;
608#endif
Simon Glasse6f66ec2015-01-25 08:27:13 -0700609}
610
Simon Glassc6202d82014-12-10 08:55:47 -0700611UCLASS_DRIVER(i2c) = {
612 .id = UCLASS_I2C,
613 .name = "i2c",
Simon Glass9cc36a22015-01-25 08:27:05 -0700614 .flags = DM_UC_FLAG_SEQ_ALIAS,
Adam Fordafa8cdd2018-08-20 20:24:34 -0500615#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
Simon Glass91195482016-07-05 17:10:10 -0600616 .post_bind = dm_scan_fdt_dev,
617#endif
Simon Glassc6202d82014-12-10 08:55:47 -0700618 .post_probe = i2c_post_probe,
Simon Glasse6f66ec2015-01-25 08:27:13 -0700619 .per_device_auto_alloc_size = sizeof(struct dm_i2c_bus),
620 .per_child_platdata_auto_alloc_size = sizeof(struct dm_i2c_chip),
621 .child_post_bind = i2c_child_post_bind,
Simon Glassc6202d82014-12-10 08:55:47 -0700622};
623
624UCLASS_DRIVER(i2c_generic) = {
625 .id = UCLASS_I2C_GENERIC,
626 .name = "i2c_generic",
627};
628
629U_BOOT_DRIVER(i2c_generic_chip_drv) = {
630 .name = "i2c_generic_chip_drv",
631 .id = UCLASS_I2C_GENERIC,
632};