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 udevice *dev; 229 230 for (device_find_first_child(bus, &dev); dev; 231 device_find_next_child(&dev)) { 232 struct dm_spi_slave_platdata *plat; 233 234 plat = dev_get_parent_platdata(dev); 235 debug("%s: plat=%p, cs=%d\n", __func__, plat, plat->cs); 236 if (plat->cs == cs) { 237 *devp = dev; 238 return 0; 239 } 240 } 241 242 return -ENODEV; 243 } 244 245 int spi_cs_is_valid(unsigned int busnum, unsigned int cs) 246 { 247 struct spi_cs_info info; 248 struct udevice *bus; 249 int ret; 250 251 ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus); 252 if (ret) { 253 debug("%s: No bus %d\n", __func__, busnum); 254 return ret; 255 } 256 257 return spi_cs_info(bus, cs, &info); 258 } 259 260 int spi_cs_info(struct udevice *bus, uint cs, struct spi_cs_info *info) 261 { 262 struct spi_cs_info local_info; 263 struct dm_spi_ops *ops; 264 int ret; 265 266 if (!info) 267 info = &local_info; 268 269 /* If there is a device attached, return it */ 270 info->dev = NULL; 271 ret = spi_find_chip_select(bus, cs, &info->dev); 272 if (!ret) 273 return 0; 274 275 /* 276 * Otherwise ask the driver. For the moment we don't have CS info. 277 * When we do we could provide the driver with a helper function 278 * to figure out what chip selects are valid, or just handle the 279 * request. 280 */ 281 ops = spi_get_ops(bus); 282 if (ops->cs_info) 283 return ops->cs_info(bus, cs, info); 284 285 /* 286 * We could assume there is at least one valid chip select. 287 * The driver didn't care enough to tell us. 288 */ 289 return 0; 290 } 291 292 int spi_find_bus_and_cs(int busnum, int cs, struct udevice **busp, 293 struct udevice **devp) 294 { 295 struct udevice *bus, *dev; 296 int ret; 297 298 ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus); 299 if (ret) { 300 debug("%s: No bus %d\n", __func__, busnum); 301 return ret; 302 } 303 ret = spi_find_chip_select(bus, cs, &dev); 304 if (ret) { 305 debug("%s: No cs %d\n", __func__, cs); 306 return ret; 307 } 308 *busp = bus; 309 *devp = dev; 310 311 return ret; 312 } 313 314 int spi_get_bus_and_cs(int busnum, int cs, int speed, int mode, 315 const char *drv_name, const char *dev_name, 316 struct udevice **busp, struct spi_slave **devp) 317 { 318 struct udevice *bus, *dev; 319 struct dm_spi_slave_platdata *plat; 320 bool created = false; 321 int ret; 322 323 #if CONFIG_IS_ENABLED(OF_PLATDATA) 324 ret = uclass_first_device_err(UCLASS_SPI, &bus); 325 #else 326 ret = uclass_get_device_by_seq(UCLASS_SPI, busnum, &bus); 327 #endif 328 if (ret) { 329 printf("Invalid bus %d (err=%d)\n", busnum, ret); 330 return ret; 331 } 332 ret = spi_find_chip_select(bus, cs, &dev); 333 334 /* 335 * If there is no such device, create one automatically. This means 336 * that we don't need a device tree node or platform data for the 337 * SPI flash chip - we will bind to the correct driver. 338 */ 339 if (ret == -ENODEV && drv_name) { 340 debug("%s: Binding new device '%s', busnum=%d, cs=%d, driver=%s\n", 341 __func__, dev_name, busnum, cs, drv_name); 342 ret = device_bind_driver(bus, drv_name, dev_name, &dev); 343 if (ret) { 344 debug("%s: Unable to bind driver (ret=%d)\n", __func__, 345 ret); 346 return ret; 347 } 348 plat = dev_get_parent_platdata(dev); 349 plat->cs = cs; 350 if (speed) { 351 plat->max_hz = speed; 352 } else { 353 printf("Warning: SPI speed fallback to %u kHz\n", 354 SPI_DEFAULT_SPEED_HZ / 1000); 355 plat->max_hz = SPI_DEFAULT_SPEED_HZ; 356 } 357 plat->mode = mode; 358 created = true; 359 } else if (ret) { 360 printf("Invalid chip select %d:%d (err=%d)\n", busnum, cs, 361 ret); 362 return ret; 363 } 364 365 if (!device_active(dev)) { 366 struct spi_slave *slave; 367 368 ret = device_probe(dev); 369 if (ret) 370 goto err; 371 slave = dev_get_parent_priv(dev); 372 slave->dev = dev; 373 } 374 375 plat = dev_get_parent_platdata(dev); 376 377 /* get speed and mode from platdata when available */ 378 if (plat->max_hz) { 379 speed = plat->max_hz; 380 mode = plat->mode; 381 } 382 ret = spi_set_speed_mode(bus, speed, mode); 383 if (ret) 384 goto err; 385 386 *busp = bus; 387 *devp = dev_get_parent_priv(dev); 388 debug("%s: bus=%p, slave=%p\n", __func__, bus, *devp); 389 390 return 0; 391 392 err: 393 debug("%s: Error path, created=%d, device '%s'\n", __func__, 394 created, dev->name); 395 if (created) { 396 device_remove(dev, DM_REMOVE_NORMAL); 397 device_unbind(dev); 398 } 399 400 return ret; 401 } 402 403 /* Compatibility function - to be removed */ 404 struct spi_slave *spi_setup_slave(unsigned int busnum, unsigned int cs, 405 unsigned int speed, unsigned int mode) 406 { 407 struct spi_slave *slave; 408 struct udevice *dev; 409 int ret; 410 411 ret = spi_get_bus_and_cs(busnum, cs, speed, mode, NULL, 0, &dev, 412 &slave); 413 if (ret) 414 return NULL; 415 416 return slave; 417 } 418 419 void spi_free_slave(struct spi_slave *slave) 420 { 421 device_remove(slave->dev, DM_REMOVE_NORMAL); 422 slave->dev = NULL; 423 } 424 425 int spi_slave_ofdata_to_platdata(struct udevice *dev, 426 struct dm_spi_slave_platdata *plat) 427 { 428 int mode = 0; 429 int value; 430 431 plat->cs = dev_read_u32_default(dev, "reg", -1); 432 plat->max_hz = dev_read_u32_default(dev, "spi-max-frequency", 433 SPI_DEFAULT_SPEED_HZ); 434 if (dev_read_bool(dev, "spi-cpol")) 435 mode |= SPI_CPOL; 436 if (dev_read_bool(dev, "spi-cpha")) 437 mode |= SPI_CPHA; 438 if (dev_read_bool(dev, "spi-cs-high")) 439 mode |= SPI_CS_HIGH; 440 if (dev_read_bool(dev, "spi-3wire")) 441 mode |= SPI_3WIRE; 442 if (dev_read_bool(dev, "spi-half-duplex")) 443 mode |= SPI_PREAMBLE; 444 445 /* Device DUAL/QUAD mode */ 446 value = dev_read_u32_default(dev, "spi-tx-bus-width", 1); 447 switch (value) { 448 case 1: 449 break; 450 case 2: 451 mode |= SPI_TX_DUAL; 452 break; 453 case 4: 454 mode |= SPI_TX_QUAD; 455 break; 456 default: 457 warn_non_spl("spi-tx-bus-width %d not supported\n", value); 458 break; 459 } 460 461 value = dev_read_u32_default(dev, "spi-rx-bus-width", 1); 462 switch (value) { 463 case 1: 464 break; 465 case 2: 466 mode |= SPI_RX_DUAL; 467 break; 468 case 4: 469 mode |= SPI_RX_QUAD; 470 break; 471 default: 472 warn_non_spl("spi-rx-bus-width %d not supported\n", value); 473 break; 474 } 475 476 plat->mode = mode; 477 478 return 0; 479 } 480 481 UCLASS_DRIVER(spi) = { 482 .id = UCLASS_SPI, 483 .name = "spi", 484 .flags = DM_UC_FLAG_SEQ_ALIAS, 485 #if !CONFIG_IS_ENABLED(OF_PLATDATA) 486 .post_bind = dm_scan_fdt_dev, 487 #endif 488 .post_probe = spi_post_probe, 489 .child_pre_probe = spi_child_pre_probe, 490 .per_device_auto_alloc_size = sizeof(struct dm_spi_bus), 491 .per_child_auto_alloc_size = sizeof(struct spi_slave), 492 .per_child_platdata_auto_alloc_size = 493 sizeof(struct dm_spi_slave_platdata), 494 #if !CONFIG_IS_ENABLED(OF_PLATDATA) 495 .child_post_bind = spi_child_post_bind, 496 #endif 497 }; 498 499 UCLASS_DRIVER(spi_generic) = { 500 .id = UCLASS_SPI_GENERIC, 501 .name = "spi_generic", 502 }; 503 504 U_BOOT_DRIVER(spi_generic_drv) = { 505 .name = "spi_generic_drv", 506 .id = UCLASS_SPI_GENERIC, 507 }; 508