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