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