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