drivers/i2c/i2c-uclass.c

   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 */
  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  */
  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
  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
 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
 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
 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
 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
 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
 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  */
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 468 static int i2c_gpio_get_pin(struct gpio_desc *pin)
 469 {
 470         return dm_gpio_get_value(pin);
 471 }
 472
 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
 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
 549 static int i2c_deblock_gpio(struct udevice *bus)
 550 {
 551         return -ENOSYS;
 552 }
 553 #endif // CONFIG_DM_GPIO
 554
 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)
 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
 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
 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 };