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