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