1
2
3
4
5
6#include <common.h>
7#include <dm.h>
8#include <errno.h>
9#include <i2c.h>
10#include <log.h>
11#include <malloc.h>
12#include <acpi/acpi_device.h>
13#include <dm/acpi.h>
14#include <dm/device-internal.h>
15#include <dm/lists.h>
16#include <dm/pinctrl.h>
17#if CONFIG_IS_ENABLED(DM_GPIO)
18#include <asm/gpio.h>
19#endif
20#include <linux/delay.h>
21#include "acpi_i2c.h"
22
23#define I2C_MAX_OFFSET_LEN 4
24
25enum {
26 PIN_SDA = 0,
27 PIN_SCL,
28 PIN_COUNT,
29};
30
31
32void i2c_dump_msgs(struct i2c_msg *msg, int nmsgs)
33{
34 int i;
35
36 for (i = 0; i < nmsgs; i++) {
37 struct i2c_msg *m = &msg[i];
38
39 printf(" %s %x len=%x", m->flags & I2C_M_RD ? "R" : "W",
40 msg->addr, msg->len);
41 if (!(m->flags & I2C_M_RD))
42 printf(": %x", m->buf[0]);
43 printf("\n");
44 }
45}
46
47
48
49
50
51
52
53
54
55
56
57static int i2c_setup_offset(struct dm_i2c_chip *chip, uint offset,
58 uint8_t offset_buf[], struct i2c_msg *msg)
59{
60 int offset_len = chip->offset_len;
61
62 msg->addr = chip->chip_addr;
63 if (chip->chip_addr_offset_mask)
64 msg->addr |= (offset >> (8 * offset_len)) &
65 chip->chip_addr_offset_mask;
66 msg->flags = chip->flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
67 msg->len = chip->offset_len;
68 msg->buf = offset_buf;
69 if (!offset_len)
70 return -EADDRNOTAVAIL;
71 assert(offset_len <= I2C_MAX_OFFSET_LEN);
72
73 while (offset_len--)
74 *offset_buf++ = offset >> (8 * offset_len);
75
76 return 0;
77}
78
79static int i2c_read_bytewise(struct udevice *dev, uint offset,
80 uint8_t *buffer, int len)
81{
82 struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
83 struct udevice *bus = dev_get_parent(dev);
84 struct dm_i2c_ops *ops = i2c_get_ops(bus);
85 struct i2c_msg msg[2], *ptr;
86 uint8_t offset_buf[I2C_MAX_OFFSET_LEN];
87 int ret;
88 int i;
89
90 for (i = 0; i < len; i++) {
91 if (i2c_setup_offset(chip, offset + i, offset_buf, msg))
92 return -EINVAL;
93 ptr = msg + 1;
94 ptr->addr = msg->addr;
95 ptr->flags = msg->flags | I2C_M_RD;
96 ptr->len = 1;
97 ptr->buf = &buffer[i];
98 ptr++;
99
100 ret = ops->xfer(bus, msg, ptr - msg);
101 if (ret)
102 return ret;
103 }
104
105 return 0;
106}
107
108static int i2c_write_bytewise(struct udevice *dev, uint offset,
109 const uint8_t *buffer, int len)
110{
111 struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
112 struct udevice *bus = dev_get_parent(dev);
113 struct dm_i2c_ops *ops = i2c_get_ops(bus);
114 struct i2c_msg msg[1];
115 uint8_t buf[I2C_MAX_OFFSET_LEN + 1];
116 int ret;
117 int i;
118
119 for (i = 0; i < len; i++) {
120 if (i2c_setup_offset(chip, offset + i, buf, msg))
121 return -EINVAL;
122 buf[msg->len++] = buffer[i];
123
124 ret = ops->xfer(bus, msg, 1);
125 if (ret)
126 return ret;
127 }
128
129 return 0;
130}
131
132int dm_i2c_read(struct udevice *dev, uint offset, uint8_t *buffer, int len)
133{
134 struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
135 struct udevice *bus = dev_get_parent(dev);
136 struct dm_i2c_ops *ops = i2c_get_ops(bus);
137 struct i2c_msg msg[2], *ptr;
138 uint8_t offset_buf[I2C_MAX_OFFSET_LEN];
139 int msg_count;
140
141 if (!ops->xfer)
142 return -ENOSYS;
143 if (chip->flags & DM_I2C_CHIP_RD_ADDRESS)
144 return i2c_read_bytewise(dev, offset, buffer, len);
145 ptr = msg;
146 if (!i2c_setup_offset(chip, offset, offset_buf, ptr))
147 ptr++;
148
149 if (len) {
150 ptr->addr = msg->addr;
151 ptr->flags = chip->flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
152 ptr->flags |= I2C_M_RD;
153 ptr->len = len;
154 ptr->buf = buffer;
155 ptr++;
156 }
157 msg_count = ptr - msg;
158
159 return ops->xfer(bus, msg, msg_count);
160}
161
162int dm_i2c_write(struct udevice *dev, uint offset, const uint8_t *buffer,
163 int len)
164{
165 struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
166 struct udevice *bus = dev_get_parent(dev);
167 struct dm_i2c_ops *ops = i2c_get_ops(bus);
168 struct i2c_msg msg[1];
169
170 if (!ops->xfer)
171 return -ENOSYS;
172
173 if (chip->flags & DM_I2C_CHIP_WR_ADDRESS)
174 return i2c_write_bytewise(dev, offset, buffer, len);
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193 if (len < 64) {
194 uint8_t buf[I2C_MAX_OFFSET_LEN + len];
195
196 i2c_setup_offset(chip, offset, buf, msg);
197 msg->len += len;
198 memcpy(buf + chip->offset_len, buffer, len);
199
200 return ops->xfer(bus, msg, 1);
201 } else {
202 uint8_t *buf;
203 int ret;
204
205 buf = malloc(I2C_MAX_OFFSET_LEN + len);
206 if (!buf)
207 return -ENOMEM;
208 i2c_setup_offset(chip, offset, buf, msg);
209 msg->len += len;
210 memcpy(buf + chip->offset_len, buffer, len);
211
212 ret = ops->xfer(bus, msg, 1);
213 free(buf);
214 return ret;
215 }
216}
217
218int dm_i2c_xfer(struct udevice *dev, struct i2c_msg *msg, int nmsgs)
219{
220 struct udevice *bus = dev_get_parent(dev);
221 struct dm_i2c_ops *ops = i2c_get_ops(bus);
222
223 if (!ops->xfer)
224 return -ENOSYS;
225
226 return ops->xfer(bus, msg, nmsgs);
227}
228
229int dm_i2c_reg_read(struct udevice *dev, uint offset)
230{
231 uint8_t val;
232 int ret;
233
234 ret = dm_i2c_read(dev, offset, &val, 1);
235 if (ret < 0)
236 return ret;
237
238 return val;
239}
240
241int dm_i2c_reg_write(struct udevice *dev, uint offset, uint value)
242{
243 uint8_t val = value;
244
245 return dm_i2c_write(dev, offset, &val, 1);
246}
247
248
249
250
251
252
253
254
255
256
257static int i2c_probe_chip(struct udevice *bus, uint chip_addr,
258 enum dm_i2c_chip_flags chip_flags)
259{
260 struct dm_i2c_ops *ops = i2c_get_ops(bus);
261 struct i2c_msg msg[1];
262 int ret;
263
264 if (ops->probe_chip) {
265 ret = ops->probe_chip(bus, chip_addr, chip_flags);
266 if (!ret || ret != -ENOSYS)
267 return ret;
268 }
269
270 if (!ops->xfer)
271 return -ENOSYS;
272
273
274 msg->addr = chip_addr;
275 msg->flags = chip_flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
276 msg->len = 0;
277 msg->buf = NULL;
278
279 return ops->xfer(bus, msg, 1);
280}
281
282static int i2c_bind_driver(struct udevice *bus, uint chip_addr, uint offset_len,
283 struct udevice **devp)
284{
285 struct dm_i2c_chip *chip;
286 char name[30], *str;
287 struct udevice *dev;
288 int ret;
289
290 snprintf(name, sizeof(name), "generic_%x", chip_addr);
291 str = strdup(name);
292 if (!str)
293 return -ENOMEM;
294 ret = device_bind_driver(bus, "i2c_generic_chip_drv", str, &dev);
295 debug("%s: device_bind_driver: ret=%d\n", __func__, ret);
296 if (ret)
297 goto err_bind;
298
299
300 chip = dev_get_parent_plat(dev);
301 chip->chip_addr = chip_addr;
302 chip->offset_len = offset_len;
303 ret = device_probe(dev);
304 debug("%s: device_probe: ret=%d\n", __func__, ret);
305 if (ret)
306 goto err_probe;
307
308 *devp = dev;
309 return 0;
310
311err_probe:
312
313
314
315
316 device_unbind(dev);
317err_bind:
318 free(str);
319 return ret;
320}
321
322int i2c_get_chip(struct udevice *bus, uint chip_addr, uint offset_len,
323 struct udevice **devp)
324{
325 struct udevice *dev;
326
327 debug("%s: Searching bus '%s' for address %02x: ", __func__,
328 bus->name, chip_addr);
329 for (device_find_first_child(bus, &dev); dev;
330 device_find_next_child(&dev)) {
331 struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
332 int ret;
333
334 if (chip->chip_addr == (chip_addr &
335 ~chip->chip_addr_offset_mask)) {
336 ret = device_probe(dev);
337 debug("found, ret=%d\n", ret);
338 if (ret)
339 return ret;
340 *devp = dev;
341 return 0;
342 }
343 }
344 debug("not found\n");
345 return i2c_bind_driver(bus, chip_addr, offset_len, devp);
346}
347
348int i2c_get_chip_for_busnum(int busnum, int chip_addr, uint offset_len,
349 struct udevice **devp)
350{
351 struct udevice *bus;
352 int ret;
353
354 ret = uclass_get_device_by_seq(UCLASS_I2C, busnum, &bus);
355 if (ret) {
356 debug("Cannot find I2C bus %d\n", busnum);
357 return ret;
358 }
359
360
361 ret = i2c_probe_chip(bus, chip_addr, 0);
362 debug("%s: bus='%s', address %02x, ret=%d\n", __func__, bus->name,
363 chip_addr, ret);
364 if (ret) {
365 debug("Cannot detect I2C chip %02x on bus %d\n", chip_addr,
366 busnum);
367 return ret;
368 }
369
370 ret = i2c_get_chip(bus, chip_addr, offset_len, devp);
371 if (ret) {
372 debug("Cannot find I2C chip %02x on bus %d\n", chip_addr,
373 busnum);
374 return ret;
375 }
376
377 return 0;
378}
379
380int dm_i2c_probe(struct udevice *bus, uint chip_addr, uint chip_flags,
381 struct udevice **devp)
382{
383 int ret;
384
385 *devp = NULL;
386
387
388 ret = i2c_probe_chip(bus, chip_addr, chip_flags);
389 debug("%s: bus='%s', address %02x, ret=%d\n", __func__, bus->name,
390 chip_addr, ret);
391 if (ret)
392 return ret;
393
394
395 ret = i2c_get_chip(bus, chip_addr, 1, devp);
396 debug("%s: i2c_get_chip: ret=%d\n", __func__, ret);
397
398 return ret;
399}
400
401int dm_i2c_set_bus_speed(struct udevice *bus, unsigned int speed)
402{
403 struct dm_i2c_ops *ops = i2c_get_ops(bus);
404 struct dm_i2c_bus *i2c = dev_get_uclass_priv(bus);
405 int ret;
406
407
408
409
410
411
412 if (ops->set_bus_speed) {
413 ret = ops->set_bus_speed(bus, speed);
414 if (ret)
415 return ret;
416 }
417 i2c->speed_hz = speed;
418
419 return 0;
420}
421
422int dm_i2c_get_bus_speed(struct udevice *bus)
423{
424 struct dm_i2c_ops *ops = i2c_get_ops(bus);
425 struct dm_i2c_bus *i2c = dev_get_uclass_priv(bus);
426
427 if (!ops->get_bus_speed)
428 return i2c->speed_hz;
429
430 return ops->get_bus_speed(bus);
431}
432
433int i2c_set_chip_flags(struct udevice *dev, uint flags)
434{
435 struct udevice *bus = dev->parent;
436 struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
437 struct dm_i2c_ops *ops = i2c_get_ops(bus);
438 int ret;
439
440 if (ops->set_flags) {
441 ret = ops->set_flags(dev, flags);
442 if (ret)
443 return ret;
444 }
445 chip->flags = flags;
446
447 return 0;
448}
449
450int i2c_get_chip_flags(struct udevice *dev, uint *flagsp)
451{
452 struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
453
454 *flagsp = chip->flags;
455
456 return 0;
457}
458
459int i2c_set_chip_offset_len(struct udevice *dev, uint offset_len)
460{
461 struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
462
463 if (offset_len > I2C_MAX_OFFSET_LEN)
464 return log_ret(-EINVAL);
465 chip->offset_len = offset_len;
466
467 return 0;
468}
469
470int i2c_get_chip_offset_len(struct udevice *dev)
471{
472 struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
473
474 return chip->offset_len;
475}
476
477int i2c_set_chip_addr_offset_mask(struct udevice *dev, uint mask)
478{
479 struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
480
481 chip->chip_addr_offset_mask = mask;
482
483 return 0;
484}
485
486uint i2c_get_chip_addr_offset_mask(struct udevice *dev)
487{
488 struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
489
490 return chip->chip_addr_offset_mask;
491}
492
493#if CONFIG_IS_ENABLED(DM_GPIO)
494static void i2c_gpio_set_pin(struct gpio_desc *pin, int bit)
495{
496 if (bit)
497 dm_gpio_set_dir_flags(pin, GPIOD_IS_IN);
498 else
499 dm_gpio_set_dir_flags(pin, GPIOD_IS_OUT |
500 GPIOD_ACTIVE_LOW |
501 GPIOD_IS_OUT_ACTIVE);
502}
503
504static int i2c_gpio_get_pin(struct gpio_desc *pin)
505{
506 return dm_gpio_get_value(pin);
507}
508
509int i2c_deblock_gpio_loop(struct gpio_desc *sda_pin,
510 struct gpio_desc *scl_pin,
511 unsigned int scl_count,
512 unsigned int start_count,
513 unsigned int delay)
514{
515 int i, ret = -EREMOTEIO;
516
517 i2c_gpio_set_pin(sda_pin, 1);
518 i2c_gpio_set_pin(scl_pin, 1);
519 udelay(delay);
520
521
522 for (; scl_count; --scl_count) {
523 i2c_gpio_set_pin(scl_pin, 1);
524 udelay(delay);
525 i2c_gpio_set_pin(scl_pin, 0);
526 udelay(delay);
527 if (i2c_gpio_get_pin(sda_pin)) {
528 ret = 0;
529 break;
530 }
531 }
532
533 if (!ret && start_count) {
534 for (i = 0; i < start_count; i++) {
535
536 udelay(delay);
537 i2c_gpio_set_pin(sda_pin, 1);
538 udelay(delay);
539 i2c_gpio_set_pin(scl_pin, 1);
540 udelay(delay);
541 i2c_gpio_set_pin(sda_pin, 0);
542 udelay(delay);
543 i2c_gpio_set_pin(scl_pin, 0);
544 }
545 }
546
547
548 i2c_gpio_set_pin(sda_pin, 0);
549 udelay(delay);
550
551 i2c_gpio_set_pin(scl_pin, 1);
552 udelay(delay);
553
554 i2c_gpio_set_pin(sda_pin, 1);
555 udelay(delay);
556
557 if (!i2c_gpio_get_pin(sda_pin) || !i2c_gpio_get_pin(scl_pin))
558 ret = -EREMOTEIO;
559
560 return ret;
561}
562
563static int i2c_deblock_gpio(struct udevice *bus)
564{
565 struct gpio_desc gpios[PIN_COUNT];
566 int ret, ret0;
567
568 ret = gpio_request_list_by_name(bus, "gpios", gpios,
569 ARRAY_SIZE(gpios), GPIOD_IS_IN);
570 if (ret != ARRAY_SIZE(gpios)) {
571 debug("%s: I2C Node '%s' has no 'gpios' property %s\n",
572 __func__, dev_read_name(bus), bus->name);
573 if (ret >= 0) {
574 gpio_free_list(bus, gpios, ret);
575 ret = -ENOENT;
576 }
577 goto out;
578 }
579
580 ret = pinctrl_select_state(bus, "gpio");
581 if (ret) {
582 debug("%s: I2C Node '%s' has no 'gpio' pinctrl state. %s\n",
583 __func__, dev_read_name(bus), bus->name);
584 goto out_no_pinctrl;
585 }
586
587 ret0 = i2c_deblock_gpio_loop(&gpios[PIN_SDA], &gpios[PIN_SCL], 9, 0, 5);
588
589 ret = pinctrl_select_state(bus, "default");
590 if (ret) {
591 debug("%s: I2C Node '%s' has no 'default' pinctrl state. %s\n",
592 __func__, dev_read_name(bus), bus->name);
593 }
594
595 ret = !ret ? ret0 : ret;
596
597out_no_pinctrl:
598 gpio_free_list(bus, gpios, ARRAY_SIZE(gpios));
599out:
600 return ret;
601}
602#else
603static int i2c_deblock_gpio(struct udevice *bus)
604{
605 return -ENOSYS;
606}
607#endif
608
609int i2c_deblock(struct udevice *bus)
610{
611 struct dm_i2c_ops *ops = i2c_get_ops(bus);
612
613 if (!ops->deblock)
614 return i2c_deblock_gpio(bus);
615
616 return ops->deblock(bus);
617}
618
619#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
620int i2c_chip_of_to_plat(struct udevice *dev, struct dm_i2c_chip *chip)
621{
622 int addr;
623
624 chip->offset_len = dev_read_u32_default(dev, "u-boot,i2c-offset-len",
625 1);
626 chip->flags = 0;
627 addr = dev_read_u32_default(dev, "reg", -1);
628 if (addr == -1) {
629 debug("%s: I2C Node '%s' has no 'reg' property %s\n", __func__,
630 dev_read_name(dev), dev->name);
631 return log_ret(-EINVAL);
632 }
633 chip->chip_addr = addr;
634
635 return 0;
636}
637#endif
638
639static int i2c_pre_probe(struct udevice *dev)
640{
641#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
642 struct dm_i2c_bus *i2c = dev_get_uclass_priv(dev);
643 unsigned int max = 0;
644 ofnode node;
645 int ret;
646
647 i2c->max_transaction_bytes = 0;
648 dev_for_each_subnode(node, dev) {
649 ret = ofnode_read_u32(node,
650 "u-boot,i2c-transaction-bytes",
651 &max);
652 if (!ret && max > i2c->max_transaction_bytes)
653 i2c->max_transaction_bytes = max;
654 }
655
656 debug("%s: I2C bus: %s max transaction bytes: %d\n", __func__,
657 dev->name, i2c->max_transaction_bytes);
658#endif
659 return 0;
660}
661
662static int i2c_post_probe(struct udevice *dev)
663{
664#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
665 struct dm_i2c_bus *i2c = dev_get_uclass_priv(dev);
666
667 i2c->speed_hz = dev_read_u32_default(dev, "clock-frequency",
668 I2C_SPEED_STANDARD_RATE);
669
670 return dm_i2c_set_bus_speed(dev, i2c->speed_hz);
671#else
672 return 0;
673#endif
674}
675
676static int i2c_child_post_bind(struct udevice *dev)
677{
678#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
679 struct dm_i2c_chip *plat = dev_get_parent_plat(dev);
680
681 if (!dev_has_ofnode(dev))
682 return 0;
683 return i2c_chip_of_to_plat(dev, plat);
684#else
685 return 0;
686#endif
687}
688
689static int i2c_post_bind(struct udevice *dev)
690{
691 int ret = 0;
692
693 debug("%s: %s, seq=%d\n", __func__, dev->name, dev_seq(dev));
694
695#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
696 ret = dm_scan_fdt_dev(dev);
697#endif
698 return ret;
699}
700
701UCLASS_DRIVER(i2c) = {
702 .id = UCLASS_I2C,
703 .name = "i2c",
704 .flags = DM_UC_FLAG_SEQ_ALIAS,
705 .post_bind = i2c_post_bind,
706 .pre_probe = i2c_pre_probe,
707 .post_probe = i2c_post_probe,
708 .per_device_auto = sizeof(struct dm_i2c_bus),
709 .per_child_plat_auto = sizeof(struct dm_i2c_chip),
710 .child_post_bind = i2c_child_post_bind,
711};
712
713UCLASS_DRIVER(i2c_generic) = {
714 .id = UCLASS_I2C_GENERIC,
715 .name = "i2c_generic",
716};
717
718static const struct udevice_id generic_chip_i2c_ids[] = {
719 { .compatible = "i2c-chip", .data = I2C_DEVICE_GENERIC },
720#if CONFIG_IS_ENABLED(ACPIGEN)
721 { .compatible = "hid-over-i2c", .data = I2C_DEVICE_HID_OVER_I2C },
722#endif
723 { }
724};
725
726U_BOOT_DRIVER(i2c_generic_chip_drv) = {
727 .name = "i2c_generic_chip_drv",
728 .id = UCLASS_I2C_GENERIC,
729 .of_match = generic_chip_i2c_ids,
730#if CONFIG_IS_ENABLED(ACPIGEN)
731 .of_to_plat = acpi_i2c_of_to_plat,
732 .priv_auto = sizeof(struct acpi_i2c_priv),
733#endif
734 ACPI_OPS_PTR(&acpi_i2c_ops)
735};
736