]> git.sur5r.net Git - u-boot/blob - drivers/i2c/i2c-uclass.c
arm: mvebu: Disable L2 cache before enabling d-cache
[u-boot] / drivers / i2c / i2c-uclass.c
1 /*
2  * Copyright (c) 2014 Google, Inc
3  *
4  * SPDX-License-Identifier:     GPL-2.0+
5  */
6
7 #include <common.h>
8 #include <dm.h>
9 #include <errno.h>
10 #include <fdtdec.h>
11 #include <i2c.h>
12 #include <malloc.h>
13 #include <dm/device-internal.h>
14 #include <dm/lists.h>
15 #include <dm/root.h>
16
17 DECLARE_GLOBAL_DATA_PTR;
18
19 #define I2C_MAX_OFFSET_LEN      4
20
21 /**
22  * i2c_setup_offset() - Set up a new message with a chip offset
23  *
24  * @chip:       Chip to use
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.
30  */
31 static int i2c_setup_offset(struct dm_i2c_chip *chip, uint offset,
32                             uint8_t offset_buf[], struct i2c_msg *msg)
33 {
34         int offset_len;
35
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;
44         while (offset_len--)
45                 *offset_buf++ = offset >> (8 * offset_len);
46
47         return 0;
48 }
49
50 static int i2c_read_bytewise(struct udevice *dev, uint offset,
51                              uint8_t *buffer, int len)
52 {
53         struct dm_i2c_chip *chip = dev_get_parent_platdata(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];
58         int ret;
59         int i;
60
61         for (i = 0; i < len; i++) {
62                 if (i2c_setup_offset(chip, offset + i, offset_buf, msg))
63                         return -EINVAL;
64                 ptr = msg + 1;
65                 ptr->addr = chip->chip_addr;
66                 ptr->flags = msg->flags | I2C_M_RD;
67                 ptr->len = 1;
68                 ptr->buf = &buffer[i];
69                 ptr++;
70
71                 ret = ops->xfer(bus, msg, ptr - msg);
72                 if (ret)
73                         return ret;
74         }
75
76         return 0;
77 }
78
79 static int i2c_write_bytewise(struct udevice *dev, uint offset,
80                              const uint8_t *buffer, int len)
81 {
82         struct dm_i2c_chip *chip = dev_get_parent_platdata(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];
87         int ret;
88         int i;
89
90         for (i = 0; i < len; i++) {
91                 if (i2c_setup_offset(chip, offset + i, buf, msg))
92                         return -EINVAL;
93                 buf[msg->len++] = buffer[i];
94
95                 ret = ops->xfer(bus, msg, 1);
96                 if (ret)
97                         return ret;
98         }
99
100         return 0;
101 }
102
103 int dm_i2c_read(struct udevice *dev, uint offset, uint8_t *buffer, int len)
104 {
105         struct dm_i2c_chip *chip = dev_get_parent_platdata(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];
110         int msg_count;
111
112         if (!ops->xfer)
113                 return -ENOSYS;
114         if (chip->flags & DM_I2C_CHIP_RD_ADDRESS)
115                 return i2c_read_bytewise(dev, offset, buffer, len);
116         ptr = msg;
117         if (!i2c_setup_offset(chip, offset, offset_buf, ptr))
118                 ptr++;
119
120         if (len) {
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;
124                 ptr->len = len;
125                 ptr->buf = buffer;
126                 ptr++;
127         }
128         msg_count = ptr - msg;
129
130         return ops->xfer(bus, msg, msg_count);
131 }
132
133 int dm_i2c_write(struct udevice *dev, uint offset, const uint8_t *buffer,
134                  int len)
135 {
136         struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
137         struct udevice *bus = dev_get_parent(dev);
138         struct dm_i2c_ops *ops = i2c_get_ops(bus);
139         struct i2c_msg msg[1];
140
141         if (!ops->xfer)
142                 return -ENOSYS;
143
144         if (chip->flags & DM_I2C_CHIP_WR_ADDRESS)
145                 return i2c_write_bytewise(dev, offset, buffer, len);
146         /*
147          * The simple approach would be to send two messages here: one to
148          * set the offset and one to write the bytes. However some drivers
149          * will not be expecting this, and some chips won't like how the
150          * driver presents this on the I2C bus.
151          *
152          * The API does not support separate offset and data. We could extend
153          * it with a flag indicating that there is data in the next message
154          * that needs to be processed in the same transaction. We could
155          * instead add an additional buffer to each message. For now, handle
156          * this in the uclass since it isn't clear what the impact on drivers
157          * would be with this extra complication. Unfortunately this means
158          * copying the message.
159          *
160          * Use the stack for small messages, malloc() for larger ones. We
161          * need to allow space for the offset (up to 4 bytes) and the message
162          * itself.
163          */
164         if (len < 64) {
165                 uint8_t buf[I2C_MAX_OFFSET_LEN + len];
166
167                 i2c_setup_offset(chip, offset, buf, msg);
168                 msg->len += len;
169                 memcpy(buf + chip->offset_len, buffer, len);
170
171                 return ops->xfer(bus, msg, 1);
172         } else {
173                 uint8_t *buf;
174                 int ret;
175
176                 buf = malloc(I2C_MAX_OFFSET_LEN + len);
177                 if (!buf)
178                         return -ENOMEM;
179                 i2c_setup_offset(chip, offset, buf, msg);
180                 msg->len += len;
181                 memcpy(buf + chip->offset_len, buffer, len);
182
183                 ret = ops->xfer(bus, msg, 1);
184                 free(buf);
185                 return ret;
186         }
187 }
188
189 int dm_i2c_reg_read(struct udevice *dev, uint offset)
190 {
191         uint8_t val;
192         int ret;
193
194         ret = dm_i2c_read(dev, offset, &val, 1);
195         if (ret < 0)
196                 return ret;
197
198         return val;
199 }
200
201 int dm_i2c_reg_write(struct udevice *dev, uint offset, uint value)
202 {
203         uint8_t val = value;
204
205         return dm_i2c_write(dev, offset, &val, 1);
206 }
207
208 /**
209  * i2c_probe_chip() - probe for a chip on a bus
210  *
211  * @bus:        Bus to probe
212  * @chip_addr:  Chip address to probe
213  * @flags:      Flags for the chip
214  * @return 0 if found, -ENOSYS if the driver is invalid, -EREMOTEIO if the chip
215  * does not respond to probe
216  */
217 static int i2c_probe_chip(struct udevice *bus, uint chip_addr,
218                           enum dm_i2c_chip_flags chip_flags)
219 {
220         struct dm_i2c_ops *ops = i2c_get_ops(bus);
221         struct i2c_msg msg[1];
222         int ret;
223
224         if (ops->probe_chip) {
225                 ret = ops->probe_chip(bus, chip_addr, chip_flags);
226                 if (!ret || ret != -ENOSYS)
227                         return ret;
228         }
229
230         if (!ops->xfer)
231                 return -ENOSYS;
232
233         /* Probe with a zero-length message */
234         msg->addr = chip_addr;
235         msg->flags = chip_flags & DM_I2C_CHIP_10BIT ? I2C_M_TEN : 0;
236         msg->len = 0;
237         msg->buf = NULL;
238
239         return ops->xfer(bus, msg, 1);
240 }
241
242 static int i2c_bind_driver(struct udevice *bus, uint chip_addr, uint offset_len,
243                            struct udevice **devp)
244 {
245         struct dm_i2c_chip *chip;
246         char name[30], *str;
247         struct udevice *dev;
248         int ret;
249
250         snprintf(name, sizeof(name), "generic_%x", chip_addr);
251         str = strdup(name);
252         if (!str)
253                 return -ENOMEM;
254         ret = device_bind_driver(bus, "i2c_generic_chip_drv", str, &dev);
255         debug("%s:  device_bind_driver: ret=%d\n", __func__, ret);
256         if (ret)
257                 goto err_bind;
258
259         /* Tell the device what we know about it */
260         chip = dev_get_parent_platdata(dev);
261         chip->chip_addr = chip_addr;
262         chip->offset_len = offset_len;
263         ret = device_probe(dev);
264         debug("%s:  device_probe: ret=%d\n", __func__, ret);
265         if (ret)
266                 goto err_probe;
267
268         *devp = dev;
269         return 0;
270
271 err_probe:
272         /*
273          * If the device failed to probe, unbind it. There is nothing there
274          * on the bus so we don't want to leave it lying around
275          */
276         device_unbind(dev);
277 err_bind:
278         free(str);
279         return ret;
280 }
281
282 int i2c_get_chip(struct udevice *bus, uint chip_addr, uint offset_len,
283                  struct udevice **devp)
284 {
285         struct udevice *dev;
286
287         debug("%s: Searching bus '%s' for address %02x: ", __func__,
288               bus->name, chip_addr);
289         for (device_find_first_child(bus, &dev); dev;
290                         device_find_next_child(&dev)) {
291                 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
292                 int ret;
293
294                 if (chip->chip_addr == chip_addr) {
295                         ret = device_probe(dev);
296                         debug("found, ret=%d\n", ret);
297                         if (ret)
298                                 return ret;
299                         *devp = dev;
300                         return 0;
301                 }
302         }
303         debug("not found\n");
304         return i2c_bind_driver(bus, chip_addr, offset_len, devp);
305 }
306
307 int i2c_get_chip_for_busnum(int busnum, int chip_addr, uint offset_len,
308                             struct udevice **devp)
309 {
310         struct udevice *bus;
311         int ret;
312
313         ret = uclass_get_device_by_seq(UCLASS_I2C, busnum, &bus);
314         if (ret) {
315                 debug("Cannot find I2C bus %d\n", busnum);
316                 return ret;
317         }
318         ret = i2c_get_chip(bus, chip_addr, offset_len, devp);
319         if (ret) {
320                 debug("Cannot find I2C chip %02x on bus %d\n", chip_addr,
321                       busnum);
322                 return ret;
323         }
324
325         return 0;
326 }
327
328 int dm_i2c_probe(struct udevice *bus, uint chip_addr, uint chip_flags,
329                  struct udevice **devp)
330 {
331         int ret;
332
333         *devp = NULL;
334
335         /* First probe that chip */
336         ret = i2c_probe_chip(bus, chip_addr, chip_flags);
337         debug("%s: bus='%s', address %02x, ret=%d\n", __func__, bus->name,
338               chip_addr, ret);
339         if (ret)
340                 return ret;
341
342         /* The chip was found, see if we have a driver, and probe it */
343         ret = i2c_get_chip(bus, chip_addr, 1, devp);
344         debug("%s:  i2c_get_chip: ret=%d\n", __func__, ret);
345
346         return ret;
347 }
348
349 int dm_i2c_set_bus_speed(struct udevice *bus, unsigned int speed)
350 {
351         struct dm_i2c_ops *ops = i2c_get_ops(bus);
352         struct dm_i2c_bus *i2c = dev_get_uclass_priv(bus);
353         int ret;
354
355         /*
356          * If we have a method, call it. If not then the driver probably wants
357          * to deal with speed changes on the next transfer. It can easily read
358          * the current speed from this uclass
359          */
360         if (ops->set_bus_speed) {
361                 ret = ops->set_bus_speed(bus, speed);
362                 if (ret)
363                         return ret;
364         }
365         i2c->speed_hz = speed;
366
367         return 0;
368 }
369
370 int dm_i2c_get_bus_speed(struct udevice *bus)
371 {
372         struct dm_i2c_ops *ops = i2c_get_ops(bus);
373         struct dm_i2c_bus *i2c = dev_get_uclass_priv(bus);
374
375         if (!ops->get_bus_speed)
376                 return i2c->speed_hz;
377
378         return ops->get_bus_speed(bus);
379 }
380
381 int i2c_set_chip_flags(struct udevice *dev, uint flags)
382 {
383         struct udevice *bus = dev->parent;
384         struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
385         struct dm_i2c_ops *ops = i2c_get_ops(bus);
386         int ret;
387
388         if (ops->set_flags) {
389                 ret = ops->set_flags(dev, flags);
390                 if (ret)
391                         return ret;
392         }
393         chip->flags = flags;
394
395         return 0;
396 }
397
398 int i2c_get_chip_flags(struct udevice *dev, uint *flagsp)
399 {
400         struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
401
402         *flagsp = chip->flags;
403
404         return 0;
405 }
406
407 int i2c_set_chip_offset_len(struct udevice *dev, uint offset_len)
408 {
409         struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
410
411         if (offset_len > I2C_MAX_OFFSET_LEN)
412                 return -EINVAL;
413         chip->offset_len = offset_len;
414
415         return 0;
416 }
417
418 int i2c_get_chip_offset_len(struct udevice *dev)
419 {
420         struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
421
422         return chip->offset_len;
423 }
424
425 int i2c_deblock(struct udevice *bus)
426 {
427         struct dm_i2c_ops *ops = i2c_get_ops(bus);
428
429         /*
430          * We could implement a software deblocking here if we could get
431          * access to the GPIOs used by I2C, and switch them to GPIO mode
432          * and then back to I2C. This is somewhat beyond our powers in
433          * driver model at present, so for now just fail.
434          *
435          * See https://patchwork.ozlabs.org/patch/399040/
436          */
437         if (!ops->deblock)
438                 return -ENOSYS;
439
440         return ops->deblock(bus);
441 }
442
443 int i2c_chip_ofdata_to_platdata(const void *blob, int node,
444                                 struct dm_i2c_chip *chip)
445 {
446         chip->offset_len = fdtdec_get_int(gd->fdt_blob, node,
447                                           "u-boot,i2c-offset-len", 1);
448         chip->flags = 0;
449         chip->chip_addr = fdtdec_get_int(gd->fdt_blob, node, "reg", -1);
450         if (chip->chip_addr == -1) {
451                 debug("%s: I2C Node '%s' has no 'reg' property\n", __func__,
452                       fdt_get_name(blob, node, NULL));
453                 return -EINVAL;
454         }
455
456         return 0;
457 }
458
459 static int i2c_post_probe(struct udevice *dev)
460 {
461         struct dm_i2c_bus *i2c = dev_get_uclass_priv(dev);
462
463         i2c->speed_hz = fdtdec_get_int(gd->fdt_blob, dev->of_offset,
464                                      "clock-frequency", 100000);
465
466         return dm_i2c_set_bus_speed(dev, i2c->speed_hz);
467 }
468
469 static int i2c_post_bind(struct udevice *dev)
470 {
471         /* Scan the bus for devices */
472         return dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset, false);
473 }
474
475 static int i2c_child_post_bind(struct udevice *dev)
476 {
477         struct dm_i2c_chip *plat = dev_get_parent_platdata(dev);
478
479         if (dev->of_offset == -1)
480                 return 0;
481
482         return i2c_chip_ofdata_to_platdata(gd->fdt_blob, dev->of_offset, plat);
483 }
484
485 UCLASS_DRIVER(i2c) = {
486         .id             = UCLASS_I2C,
487         .name           = "i2c",
488         .flags          = DM_UC_FLAG_SEQ_ALIAS,
489         .post_bind      = i2c_post_bind,
490         .post_probe     = i2c_post_probe,
491         .per_device_auto_alloc_size = sizeof(struct dm_i2c_bus),
492         .per_child_platdata_auto_alloc_size = sizeof(struct dm_i2c_chip),
493         .child_post_bind = i2c_child_post_bind,
494 };
495
496 UCLASS_DRIVER(i2c_generic) = {
497         .id             = UCLASS_I2C_GENERIC,
498         .name           = "i2c_generic",
499 };
500
501 U_BOOT_DRIVER(i2c_generic_chip_drv) = {
502         .name           = "i2c_generic_chip_drv",
503         .id             = UCLASS_I2C_GENERIC,
504 };