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