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