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