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