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