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 <malloc.h> 11 #include <spi.h> 12 #include <dm/device-internal.h> 13 #include <dm/uclass-internal.h> 14 #include <dm/lists.h> 15 #include <dm/util.h> 16 17 DECLARE_GLOBAL_DATA_PTR; 18 19 #define SPI_DEFAULT_SPEED_HZ 100000 20 21 static int spi_set_speed_mode(struct udevice *bus, int speed, int mode) 22 { 23 struct dm_spi_ops *ops; 24 int ret; 25 26 ops = spi_get_ops(bus); 27 if (ops->set_speed) 28 ret = ops->set_speed(bus, speed); 29 else 30 ret = -EINVAL; 31 if (ret) { 32 printf("Cannot set speed (err=%d)\n", ret); 33 return ret; 34 } 35 36 if (ops->set_mode) 37 ret = ops->set_mode(bus, mode); 38 else 39 ret = -EINVAL; 40 if (ret) { 41 printf("Cannot set mode (err=%d)\n", ret); 42 return ret; 43 } 44 45 return 0; 46 } 47 48 int dm_spi_claim_bus(struct udevice *dev) 49 { 50 struct udevice *bus = dev->parent; 51 struct dm_spi_ops *ops = spi_get_ops(bus); 52 struct dm_spi_bus *spi = dev_get_uclass_priv(bus); 53 struct spi_slave *slave = dev_get_parent_priv(dev); 54 uint speed, mode; 55 56 speed = slave->max_hz; 57 mode = slave->mode; 58 59 if (spi->max_hz) { 60 if (speed) 61 speed = min(speed, spi->max_hz); 62 else 63 speed = spi->max_hz; 64 } 65 if (!speed) 66 speed = SPI_DEFAULT_SPEED_HZ; 67 68 if (speed != spi->speed || mode != spi->mode) { 69 int ret = spi_set_speed_mode(bus, speed, slave->mode); 70 71 if (ret) 72 return log_ret(ret); 73 74 spi->speed = speed; 75 spi->mode = mode; 76 } 77 78 return log_ret(ops->claim_bus ? ops->claim_bus(dev) : 0); 79 } 80 81 void dm_spi_release_bus(struct udevice *dev) 82 { 83 struct udevice *bus = dev->parent; 84 struct dm_spi_ops *ops = spi_get_ops(bus); 85 86 if (ops->release_bus) 87 ops->release_bus(dev); 88 } 89 90 int dm_spi_xfer(struct udevice *dev, unsigned int bitlen, 91 const void *dout, void *din, unsigned long flags) 92 { 93 struct udevice *bus = dev->parent; 94 struct dm_spi_ops *ops = spi_get_ops(bus); 95 96 if (bus->uclass->uc_drv->id != UCLASS_SPI) 97 return -EOPNOTSUPP; 98 if (!ops->xfer) 99 return -ENOSYS; 100 101 return ops->xfer(dev, bitlen, dout, din, flags); 102 } 103 104 int dm_spi_get_mmap(struct udevice *dev, ulong *map_basep, uint *map_sizep, 105 uint *offsetp) 106 { 107 struct udevice *bus = dev->parent; 108 struct dm_spi_ops *ops = spi_get_ops(bus); 109 110 if (bus->uclass->uc_drv->id != UCLASS_SPI) 111 return -EOPNOTSUPP; 112 if (!ops->get_mmap) 113 return -ENOSYS; 114 115 return ops->get_mmap(dev, map_basep, map_sizep, offsetp); 116 } 117 118 int spi_claim_bus(struct spi_slave *slave) 119 { 120 return log_ret(dm_spi_claim_bus(slave->dev)); 121 } 122 123 void spi_release_bus(struct spi_slave *slave) 124 { 125 dm_spi_release_bus(slave->dev); 126 } 127 128 int spi_xfer(struct spi_slave *slave, unsigned int bitlen, 129 const void *dout, void *din, unsigned long flags) 130 { 131 return dm_spi_xfer(slave->dev, bitlen, dout, din, flags); 132 } 133 134 int spi_write_then_read(struct spi_slave *slave, const u8 *opcode, 135 size_t n_opcode, const u8 *txbuf, u8 *rxbuf, 136 size_t n_buf) 137 { 138 unsigned long flags = SPI_XFER_BEGIN; 139 int ret; 140 141 if (n_buf == 0) 142 flags |= SPI_XFER_END; 143 144 ret = spi_xfer(slave, n_opcode * 8, opcode, NULL, flags); 145 if (ret) { 146 debug("spi: failed to send command (%zu bytes): %d\n", 147 n_opcode, ret); 148 } else if (n_buf != 0) { 149 ret = spi_xfer(slave, n_buf * 8, txbuf, rxbuf, SPI_XFER_END); 150 if (ret) 151 debug("spi: failed to transfer %zu bytes of data: %d\n", 152 n_buf, ret); 153 } 154 155 return ret; 156 } 157 158 #if !CONFIG_IS_ENABLED(OF_PLATDATA) 159 static int spi_child_post_bind(struct udevice *dev) 160 { 161 struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev); 162 163 if (!dev_of_valid(dev)) 164 return 0; 165 166 return spi_slave_ofdata_to_platdata(dev, plat); 167 } 168 #endif 169 170 static int spi_post_probe(struct udevice *bus) 171 { 172 #if !CONFIG_IS_ENABLED(OF_PLATDATA) 173 struct dm_spi_bus *spi = dev_get_uclass_priv(bus); 174 175 spi->max_hz = dev_read_u32_default(bus, "spi-max-frequency", 0); 176 #endif 177 #if defined(CONFIG_NEEDS_MANUAL_RELOC) 178 struct dm_spi_ops *ops = spi_get_ops(bus); 179 static int reloc_done; 180 181 if (!reloc_done) { 182 if (ops->claim_bus) 183 ops->claim_bus += gd->reloc_off; 184 if (ops->release_bus) 185 ops->release_bus += gd->reloc_off; 186 if (ops->set_wordlen) 187 ops->set_wordlen += gd->reloc_off; 188 if (ops->xfer) 189 ops->xfer += gd->reloc_off; 190 if (ops->set_speed) 191 ops->set_speed += gd->reloc_off; 192 if (ops->set_mode) 193 ops->set_mode += gd->reloc_off; 194 if (ops->cs_info) 195 ops->cs_info += gd->reloc_off; 196 reloc_done++; 197 } 198 #endif 199 200 return 0; 201 } 202 203 static int spi_child_pre_probe(struct udevice *dev) 204 { 205 struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev); 206 struct spi_slave *slave = dev_get_parent_priv(dev); 207 208 /* 209 * This is needed because we pass struct spi_slave around the place 210 * instead slave->dev (a struct udevice). So we have to have some 211 * way to access the slave udevice given struct spi_slave. Once we 212 * change the SPI API to use udevice instead of spi_slave, we can 213 * drop this. 214 */ 215 slave->dev = dev; 216 217 slave->max_hz = plat->max_hz; 218 slave->mode = plat->mode; 219 slave->wordlen = SPI_DEFAULT_WORDLEN; 220 221 return 0; 222 } 223 224 int spi_chip_select(struct udevice *dev) 225 { 226 struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev); 227 228 return plat ? plat->cs : -ENOENT; 229 } 230 231 int spi_find_chip_select(struct udevice *bus, int cs, struct udevice **devp) 232 { 233 struct dm_spi_ops *ops; 234 struct spi_cs_info info; 235 struct udevice *dev; 236 int ret; 237 238 /* 239 * Ask the driver. For the moment we don't have CS info. 240 * When we do we could provide the driver with a helper function 241 * to figure out what chip selects are valid, or just handle the 242 * request. 243 */ 244 ops = spi_get_ops(bus); 245 if (ops->cs_info) { 246 ret = ops->cs_info(bus, cs, &info); 247 } else { 248 /* 249 * We could assume there is at least one valid chip select. 250 * The driver didn't care enough to tell us. 251 */ 252 ret = 0; 253 } 254 255 if (ret) { 256 printf("Invalid cs %d (err=%d)\n", cs, ret); 257 return ret; 258 } 259 260 for (device_find_first_child(bus, &dev); dev; 261 device_find_next_child(&dev)) { 262 struct dm_spi_slave_platdata *plat; 263 264 plat = dev_get_parent_platdata(dev); 265 debug("%s: plat=%p, cs=%d\n", __func__, plat, plat->cs); 266 if (plat->cs == cs) { 267 *devp = dev; 268 return 0; 269 } 270 } 271 272 return -ENODEV; 273 } 274 275 int spi_cs_is_valid(unsigned int busnum, unsigned int cs) 276 { 277 struct spi_cs_info info; 278 struct udevice *bus; 279 int ret; 280 281 ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus); 282 if (ret) { 283 debug("%s: No bus %d\n", __func__, busnum); 284 return ret; 285 } 286 287 return spi_cs_info(bus, cs, &info); 288 } 289 290 int spi_cs_info(struct udevice *bus, uint cs, struct spi_cs_info *info) 291 { 292 struct spi_cs_info local_info; 293 int ret; 294 295 if (!info) 296 info = &local_info; 297 298 /* If there is a device attached, return it */ 299 info->dev = NULL; 300 ret = spi_find_chip_select(bus, cs, &info->dev); 301 return ret == -ENODEV ? 0 : ret; 302 } 303 304 int spi_find_bus_and_cs(int busnum, int cs, struct udevice **busp, 305 struct udevice **devp) 306 { 307 struct udevice *bus, *dev; 308 int ret; 309 310 ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus); 311 if (ret) { 312 debug("%s: No bus %d\n", __func__, busnum); 313 return ret; 314 } 315 ret = spi_find_chip_select(bus, cs, &dev); 316 if (ret) { 317 debug("%s: No cs %d\n", __func__, cs); 318 return ret; 319 } 320 *busp = bus; 321 *devp = dev; 322 323 return ret; 324 } 325 326 int spi_get_bus_and_cs(int busnum, int cs, int speed, int mode, 327 const char *drv_name, const char *dev_name, 328 struct udevice **busp, struct spi_slave **devp) 329 { 330 struct udevice *bus, *dev; 331 struct dm_spi_slave_platdata *plat; 332 struct dm_spi_bus *bus_data; 333 struct spi_slave *slave; 334 bool created = false; 335 int ret; 336 337 #if CONFIG_IS_ENABLED(OF_PLATDATA) 338 ret = uclass_first_device_err(UCLASS_SPI, &bus); 339 #else 340 ret = uclass_get_device_by_seq(UCLASS_SPI, busnum, &bus); 341 #endif 342 if (ret) { 343 printf("Invalid bus %d (err=%d)\n", busnum, ret); 344 return ret; 345 } 346 ret = spi_find_chip_select(bus, cs, &dev); 347 348 /* 349 * If there is no such device, create one automatically. This means 350 * that we don't need a device tree node or platform data for the 351 * SPI flash chip - we will bind to the correct driver. 352 */ 353 if (ret == -ENODEV && drv_name) { 354 debug("%s: Binding new device '%s', busnum=%d, cs=%d, driver=%s\n", 355 __func__, dev_name, busnum, cs, drv_name); 356 ret = device_bind_driver(bus, drv_name, dev_name, &dev); 357 if (ret) { 358 debug("%s: Unable to bind driver (ret=%d)\n", __func__, 359 ret); 360 return ret; 361 } 362 plat = dev_get_parent_platdata(dev); 363 plat->cs = cs; 364 if (speed) { 365 plat->max_hz = speed; 366 } else { 367 printf("Warning: SPI speed fallback to %u kHz\n", 368 SPI_DEFAULT_SPEED_HZ / 1000); 369 plat->max_hz = SPI_DEFAULT_SPEED_HZ; 370 } 371 plat->mode = mode; 372 created = true; 373 } else if (ret) { 374 printf("Invalid chip select %d:%d (err=%d)\n", busnum, cs, 375 ret); 376 return ret; 377 } 378 379 if (!device_active(dev)) { 380 struct spi_slave *slave; 381 382 ret = device_probe(dev); 383 if (ret) 384 goto err; 385 slave = dev_get_parent_priv(dev); 386 slave->dev = dev; 387 } 388 389 slave = dev_get_parent_priv(dev); 390 bus_data = dev_get_uclass_priv(bus); 391 392 /* 393 * In case the operation speed is not yet established by 394 * dm_spi_claim_bus() ensure the bus is configured properly. 395 */ 396 if (!bus_data->speed) { 397 ret = spi_claim_bus(slave); 398 if (ret) 399 goto err; 400 } 401 402 *busp = bus; 403 *devp = slave; 404 debug("%s: bus=%p, slave=%p\n", __func__, bus, *devp); 405 406 return 0; 407 408 err: 409 debug("%s: Error path, created=%d, device '%s'\n", __func__, 410 created, dev->name); 411 if (created) { 412 device_remove(dev, DM_REMOVE_NORMAL); 413 device_unbind(dev); 414 } 415 416 return ret; 417 } 418 419 /* Compatibility function - to be removed */ 420 struct spi_slave *spi_setup_slave(unsigned int busnum, unsigned int cs, 421 unsigned int speed, unsigned int mode) 422 { 423 struct spi_slave *slave; 424 struct udevice *dev; 425 int ret; 426 427 ret = spi_get_bus_and_cs(busnum, cs, speed, mode, NULL, 0, &dev, 428 &slave); 429 if (ret) 430 return NULL; 431 432 return slave; 433 } 434 435 void spi_free_slave(struct spi_slave *slave) 436 { 437 device_remove(slave->dev, DM_REMOVE_NORMAL); 438 slave->dev = NULL; 439 } 440 441 int spi_slave_ofdata_to_platdata(struct udevice *dev, 442 struct dm_spi_slave_platdata *plat) 443 { 444 int mode = 0; 445 int value; 446 447 plat->cs = dev_read_u32_default(dev, "reg", -1); 448 plat->max_hz = dev_read_u32_default(dev, "spi-max-frequency", 449 SPI_DEFAULT_SPEED_HZ); 450 if (dev_read_bool(dev, "spi-cpol")) 451 mode |= SPI_CPOL; 452 if (dev_read_bool(dev, "spi-cpha")) 453 mode |= SPI_CPHA; 454 if (dev_read_bool(dev, "spi-cs-high")) 455 mode |= SPI_CS_HIGH; 456 if (dev_read_bool(dev, "spi-3wire")) 457 mode |= SPI_3WIRE; 458 if (dev_read_bool(dev, "spi-half-duplex")) 459 mode |= SPI_PREAMBLE; 460 461 /* Device DUAL/QUAD mode */ 462 value = dev_read_u32_default(dev, "spi-tx-bus-width", 1); 463 switch (value) { 464 case 1: 465 break; 466 case 2: 467 mode |= SPI_TX_DUAL; 468 break; 469 case 4: 470 mode |= SPI_TX_QUAD; 471 break; 472 case 8: 473 mode |= SPI_TX_OCTAL; 474 break; 475 default: 476 warn_non_spl("spi-tx-bus-width %d not supported\n", value); 477 break; 478 } 479 480 value = dev_read_u32_default(dev, "spi-rx-bus-width", 1); 481 switch (value) { 482 case 1: 483 break; 484 case 2: 485 mode |= SPI_RX_DUAL; 486 break; 487 case 4: 488 mode |= SPI_RX_QUAD; 489 break; 490 case 8: 491 mode |= SPI_RX_OCTAL; 492 break; 493 default: 494 warn_non_spl("spi-rx-bus-width %d not supported\n", value); 495 break; 496 } 497 498 plat->mode = mode; 499 500 return 0; 501 } 502 503 UCLASS_DRIVER(spi) = { 504 .id = UCLASS_SPI, 505 .name = "spi", 506 .flags = DM_UC_FLAG_SEQ_ALIAS, 507 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA) 508 .post_bind = dm_scan_fdt_dev, 509 #endif 510 .post_probe = spi_post_probe, 511 .child_pre_probe = spi_child_pre_probe, 512 .per_device_auto_alloc_size = sizeof(struct dm_spi_bus), 513 .per_child_auto_alloc_size = sizeof(struct spi_slave), 514 .per_child_platdata_auto_alloc_size = 515 sizeof(struct dm_spi_slave_platdata), 516 #if !CONFIG_IS_ENABLED(OF_PLATDATA) 517 .child_post_bind = spi_child_post_bind, 518 #endif 519 }; 520 521 UCLASS_DRIVER(spi_generic) = { 522 .id = UCLASS_SPI_GENERIC, 523 .name = "spi_generic", 524 }; 525 526 U_BOOT_DRIVER(spi_generic_drv) = { 527 .name = "spi_generic_drv", 528 .id = UCLASS_SPI_GENERIC, 529 }; 530