1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (c) 2014 Google, Inc
4 */
5
6 #include <common.h>
7 #include <dm.h>
8 #include <errno.h>
9 #include <i2c.h>
10 #include <malloc.h>
11 #include <dm/device-internal.h>
12 #include <dm/lists.h>
13 #include <dm/pinctrl.h>
14 #ifdef CONFIG_DM_GPIO
15 #include <asm/gpio.h>
16 #endif
17
18 #define I2C_MAX_OFFSET_LEN 4
19
20 enum {
21 PIN_SDA = 0,
22 PIN_SCL,
23 PIN_COUNT,
24 };
25
26 /* Useful debugging function */
i2c_dump_msgs(struct i2c_msg * msg,int nmsgs)27 void 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
42 /**
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 */
i2c_setup_offset(struct dm_i2c_chip * chip,uint offset,uint8_t offset_buf[],struct i2c_msg * msg)52 static 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
i2c_read_bytewise(struct udevice * dev,uint offset,uint8_t * buffer,int len)71 static int i2c_read_bytewise(struct udevice *dev, uint offset,
72 uint8_t *buffer, int len)
73 {
74 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
75 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
i2c_write_bytewise(struct udevice * dev,uint offset,const uint8_t * buffer,int len)100 static int i2c_write_bytewise(struct udevice *dev, uint offset,
101 const uint8_t *buffer, int len)
102 {
103 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
104 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
dm_i2c_read(struct udevice * dev,uint offset,uint8_t * buffer,int len)124 int dm_i2c_read(struct udevice *dev, uint offset, uint8_t *buffer, int len)
125 {
126 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
127 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
dm_i2c_write(struct udevice * dev,uint offset,const uint8_t * buffer,int len)154 int dm_i2c_write(struct udevice *dev, uint offset, const uint8_t *buffer,
155 int len)
156 {
157 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
158 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
dm_i2c_xfer(struct udevice * dev,struct i2c_msg * msg,int nmsgs)210 int 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
dm_i2c_reg_read(struct udevice * dev,uint offset)221 int 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
dm_i2c_reg_write(struct udevice * dev,uint offset,uint value)233 int 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
240 /**
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 */
i2c_probe_chip(struct udevice * bus,uint chip_addr,enum dm_i2c_chip_flags chip_flags)249 static 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
i2c_bind_driver(struct udevice * bus,uint chip_addr,uint offset_len,struct udevice ** devp)274 static int i2c_bind_driver(struct udevice *bus, uint chip_addr, uint offset_len,
275 struct udevice **devp)
276 {
277 struct dm_i2c_chip *chip;
278 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);
284 if (!str)
285 return -ENOMEM;
286 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 */
292 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);
297 if (ret)
298 goto err_probe;
299
300 *devp = dev;
301 return 0;
302
303 err_probe:
304 /*
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 */
308 device_unbind(dev);
309 err_bind:
310 free(str);
311 return ret;
312 }
313
i2c_get_chip(struct udevice * bus,uint chip_addr,uint offset_len,struct udevice ** devp)314 int i2c_get_chip(struct udevice *bus, uint chip_addr, uint offset_len,
315 struct udevice **devp)
316 {
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)) {
323 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
324 int ret;
325
326 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");
336 return i2c_bind_driver(bus, chip_addr, offset_len, devp);
337 }
338
i2c_get_chip_for_busnum(int busnum,int chip_addr,uint offset_len,struct udevice ** devp)339 int i2c_get_chip_for_busnum(int busnum, int chip_addr, uint offset_len,
340 struct udevice **devp)
341 {
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 }
350 ret = i2c_get_chip(bus, chip_addr, offset_len, devp);
351 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
dm_i2c_probe(struct udevice * bus,uint chip_addr,uint chip_flags,struct udevice ** devp)360 int dm_i2c_probe(struct udevice *bus, uint chip_addr, uint chip_flags,
361 struct udevice **devp)
362 {
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 */
375 ret = i2c_get_chip(bus, chip_addr, 1, devp);
376 debug("%s: i2c_get_chip: ret=%d\n", __func__, ret);
377
378 return ret;
379 }
380
dm_i2c_set_bus_speed(struct udevice * bus,unsigned int speed)381 int dm_i2c_set_bus_speed(struct udevice *bus, unsigned int speed)
382 {
383 struct dm_i2c_ops *ops = i2c_get_ops(bus);
384 struct dm_i2c_bus *i2c = dev_get_uclass_priv(bus);
385 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
dm_i2c_get_bus_speed(struct udevice * bus)402 int dm_i2c_get_bus_speed(struct udevice *bus)
403 {
404 struct dm_i2c_ops *ops = i2c_get_ops(bus);
405 struct dm_i2c_bus *i2c = dev_get_uclass_priv(bus);
406
407 if (!ops->get_bus_speed)
408 return i2c->speed_hz;
409
410 return ops->get_bus_speed(bus);
411 }
412
i2c_set_chip_flags(struct udevice * dev,uint flags)413 int i2c_set_chip_flags(struct udevice *dev, uint flags)
414 {
415 struct udevice *bus = dev->parent;
416 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
417 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
i2c_get_chip_flags(struct udevice * dev,uint * flagsp)430 int i2c_get_chip_flags(struct udevice *dev, uint *flagsp)
431 {
432 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
433
434 *flagsp = chip->flags;
435
436 return 0;
437 }
438
i2c_set_chip_offset_len(struct udevice * dev,uint offset_len)439 int i2c_set_chip_offset_len(struct udevice *dev, uint offset_len)
440 {
441 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
442
443 if (offset_len > I2C_MAX_OFFSET_LEN)
444 return -EINVAL;
445 chip->offset_len = offset_len;
446
447 return 0;
448 }
449
i2c_get_chip_offset_len(struct udevice * dev)450 int 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
457 #ifdef CONFIG_DM_GPIO
i2c_gpio_set_pin(struct gpio_desc * pin,int bit)458 static 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
i2c_gpio_get_pin(struct gpio_desc * pin)468 static int i2c_gpio_get_pin(struct gpio_desc *pin)
469 {
470 return dm_gpio_get_value(pin);
471 }
472
i2c_deblock_gpio_loop(struct gpio_desc * sda_pin,struct gpio_desc * scl_pin)473 static 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
i2c_deblock_gpio(struct udevice * bus)509 static 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
543 out_no_pinctrl:
544 gpio_free_list(bus, gpios, ARRAY_SIZE(gpios));
545 out:
546 return ret;
547 }
548 #else
i2c_deblock_gpio(struct udevice * bus)549 static int i2c_deblock_gpio(struct udevice *bus)
550 {
551 return -ENOSYS;
552 }
553 #endif // CONFIG_DM_GPIO
554
i2c_deblock(struct udevice * bus)555 int i2c_deblock(struct udevice *bus)
556 {
557 struct dm_i2c_ops *ops = i2c_get_ops(bus);
558
559 if (!ops->deblock)
560 return i2c_deblock_gpio(bus);
561
562 return ops->deblock(bus);
563 }
564
565 #if CONFIG_IS_ENABLED(OF_CONTROL)
i2c_chip_ofdata_to_platdata(struct udevice * dev,struct dm_i2c_chip * chip)566 int i2c_chip_ofdata_to_platdata(struct udevice *dev, struct dm_i2c_chip *chip)
567 {
568 int addr;
569
570 chip->offset_len = dev_read_u32_default(dev, "u-boot,i2c-offset-len",
571 1);
572 chip->flags = 0;
573 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);
577 return -EINVAL;
578 }
579 chip->chip_addr = addr;
580
581 return 0;
582 }
583 #endif
584
i2c_post_probe(struct udevice * dev)585 static int i2c_post_probe(struct udevice *dev)
586 {
587 #if CONFIG_IS_ENABLED(OF_CONTROL)
588 struct dm_i2c_bus *i2c = dev_get_uclass_priv(dev);
589
590 i2c->speed_hz = dev_read_u32_default(dev, "clock-frequency", 100000);
591
592 return dm_i2c_set_bus_speed(dev, i2c->speed_hz);
593 #else
594 return 0;
595 #endif
596 }
597
i2c_child_post_bind(struct udevice * dev)598 static int i2c_child_post_bind(struct udevice *dev)
599 {
600 #if CONFIG_IS_ENABLED(OF_CONTROL)
601 struct dm_i2c_chip *plat = dev_get_parent_platdata(dev);
602
603 if (!dev_of_valid(dev))
604 return 0;
605 return i2c_chip_ofdata_to_platdata(dev, plat);
606 #else
607 return 0;
608 #endif
609 }
610
611 UCLASS_DRIVER(i2c) = {
612 .id = UCLASS_I2C,
613 .name = "i2c",
614 .flags = DM_UC_FLAG_SEQ_ALIAS,
615 #if CONFIG_IS_ENABLED(OF_CONTROL)
616 .post_bind = dm_scan_fdt_dev,
617 #endif
618 .post_probe = i2c_post_probe,
619 .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,
622 };
623
624 UCLASS_DRIVER(i2c_generic) = {
625 .id = UCLASS_I2C_GENERIC,
626 .name = "i2c_generic",
627 };
628
629 U_BOOT_DRIVER(i2c_generic_chip_drv) = {
630 .name = "i2c_generic_chip_drv",
631 .id = UCLASS_I2C_GENERIC,
632 };
633