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