1 // SPDX-License-Identifier: GPL-2.0-or-later 2 // SPI init/core code 3 // 4 // Copyright (C) 2005 David Brownell 5 // Copyright (C) 2008 Secret Lab Technologies Ltd. 6 7 #include <linux/kernel.h> 8 #include <linux/device.h> 9 #include <linux/init.h> 10 #include <linux/cache.h> 11 #include <linux/dma-mapping.h> 12 #include <linux/dmaengine.h> 13 #include <linux/mutex.h> 14 #include <linux/of_device.h> 15 #include <linux/of_irq.h> 16 #include <linux/clk/clk-conf.h> 17 #include <linux/slab.h> 18 #include <linux/mod_devicetable.h> 19 #include <linux/spi/spi.h> 20 #include <linux/spi/spi-mem.h> 21 #include <linux/gpio/consumer.h> 22 #include <linux/pm_runtime.h> 23 #include <linux/pm_domain.h> 24 #include <linux/property.h> 25 #include <linux/export.h> 26 #include <linux/sched/rt.h> 27 #include <uapi/linux/sched/types.h> 28 #include <linux/delay.h> 29 #include <linux/kthread.h> 30 #include <linux/ioport.h> 31 #include <linux/acpi.h> 32 #include <linux/highmem.h> 33 #include <linux/idr.h> 34 #include <linux/platform_data/x86/apple.h> 35 #include <linux/ptp_clock_kernel.h> 36 #include <linux/percpu.h> 37 38 #define CREATE_TRACE_POINTS 39 #include <trace/events/spi.h> 40 EXPORT_TRACEPOINT_SYMBOL(spi_transfer_start); 41 EXPORT_TRACEPOINT_SYMBOL(spi_transfer_stop); 42 43 #include "internals.h" 44 45 static DEFINE_IDR(spi_master_idr); 46 47 static void spidev_release(struct device *dev) 48 { 49 struct spi_device *spi = to_spi_device(dev); 50 51 spi_controller_put(spi->controller); 52 kfree(spi->driver_override); 53 free_percpu(spi->pcpu_statistics); 54 kfree(spi); 55 } 56 57 static ssize_t 58 modalias_show(struct device *dev, struct device_attribute *a, char *buf) 59 { 60 const struct spi_device *spi = to_spi_device(dev); 61 int len; 62 63 len = acpi_device_modalias(dev, buf, PAGE_SIZE - 1); 64 if (len != -ENODEV) 65 return len; 66 67 return sprintf(buf, "%s%s\n", SPI_MODULE_PREFIX, spi->modalias); 68 } 69 static DEVICE_ATTR_RO(modalias); 70 71 static ssize_t driver_override_store(struct device *dev, 72 struct device_attribute *a, 73 const char *buf, size_t count) 74 { 75 struct spi_device *spi = to_spi_device(dev); 76 int ret; 77 78 ret = driver_set_override(dev, &spi->driver_override, buf, count); 79 if (ret) 80 return ret; 81 82 return count; 83 } 84 85 static ssize_t driver_override_show(struct device *dev, 86 struct device_attribute *a, char *buf) 87 { 88 const struct spi_device *spi = to_spi_device(dev); 89 ssize_t len; 90 91 device_lock(dev); 92 len = snprintf(buf, PAGE_SIZE, "%s\n", spi->driver_override ? : ""); 93 device_unlock(dev); 94 return len; 95 } 96 static DEVICE_ATTR_RW(driver_override); 97 98 static struct spi_statistics __percpu *spi_alloc_pcpu_stats(struct device *dev) 99 { 100 struct spi_statistics __percpu *pcpu_stats; 101 102 if (dev) 103 pcpu_stats = devm_alloc_percpu(dev, struct spi_statistics); 104 else 105 pcpu_stats = alloc_percpu_gfp(struct spi_statistics, GFP_KERNEL); 106 107 if (pcpu_stats) { 108 int cpu; 109 110 for_each_possible_cpu(cpu) { 111 struct spi_statistics *stat; 112 113 stat = per_cpu_ptr(pcpu_stats, cpu); 114 u64_stats_init(&stat->syncp); 115 } 116 } 117 return pcpu_stats; 118 } 119 120 #define spi_pcpu_stats_totalize(ret, in, field) \ 121 do { \ 122 int i; \ 123 ret = 0; \ 124 for_each_possible_cpu(i) { \ 125 const struct spi_statistics *pcpu_stats; \ 126 u64 inc; \ 127 unsigned int start; \ 128 pcpu_stats = per_cpu_ptr(in, i); \ 129 do { \ 130 start = u64_stats_fetch_begin( \ 131 &pcpu_stats->syncp); \ 132 inc = u64_stats_read(&pcpu_stats->field); \ 133 } while (u64_stats_fetch_retry( \ 134 &pcpu_stats->syncp, start)); \ 135 ret += inc; \ 136 } \ 137 } while (0) 138 139 #define SPI_STATISTICS_ATTRS(field, file) \ 140 static ssize_t spi_controller_##field##_show(struct device *dev, \ 141 struct device_attribute *attr, \ 142 char *buf) \ 143 { \ 144 struct spi_controller *ctlr = container_of(dev, \ 145 struct spi_controller, dev); \ 146 return spi_statistics_##field##_show(ctlr->pcpu_statistics, buf); \ 147 } \ 148 static struct device_attribute dev_attr_spi_controller_##field = { \ 149 .attr = { .name = file, .mode = 0444 }, \ 150 .show = spi_controller_##field##_show, \ 151 }; \ 152 static ssize_t spi_device_##field##_show(struct device *dev, \ 153 struct device_attribute *attr, \ 154 char *buf) \ 155 { \ 156 struct spi_device *spi = to_spi_device(dev); \ 157 return spi_statistics_##field##_show(spi->pcpu_statistics, buf); \ 158 } \ 159 static struct device_attribute dev_attr_spi_device_##field = { \ 160 .attr = { .name = file, .mode = 0444 }, \ 161 .show = spi_device_##field##_show, \ 162 } 163 164 #define SPI_STATISTICS_SHOW_NAME(name, file, field) \ 165 static ssize_t spi_statistics_##name##_show(struct spi_statistics __percpu *stat, \ 166 char *buf) \ 167 { \ 168 ssize_t len; \ 169 u64 val; \ 170 spi_pcpu_stats_totalize(val, stat, field); \ 171 len = sysfs_emit(buf, "%llu\n", val); \ 172 return len; \ 173 } \ 174 SPI_STATISTICS_ATTRS(name, file) 175 176 #define SPI_STATISTICS_SHOW(field) \ 177 SPI_STATISTICS_SHOW_NAME(field, __stringify(field), \ 178 field) 179 180 SPI_STATISTICS_SHOW(messages); 181 SPI_STATISTICS_SHOW(transfers); 182 SPI_STATISTICS_SHOW(errors); 183 SPI_STATISTICS_SHOW(timedout); 184 185 SPI_STATISTICS_SHOW(spi_sync); 186 SPI_STATISTICS_SHOW(spi_sync_immediate); 187 SPI_STATISTICS_SHOW(spi_async); 188 189 SPI_STATISTICS_SHOW(bytes); 190 SPI_STATISTICS_SHOW(bytes_rx); 191 SPI_STATISTICS_SHOW(bytes_tx); 192 193 #define SPI_STATISTICS_TRANSFER_BYTES_HISTO(index, number) \ 194 SPI_STATISTICS_SHOW_NAME(transfer_bytes_histo##index, \ 195 "transfer_bytes_histo_" number, \ 196 transfer_bytes_histo[index]) 197 SPI_STATISTICS_TRANSFER_BYTES_HISTO(0, "0-1"); 198 SPI_STATISTICS_TRANSFER_BYTES_HISTO(1, "2-3"); 199 SPI_STATISTICS_TRANSFER_BYTES_HISTO(2, "4-7"); 200 SPI_STATISTICS_TRANSFER_BYTES_HISTO(3, "8-15"); 201 SPI_STATISTICS_TRANSFER_BYTES_HISTO(4, "16-31"); 202 SPI_STATISTICS_TRANSFER_BYTES_HISTO(5, "32-63"); 203 SPI_STATISTICS_TRANSFER_BYTES_HISTO(6, "64-127"); 204 SPI_STATISTICS_TRANSFER_BYTES_HISTO(7, "128-255"); 205 SPI_STATISTICS_TRANSFER_BYTES_HISTO(8, "256-511"); 206 SPI_STATISTICS_TRANSFER_BYTES_HISTO(9, "512-1023"); 207 SPI_STATISTICS_TRANSFER_BYTES_HISTO(10, "1024-2047"); 208 SPI_STATISTICS_TRANSFER_BYTES_HISTO(11, "2048-4095"); 209 SPI_STATISTICS_TRANSFER_BYTES_HISTO(12, "4096-8191"); 210 SPI_STATISTICS_TRANSFER_BYTES_HISTO(13, "8192-16383"); 211 SPI_STATISTICS_TRANSFER_BYTES_HISTO(14, "16384-32767"); 212 SPI_STATISTICS_TRANSFER_BYTES_HISTO(15, "32768-65535"); 213 SPI_STATISTICS_TRANSFER_BYTES_HISTO(16, "65536+"); 214 215 SPI_STATISTICS_SHOW(transfers_split_maxsize); 216 217 static struct attribute *spi_dev_attrs[] = { 218 &dev_attr_modalias.attr, 219 &dev_attr_driver_override.attr, 220 NULL, 221 }; 222 223 static const struct attribute_group spi_dev_group = { 224 .attrs = spi_dev_attrs, 225 }; 226 227 static struct attribute *spi_device_statistics_attrs[] = { 228 &dev_attr_spi_device_messages.attr, 229 &dev_attr_spi_device_transfers.attr, 230 &dev_attr_spi_device_errors.attr, 231 &dev_attr_spi_device_timedout.attr, 232 &dev_attr_spi_device_spi_sync.attr, 233 &dev_attr_spi_device_spi_sync_immediate.attr, 234 &dev_attr_spi_device_spi_async.attr, 235 &dev_attr_spi_device_bytes.attr, 236 &dev_attr_spi_device_bytes_rx.attr, 237 &dev_attr_spi_device_bytes_tx.attr, 238 &dev_attr_spi_device_transfer_bytes_histo0.attr, 239 &dev_attr_spi_device_transfer_bytes_histo1.attr, 240 &dev_attr_spi_device_transfer_bytes_histo2.attr, 241 &dev_attr_spi_device_transfer_bytes_histo3.attr, 242 &dev_attr_spi_device_transfer_bytes_histo4.attr, 243 &dev_attr_spi_device_transfer_bytes_histo5.attr, 244 &dev_attr_spi_device_transfer_bytes_histo6.attr, 245 &dev_attr_spi_device_transfer_bytes_histo7.attr, 246 &dev_attr_spi_device_transfer_bytes_histo8.attr, 247 &dev_attr_spi_device_transfer_bytes_histo9.attr, 248 &dev_attr_spi_device_transfer_bytes_histo10.attr, 249 &dev_attr_spi_device_transfer_bytes_histo11.attr, 250 &dev_attr_spi_device_transfer_bytes_histo12.attr, 251 &dev_attr_spi_device_transfer_bytes_histo13.attr, 252 &dev_attr_spi_device_transfer_bytes_histo14.attr, 253 &dev_attr_spi_device_transfer_bytes_histo15.attr, 254 &dev_attr_spi_device_transfer_bytes_histo16.attr, 255 &dev_attr_spi_device_transfers_split_maxsize.attr, 256 NULL, 257 }; 258 259 static const struct attribute_group spi_device_statistics_group = { 260 .name = "statistics", 261 .attrs = spi_device_statistics_attrs, 262 }; 263 264 static const struct attribute_group *spi_dev_groups[] = { 265 &spi_dev_group, 266 &spi_device_statistics_group, 267 NULL, 268 }; 269 270 static struct attribute *spi_controller_statistics_attrs[] = { 271 &dev_attr_spi_controller_messages.attr, 272 &dev_attr_spi_controller_transfers.attr, 273 &dev_attr_spi_controller_errors.attr, 274 &dev_attr_spi_controller_timedout.attr, 275 &dev_attr_spi_controller_spi_sync.attr, 276 &dev_attr_spi_controller_spi_sync_immediate.attr, 277 &dev_attr_spi_controller_spi_async.attr, 278 &dev_attr_spi_controller_bytes.attr, 279 &dev_attr_spi_controller_bytes_rx.attr, 280 &dev_attr_spi_controller_bytes_tx.attr, 281 &dev_attr_spi_controller_transfer_bytes_histo0.attr, 282 &dev_attr_spi_controller_transfer_bytes_histo1.attr, 283 &dev_attr_spi_controller_transfer_bytes_histo2.attr, 284 &dev_attr_spi_controller_transfer_bytes_histo3.attr, 285 &dev_attr_spi_controller_transfer_bytes_histo4.attr, 286 &dev_attr_spi_controller_transfer_bytes_histo5.attr, 287 &dev_attr_spi_controller_transfer_bytes_histo6.attr, 288 &dev_attr_spi_controller_transfer_bytes_histo7.attr, 289 &dev_attr_spi_controller_transfer_bytes_histo8.attr, 290 &dev_attr_spi_controller_transfer_bytes_histo9.attr, 291 &dev_attr_spi_controller_transfer_bytes_histo10.attr, 292 &dev_attr_spi_controller_transfer_bytes_histo11.attr, 293 &dev_attr_spi_controller_transfer_bytes_histo12.attr, 294 &dev_attr_spi_controller_transfer_bytes_histo13.attr, 295 &dev_attr_spi_controller_transfer_bytes_histo14.attr, 296 &dev_attr_spi_controller_transfer_bytes_histo15.attr, 297 &dev_attr_spi_controller_transfer_bytes_histo16.attr, 298 &dev_attr_spi_controller_transfers_split_maxsize.attr, 299 NULL, 300 }; 301 302 static const struct attribute_group spi_controller_statistics_group = { 303 .name = "statistics", 304 .attrs = spi_controller_statistics_attrs, 305 }; 306 307 static const struct attribute_group *spi_master_groups[] = { 308 &spi_controller_statistics_group, 309 NULL, 310 }; 311 312 static void spi_statistics_add_transfer_stats(struct spi_statistics __percpu *pcpu_stats, 313 struct spi_transfer *xfer, 314 struct spi_controller *ctlr) 315 { 316 int l2len = min(fls(xfer->len), SPI_STATISTICS_HISTO_SIZE) - 1; 317 struct spi_statistics *stats; 318 319 if (l2len < 0) 320 l2len = 0; 321 322 get_cpu(); 323 stats = this_cpu_ptr(pcpu_stats); 324 u64_stats_update_begin(&stats->syncp); 325 326 u64_stats_inc(&stats->transfers); 327 u64_stats_inc(&stats->transfer_bytes_histo[l2len]); 328 329 u64_stats_add(&stats->bytes, xfer->len); 330 if ((xfer->tx_buf) && 331 (xfer->tx_buf != ctlr->dummy_tx)) 332 u64_stats_add(&stats->bytes_tx, xfer->len); 333 if ((xfer->rx_buf) && 334 (xfer->rx_buf != ctlr->dummy_rx)) 335 u64_stats_add(&stats->bytes_rx, xfer->len); 336 337 u64_stats_update_end(&stats->syncp); 338 put_cpu(); 339 } 340 341 /* 342 * modalias support makes "modprobe $MODALIAS" new-style hotplug work, 343 * and the sysfs version makes coldplug work too. 344 */ 345 static const struct spi_device_id *spi_match_id(const struct spi_device_id *id, const char *name) 346 { 347 while (id->name[0]) { 348 if (!strcmp(name, id->name)) 349 return id; 350 id++; 351 } 352 return NULL; 353 } 354 355 const struct spi_device_id *spi_get_device_id(const struct spi_device *sdev) 356 { 357 const struct spi_driver *sdrv = to_spi_driver(sdev->dev.driver); 358 359 return spi_match_id(sdrv->id_table, sdev->modalias); 360 } 361 EXPORT_SYMBOL_GPL(spi_get_device_id); 362 363 const void *spi_get_device_match_data(const struct spi_device *sdev) 364 { 365 const void *match; 366 367 match = device_get_match_data(&sdev->dev); 368 if (match) 369 return match; 370 371 return (const void *)spi_get_device_id(sdev)->driver_data; 372 } 373 EXPORT_SYMBOL_GPL(spi_get_device_match_data); 374 375 static int spi_match_device(struct device *dev, struct device_driver *drv) 376 { 377 const struct spi_device *spi = to_spi_device(dev); 378 const struct spi_driver *sdrv = to_spi_driver(drv); 379 380 /* Check override first, and if set, only use the named driver */ 381 if (spi->driver_override) 382 return strcmp(spi->driver_override, drv->name) == 0; 383 384 /* Attempt an OF style match */ 385 if (of_driver_match_device(dev, drv)) 386 return 1; 387 388 /* Then try ACPI */ 389 if (acpi_driver_match_device(dev, drv)) 390 return 1; 391 392 if (sdrv->id_table) 393 return !!spi_match_id(sdrv->id_table, spi->modalias); 394 395 return strcmp(spi->modalias, drv->name) == 0; 396 } 397 398 static int spi_uevent(struct device *dev, struct kobj_uevent_env *env) 399 { 400 const struct spi_device *spi = to_spi_device(dev); 401 int rc; 402 403 rc = acpi_device_uevent_modalias(dev, env); 404 if (rc != -ENODEV) 405 return rc; 406 407 return add_uevent_var(env, "MODALIAS=%s%s", SPI_MODULE_PREFIX, spi->modalias); 408 } 409 410 static int spi_probe(struct device *dev) 411 { 412 const struct spi_driver *sdrv = to_spi_driver(dev->driver); 413 struct spi_device *spi = to_spi_device(dev); 414 int ret; 415 416 ret = of_clk_set_defaults(dev->of_node, false); 417 if (ret) 418 return ret; 419 420 if (dev->of_node) { 421 spi->irq = of_irq_get(dev->of_node, 0); 422 if (spi->irq == -EPROBE_DEFER) 423 return -EPROBE_DEFER; 424 if (spi->irq < 0) 425 spi->irq = 0; 426 } 427 428 ret = dev_pm_domain_attach(dev, true); 429 if (ret) 430 return ret; 431 432 if (sdrv->probe) { 433 ret = sdrv->probe(spi); 434 if (ret) 435 dev_pm_domain_detach(dev, true); 436 } 437 438 return ret; 439 } 440 441 static void spi_remove(struct device *dev) 442 { 443 const struct spi_driver *sdrv = to_spi_driver(dev->driver); 444 445 if (sdrv->remove) 446 sdrv->remove(to_spi_device(dev)); 447 448 dev_pm_domain_detach(dev, true); 449 } 450 451 static void spi_shutdown(struct device *dev) 452 { 453 if (dev->driver) { 454 const struct spi_driver *sdrv = to_spi_driver(dev->driver); 455 456 if (sdrv->shutdown) 457 sdrv->shutdown(to_spi_device(dev)); 458 } 459 } 460 461 struct bus_type spi_bus_type = { 462 .name = "spi", 463 .dev_groups = spi_dev_groups, 464 .match = spi_match_device, 465 .uevent = spi_uevent, 466 .probe = spi_probe, 467 .remove = spi_remove, 468 .shutdown = spi_shutdown, 469 }; 470 EXPORT_SYMBOL_GPL(spi_bus_type); 471 472 /** 473 * __spi_register_driver - register a SPI driver 474 * @owner: owner module of the driver to register 475 * @sdrv: the driver to register 476 * Context: can sleep 477 * 478 * Return: zero on success, else a negative error code. 479 */ 480 int __spi_register_driver(struct module *owner, struct spi_driver *sdrv) 481 { 482 sdrv->driver.owner = owner; 483 sdrv->driver.bus = &spi_bus_type; 484 485 /* 486 * For Really Good Reasons we use spi: modaliases not of: 487 * modaliases for DT so module autoloading won't work if we 488 * don't have a spi_device_id as well as a compatible string. 489 */ 490 if (sdrv->driver.of_match_table) { 491 const struct of_device_id *of_id; 492 493 for (of_id = sdrv->driver.of_match_table; of_id->compatible[0]; 494 of_id++) { 495 const char *of_name; 496 497 /* Strip off any vendor prefix */ 498 of_name = strnchr(of_id->compatible, 499 sizeof(of_id->compatible), ','); 500 if (of_name) 501 of_name++; 502 else 503 of_name = of_id->compatible; 504 505 if (sdrv->id_table) { 506 const struct spi_device_id *spi_id; 507 508 spi_id = spi_match_id(sdrv->id_table, of_name); 509 if (spi_id) 510 continue; 511 } else { 512 if (strcmp(sdrv->driver.name, of_name) == 0) 513 continue; 514 } 515 516 pr_warn("SPI driver %s has no spi_device_id for %s\n", 517 sdrv->driver.name, of_id->compatible); 518 } 519 } 520 521 return driver_register(&sdrv->driver); 522 } 523 EXPORT_SYMBOL_GPL(__spi_register_driver); 524 525 /*-------------------------------------------------------------------------*/ 526 527 /* 528 * SPI devices should normally not be created by SPI device drivers; that 529 * would make them board-specific. Similarly with SPI controller drivers. 530 * Device registration normally goes into like arch/.../mach.../board-YYY.c 531 * with other readonly (flashable) information about mainboard devices. 532 */ 533 534 struct boardinfo { 535 struct list_head list; 536 struct spi_board_info board_info; 537 }; 538 539 static LIST_HEAD(board_list); 540 static LIST_HEAD(spi_controller_list); 541 542 /* 543 * Used to protect add/del operation for board_info list and 544 * spi_controller list, and their matching process also used 545 * to protect object of type struct idr. 546 */ 547 static DEFINE_MUTEX(board_lock); 548 549 /** 550 * spi_alloc_device - Allocate a new SPI device 551 * @ctlr: Controller to which device is connected 552 * Context: can sleep 553 * 554 * Allows a driver to allocate and initialize a spi_device without 555 * registering it immediately. This allows a driver to directly 556 * fill the spi_device with device parameters before calling 557 * spi_add_device() on it. 558 * 559 * Caller is responsible to call spi_add_device() on the returned 560 * spi_device structure to add it to the SPI controller. If the caller 561 * needs to discard the spi_device without adding it, then it should 562 * call spi_dev_put() on it. 563 * 564 * Return: a pointer to the new device, or NULL. 565 */ 566 struct spi_device *spi_alloc_device(struct spi_controller *ctlr) 567 { 568 struct spi_device *spi; 569 570 if (!spi_controller_get(ctlr)) 571 return NULL; 572 573 spi = kzalloc(sizeof(*spi), GFP_KERNEL); 574 if (!spi) { 575 spi_controller_put(ctlr); 576 return NULL; 577 } 578 579 spi->pcpu_statistics = spi_alloc_pcpu_stats(NULL); 580 if (!spi->pcpu_statistics) { 581 kfree(spi); 582 spi_controller_put(ctlr); 583 return NULL; 584 } 585 586 spi->master = spi->controller = ctlr; 587 spi->dev.parent = &ctlr->dev; 588 spi->dev.bus = &spi_bus_type; 589 spi->dev.release = spidev_release; 590 spi->mode = ctlr->buswidth_override_bits; 591 592 device_initialize(&spi->dev); 593 return spi; 594 } 595 EXPORT_SYMBOL_GPL(spi_alloc_device); 596 597 static void spi_dev_set_name(struct spi_device *spi) 598 { 599 struct acpi_device *adev = ACPI_COMPANION(&spi->dev); 600 601 if (adev) { 602 dev_set_name(&spi->dev, "spi-%s", acpi_dev_name(adev)); 603 return; 604 } 605 606 dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->controller->dev), 607 spi->chip_select); 608 } 609 610 static int spi_dev_check(struct device *dev, void *data) 611 { 612 struct spi_device *spi = to_spi_device(dev); 613 struct spi_device *new_spi = data; 614 615 if (spi->controller == new_spi->controller && 616 spi->chip_select == new_spi->chip_select) 617 return -EBUSY; 618 return 0; 619 } 620 621 static void spi_cleanup(struct spi_device *spi) 622 { 623 if (spi->controller->cleanup) 624 spi->controller->cleanup(spi); 625 } 626 627 static int __spi_add_device(struct spi_device *spi) 628 { 629 struct spi_controller *ctlr = spi->controller; 630 struct device *dev = ctlr->dev.parent; 631 int status; 632 633 /* 634 * We need to make sure there's no other device with this 635 * chipselect **BEFORE** we call setup(), else we'll trash 636 * its configuration. 637 */ 638 status = bus_for_each_dev(&spi_bus_type, NULL, spi, spi_dev_check); 639 if (status) { 640 dev_err(dev, "chipselect %d already in use\n", 641 spi->chip_select); 642 return status; 643 } 644 645 /* Controller may unregister concurrently */ 646 if (IS_ENABLED(CONFIG_SPI_DYNAMIC) && 647 !device_is_registered(&ctlr->dev)) { 648 return -ENODEV; 649 } 650 651 if (ctlr->cs_gpiods) 652 spi->cs_gpiod = ctlr->cs_gpiods[spi->chip_select]; 653 654 /* 655 * Drivers may modify this initial i/o setup, but will 656 * normally rely on the device being setup. Devices 657 * using SPI_CS_HIGH can't coexist well otherwise... 658 */ 659 status = spi_setup(spi); 660 if (status < 0) { 661 dev_err(dev, "can't setup %s, status %d\n", 662 dev_name(&spi->dev), status); 663 return status; 664 } 665 666 /* Device may be bound to an active driver when this returns */ 667 status = device_add(&spi->dev); 668 if (status < 0) { 669 dev_err(dev, "can't add %s, status %d\n", 670 dev_name(&spi->dev), status); 671 spi_cleanup(spi); 672 } else { 673 dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev)); 674 } 675 676 return status; 677 } 678 679 /** 680 * spi_add_device - Add spi_device allocated with spi_alloc_device 681 * @spi: spi_device to register 682 * 683 * Companion function to spi_alloc_device. Devices allocated with 684 * spi_alloc_device can be added onto the spi bus with this function. 685 * 686 * Return: 0 on success; negative errno on failure 687 */ 688 int spi_add_device(struct spi_device *spi) 689 { 690 struct spi_controller *ctlr = spi->controller; 691 struct device *dev = ctlr->dev.parent; 692 int status; 693 694 /* Chipselects are numbered 0..max; validate. */ 695 if (spi->chip_select >= ctlr->num_chipselect) { 696 dev_err(dev, "cs%d >= max %d\n", spi->chip_select, 697 ctlr->num_chipselect); 698 return -EINVAL; 699 } 700 701 /* Set the bus ID string */ 702 spi_dev_set_name(spi); 703 704 mutex_lock(&ctlr->add_lock); 705 status = __spi_add_device(spi); 706 mutex_unlock(&ctlr->add_lock); 707 return status; 708 } 709 EXPORT_SYMBOL_GPL(spi_add_device); 710 711 static int spi_add_device_locked(struct spi_device *spi) 712 { 713 struct spi_controller *ctlr = spi->controller; 714 struct device *dev = ctlr->dev.parent; 715 716 /* Chipselects are numbered 0..max; validate. */ 717 if (spi->chip_select >= ctlr->num_chipselect) { 718 dev_err(dev, "cs%d >= max %d\n", spi->chip_select, 719 ctlr->num_chipselect); 720 return -EINVAL; 721 } 722 723 /* Set the bus ID string */ 724 spi_dev_set_name(spi); 725 726 WARN_ON(!mutex_is_locked(&ctlr->add_lock)); 727 return __spi_add_device(spi); 728 } 729 730 /** 731 * spi_new_device - instantiate one new SPI device 732 * @ctlr: Controller to which device is connected 733 * @chip: Describes the SPI device 734 * Context: can sleep 735 * 736 * On typical mainboards, this is purely internal; and it's not needed 737 * after board init creates the hard-wired devices. Some development 738 * platforms may not be able to use spi_register_board_info though, and 739 * this is exported so that for example a USB or parport based adapter 740 * driver could add devices (which it would learn about out-of-band). 741 * 742 * Return: the new device, or NULL. 743 */ 744 struct spi_device *spi_new_device(struct spi_controller *ctlr, 745 struct spi_board_info *chip) 746 { 747 struct spi_device *proxy; 748 int status; 749 750 /* 751 * NOTE: caller did any chip->bus_num checks necessary. 752 * 753 * Also, unless we change the return value convention to use 754 * error-or-pointer (not NULL-or-pointer), troubleshootability 755 * suggests syslogged diagnostics are best here (ugh). 756 */ 757 758 proxy = spi_alloc_device(ctlr); 759 if (!proxy) 760 return NULL; 761 762 WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias)); 763 764 proxy->chip_select = chip->chip_select; 765 proxy->max_speed_hz = chip->max_speed_hz; 766 proxy->mode = chip->mode; 767 proxy->irq = chip->irq; 768 strscpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias)); 769 proxy->dev.platform_data = (void *) chip->platform_data; 770 proxy->controller_data = chip->controller_data; 771 proxy->controller_state = NULL; 772 773 if (chip->swnode) { 774 status = device_add_software_node(&proxy->dev, chip->swnode); 775 if (status) { 776 dev_err(&ctlr->dev, "failed to add software node to '%s': %d\n", 777 chip->modalias, status); 778 goto err_dev_put; 779 } 780 } 781 782 status = spi_add_device(proxy); 783 if (status < 0) 784 goto err_dev_put; 785 786 return proxy; 787 788 err_dev_put: 789 device_remove_software_node(&proxy->dev); 790 spi_dev_put(proxy); 791 return NULL; 792 } 793 EXPORT_SYMBOL_GPL(spi_new_device); 794 795 /** 796 * spi_unregister_device - unregister a single SPI device 797 * @spi: spi_device to unregister 798 * 799 * Start making the passed SPI device vanish. Normally this would be handled 800 * by spi_unregister_controller(). 801 */ 802 void spi_unregister_device(struct spi_device *spi) 803 { 804 if (!spi) 805 return; 806 807 if (spi->dev.of_node) { 808 of_node_clear_flag(spi->dev.of_node, OF_POPULATED); 809 of_node_put(spi->dev.of_node); 810 } 811 if (ACPI_COMPANION(&spi->dev)) 812 acpi_device_clear_enumerated(ACPI_COMPANION(&spi->dev)); 813 device_remove_software_node(&spi->dev); 814 device_del(&spi->dev); 815 spi_cleanup(spi); 816 put_device(&spi->dev); 817 } 818 EXPORT_SYMBOL_GPL(spi_unregister_device); 819 820 static void spi_match_controller_to_boardinfo(struct spi_controller *ctlr, 821 struct spi_board_info *bi) 822 { 823 struct spi_device *dev; 824 825 if (ctlr->bus_num != bi->bus_num) 826 return; 827 828 dev = spi_new_device(ctlr, bi); 829 if (!dev) 830 dev_err(ctlr->dev.parent, "can't create new device for %s\n", 831 bi->modalias); 832 } 833 834 /** 835 * spi_register_board_info - register SPI devices for a given board 836 * @info: array of chip descriptors 837 * @n: how many descriptors are provided 838 * Context: can sleep 839 * 840 * Board-specific early init code calls this (probably during arch_initcall) 841 * with segments of the SPI device table. Any device nodes are created later, 842 * after the relevant parent SPI controller (bus_num) is defined. We keep 843 * this table of devices forever, so that reloading a controller driver will 844 * not make Linux forget about these hard-wired devices. 845 * 846 * Other code can also call this, e.g. a particular add-on board might provide 847 * SPI devices through its expansion connector, so code initializing that board 848 * would naturally declare its SPI devices. 849 * 850 * The board info passed can safely be __initdata ... but be careful of 851 * any embedded pointers (platform_data, etc), they're copied as-is. 852 * 853 * Return: zero on success, else a negative error code. 854 */ 855 int spi_register_board_info(struct spi_board_info const *info, unsigned n) 856 { 857 struct boardinfo *bi; 858 int i; 859 860 if (!n) 861 return 0; 862 863 bi = kcalloc(n, sizeof(*bi), GFP_KERNEL); 864 if (!bi) 865 return -ENOMEM; 866 867 for (i = 0; i < n; i++, bi++, info++) { 868 struct spi_controller *ctlr; 869 870 memcpy(&bi->board_info, info, sizeof(*info)); 871 872 mutex_lock(&board_lock); 873 list_add_tail(&bi->list, &board_list); 874 list_for_each_entry(ctlr, &spi_controller_list, list) 875 spi_match_controller_to_boardinfo(ctlr, 876 &bi->board_info); 877 mutex_unlock(&board_lock); 878 } 879 880 return 0; 881 } 882 883 /*-------------------------------------------------------------------------*/ 884 885 /* Core methods for SPI resource management */ 886 887 /** 888 * spi_res_alloc - allocate a spi resource that is life-cycle managed 889 * during the processing of a spi_message while using 890 * spi_transfer_one 891 * @spi: the spi device for which we allocate memory 892 * @release: the release code to execute for this resource 893 * @size: size to alloc and return 894 * @gfp: GFP allocation flags 895 * 896 * Return: the pointer to the allocated data 897 * 898 * This may get enhanced in the future to allocate from a memory pool 899 * of the @spi_device or @spi_controller to avoid repeated allocations. 900 */ 901 static void *spi_res_alloc(struct spi_device *spi, spi_res_release_t release, 902 size_t size, gfp_t gfp) 903 { 904 struct spi_res *sres; 905 906 sres = kzalloc(sizeof(*sres) + size, gfp); 907 if (!sres) 908 return NULL; 909 910 INIT_LIST_HEAD(&sres->entry); 911 sres->release = release; 912 913 return sres->data; 914 } 915 916 /** 917 * spi_res_free - free an spi resource 918 * @res: pointer to the custom data of a resource 919 */ 920 static void spi_res_free(void *res) 921 { 922 struct spi_res *sres = container_of(res, struct spi_res, data); 923 924 if (!res) 925 return; 926 927 WARN_ON(!list_empty(&sres->entry)); 928 kfree(sres); 929 } 930 931 /** 932 * spi_res_add - add a spi_res to the spi_message 933 * @message: the spi message 934 * @res: the spi_resource 935 */ 936 static void spi_res_add(struct spi_message *message, void *res) 937 { 938 struct spi_res *sres = container_of(res, struct spi_res, data); 939 940 WARN_ON(!list_empty(&sres->entry)); 941 list_add_tail(&sres->entry, &message->resources); 942 } 943 944 /** 945 * spi_res_release - release all spi resources for this message 946 * @ctlr: the @spi_controller 947 * @message: the @spi_message 948 */ 949 static void spi_res_release(struct spi_controller *ctlr, struct spi_message *message) 950 { 951 struct spi_res *res, *tmp; 952 953 list_for_each_entry_safe_reverse(res, tmp, &message->resources, entry) { 954 if (res->release) 955 res->release(ctlr, message, res->data); 956 957 list_del(&res->entry); 958 959 kfree(res); 960 } 961 } 962 963 /*-------------------------------------------------------------------------*/ 964 965 static void spi_set_cs(struct spi_device *spi, bool enable, bool force) 966 { 967 bool activate = enable; 968 969 /* 970 * Avoid calling into the driver (or doing delays) if the chip select 971 * isn't actually changing from the last time this was called. 972 */ 973 if (!force && ((enable && spi->controller->last_cs == spi->chip_select) || 974 (!enable && spi->controller->last_cs != spi->chip_select)) && 975 (spi->controller->last_cs_mode_high == (spi->mode & SPI_CS_HIGH))) 976 return; 977 978 trace_spi_set_cs(spi, activate); 979 980 spi->controller->last_cs = enable ? spi->chip_select : -1; 981 spi->controller->last_cs_mode_high = spi->mode & SPI_CS_HIGH; 982 983 if ((spi->cs_gpiod || !spi->controller->set_cs_timing) && !activate) { 984 spi_delay_exec(&spi->cs_hold, NULL); 985 } 986 987 if (spi->mode & SPI_CS_HIGH) 988 enable = !enable; 989 990 if (spi->cs_gpiod) { 991 if (!(spi->mode & SPI_NO_CS)) { 992 /* 993 * Historically ACPI has no means of the GPIO polarity and 994 * thus the SPISerialBus() resource defines it on the per-chip 995 * basis. In order to avoid a chain of negations, the GPIO 996 * polarity is considered being Active High. Even for the cases 997 * when _DSD() is involved (in the updated versions of ACPI) 998 * the GPIO CS polarity must be defined Active High to avoid 999 * ambiguity. That's why we use enable, that takes SPI_CS_HIGH 1000 * into account. 1001 */ 1002 if (has_acpi_companion(&spi->dev)) 1003 gpiod_set_value_cansleep(spi->cs_gpiod, !enable); 1004 else 1005 /* Polarity handled by GPIO library */ 1006 gpiod_set_value_cansleep(spi->cs_gpiod, activate); 1007 } 1008 /* Some SPI masters need both GPIO CS & slave_select */ 1009 if ((spi->controller->flags & SPI_MASTER_GPIO_SS) && 1010 spi->controller->set_cs) 1011 spi->controller->set_cs(spi, !enable); 1012 } else if (spi->controller->set_cs) { 1013 spi->controller->set_cs(spi, !enable); 1014 } 1015 1016 if (spi->cs_gpiod || !spi->controller->set_cs_timing) { 1017 if (activate) 1018 spi_delay_exec(&spi->cs_setup, NULL); 1019 else 1020 spi_delay_exec(&spi->cs_inactive, NULL); 1021 } 1022 } 1023 1024 #ifdef CONFIG_HAS_DMA 1025 static int spi_map_buf_attrs(struct spi_controller *ctlr, struct device *dev, 1026 struct sg_table *sgt, void *buf, size_t len, 1027 enum dma_data_direction dir, unsigned long attrs) 1028 { 1029 const bool vmalloced_buf = is_vmalloc_addr(buf); 1030 unsigned int max_seg_size = dma_get_max_seg_size(dev); 1031 #ifdef CONFIG_HIGHMEM 1032 const bool kmap_buf = ((unsigned long)buf >= PKMAP_BASE && 1033 (unsigned long)buf < (PKMAP_BASE + 1034 (LAST_PKMAP * PAGE_SIZE))); 1035 #else 1036 const bool kmap_buf = false; 1037 #endif 1038 int desc_len; 1039 int sgs; 1040 struct page *vm_page; 1041 struct scatterlist *sg; 1042 void *sg_buf; 1043 size_t min; 1044 int i, ret; 1045 1046 if (vmalloced_buf || kmap_buf) { 1047 desc_len = min_t(unsigned long, max_seg_size, PAGE_SIZE); 1048 sgs = DIV_ROUND_UP(len + offset_in_page(buf), desc_len); 1049 } else if (virt_addr_valid(buf)) { 1050 desc_len = min_t(size_t, max_seg_size, ctlr->max_dma_len); 1051 sgs = DIV_ROUND_UP(len, desc_len); 1052 } else { 1053 return -EINVAL; 1054 } 1055 1056 ret = sg_alloc_table(sgt, sgs, GFP_KERNEL); 1057 if (ret != 0) 1058 return ret; 1059 1060 sg = &sgt->sgl[0]; 1061 for (i = 0; i < sgs; i++) { 1062 1063 if (vmalloced_buf || kmap_buf) { 1064 /* 1065 * Next scatterlist entry size is the minimum between 1066 * the desc_len and the remaining buffer length that 1067 * fits in a page. 1068 */ 1069 min = min_t(size_t, desc_len, 1070 min_t(size_t, len, 1071 PAGE_SIZE - offset_in_page(buf))); 1072 if (vmalloced_buf) 1073 vm_page = vmalloc_to_page(buf); 1074 else 1075 vm_page = kmap_to_page(buf); 1076 if (!vm_page) { 1077 sg_free_table(sgt); 1078 return -ENOMEM; 1079 } 1080 sg_set_page(sg, vm_page, 1081 min, offset_in_page(buf)); 1082 } else { 1083 min = min_t(size_t, len, desc_len); 1084 sg_buf = buf; 1085 sg_set_buf(sg, sg_buf, min); 1086 } 1087 1088 buf += min; 1089 len -= min; 1090 sg = sg_next(sg); 1091 } 1092 1093 ret = dma_map_sgtable(dev, sgt, dir, attrs); 1094 if (ret < 0) { 1095 sg_free_table(sgt); 1096 return ret; 1097 } 1098 1099 return 0; 1100 } 1101 1102 int spi_map_buf(struct spi_controller *ctlr, struct device *dev, 1103 struct sg_table *sgt, void *buf, size_t len, 1104 enum dma_data_direction dir) 1105 { 1106 return spi_map_buf_attrs(ctlr, dev, sgt, buf, len, dir, 0); 1107 } 1108 1109 static void spi_unmap_buf_attrs(struct spi_controller *ctlr, 1110 struct device *dev, struct sg_table *sgt, 1111 enum dma_data_direction dir, 1112 unsigned long attrs) 1113 { 1114 if (sgt->orig_nents) { 1115 dma_unmap_sgtable(dev, sgt, dir, attrs); 1116 sg_free_table(sgt); 1117 sgt->orig_nents = 0; 1118 sgt->nents = 0; 1119 } 1120 } 1121 1122 void spi_unmap_buf(struct spi_controller *ctlr, struct device *dev, 1123 struct sg_table *sgt, enum dma_data_direction dir) 1124 { 1125 spi_unmap_buf_attrs(ctlr, dev, sgt, dir, 0); 1126 } 1127 1128 static int __spi_map_msg(struct spi_controller *ctlr, struct spi_message *msg) 1129 { 1130 struct device *tx_dev, *rx_dev; 1131 struct spi_transfer *xfer; 1132 int ret; 1133 1134 if (!ctlr->can_dma) 1135 return 0; 1136 1137 if (ctlr->dma_tx) 1138 tx_dev = ctlr->dma_tx->device->dev; 1139 else if (ctlr->dma_map_dev) 1140 tx_dev = ctlr->dma_map_dev; 1141 else 1142 tx_dev = ctlr->dev.parent; 1143 1144 if (ctlr->dma_rx) 1145 rx_dev = ctlr->dma_rx->device->dev; 1146 else if (ctlr->dma_map_dev) 1147 rx_dev = ctlr->dma_map_dev; 1148 else 1149 rx_dev = ctlr->dev.parent; 1150 1151 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 1152 /* The sync is done before each transfer. */ 1153 unsigned long attrs = DMA_ATTR_SKIP_CPU_SYNC; 1154 1155 if (!ctlr->can_dma(ctlr, msg->spi, xfer)) 1156 continue; 1157 1158 if (xfer->tx_buf != NULL) { 1159 ret = spi_map_buf_attrs(ctlr, tx_dev, &xfer->tx_sg, 1160 (void *)xfer->tx_buf, 1161 xfer->len, DMA_TO_DEVICE, 1162 attrs); 1163 if (ret != 0) 1164 return ret; 1165 } 1166 1167 if (xfer->rx_buf != NULL) { 1168 ret = spi_map_buf_attrs(ctlr, rx_dev, &xfer->rx_sg, 1169 xfer->rx_buf, xfer->len, 1170 DMA_FROM_DEVICE, attrs); 1171 if (ret != 0) { 1172 spi_unmap_buf_attrs(ctlr, tx_dev, 1173 &xfer->tx_sg, DMA_TO_DEVICE, 1174 attrs); 1175 1176 return ret; 1177 } 1178 } 1179 } 1180 1181 ctlr->cur_rx_dma_dev = rx_dev; 1182 ctlr->cur_tx_dma_dev = tx_dev; 1183 ctlr->cur_msg_mapped = true; 1184 1185 return 0; 1186 } 1187 1188 static int __spi_unmap_msg(struct spi_controller *ctlr, struct spi_message *msg) 1189 { 1190 struct device *rx_dev = ctlr->cur_rx_dma_dev; 1191 struct device *tx_dev = ctlr->cur_tx_dma_dev; 1192 struct spi_transfer *xfer; 1193 1194 if (!ctlr->cur_msg_mapped || !ctlr->can_dma) 1195 return 0; 1196 1197 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 1198 /* The sync has already been done after each transfer. */ 1199 unsigned long attrs = DMA_ATTR_SKIP_CPU_SYNC; 1200 1201 if (!ctlr->can_dma(ctlr, msg->spi, xfer)) 1202 continue; 1203 1204 spi_unmap_buf_attrs(ctlr, rx_dev, &xfer->rx_sg, 1205 DMA_FROM_DEVICE, attrs); 1206 spi_unmap_buf_attrs(ctlr, tx_dev, &xfer->tx_sg, 1207 DMA_TO_DEVICE, attrs); 1208 } 1209 1210 ctlr->cur_msg_mapped = false; 1211 1212 return 0; 1213 } 1214 1215 static void spi_dma_sync_for_device(struct spi_controller *ctlr, 1216 struct spi_transfer *xfer) 1217 { 1218 struct device *rx_dev = ctlr->cur_rx_dma_dev; 1219 struct device *tx_dev = ctlr->cur_tx_dma_dev; 1220 1221 if (!ctlr->cur_msg_mapped) 1222 return; 1223 1224 if (xfer->tx_sg.orig_nents) 1225 dma_sync_sgtable_for_device(tx_dev, &xfer->tx_sg, DMA_TO_DEVICE); 1226 if (xfer->rx_sg.orig_nents) 1227 dma_sync_sgtable_for_device(rx_dev, &xfer->rx_sg, DMA_FROM_DEVICE); 1228 } 1229 1230 static void spi_dma_sync_for_cpu(struct spi_controller *ctlr, 1231 struct spi_transfer *xfer) 1232 { 1233 struct device *rx_dev = ctlr->cur_rx_dma_dev; 1234 struct device *tx_dev = ctlr->cur_tx_dma_dev; 1235 1236 if (!ctlr->cur_msg_mapped) 1237 return; 1238 1239 if (xfer->rx_sg.orig_nents) 1240 dma_sync_sgtable_for_cpu(rx_dev, &xfer->rx_sg, DMA_FROM_DEVICE); 1241 if (xfer->tx_sg.orig_nents) 1242 dma_sync_sgtable_for_cpu(tx_dev, &xfer->tx_sg, DMA_TO_DEVICE); 1243 } 1244 #else /* !CONFIG_HAS_DMA */ 1245 static inline int __spi_map_msg(struct spi_controller *ctlr, 1246 struct spi_message *msg) 1247 { 1248 return 0; 1249 } 1250 1251 static inline int __spi_unmap_msg(struct spi_controller *ctlr, 1252 struct spi_message *msg) 1253 { 1254 return 0; 1255 } 1256 1257 static void spi_dma_sync_for_device(struct spi_controller *ctrl, 1258 struct spi_transfer *xfer) 1259 { 1260 } 1261 1262 static void spi_dma_sync_for_cpu(struct spi_controller *ctrl, 1263 struct spi_transfer *xfer) 1264 { 1265 } 1266 #endif /* !CONFIG_HAS_DMA */ 1267 1268 static inline int spi_unmap_msg(struct spi_controller *ctlr, 1269 struct spi_message *msg) 1270 { 1271 struct spi_transfer *xfer; 1272 1273 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 1274 /* 1275 * Restore the original value of tx_buf or rx_buf if they are 1276 * NULL. 1277 */ 1278 if (xfer->tx_buf == ctlr->dummy_tx) 1279 xfer->tx_buf = NULL; 1280 if (xfer->rx_buf == ctlr->dummy_rx) 1281 xfer->rx_buf = NULL; 1282 } 1283 1284 return __spi_unmap_msg(ctlr, msg); 1285 } 1286 1287 static int spi_map_msg(struct spi_controller *ctlr, struct spi_message *msg) 1288 { 1289 struct spi_transfer *xfer; 1290 void *tmp; 1291 unsigned int max_tx, max_rx; 1292 1293 if ((ctlr->flags & (SPI_CONTROLLER_MUST_RX | SPI_CONTROLLER_MUST_TX)) 1294 && !(msg->spi->mode & SPI_3WIRE)) { 1295 max_tx = 0; 1296 max_rx = 0; 1297 1298 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 1299 if ((ctlr->flags & SPI_CONTROLLER_MUST_TX) && 1300 !xfer->tx_buf) 1301 max_tx = max(xfer->len, max_tx); 1302 if ((ctlr->flags & SPI_CONTROLLER_MUST_RX) && 1303 !xfer->rx_buf) 1304 max_rx = max(xfer->len, max_rx); 1305 } 1306 1307 if (max_tx) { 1308 tmp = krealloc(ctlr->dummy_tx, max_tx, 1309 GFP_KERNEL | GFP_DMA | __GFP_ZERO); 1310 if (!tmp) 1311 return -ENOMEM; 1312 ctlr->dummy_tx = tmp; 1313 } 1314 1315 if (max_rx) { 1316 tmp = krealloc(ctlr->dummy_rx, max_rx, 1317 GFP_KERNEL | GFP_DMA); 1318 if (!tmp) 1319 return -ENOMEM; 1320 ctlr->dummy_rx = tmp; 1321 } 1322 1323 if (max_tx || max_rx) { 1324 list_for_each_entry(xfer, &msg->transfers, 1325 transfer_list) { 1326 if (!xfer->len) 1327 continue; 1328 if (!xfer->tx_buf) 1329 xfer->tx_buf = ctlr->dummy_tx; 1330 if (!xfer->rx_buf) 1331 xfer->rx_buf = ctlr->dummy_rx; 1332 } 1333 } 1334 } 1335 1336 return __spi_map_msg(ctlr, msg); 1337 } 1338 1339 static int spi_transfer_wait(struct spi_controller *ctlr, 1340 struct spi_message *msg, 1341 struct spi_transfer *xfer) 1342 { 1343 struct spi_statistics __percpu *statm = ctlr->pcpu_statistics; 1344 struct spi_statistics __percpu *stats = msg->spi->pcpu_statistics; 1345 u32 speed_hz = xfer->speed_hz; 1346 unsigned long long ms; 1347 1348 if (spi_controller_is_slave(ctlr)) { 1349 if (wait_for_completion_interruptible(&ctlr->xfer_completion)) { 1350 dev_dbg(&msg->spi->dev, "SPI transfer interrupted\n"); 1351 return -EINTR; 1352 } 1353 } else { 1354 if (!speed_hz) 1355 speed_hz = 100000; 1356 1357 /* 1358 * For each byte we wait for 8 cycles of the SPI clock. 1359 * Since speed is defined in Hz and we want milliseconds, 1360 * use respective multiplier, but before the division, 1361 * otherwise we may get 0 for short transfers. 1362 */ 1363 ms = 8LL * MSEC_PER_SEC * xfer->len; 1364 do_div(ms, speed_hz); 1365 1366 /* 1367 * Increase it twice and add 200 ms tolerance, use 1368 * predefined maximum in case of overflow. 1369 */ 1370 ms += ms + 200; 1371 if (ms > UINT_MAX) 1372 ms = UINT_MAX; 1373 1374 ms = wait_for_completion_timeout(&ctlr->xfer_completion, 1375 msecs_to_jiffies(ms)); 1376 1377 if (ms == 0) { 1378 SPI_STATISTICS_INCREMENT_FIELD(statm, timedout); 1379 SPI_STATISTICS_INCREMENT_FIELD(stats, timedout); 1380 dev_err(&msg->spi->dev, 1381 "SPI transfer timed out\n"); 1382 return -ETIMEDOUT; 1383 } 1384 } 1385 1386 return 0; 1387 } 1388 1389 static void _spi_transfer_delay_ns(u32 ns) 1390 { 1391 if (!ns) 1392 return; 1393 if (ns <= NSEC_PER_USEC) { 1394 ndelay(ns); 1395 } else { 1396 u32 us = DIV_ROUND_UP(ns, NSEC_PER_USEC); 1397 1398 if (us <= 10) 1399 udelay(us); 1400 else 1401 usleep_range(us, us + DIV_ROUND_UP(us, 10)); 1402 } 1403 } 1404 1405 int spi_delay_to_ns(struct spi_delay *_delay, struct spi_transfer *xfer) 1406 { 1407 u32 delay = _delay->value; 1408 u32 unit = _delay->unit; 1409 u32 hz; 1410 1411 if (!delay) 1412 return 0; 1413 1414 switch (unit) { 1415 case SPI_DELAY_UNIT_USECS: 1416 delay *= NSEC_PER_USEC; 1417 break; 1418 case SPI_DELAY_UNIT_NSECS: 1419 /* Nothing to do here */ 1420 break; 1421 case SPI_DELAY_UNIT_SCK: 1422 /* Clock cycles need to be obtained from spi_transfer */ 1423 if (!xfer) 1424 return -EINVAL; 1425 /* 1426 * If there is unknown effective speed, approximate it 1427 * by underestimating with half of the requested hz. 1428 */ 1429 hz = xfer->effective_speed_hz ?: xfer->speed_hz / 2; 1430 if (!hz) 1431 return -EINVAL; 1432 1433 /* Convert delay to nanoseconds */ 1434 delay *= DIV_ROUND_UP(NSEC_PER_SEC, hz); 1435 break; 1436 default: 1437 return -EINVAL; 1438 } 1439 1440 return delay; 1441 } 1442 EXPORT_SYMBOL_GPL(spi_delay_to_ns); 1443 1444 int spi_delay_exec(struct spi_delay *_delay, struct spi_transfer *xfer) 1445 { 1446 int delay; 1447 1448 might_sleep(); 1449 1450 if (!_delay) 1451 return -EINVAL; 1452 1453 delay = spi_delay_to_ns(_delay, xfer); 1454 if (delay < 0) 1455 return delay; 1456 1457 _spi_transfer_delay_ns(delay); 1458 1459 return 0; 1460 } 1461 EXPORT_SYMBOL_GPL(spi_delay_exec); 1462 1463 static void _spi_transfer_cs_change_delay(struct spi_message *msg, 1464 struct spi_transfer *xfer) 1465 { 1466 u32 default_delay_ns = 10 * NSEC_PER_USEC; 1467 u32 delay = xfer->cs_change_delay.value; 1468 u32 unit = xfer->cs_change_delay.unit; 1469 int ret; 1470 1471 /* Return early on "fast" mode - for everything but USECS */ 1472 if (!delay) { 1473 if (unit == SPI_DELAY_UNIT_USECS) 1474 _spi_transfer_delay_ns(default_delay_ns); 1475 return; 1476 } 1477 1478 ret = spi_delay_exec(&xfer->cs_change_delay, xfer); 1479 if (ret) { 1480 dev_err_once(&msg->spi->dev, 1481 "Use of unsupported delay unit %i, using default of %luus\n", 1482 unit, default_delay_ns / NSEC_PER_USEC); 1483 _spi_transfer_delay_ns(default_delay_ns); 1484 } 1485 } 1486 1487 /* 1488 * spi_transfer_one_message - Default implementation of transfer_one_message() 1489 * 1490 * This is a standard implementation of transfer_one_message() for 1491 * drivers which implement a transfer_one() operation. It provides 1492 * standard handling of delays and chip select management. 1493 */ 1494 static int spi_transfer_one_message(struct spi_controller *ctlr, 1495 struct spi_message *msg) 1496 { 1497 struct spi_transfer *xfer; 1498 bool keep_cs = false; 1499 int ret = 0; 1500 struct spi_statistics __percpu *statm = ctlr->pcpu_statistics; 1501 struct spi_statistics __percpu *stats = msg->spi->pcpu_statistics; 1502 1503 xfer = list_first_entry(&msg->transfers, struct spi_transfer, transfer_list); 1504 spi_set_cs(msg->spi, !xfer->cs_off, false); 1505 1506 SPI_STATISTICS_INCREMENT_FIELD(statm, messages); 1507 SPI_STATISTICS_INCREMENT_FIELD(stats, messages); 1508 1509 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 1510 trace_spi_transfer_start(msg, xfer); 1511 1512 spi_statistics_add_transfer_stats(statm, xfer, ctlr); 1513 spi_statistics_add_transfer_stats(stats, xfer, ctlr); 1514 1515 if (!ctlr->ptp_sts_supported) { 1516 xfer->ptp_sts_word_pre = 0; 1517 ptp_read_system_prets(xfer->ptp_sts); 1518 } 1519 1520 if ((xfer->tx_buf || xfer->rx_buf) && xfer->len) { 1521 reinit_completion(&ctlr->xfer_completion); 1522 1523 fallback_pio: 1524 spi_dma_sync_for_device(ctlr, xfer); 1525 ret = ctlr->transfer_one(ctlr, msg->spi, xfer); 1526 if (ret < 0) { 1527 spi_dma_sync_for_cpu(ctlr, xfer); 1528 1529 if (ctlr->cur_msg_mapped && 1530 (xfer->error & SPI_TRANS_FAIL_NO_START)) { 1531 __spi_unmap_msg(ctlr, msg); 1532 ctlr->fallback = true; 1533 xfer->error &= ~SPI_TRANS_FAIL_NO_START; 1534 goto fallback_pio; 1535 } 1536 1537 SPI_STATISTICS_INCREMENT_FIELD(statm, 1538 errors); 1539 SPI_STATISTICS_INCREMENT_FIELD(stats, 1540 errors); 1541 dev_err(&msg->spi->dev, 1542 "SPI transfer failed: %d\n", ret); 1543 goto out; 1544 } 1545 1546 if (ret > 0) { 1547 ret = spi_transfer_wait(ctlr, msg, xfer); 1548 if (ret < 0) 1549 msg->status = ret; 1550 } 1551 1552 spi_dma_sync_for_cpu(ctlr, xfer); 1553 } else { 1554 if (xfer->len) 1555 dev_err(&msg->spi->dev, 1556 "Bufferless transfer has length %u\n", 1557 xfer->len); 1558 } 1559 1560 if (!ctlr->ptp_sts_supported) { 1561 ptp_read_system_postts(xfer->ptp_sts); 1562 xfer->ptp_sts_word_post = xfer->len; 1563 } 1564 1565 trace_spi_transfer_stop(msg, xfer); 1566 1567 if (msg->status != -EINPROGRESS) 1568 goto out; 1569 1570 spi_transfer_delay_exec(xfer); 1571 1572 if (xfer->cs_change) { 1573 if (list_is_last(&xfer->transfer_list, 1574 &msg->transfers)) { 1575 keep_cs = true; 1576 } else { 1577 if (!xfer->cs_off) 1578 spi_set_cs(msg->spi, false, false); 1579 _spi_transfer_cs_change_delay(msg, xfer); 1580 if (!list_next_entry(xfer, transfer_list)->cs_off) 1581 spi_set_cs(msg->spi, true, false); 1582 } 1583 } else if (!list_is_last(&xfer->transfer_list, &msg->transfers) && 1584 xfer->cs_off != list_next_entry(xfer, transfer_list)->cs_off) { 1585 spi_set_cs(msg->spi, xfer->cs_off, false); 1586 } 1587 1588 msg->actual_length += xfer->len; 1589 } 1590 1591 out: 1592 if (ret != 0 || !keep_cs) 1593 spi_set_cs(msg->spi, false, false); 1594 1595 if (msg->status == -EINPROGRESS) 1596 msg->status = ret; 1597 1598 if (msg->status && ctlr->handle_err) 1599 ctlr->handle_err(ctlr, msg); 1600 1601 spi_finalize_current_message(ctlr); 1602 1603 return ret; 1604 } 1605 1606 /** 1607 * spi_finalize_current_transfer - report completion of a transfer 1608 * @ctlr: the controller reporting completion 1609 * 1610 * Called by SPI drivers using the core transfer_one_message() 1611 * implementation to notify it that the current interrupt driven 1612 * transfer has finished and the next one may be scheduled. 1613 */ 1614 void spi_finalize_current_transfer(struct spi_controller *ctlr) 1615 { 1616 complete(&ctlr->xfer_completion); 1617 } 1618 EXPORT_SYMBOL_GPL(spi_finalize_current_transfer); 1619 1620 static void spi_idle_runtime_pm(struct spi_controller *ctlr) 1621 { 1622 if (ctlr->auto_runtime_pm) { 1623 pm_runtime_mark_last_busy(ctlr->dev.parent); 1624 pm_runtime_put_autosuspend(ctlr->dev.parent); 1625 } 1626 } 1627 1628 static int __spi_pump_transfer_message(struct spi_controller *ctlr, 1629 struct spi_message *msg, bool was_busy) 1630 { 1631 struct spi_transfer *xfer; 1632 int ret; 1633 1634 if (!was_busy && ctlr->auto_runtime_pm) { 1635 ret = pm_runtime_get_sync(ctlr->dev.parent); 1636 if (ret < 0) { 1637 pm_runtime_put_noidle(ctlr->dev.parent); 1638 dev_err(&ctlr->dev, "Failed to power device: %d\n", 1639 ret); 1640 return ret; 1641 } 1642 } 1643 1644 if (!was_busy) 1645 trace_spi_controller_busy(ctlr); 1646 1647 if (!was_busy && ctlr->prepare_transfer_hardware) { 1648 ret = ctlr->prepare_transfer_hardware(ctlr); 1649 if (ret) { 1650 dev_err(&ctlr->dev, 1651 "failed to prepare transfer hardware: %d\n", 1652 ret); 1653 1654 if (ctlr->auto_runtime_pm) 1655 pm_runtime_put(ctlr->dev.parent); 1656 1657 msg->status = ret; 1658 spi_finalize_current_message(ctlr); 1659 1660 return ret; 1661 } 1662 } 1663 1664 trace_spi_message_start(msg); 1665 1666 ret = spi_split_transfers_maxsize(ctlr, msg, 1667 spi_max_transfer_size(msg->spi), 1668 GFP_KERNEL | GFP_DMA); 1669 if (ret) { 1670 msg->status = ret; 1671 spi_finalize_current_message(ctlr); 1672 return ret; 1673 } 1674 1675 if (ctlr->prepare_message) { 1676 ret = ctlr->prepare_message(ctlr, msg); 1677 if (ret) { 1678 dev_err(&ctlr->dev, "failed to prepare message: %d\n", 1679 ret); 1680 msg->status = ret; 1681 spi_finalize_current_message(ctlr); 1682 return ret; 1683 } 1684 msg->prepared = true; 1685 } 1686 1687 ret = spi_map_msg(ctlr, msg); 1688 if (ret) { 1689 msg->status = ret; 1690 spi_finalize_current_message(ctlr); 1691 return ret; 1692 } 1693 1694 if (!ctlr->ptp_sts_supported && !ctlr->transfer_one) { 1695 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 1696 xfer->ptp_sts_word_pre = 0; 1697 ptp_read_system_prets(xfer->ptp_sts); 1698 } 1699 } 1700 1701 /* 1702 * Drivers implementation of transfer_one_message() must arrange for 1703 * spi_finalize_current_message() to get called. Most drivers will do 1704 * this in the calling context, but some don't. For those cases, a 1705 * completion is used to guarantee that this function does not return 1706 * until spi_finalize_current_message() is done accessing 1707 * ctlr->cur_msg. 1708 * Use of the following two flags enable to opportunistically skip the 1709 * use of the completion since its use involves expensive spin locks. 1710 * In case of a race with the context that calls 1711 * spi_finalize_current_message() the completion will always be used, 1712 * due to strict ordering of these flags using barriers. 1713 */ 1714 WRITE_ONCE(ctlr->cur_msg_incomplete, true); 1715 WRITE_ONCE(ctlr->cur_msg_need_completion, false); 1716 reinit_completion(&ctlr->cur_msg_completion); 1717 smp_wmb(); /* Make these available to spi_finalize_current_message() */ 1718 1719 ret = ctlr->transfer_one_message(ctlr, msg); 1720 if (ret) { 1721 dev_err(&ctlr->dev, 1722 "failed to transfer one message from queue\n"); 1723 return ret; 1724 } 1725 1726 WRITE_ONCE(ctlr->cur_msg_need_completion, true); 1727 smp_mb(); /* See spi_finalize_current_message()... */ 1728 if (READ_ONCE(ctlr->cur_msg_incomplete)) 1729 wait_for_completion(&ctlr->cur_msg_completion); 1730 1731 return 0; 1732 } 1733 1734 /** 1735 * __spi_pump_messages - function which processes spi message queue 1736 * @ctlr: controller to process queue for 1737 * @in_kthread: true if we are in the context of the message pump thread 1738 * 1739 * This function checks if there is any spi message in the queue that 1740 * needs processing and if so call out to the driver to initialize hardware 1741 * and transfer each message. 1742 * 1743 * Note that it is called both from the kthread itself and also from 1744 * inside spi_sync(); the queue extraction handling at the top of the 1745 * function should deal with this safely. 1746 */ 1747 static void __spi_pump_messages(struct spi_controller *ctlr, bool in_kthread) 1748 { 1749 struct spi_message *msg; 1750 bool was_busy = false; 1751 unsigned long flags; 1752 int ret; 1753 1754 /* Take the IO mutex */ 1755 mutex_lock(&ctlr->io_mutex); 1756 1757 /* Lock queue */ 1758 spin_lock_irqsave(&ctlr->queue_lock, flags); 1759 1760 /* Make sure we are not already running a message */ 1761 if (ctlr->cur_msg) 1762 goto out_unlock; 1763 1764 /* Check if the queue is idle */ 1765 if (list_empty(&ctlr->queue) || !ctlr->running) { 1766 if (!ctlr->busy) 1767 goto out_unlock; 1768 1769 /* Defer any non-atomic teardown to the thread */ 1770 if (!in_kthread) { 1771 if (!ctlr->dummy_rx && !ctlr->dummy_tx && 1772 !ctlr->unprepare_transfer_hardware) { 1773 spi_idle_runtime_pm(ctlr); 1774 ctlr->busy = false; 1775 ctlr->queue_empty = true; 1776 trace_spi_controller_idle(ctlr); 1777 } else { 1778 kthread_queue_work(ctlr->kworker, 1779 &ctlr->pump_messages); 1780 } 1781 goto out_unlock; 1782 } 1783 1784 ctlr->busy = false; 1785 spin_unlock_irqrestore(&ctlr->queue_lock, flags); 1786 1787 kfree(ctlr->dummy_rx); 1788 ctlr->dummy_rx = NULL; 1789 kfree(ctlr->dummy_tx); 1790 ctlr->dummy_tx = NULL; 1791 if (ctlr->unprepare_transfer_hardware && 1792 ctlr->unprepare_transfer_hardware(ctlr)) 1793 dev_err(&ctlr->dev, 1794 "failed to unprepare transfer hardware\n"); 1795 spi_idle_runtime_pm(ctlr); 1796 trace_spi_controller_idle(ctlr); 1797 1798 spin_lock_irqsave(&ctlr->queue_lock, flags); 1799 ctlr->queue_empty = true; 1800 goto out_unlock; 1801 } 1802 1803 /* Extract head of queue */ 1804 msg = list_first_entry(&ctlr->queue, struct spi_message, queue); 1805 ctlr->cur_msg = msg; 1806 1807 list_del_init(&msg->queue); 1808 if (ctlr->busy) 1809 was_busy = true; 1810 else 1811 ctlr->busy = true; 1812 spin_unlock_irqrestore(&ctlr->queue_lock, flags); 1813 1814 ret = __spi_pump_transfer_message(ctlr, msg, was_busy); 1815 kthread_queue_work(ctlr->kworker, &ctlr->pump_messages); 1816 1817 ctlr->cur_msg = NULL; 1818 ctlr->fallback = false; 1819 1820 mutex_unlock(&ctlr->io_mutex); 1821 1822 /* Prod the scheduler in case transfer_one() was busy waiting */ 1823 if (!ret) 1824 cond_resched(); 1825 return; 1826 1827 out_unlock: 1828 spin_unlock_irqrestore(&ctlr->queue_lock, flags); 1829 mutex_unlock(&ctlr->io_mutex); 1830 } 1831 1832 /** 1833 * spi_pump_messages - kthread work function which processes spi message queue 1834 * @work: pointer to kthread work struct contained in the controller struct 1835 */ 1836 static void spi_pump_messages(struct kthread_work *work) 1837 { 1838 struct spi_controller *ctlr = 1839 container_of(work, struct spi_controller, pump_messages); 1840 1841 __spi_pump_messages(ctlr, true); 1842 } 1843 1844 /** 1845 * spi_take_timestamp_pre - helper to collect the beginning of the TX timestamp 1846 * @ctlr: Pointer to the spi_controller structure of the driver 1847 * @xfer: Pointer to the transfer being timestamped 1848 * @progress: How many words (not bytes) have been transferred so far 1849 * @irqs_off: If true, will disable IRQs and preemption for the duration of the 1850 * transfer, for less jitter in time measurement. Only compatible 1851 * with PIO drivers. If true, must follow up with 1852 * spi_take_timestamp_post or otherwise system will crash. 1853 * WARNING: for fully predictable results, the CPU frequency must 1854 * also be under control (governor). 1855 * 1856 * This is a helper for drivers to collect the beginning of the TX timestamp 1857 * for the requested byte from the SPI transfer. The frequency with which this 1858 * function must be called (once per word, once for the whole transfer, once 1859 * per batch of words etc) is arbitrary as long as the @tx buffer offset is 1860 * greater than or equal to the requested byte at the time of the call. The 1861 * timestamp is only taken once, at the first such call. It is assumed that 1862 * the driver advances its @tx buffer pointer monotonically. 1863 */ 1864 void spi_take_timestamp_pre(struct spi_controller *ctlr, 1865 struct spi_transfer *xfer, 1866 size_t progress, bool irqs_off) 1867 { 1868 if (!xfer->ptp_sts) 1869 return; 1870 1871 if (xfer->timestamped) 1872 return; 1873 1874 if (progress > xfer->ptp_sts_word_pre) 1875 return; 1876 1877 /* Capture the resolution of the timestamp */ 1878 xfer->ptp_sts_word_pre = progress; 1879 1880 if (irqs_off) { 1881 local_irq_save(ctlr->irq_flags); 1882 preempt_disable(); 1883 } 1884 1885 ptp_read_system_prets(xfer->ptp_sts); 1886 } 1887 EXPORT_SYMBOL_GPL(spi_take_timestamp_pre); 1888 1889 /** 1890 * spi_take_timestamp_post - helper to collect the end of the TX timestamp 1891 * @ctlr: Pointer to the spi_controller structure of the driver 1892 * @xfer: Pointer to the transfer being timestamped 1893 * @progress: How many words (not bytes) have been transferred so far 1894 * @irqs_off: If true, will re-enable IRQs and preemption for the local CPU. 1895 * 1896 * This is a helper for drivers to collect the end of the TX timestamp for 1897 * the requested byte from the SPI transfer. Can be called with an arbitrary 1898 * frequency: only the first call where @tx exceeds or is equal to the 1899 * requested word will be timestamped. 1900 */ 1901 void spi_take_timestamp_post(struct spi_controller *ctlr, 1902 struct spi_transfer *xfer, 1903 size_t progress, bool irqs_off) 1904 { 1905 if (!xfer->ptp_sts) 1906 return; 1907 1908 if (xfer->timestamped) 1909 return; 1910 1911 if (progress < xfer->ptp_sts_word_post) 1912 return; 1913 1914 ptp_read_system_postts(xfer->ptp_sts); 1915 1916 if (irqs_off) { 1917 local_irq_restore(ctlr->irq_flags); 1918 preempt_enable(); 1919 } 1920 1921 /* Capture the resolution of the timestamp */ 1922 xfer->ptp_sts_word_post = progress; 1923 1924 xfer->timestamped = true; 1925 } 1926 EXPORT_SYMBOL_GPL(spi_take_timestamp_post); 1927 1928 /** 1929 * spi_set_thread_rt - set the controller to pump at realtime priority 1930 * @ctlr: controller to boost priority of 1931 * 1932 * This can be called because the controller requested realtime priority 1933 * (by setting the ->rt value before calling spi_register_controller()) or 1934 * because a device on the bus said that its transfers needed realtime 1935 * priority. 1936 * 1937 * NOTE: at the moment if any device on a bus says it needs realtime then 1938 * the thread will be at realtime priority for all transfers on that 1939 * controller. If this eventually becomes a problem we may see if we can 1940 * find a way to boost the priority only temporarily during relevant 1941 * transfers. 1942 */ 1943 static void spi_set_thread_rt(struct spi_controller *ctlr) 1944 { 1945 dev_info(&ctlr->dev, 1946 "will run message pump with realtime priority\n"); 1947 sched_set_fifo(ctlr->kworker->task); 1948 } 1949 1950 static int spi_init_queue(struct spi_controller *ctlr) 1951 { 1952 ctlr->running = false; 1953 ctlr->busy = false; 1954 ctlr->queue_empty = true; 1955 1956 ctlr->kworker = kthread_create_worker(0, dev_name(&ctlr->dev)); 1957 if (IS_ERR(ctlr->kworker)) { 1958 dev_err(&ctlr->dev, "failed to create message pump kworker\n"); 1959 return PTR_ERR(ctlr->kworker); 1960 } 1961 1962 kthread_init_work(&ctlr->pump_messages, spi_pump_messages); 1963 1964 /* 1965 * Controller config will indicate if this controller should run the 1966 * message pump with high (realtime) priority to reduce the transfer 1967 * latency on the bus by minimising the delay between a transfer 1968 * request and the scheduling of the message pump thread. Without this 1969 * setting the message pump thread will remain at default priority. 1970 */ 1971 if (ctlr->rt) 1972 spi_set_thread_rt(ctlr); 1973 1974 return 0; 1975 } 1976 1977 /** 1978 * spi_get_next_queued_message() - called by driver to check for queued 1979 * messages 1980 * @ctlr: the controller to check for queued messages 1981 * 1982 * If there are more messages in the queue, the next message is returned from 1983 * this call. 1984 * 1985 * Return: the next message in the queue, else NULL if the queue is empty. 1986 */ 1987 struct spi_message *spi_get_next_queued_message(struct spi_controller *ctlr) 1988 { 1989 struct spi_message *next; 1990 unsigned long flags; 1991 1992 /* Get a pointer to the next message, if any */ 1993 spin_lock_irqsave(&ctlr->queue_lock, flags); 1994 next = list_first_entry_or_null(&ctlr->queue, struct spi_message, 1995 queue); 1996 spin_unlock_irqrestore(&ctlr->queue_lock, flags); 1997 1998 return next; 1999 } 2000 EXPORT_SYMBOL_GPL(spi_get_next_queued_message); 2001 2002 /** 2003 * spi_finalize_current_message() - the current message is complete 2004 * @ctlr: the controller to return the message to 2005 * 2006 * Called by the driver to notify the core that the message in the front of the 2007 * queue is complete and can be removed from the queue. 2008 */ 2009 void spi_finalize_current_message(struct spi_controller *ctlr) 2010 { 2011 struct spi_transfer *xfer; 2012 struct spi_message *mesg; 2013 int ret; 2014 2015 mesg = ctlr->cur_msg; 2016 2017 if (!ctlr->ptp_sts_supported && !ctlr->transfer_one) { 2018 list_for_each_entry(xfer, &mesg->transfers, transfer_list) { 2019 ptp_read_system_postts(xfer->ptp_sts); 2020 xfer->ptp_sts_word_post = xfer->len; 2021 } 2022 } 2023 2024 if (unlikely(ctlr->ptp_sts_supported)) 2025 list_for_each_entry(xfer, &mesg->transfers, transfer_list) 2026 WARN_ON_ONCE(xfer->ptp_sts && !xfer->timestamped); 2027 2028 spi_unmap_msg(ctlr, mesg); 2029 2030 /* 2031 * In the prepare_messages callback the SPI bus has the opportunity 2032 * to split a transfer to smaller chunks. 2033 * 2034 * Release the split transfers here since spi_map_msg() is done on 2035 * the split transfers. 2036 */ 2037 spi_res_release(ctlr, mesg); 2038 2039 if (mesg->prepared && ctlr->unprepare_message) { 2040 ret = ctlr->unprepare_message(ctlr, mesg); 2041 if (ret) { 2042 dev_err(&ctlr->dev, "failed to unprepare message: %d\n", 2043 ret); 2044 } 2045 } 2046 2047 mesg->prepared = false; 2048 2049 WRITE_ONCE(ctlr->cur_msg_incomplete, false); 2050 smp_mb(); /* See __spi_pump_transfer_message()... */ 2051 if (READ_ONCE(ctlr->cur_msg_need_completion)) 2052 complete(&ctlr->cur_msg_completion); 2053 2054 trace_spi_message_done(mesg); 2055 2056 mesg->state = NULL; 2057 if (mesg->complete) 2058 mesg->complete(mesg->context); 2059 } 2060 EXPORT_SYMBOL_GPL(spi_finalize_current_message); 2061 2062 static int spi_start_queue(struct spi_controller *ctlr) 2063 { 2064 unsigned long flags; 2065 2066 spin_lock_irqsave(&ctlr->queue_lock, flags); 2067 2068 if (ctlr->running || ctlr->busy) { 2069 spin_unlock_irqrestore(&ctlr->queue_lock, flags); 2070 return -EBUSY; 2071 } 2072 2073 ctlr->running = true; 2074 ctlr->cur_msg = NULL; 2075 spin_unlock_irqrestore(&ctlr->queue_lock, flags); 2076 2077 kthread_queue_work(ctlr->kworker, &ctlr->pump_messages); 2078 2079 return 0; 2080 } 2081 2082 static int spi_stop_queue(struct spi_controller *ctlr) 2083 { 2084 unsigned long flags; 2085 unsigned limit = 500; 2086 int ret = 0; 2087 2088 spin_lock_irqsave(&ctlr->queue_lock, flags); 2089 2090 /* 2091 * This is a bit lame, but is optimized for the common execution path. 2092 * A wait_queue on the ctlr->busy could be used, but then the common 2093 * execution path (pump_messages) would be required to call wake_up or 2094 * friends on every SPI message. Do this instead. 2095 */ 2096 while ((!list_empty(&ctlr->queue) || ctlr->busy) && limit--) { 2097 spin_unlock_irqrestore(&ctlr->queue_lock, flags); 2098 usleep_range(10000, 11000); 2099 spin_lock_irqsave(&ctlr->queue_lock, flags); 2100 } 2101 2102 if (!list_empty(&ctlr->queue) || ctlr->busy) 2103 ret = -EBUSY; 2104 else 2105 ctlr->running = false; 2106 2107 spin_unlock_irqrestore(&ctlr->queue_lock, flags); 2108 2109 if (ret) { 2110 dev_warn(&ctlr->dev, "could not stop message queue\n"); 2111 return ret; 2112 } 2113 return ret; 2114 } 2115 2116 static int spi_destroy_queue(struct spi_controller *ctlr) 2117 { 2118 int ret; 2119 2120 ret = spi_stop_queue(ctlr); 2121 2122 /* 2123 * kthread_flush_worker will block until all work is done. 2124 * If the reason that stop_queue timed out is that the work will never 2125 * finish, then it does no good to call flush/stop thread, so 2126 * return anyway. 2127 */ 2128 if (ret) { 2129 dev_err(&ctlr->dev, "problem destroying queue\n"); 2130 return ret; 2131 } 2132 2133 kthread_destroy_worker(ctlr->kworker); 2134 2135 return 0; 2136 } 2137 2138 static int __spi_queued_transfer(struct spi_device *spi, 2139 struct spi_message *msg, 2140 bool need_pump) 2141 { 2142 struct spi_controller *ctlr = spi->controller; 2143 unsigned long flags; 2144 2145 spin_lock_irqsave(&ctlr->queue_lock, flags); 2146 2147 if (!ctlr->running) { 2148 spin_unlock_irqrestore(&ctlr->queue_lock, flags); 2149 return -ESHUTDOWN; 2150 } 2151 msg->actual_length = 0; 2152 msg->status = -EINPROGRESS; 2153 2154 list_add_tail(&msg->queue, &ctlr->queue); 2155 ctlr->queue_empty = false; 2156 if (!ctlr->busy && need_pump) 2157 kthread_queue_work(ctlr->kworker, &ctlr->pump_messages); 2158 2159 spin_unlock_irqrestore(&ctlr->queue_lock, flags); 2160 return 0; 2161 } 2162 2163 /** 2164 * spi_queued_transfer - transfer function for queued transfers 2165 * @spi: spi device which is requesting transfer 2166 * @msg: spi message which is to handled is queued to driver queue 2167 * 2168 * Return: zero on success, else a negative error code. 2169 */ 2170 static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg) 2171 { 2172 return __spi_queued_transfer(spi, msg, true); 2173 } 2174 2175 static int spi_controller_initialize_queue(struct spi_controller *ctlr) 2176 { 2177 int ret; 2178 2179 ctlr->transfer = spi_queued_transfer; 2180 if (!ctlr->transfer_one_message) 2181 ctlr->transfer_one_message = spi_transfer_one_message; 2182 2183 /* Initialize and start queue */ 2184 ret = spi_init_queue(ctlr); 2185 if (ret) { 2186 dev_err(&ctlr->dev, "problem initializing queue\n"); 2187 goto err_init_queue; 2188 } 2189 ctlr->queued = true; 2190 ret = spi_start_queue(ctlr); 2191 if (ret) { 2192 dev_err(&ctlr->dev, "problem starting queue\n"); 2193 goto err_start_queue; 2194 } 2195 2196 return 0; 2197 2198 err_start_queue: 2199 spi_destroy_queue(ctlr); 2200 err_init_queue: 2201 return ret; 2202 } 2203 2204 /** 2205 * spi_flush_queue - Send all pending messages in the queue from the callers' 2206 * context 2207 * @ctlr: controller to process queue for 2208 * 2209 * This should be used when one wants to ensure all pending messages have been 2210 * sent before doing something. Is used by the spi-mem code to make sure SPI 2211 * memory operations do not preempt regular SPI transfers that have been queued 2212 * before the spi-mem operation. 2213 */ 2214 void spi_flush_queue(struct spi_controller *ctlr) 2215 { 2216 if (ctlr->transfer == spi_queued_transfer) 2217 __spi_pump_messages(ctlr, false); 2218 } 2219 2220 /*-------------------------------------------------------------------------*/ 2221 2222 #if defined(CONFIG_OF) 2223 static void of_spi_parse_dt_cs_delay(struct device_node *nc, 2224 struct spi_delay *delay, const char *prop) 2225 { 2226 u32 value; 2227 2228 if (!of_property_read_u32(nc, prop, &value)) { 2229 if (value > U16_MAX) { 2230 delay->value = DIV_ROUND_UP(value, 1000); 2231 delay->unit = SPI_DELAY_UNIT_USECS; 2232 } else { 2233 delay->value = value; 2234 delay->unit = SPI_DELAY_UNIT_NSECS; 2235 } 2236 } 2237 } 2238 2239 static int of_spi_parse_dt(struct spi_controller *ctlr, struct spi_device *spi, 2240 struct device_node *nc) 2241 { 2242 u32 value; 2243 int rc; 2244 2245 /* Mode (clock phase/polarity/etc.) */ 2246 if (of_property_read_bool(nc, "spi-cpha")) 2247 spi->mode |= SPI_CPHA; 2248 if (of_property_read_bool(nc, "spi-cpol")) 2249 spi->mode |= SPI_CPOL; 2250 if (of_property_read_bool(nc, "spi-3wire")) 2251 spi->mode |= SPI_3WIRE; 2252 if (of_property_read_bool(nc, "spi-lsb-first")) 2253 spi->mode |= SPI_LSB_FIRST; 2254 if (of_property_read_bool(nc, "spi-cs-high")) 2255 spi->mode |= SPI_CS_HIGH; 2256 2257 /* Device DUAL/QUAD mode */ 2258 if (!of_property_read_u32(nc, "spi-tx-bus-width", &value)) { 2259 switch (value) { 2260 case 0: 2261 spi->mode |= SPI_NO_TX; 2262 break; 2263 case 1: 2264 break; 2265 case 2: 2266 spi->mode |= SPI_TX_DUAL; 2267 break; 2268 case 4: 2269 spi->mode |= SPI_TX_QUAD; 2270 break; 2271 case 8: 2272 spi->mode |= SPI_TX_OCTAL; 2273 break; 2274 default: 2275 dev_warn(&ctlr->dev, 2276 "spi-tx-bus-width %d not supported\n", 2277 value); 2278 break; 2279 } 2280 } 2281 2282 if (!of_property_read_u32(nc, "spi-rx-bus-width", &value)) { 2283 switch (value) { 2284 case 0: 2285 spi->mode |= SPI_NO_RX; 2286 break; 2287 case 1: 2288 break; 2289 case 2: 2290 spi->mode |= SPI_RX_DUAL; 2291 break; 2292 case 4: 2293 spi->mode |= SPI_RX_QUAD; 2294 break; 2295 case 8: 2296 spi->mode |= SPI_RX_OCTAL; 2297 break; 2298 default: 2299 dev_warn(&ctlr->dev, 2300 "spi-rx-bus-width %d not supported\n", 2301 value); 2302 break; 2303 } 2304 } 2305 2306 if (spi_controller_is_slave(ctlr)) { 2307 if (!of_node_name_eq(nc, "slave")) { 2308 dev_err(&ctlr->dev, "%pOF is not called 'slave'\n", 2309 nc); 2310 return -EINVAL; 2311 } 2312 return 0; 2313 } 2314 2315 /* Device address */ 2316 rc = of_property_read_u32(nc, "reg", &value); 2317 if (rc) { 2318 dev_err(&ctlr->dev, "%pOF has no valid 'reg' property (%d)\n", 2319 nc, rc); 2320 return rc; 2321 } 2322 spi->chip_select = value; 2323 2324 /* Device speed */ 2325 if (!of_property_read_u32(nc, "spi-max-frequency", &value)) 2326 spi->max_speed_hz = value; 2327 2328 /* Device CS delays */ 2329 of_spi_parse_dt_cs_delay(nc, &spi->cs_setup, "spi-cs-setup-delay-ns"); 2330 2331 return 0; 2332 } 2333 2334 static struct spi_device * 2335 of_register_spi_device(struct spi_controller *ctlr, struct device_node *nc) 2336 { 2337 struct spi_device *spi; 2338 int rc; 2339 2340 /* Alloc an spi_device */ 2341 spi = spi_alloc_device(ctlr); 2342 if (!spi) { 2343 dev_err(&ctlr->dev, "spi_device alloc error for %pOF\n", nc); 2344 rc = -ENOMEM; 2345 goto err_out; 2346 } 2347 2348 /* Select device driver */ 2349 rc = of_modalias_node(nc, spi->modalias, 2350 sizeof(spi->modalias)); 2351 if (rc < 0) { 2352 dev_err(&ctlr->dev, "cannot find modalias for %pOF\n", nc); 2353 goto err_out; 2354 } 2355 2356 rc = of_spi_parse_dt(ctlr, spi, nc); 2357 if (rc) 2358 goto err_out; 2359 2360 /* Store a pointer to the node in the device structure */ 2361 of_node_get(nc); 2362 spi->dev.of_node = nc; 2363 spi->dev.fwnode = of_fwnode_handle(nc); 2364 2365 /* Register the new device */ 2366 rc = spi_add_device(spi); 2367 if (rc) { 2368 dev_err(&ctlr->dev, "spi_device register error %pOF\n", nc); 2369 goto err_of_node_put; 2370 } 2371 2372 return spi; 2373 2374 err_of_node_put: 2375 of_node_put(nc); 2376 err_out: 2377 spi_dev_put(spi); 2378 return ERR_PTR(rc); 2379 } 2380 2381 /** 2382 * of_register_spi_devices() - Register child devices onto the SPI bus 2383 * @ctlr: Pointer to spi_controller device 2384 * 2385 * Registers an spi_device for each child node of controller node which 2386 * represents a valid SPI slave. 2387 */ 2388 static void of_register_spi_devices(struct spi_controller *ctlr) 2389 { 2390 struct spi_device *spi; 2391 struct device_node *nc; 2392 2393 if (!ctlr->dev.of_node) 2394 return; 2395 2396 for_each_available_child_of_node(ctlr->dev.of_node, nc) { 2397 if (of_node_test_and_set_flag(nc, OF_POPULATED)) 2398 continue; 2399 spi = of_register_spi_device(ctlr, nc); 2400 if (IS_ERR(spi)) { 2401 dev_warn(&ctlr->dev, 2402 "Failed to create SPI device for %pOF\n", nc); 2403 of_node_clear_flag(nc, OF_POPULATED); 2404 } 2405 } 2406 } 2407 #else 2408 static void of_register_spi_devices(struct spi_controller *ctlr) { } 2409 #endif 2410 2411 /** 2412 * spi_new_ancillary_device() - Register ancillary SPI device 2413 * @spi: Pointer to the main SPI device registering the ancillary device 2414 * @chip_select: Chip Select of the ancillary device 2415 * 2416 * Register an ancillary SPI device; for example some chips have a chip-select 2417 * for normal device usage and another one for setup/firmware upload. 2418 * 2419 * This may only be called from main SPI device's probe routine. 2420 * 2421 * Return: 0 on success; negative errno on failure 2422 */ 2423 struct spi_device *spi_new_ancillary_device(struct spi_device *spi, 2424 u8 chip_select) 2425 { 2426 struct spi_device *ancillary; 2427 int rc = 0; 2428 2429 /* Alloc an spi_device */ 2430 ancillary = spi_alloc_device(spi->controller); 2431 if (!ancillary) { 2432 rc = -ENOMEM; 2433 goto err_out; 2434 } 2435 2436 strscpy(ancillary->modalias, "dummy", sizeof(ancillary->modalias)); 2437 2438 /* Use provided chip-select for ancillary device */ 2439 ancillary->chip_select = chip_select; 2440 2441 /* Take over SPI mode/speed from SPI main device */ 2442 ancillary->max_speed_hz = spi->max_speed_hz; 2443 ancillary->mode = spi->mode; 2444 2445 /* Register the new device */ 2446 rc = spi_add_device_locked(ancillary); 2447 if (rc) { 2448 dev_err(&spi->dev, "failed to register ancillary device\n"); 2449 goto err_out; 2450 } 2451 2452 return ancillary; 2453 2454 err_out: 2455 spi_dev_put(ancillary); 2456 return ERR_PTR(rc); 2457 } 2458 EXPORT_SYMBOL_GPL(spi_new_ancillary_device); 2459 2460 #ifdef CONFIG_ACPI 2461 struct acpi_spi_lookup { 2462 struct spi_controller *ctlr; 2463 u32 max_speed_hz; 2464 u32 mode; 2465 int irq; 2466 u8 bits_per_word; 2467 u8 chip_select; 2468 int n; 2469 int index; 2470 }; 2471 2472 static int acpi_spi_count(struct acpi_resource *ares, void *data) 2473 { 2474 struct acpi_resource_spi_serialbus *sb; 2475 int *count = data; 2476 2477 if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) 2478 return 1; 2479 2480 sb = &ares->data.spi_serial_bus; 2481 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_SPI) 2482 return 1; 2483 2484 *count = *count + 1; 2485 2486 return 1; 2487 } 2488 2489 /** 2490 * acpi_spi_count_resources - Count the number of SpiSerialBus resources 2491 * @adev: ACPI device 2492 * 2493 * Returns the number of SpiSerialBus resources in the ACPI-device's 2494 * resource-list; or a negative error code. 2495 */ 2496 int acpi_spi_count_resources(struct acpi_device *adev) 2497 { 2498 LIST_HEAD(r); 2499 int count = 0; 2500 int ret; 2501 2502 ret = acpi_dev_get_resources(adev, &r, acpi_spi_count, &count); 2503 if (ret < 0) 2504 return ret; 2505 2506 acpi_dev_free_resource_list(&r); 2507 2508 return count; 2509 } 2510 EXPORT_SYMBOL_GPL(acpi_spi_count_resources); 2511 2512 static void acpi_spi_parse_apple_properties(struct acpi_device *dev, 2513 struct acpi_spi_lookup *lookup) 2514 { 2515 const union acpi_object *obj; 2516 2517 if (!x86_apple_machine) 2518 return; 2519 2520 if (!acpi_dev_get_property(dev, "spiSclkPeriod", ACPI_TYPE_BUFFER, &obj) 2521 && obj->buffer.length >= 4) 2522 lookup->max_speed_hz = NSEC_PER_SEC / *(u32 *)obj->buffer.pointer; 2523 2524 if (!acpi_dev_get_property(dev, "spiWordSize", ACPI_TYPE_BUFFER, &obj) 2525 && obj->buffer.length == 8) 2526 lookup->bits_per_word = *(u64 *)obj->buffer.pointer; 2527 2528 if (!acpi_dev_get_property(dev, "spiBitOrder", ACPI_TYPE_BUFFER, &obj) 2529 && obj->buffer.length == 8 && !*(u64 *)obj->buffer.pointer) 2530 lookup->mode |= SPI_LSB_FIRST; 2531 2532 if (!acpi_dev_get_property(dev, "spiSPO", ACPI_TYPE_BUFFER, &obj) 2533 && obj->buffer.length == 8 && *(u64 *)obj->buffer.pointer) 2534 lookup->mode |= SPI_CPOL; 2535 2536 if (!acpi_dev_get_property(dev, "spiSPH", ACPI_TYPE_BUFFER, &obj) 2537 && obj->buffer.length == 8 && *(u64 *)obj->buffer.pointer) 2538 lookup->mode |= SPI_CPHA; 2539 } 2540 2541 static struct spi_controller *acpi_spi_find_controller_by_adev(struct acpi_device *adev); 2542 2543 static int acpi_spi_add_resource(struct acpi_resource *ares, void *data) 2544 { 2545 struct acpi_spi_lookup *lookup = data; 2546 struct spi_controller *ctlr = lookup->ctlr; 2547 2548 if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) { 2549 struct acpi_resource_spi_serialbus *sb; 2550 acpi_handle parent_handle; 2551 acpi_status status; 2552 2553 sb = &ares->data.spi_serial_bus; 2554 if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_SPI) { 2555 2556 if (lookup->index != -1 && lookup->n++ != lookup->index) 2557 return 1; 2558 2559 status = acpi_get_handle(NULL, 2560 sb->resource_source.string_ptr, 2561 &parent_handle); 2562 2563 if (ACPI_FAILURE(status)) 2564 return -ENODEV; 2565 2566 if (ctlr) { 2567 if (ACPI_HANDLE(ctlr->dev.parent) != parent_handle) 2568 return -ENODEV; 2569 } else { 2570 struct acpi_device *adev; 2571 2572 adev = acpi_fetch_acpi_dev(parent_handle); 2573 if (!adev) 2574 return -ENODEV; 2575 2576 ctlr = acpi_spi_find_controller_by_adev(adev); 2577 if (!ctlr) 2578 return -EPROBE_DEFER; 2579 2580 lookup->ctlr = ctlr; 2581 } 2582 2583 /* 2584 * ACPI DeviceSelection numbering is handled by the 2585 * host controller driver in Windows and can vary 2586 * from driver to driver. In Linux we always expect 2587 * 0 .. max - 1 so we need to ask the driver to 2588 * translate between the two schemes. 2589 */ 2590 if (ctlr->fw_translate_cs) { 2591 int cs = ctlr->fw_translate_cs(ctlr, 2592 sb->device_selection); 2593 if (cs < 0) 2594 return cs; 2595 lookup->chip_select = cs; 2596 } else { 2597 lookup->chip_select = sb->device_selection; 2598 } 2599 2600 lookup->max_speed_hz = sb->connection_speed; 2601 lookup->bits_per_word = sb->data_bit_length; 2602 2603 if (sb->clock_phase == ACPI_SPI_SECOND_PHASE) 2604 lookup->mode |= SPI_CPHA; 2605 if (sb->clock_polarity == ACPI_SPI_START_HIGH) 2606 lookup->mode |= SPI_CPOL; 2607 if (sb->device_polarity == ACPI_SPI_ACTIVE_HIGH) 2608 lookup->mode |= SPI_CS_HIGH; 2609 } 2610 } else if (lookup->irq < 0) { 2611 struct resource r; 2612 2613 if (acpi_dev_resource_interrupt(ares, 0, &r)) 2614 lookup->irq = r.start; 2615 } 2616 2617 /* Always tell the ACPI core to skip this resource */ 2618 return 1; 2619 } 2620 2621 /** 2622 * acpi_spi_device_alloc - Allocate a spi device, and fill it in with ACPI information 2623 * @ctlr: controller to which the spi device belongs 2624 * @adev: ACPI Device for the spi device 2625 * @index: Index of the spi resource inside the ACPI Node 2626 * 2627 * This should be used to allocate a new spi device from and ACPI Node. 2628 * The caller is responsible for calling spi_add_device to register the spi device. 2629 * 2630 * If ctlr is set to NULL, the Controller for the spi device will be looked up 2631 * using the resource. 2632 * If index is set to -1, index is not used. 2633 * Note: If index is -1, ctlr must be set. 2634 * 2635 * Return: a pointer to the new device, or ERR_PTR on error. 2636 */ 2637 struct spi_device *acpi_spi_device_alloc(struct spi_controller *ctlr, 2638 struct acpi_device *adev, 2639 int index) 2640 { 2641 acpi_handle parent_handle = NULL; 2642 struct list_head resource_list; 2643 struct acpi_spi_lookup lookup = {}; 2644 struct spi_device *spi; 2645 int ret; 2646 2647 if (!ctlr && index == -1) 2648 return ERR_PTR(-EINVAL); 2649 2650 lookup.ctlr = ctlr; 2651 lookup.irq = -1; 2652 lookup.index = index; 2653 lookup.n = 0; 2654 2655 INIT_LIST_HEAD(&resource_list); 2656 ret = acpi_dev_get_resources(adev, &resource_list, 2657 acpi_spi_add_resource, &lookup); 2658 acpi_dev_free_resource_list(&resource_list); 2659 2660 if (ret < 0) 2661 /* Found SPI in _CRS but it points to another controller */ 2662 return ERR_PTR(ret); 2663 2664 if (!lookup.max_speed_hz && 2665 ACPI_SUCCESS(acpi_get_parent(adev->handle, &parent_handle)) && 2666 ACPI_HANDLE(lookup.ctlr->dev.parent) == parent_handle) { 2667 /* Apple does not use _CRS but nested devices for SPI slaves */ 2668 acpi_spi_parse_apple_properties(adev, &lookup); 2669 } 2670 2671 if (!lookup.max_speed_hz) 2672 return ERR_PTR(-ENODEV); 2673 2674 spi = spi_alloc_device(lookup.ctlr); 2675 if (!spi) { 2676 dev_err(&lookup.ctlr->dev, "failed to allocate SPI device for %s\n", 2677 dev_name(&adev->dev)); 2678 return ERR_PTR(-ENOMEM); 2679 } 2680 2681 ACPI_COMPANION_SET(&spi->dev, adev); 2682 spi->max_speed_hz = lookup.max_speed_hz; 2683 spi->mode |= lookup.mode; 2684 spi->irq = lookup.irq; 2685 spi->bits_per_word = lookup.bits_per_word; 2686 spi->chip_select = lookup.chip_select; 2687 2688 return spi; 2689 } 2690 EXPORT_SYMBOL_GPL(acpi_spi_device_alloc); 2691 2692 static acpi_status acpi_register_spi_device(struct spi_controller *ctlr, 2693 struct acpi_device *adev) 2694 { 2695 struct spi_device *spi; 2696 2697 if (acpi_bus_get_status(adev) || !adev->status.present || 2698 acpi_device_enumerated(adev)) 2699 return AE_OK; 2700 2701 spi = acpi_spi_device_alloc(ctlr, adev, -1); 2702 if (IS_ERR(spi)) { 2703 if (PTR_ERR(spi) == -ENOMEM) 2704 return AE_NO_MEMORY; 2705 else 2706 return AE_OK; 2707 } 2708 2709 acpi_set_modalias(adev, acpi_device_hid(adev), spi->modalias, 2710 sizeof(spi->modalias)); 2711 2712 if (spi->irq < 0) 2713 spi->irq = acpi_dev_gpio_irq_get(adev, 0); 2714 2715 acpi_device_set_enumerated(adev); 2716 2717 adev->power.flags.ignore_parent = true; 2718 if (spi_add_device(spi)) { 2719 adev->power.flags.ignore_parent = false; 2720 dev_err(&ctlr->dev, "failed to add SPI device %s from ACPI\n", 2721 dev_name(&adev->dev)); 2722 spi_dev_put(spi); 2723 } 2724 2725 return AE_OK; 2726 } 2727 2728 static acpi_status acpi_spi_add_device(acpi_handle handle, u32 level, 2729 void *data, void **return_value) 2730 { 2731 struct acpi_device *adev = acpi_fetch_acpi_dev(handle); 2732 struct spi_controller *ctlr = data; 2733 2734 if (!adev) 2735 return AE_OK; 2736 2737 return acpi_register_spi_device(ctlr, adev); 2738 } 2739 2740 #define SPI_ACPI_ENUMERATE_MAX_DEPTH 32 2741 2742 static void acpi_register_spi_devices(struct spi_controller *ctlr) 2743 { 2744 acpi_status status; 2745 acpi_handle handle; 2746 2747 handle = ACPI_HANDLE(ctlr->dev.parent); 2748 if (!handle) 2749 return; 2750 2751 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 2752 SPI_ACPI_ENUMERATE_MAX_DEPTH, 2753 acpi_spi_add_device, NULL, ctlr, NULL); 2754 if (ACPI_FAILURE(status)) 2755 dev_warn(&ctlr->dev, "failed to enumerate SPI slaves\n"); 2756 } 2757 #else 2758 static inline void acpi_register_spi_devices(struct spi_controller *ctlr) {} 2759 #endif /* CONFIG_ACPI */ 2760 2761 static void spi_controller_release(struct device *dev) 2762 { 2763 struct spi_controller *ctlr; 2764 2765 ctlr = container_of(dev, struct spi_controller, dev); 2766 kfree(ctlr); 2767 } 2768 2769 static struct class spi_master_class = { 2770 .name = "spi_master", 2771 .owner = THIS_MODULE, 2772 .dev_release = spi_controller_release, 2773 .dev_groups = spi_master_groups, 2774 }; 2775 2776 #ifdef CONFIG_SPI_SLAVE 2777 /** 2778 * spi_slave_abort - abort the ongoing transfer request on an SPI slave 2779 * controller 2780 * @spi: device used for the current transfer 2781 */ 2782 int spi_slave_abort(struct spi_device *spi) 2783 { 2784 struct spi_controller *ctlr = spi->controller; 2785 2786 if (spi_controller_is_slave(ctlr) && ctlr->slave_abort) 2787 return ctlr->slave_abort(ctlr); 2788 2789 return -ENOTSUPP; 2790 } 2791 EXPORT_SYMBOL_GPL(spi_slave_abort); 2792 2793 int spi_target_abort(struct spi_device *spi) 2794 { 2795 struct spi_controller *ctlr = spi->controller; 2796 2797 if (spi_controller_is_target(ctlr) && ctlr->target_abort) 2798 return ctlr->target_abort(ctlr); 2799 2800 return -ENOTSUPP; 2801 } 2802 EXPORT_SYMBOL_GPL(spi_target_abort); 2803 2804 static ssize_t slave_show(struct device *dev, struct device_attribute *attr, 2805 char *buf) 2806 { 2807 struct spi_controller *ctlr = container_of(dev, struct spi_controller, 2808 dev); 2809 struct device *child; 2810 2811 child = device_find_any_child(&ctlr->dev); 2812 return sprintf(buf, "%s\n", 2813 child ? to_spi_device(child)->modalias : NULL); 2814 } 2815 2816 static ssize_t slave_store(struct device *dev, struct device_attribute *attr, 2817 const char *buf, size_t count) 2818 { 2819 struct spi_controller *ctlr = container_of(dev, struct spi_controller, 2820 dev); 2821 struct spi_device *spi; 2822 struct device *child; 2823 char name[32]; 2824 int rc; 2825 2826 rc = sscanf(buf, "%31s", name); 2827 if (rc != 1 || !name[0]) 2828 return -EINVAL; 2829 2830 child = device_find_any_child(&ctlr->dev); 2831 if (child) { 2832 /* Remove registered slave */ 2833 device_unregister(child); 2834 put_device(child); 2835 } 2836 2837 if (strcmp(name, "(null)")) { 2838 /* Register new slave */ 2839 spi = spi_alloc_device(ctlr); 2840 if (!spi) 2841 return -ENOMEM; 2842 2843 strscpy(spi->modalias, name, sizeof(spi->modalias)); 2844 2845 rc = spi_add_device(spi); 2846 if (rc) { 2847 spi_dev_put(spi); 2848 return rc; 2849 } 2850 } 2851 2852 return count; 2853 } 2854 2855 static DEVICE_ATTR_RW(slave); 2856 2857 static struct attribute *spi_slave_attrs[] = { 2858 &dev_attr_slave.attr, 2859 NULL, 2860 }; 2861 2862 static const struct attribute_group spi_slave_group = { 2863 .attrs = spi_slave_attrs, 2864 }; 2865 2866 static const struct attribute_group *spi_slave_groups[] = { 2867 &spi_controller_statistics_group, 2868 &spi_slave_group, 2869 NULL, 2870 }; 2871 2872 static struct class spi_slave_class = { 2873 .name = "spi_slave", 2874 .owner = THIS_MODULE, 2875 .dev_release = spi_controller_release, 2876 .dev_groups = spi_slave_groups, 2877 }; 2878 #else 2879 extern struct class spi_slave_class; /* dummy */ 2880 #endif 2881 2882 /** 2883 * __spi_alloc_controller - allocate an SPI master or slave controller 2884 * @dev: the controller, possibly using the platform_bus 2885 * @size: how much zeroed driver-private data to allocate; the pointer to this 2886 * memory is in the driver_data field of the returned device, accessible 2887 * with spi_controller_get_devdata(); the memory is cacheline aligned; 2888 * drivers granting DMA access to portions of their private data need to 2889 * round up @size using ALIGN(size, dma_get_cache_alignment()). 2890 * @slave: flag indicating whether to allocate an SPI master (false) or SPI 2891 * slave (true) controller 2892 * Context: can sleep 2893 * 2894 * This call is used only by SPI controller drivers, which are the 2895 * only ones directly touching chip registers. It's how they allocate 2896 * an spi_controller structure, prior to calling spi_register_controller(). 2897 * 2898 * This must be called from context that can sleep. 2899 * 2900 * The caller is responsible for assigning the bus number and initializing the 2901 * controller's methods before calling spi_register_controller(); and (after 2902 * errors adding the device) calling spi_controller_put() to prevent a memory 2903 * leak. 2904 * 2905 * Return: the SPI controller structure on success, else NULL. 2906 */ 2907 struct spi_controller *__spi_alloc_controller(struct device *dev, 2908 unsigned int size, bool slave) 2909 { 2910 struct spi_controller *ctlr; 2911 size_t ctlr_size = ALIGN(sizeof(*ctlr), dma_get_cache_alignment()); 2912 2913 if (!dev) 2914 return NULL; 2915 2916 ctlr = kzalloc(size + ctlr_size, GFP_KERNEL); 2917 if (!ctlr) 2918 return NULL; 2919 2920 device_initialize(&ctlr->dev); 2921 INIT_LIST_HEAD(&ctlr->queue); 2922 spin_lock_init(&ctlr->queue_lock); 2923 spin_lock_init(&ctlr->bus_lock_spinlock); 2924 mutex_init(&ctlr->bus_lock_mutex); 2925 mutex_init(&ctlr->io_mutex); 2926 mutex_init(&ctlr->add_lock); 2927 ctlr->bus_num = -1; 2928 ctlr->num_chipselect = 1; 2929 ctlr->slave = slave; 2930 if (IS_ENABLED(CONFIG_SPI_SLAVE) && slave) 2931 ctlr->dev.class = &spi_slave_class; 2932 else 2933 ctlr->dev.class = &spi_master_class; 2934 ctlr->dev.parent = dev; 2935 pm_suspend_ignore_children(&ctlr->dev, true); 2936 spi_controller_set_devdata(ctlr, (void *)ctlr + ctlr_size); 2937 2938 return ctlr; 2939 } 2940 EXPORT_SYMBOL_GPL(__spi_alloc_controller); 2941 2942 static void devm_spi_release_controller(struct device *dev, void *ctlr) 2943 { 2944 spi_controller_put(*(struct spi_controller **)ctlr); 2945 } 2946 2947 /** 2948 * __devm_spi_alloc_controller - resource-managed __spi_alloc_controller() 2949 * @dev: physical device of SPI controller 2950 * @size: how much zeroed driver-private data to allocate 2951 * @slave: whether to allocate an SPI master (false) or SPI slave (true) 2952 * Context: can sleep 2953 * 2954 * Allocate an SPI controller and automatically release a reference on it 2955 * when @dev is unbound from its driver. Drivers are thus relieved from 2956 * having to call spi_controller_put(). 2957 * 2958 * The arguments to this function are identical to __spi_alloc_controller(). 2959 * 2960 * Return: the SPI controller structure on success, else NULL. 2961 */ 2962 struct spi_controller *__devm_spi_alloc_controller(struct device *dev, 2963 unsigned int size, 2964 bool slave) 2965 { 2966 struct spi_controller **ptr, *ctlr; 2967 2968 ptr = devres_alloc(devm_spi_release_controller, sizeof(*ptr), 2969 GFP_KERNEL); 2970 if (!ptr) 2971 return NULL; 2972 2973 ctlr = __spi_alloc_controller(dev, size, slave); 2974 if (ctlr) { 2975 ctlr->devm_allocated = true; 2976 *ptr = ctlr; 2977 devres_add(dev, ptr); 2978 } else { 2979 devres_free(ptr); 2980 } 2981 2982 return ctlr; 2983 } 2984 EXPORT_SYMBOL_GPL(__devm_spi_alloc_controller); 2985 2986 /** 2987 * spi_get_gpio_descs() - grab chip select GPIOs for the master 2988 * @ctlr: The SPI master to grab GPIO descriptors for 2989 */ 2990 static int spi_get_gpio_descs(struct spi_controller *ctlr) 2991 { 2992 int nb, i; 2993 struct gpio_desc **cs; 2994 struct device *dev = &ctlr->dev; 2995 unsigned long native_cs_mask = 0; 2996 unsigned int num_cs_gpios = 0; 2997 2998 nb = gpiod_count(dev, "cs"); 2999 if (nb < 0) { 3000 /* No GPIOs at all is fine, else return the error */ 3001 if (nb == -ENOENT) 3002 return 0; 3003 return nb; 3004 } 3005 3006 ctlr->num_chipselect = max_t(int, nb, ctlr->num_chipselect); 3007 3008 cs = devm_kcalloc(dev, ctlr->num_chipselect, sizeof(*cs), 3009 GFP_KERNEL); 3010 if (!cs) 3011 return -ENOMEM; 3012 ctlr->cs_gpiods = cs; 3013 3014 for (i = 0; i < nb; i++) { 3015 /* 3016 * Most chipselects are active low, the inverted 3017 * semantics are handled by special quirks in gpiolib, 3018 * so initializing them GPIOD_OUT_LOW here means 3019 * "unasserted", in most cases this will drive the physical 3020 * line high. 3021 */ 3022 cs[i] = devm_gpiod_get_index_optional(dev, "cs", i, 3023 GPIOD_OUT_LOW); 3024 if (IS_ERR(cs[i])) 3025 return PTR_ERR(cs[i]); 3026 3027 if (cs[i]) { 3028 /* 3029 * If we find a CS GPIO, name it after the device and 3030 * chip select line. 3031 */ 3032 char *gpioname; 3033 3034 gpioname = devm_kasprintf(dev, GFP_KERNEL, "%s CS%d", 3035 dev_name(dev), i); 3036 if (!gpioname) 3037 return -ENOMEM; 3038 gpiod_set_consumer_name(cs[i], gpioname); 3039 num_cs_gpios++; 3040 continue; 3041 } 3042 3043 if (ctlr->max_native_cs && i >= ctlr->max_native_cs) { 3044 dev_err(dev, "Invalid native chip select %d\n", i); 3045 return -EINVAL; 3046 } 3047 native_cs_mask |= BIT(i); 3048 } 3049 3050 ctlr->unused_native_cs = ffs(~native_cs_mask) - 1; 3051 3052 if ((ctlr->flags & SPI_MASTER_GPIO_SS) && num_cs_gpios && 3053 ctlr->max_native_cs && ctlr->unused_native_cs >= ctlr->max_native_cs) { 3054 dev_err(dev, "No unused native chip select available\n"); 3055 return -EINVAL; 3056 } 3057 3058 return 0; 3059 } 3060 3061 static int spi_controller_check_ops(struct spi_controller *ctlr) 3062 { 3063 /* 3064 * The controller may implement only the high-level SPI-memory like 3065 * operations if it does not support regular SPI transfers, and this is 3066 * valid use case. 3067 * If ->mem_ops is NULL, we request that at least one of the 3068 * ->transfer_xxx() method be implemented. 3069 */ 3070 if (ctlr->mem_ops) { 3071 if (!ctlr->mem_ops->exec_op) 3072 return -EINVAL; 3073 } else if (!ctlr->transfer && !ctlr->transfer_one && 3074 !ctlr->transfer_one_message) { 3075 return -EINVAL; 3076 } 3077 3078 return 0; 3079 } 3080 3081 /** 3082 * spi_register_controller - register SPI master or slave controller 3083 * @ctlr: initialized master, originally from spi_alloc_master() or 3084 * spi_alloc_slave() 3085 * Context: can sleep 3086 * 3087 * SPI controllers connect to their drivers using some non-SPI bus, 3088 * such as the platform bus. The final stage of probe() in that code 3089 * includes calling spi_register_controller() to hook up to this SPI bus glue. 3090 * 3091 * SPI controllers use board specific (often SOC specific) bus numbers, 3092 * and board-specific addressing for SPI devices combines those numbers 3093 * with chip select numbers. Since SPI does not directly support dynamic 3094 * device identification, boards need configuration tables telling which 3095 * chip is at which address. 3096 * 3097 * This must be called from context that can sleep. It returns zero on 3098 * success, else a negative error code (dropping the controller's refcount). 3099 * After a successful return, the caller is responsible for calling 3100 * spi_unregister_controller(). 3101 * 3102 * Return: zero on success, else a negative error code. 3103 */ 3104 int spi_register_controller(struct spi_controller *ctlr) 3105 { 3106 struct device *dev = ctlr->dev.parent; 3107 struct boardinfo *bi; 3108 int status; 3109 int id, first_dynamic; 3110 3111 if (!dev) 3112 return -ENODEV; 3113 3114 /* 3115 * Make sure all necessary hooks are implemented before registering 3116 * the SPI controller. 3117 */ 3118 status = spi_controller_check_ops(ctlr); 3119 if (status) 3120 return status; 3121 3122 if (ctlr->bus_num >= 0) { 3123 /* Devices with a fixed bus num must check-in with the num */ 3124 mutex_lock(&board_lock); 3125 id = idr_alloc(&spi_master_idr, ctlr, ctlr->bus_num, 3126 ctlr->bus_num + 1, GFP_KERNEL); 3127 mutex_unlock(&board_lock); 3128 if (WARN(id < 0, "couldn't get idr")) 3129 return id == -ENOSPC ? -EBUSY : id; 3130 ctlr->bus_num = id; 3131 } else if (ctlr->dev.of_node) { 3132 /* Allocate dynamic bus number using Linux idr */ 3133 id = of_alias_get_id(ctlr->dev.of_node, "spi"); 3134 if (id >= 0) { 3135 ctlr->bus_num = id; 3136 mutex_lock(&board_lock); 3137 id = idr_alloc(&spi_master_idr, ctlr, ctlr->bus_num, 3138 ctlr->bus_num + 1, GFP_KERNEL); 3139 mutex_unlock(&board_lock); 3140 if (WARN(id < 0, "couldn't get idr")) 3141 return id == -ENOSPC ? -EBUSY : id; 3142 } 3143 } 3144 if (ctlr->bus_num < 0) { 3145 first_dynamic = of_alias_get_highest_id("spi"); 3146 if (first_dynamic < 0) 3147 first_dynamic = 0; 3148 else 3149 first_dynamic++; 3150 3151 mutex_lock(&board_lock); 3152 id = idr_alloc(&spi_master_idr, ctlr, first_dynamic, 3153 0, GFP_KERNEL); 3154 mutex_unlock(&board_lock); 3155 if (WARN(id < 0, "couldn't get idr")) 3156 return id; 3157 ctlr->bus_num = id; 3158 } 3159 ctlr->bus_lock_flag = 0; 3160 init_completion(&ctlr->xfer_completion); 3161 init_completion(&ctlr->cur_msg_completion); 3162 if (!ctlr->max_dma_len) 3163 ctlr->max_dma_len = INT_MAX; 3164 3165 /* 3166 * Register the device, then userspace will see it. 3167 * Registration fails if the bus ID is in use. 3168 */ 3169 dev_set_name(&ctlr->dev, "spi%u", ctlr->bus_num); 3170 3171 if (!spi_controller_is_slave(ctlr) && ctlr->use_gpio_descriptors) { 3172 status = spi_get_gpio_descs(ctlr); 3173 if (status) 3174 goto free_bus_id; 3175 /* 3176 * A controller using GPIO descriptors always 3177 * supports SPI_CS_HIGH if need be. 3178 */ 3179 ctlr->mode_bits |= SPI_CS_HIGH; 3180 } 3181 3182 /* 3183 * Even if it's just one always-selected device, there must 3184 * be at least one chipselect. 3185 */ 3186 if (!ctlr->num_chipselect) { 3187 status = -EINVAL; 3188 goto free_bus_id; 3189 } 3190 3191 /* Setting last_cs to -1 means no chip selected */ 3192 ctlr->last_cs = -1; 3193 3194 status = device_add(&ctlr->dev); 3195 if (status < 0) 3196 goto free_bus_id; 3197 dev_dbg(dev, "registered %s %s\n", 3198 spi_controller_is_slave(ctlr) ? "slave" : "master", 3199 dev_name(&ctlr->dev)); 3200 3201 /* 3202 * If we're using a queued driver, start the queue. Note that we don't 3203 * need the queueing logic if the driver is only supporting high-level 3204 * memory operations. 3205 */ 3206 if (ctlr->transfer) { 3207 dev_info(dev, "controller is unqueued, this is deprecated\n"); 3208 } else if (ctlr->transfer_one || ctlr->transfer_one_message) { 3209 status = spi_controller_initialize_queue(ctlr); 3210 if (status) { 3211 device_del(&ctlr->dev); 3212 goto free_bus_id; 3213 } 3214 } 3215 /* Add statistics */ 3216 ctlr->pcpu_statistics = spi_alloc_pcpu_stats(dev); 3217 if (!ctlr->pcpu_statistics) { 3218 dev_err(dev, "Error allocating per-cpu statistics\n"); 3219 status = -ENOMEM; 3220 goto destroy_queue; 3221 } 3222 3223 mutex_lock(&board_lock); 3224 list_add_tail(&ctlr->list, &spi_controller_list); 3225 list_for_each_entry(bi, &board_list, list) 3226 spi_match_controller_to_boardinfo(ctlr, &bi->board_info); 3227 mutex_unlock(&board_lock); 3228 3229 /* Register devices from the device tree and ACPI */ 3230 of_register_spi_devices(ctlr); 3231 acpi_register_spi_devices(ctlr); 3232 return status; 3233 3234 destroy_queue: 3235 spi_destroy_queue(ctlr); 3236 free_bus_id: 3237 mutex_lock(&board_lock); 3238 idr_remove(&spi_master_idr, ctlr->bus_num); 3239 mutex_unlock(&board_lock); 3240 return status; 3241 } 3242 EXPORT_SYMBOL_GPL(spi_register_controller); 3243 3244 static void devm_spi_unregister(struct device *dev, void *res) 3245 { 3246 spi_unregister_controller(*(struct spi_controller **)res); 3247 } 3248 3249 /** 3250 * devm_spi_register_controller - register managed SPI master or slave 3251 * controller 3252 * @dev: device managing SPI controller 3253 * @ctlr: initialized controller, originally from spi_alloc_master() or 3254 * spi_alloc_slave() 3255 * Context: can sleep 3256 * 3257 * Register a SPI device as with spi_register_controller() which will 3258 * automatically be unregistered and freed. 3259 * 3260 * Return: zero on success, else a negative error code. 3261 */ 3262 int devm_spi_register_controller(struct device *dev, 3263 struct spi_controller *ctlr) 3264 { 3265 struct spi_controller **ptr; 3266 int ret; 3267 3268 ptr = devres_alloc(devm_spi_unregister, sizeof(*ptr), GFP_KERNEL); 3269 if (!ptr) 3270 return -ENOMEM; 3271 3272 ret = spi_register_controller(ctlr); 3273 if (!ret) { 3274 *ptr = ctlr; 3275 devres_add(dev, ptr); 3276 } else { 3277 devres_free(ptr); 3278 } 3279 3280 return ret; 3281 } 3282 EXPORT_SYMBOL_GPL(devm_spi_register_controller); 3283 3284 static int __unregister(struct device *dev, void *null) 3285 { 3286 spi_unregister_device(to_spi_device(dev)); 3287 return 0; 3288 } 3289 3290 /** 3291 * spi_unregister_controller - unregister SPI master or slave controller 3292 * @ctlr: the controller being unregistered 3293 * Context: can sleep 3294 * 3295 * This call is used only by SPI controller drivers, which are the 3296 * only ones directly touching chip registers. 3297 * 3298 * This must be called from context that can sleep. 3299 * 3300 * Note that this function also drops a reference to the controller. 3301 */ 3302 void spi_unregister_controller(struct spi_controller *ctlr) 3303 { 3304 struct spi_controller *found; 3305 int id = ctlr->bus_num; 3306 3307 /* Prevent addition of new devices, unregister existing ones */ 3308 if (IS_ENABLED(CONFIG_SPI_DYNAMIC)) 3309 mutex_lock(&ctlr->add_lock); 3310 3311 device_for_each_child(&ctlr->dev, NULL, __unregister); 3312 3313 /* First make sure that this controller was ever added */ 3314 mutex_lock(&board_lock); 3315 found = idr_find(&spi_master_idr, id); 3316 mutex_unlock(&board_lock); 3317 if (ctlr->queued) { 3318 if (spi_destroy_queue(ctlr)) 3319 dev_err(&ctlr->dev, "queue remove failed\n"); 3320 } 3321 mutex_lock(&board_lock); 3322 list_del(&ctlr->list); 3323 mutex_unlock(&board_lock); 3324 3325 device_del(&ctlr->dev); 3326 3327 /* Free bus id */ 3328 mutex_lock(&board_lock); 3329 if (found == ctlr) 3330 idr_remove(&spi_master_idr, id); 3331 mutex_unlock(&board_lock); 3332 3333 if (IS_ENABLED(CONFIG_SPI_DYNAMIC)) 3334 mutex_unlock(&ctlr->add_lock); 3335 3336 /* Release the last reference on the controller if its driver 3337 * has not yet been converted to devm_spi_alloc_master/slave(). 3338 */ 3339 if (!ctlr->devm_allocated) 3340 put_device(&ctlr->dev); 3341 } 3342 EXPORT_SYMBOL_GPL(spi_unregister_controller); 3343 3344 int spi_controller_suspend(struct spi_controller *ctlr) 3345 { 3346 int ret; 3347 3348 /* Basically no-ops for non-queued controllers */ 3349 if (!ctlr->queued) 3350 return 0; 3351 3352 ret = spi_stop_queue(ctlr); 3353 if (ret) 3354 dev_err(&ctlr->dev, "queue stop failed\n"); 3355 3356 return ret; 3357 } 3358 EXPORT_SYMBOL_GPL(spi_controller_suspend); 3359 3360 int spi_controller_resume(struct spi_controller *ctlr) 3361 { 3362 int ret; 3363 3364 if (!ctlr->queued) 3365 return 0; 3366 3367 ret = spi_start_queue(ctlr); 3368 if (ret) 3369 dev_err(&ctlr->dev, "queue restart failed\n"); 3370 3371 return ret; 3372 } 3373 EXPORT_SYMBOL_GPL(spi_controller_resume); 3374 3375 /*-------------------------------------------------------------------------*/ 3376 3377 /* Core methods for spi_message alterations */ 3378 3379 static void __spi_replace_transfers_release(struct spi_controller *ctlr, 3380 struct spi_message *msg, 3381 void *res) 3382 { 3383 struct spi_replaced_transfers *rxfer = res; 3384 size_t i; 3385 3386 /* Call extra callback if requested */ 3387 if (rxfer->release) 3388 rxfer->release(ctlr, msg, res); 3389 3390 /* Insert replaced transfers back into the message */ 3391 list_splice(&rxfer->replaced_transfers, rxfer->replaced_after); 3392 3393 /* Remove the formerly inserted entries */ 3394 for (i = 0; i < rxfer->inserted; i++) 3395 list_del(&rxfer->inserted_transfers[i].transfer_list); 3396 } 3397 3398 /** 3399 * spi_replace_transfers - replace transfers with several transfers 3400 * and register change with spi_message.resources 3401 * @msg: the spi_message we work upon 3402 * @xfer_first: the first spi_transfer we want to replace 3403 * @remove: number of transfers to remove 3404 * @insert: the number of transfers we want to insert instead 3405 * @release: extra release code necessary in some circumstances 3406 * @extradatasize: extra data to allocate (with alignment guarantees 3407 * of struct @spi_transfer) 3408 * @gfp: gfp flags 3409 * 3410 * Returns: pointer to @spi_replaced_transfers, 3411 * PTR_ERR(...) in case of errors. 3412 */ 3413 static struct spi_replaced_transfers *spi_replace_transfers( 3414 struct spi_message *msg, 3415 struct spi_transfer *xfer_first, 3416 size_t remove, 3417 size_t insert, 3418 spi_replaced_release_t release, 3419 size_t extradatasize, 3420 gfp_t gfp) 3421 { 3422 struct spi_replaced_transfers *rxfer; 3423 struct spi_transfer *xfer; 3424 size_t i; 3425 3426 /* Allocate the structure using spi_res */ 3427 rxfer = spi_res_alloc(msg->spi, __spi_replace_transfers_release, 3428 struct_size(rxfer, inserted_transfers, insert) 3429 + extradatasize, 3430 gfp); 3431 if (!rxfer) 3432 return ERR_PTR(-ENOMEM); 3433 3434 /* The release code to invoke before running the generic release */ 3435 rxfer->release = release; 3436 3437 /* Assign extradata */ 3438 if (extradatasize) 3439 rxfer->extradata = 3440 &rxfer->inserted_transfers[insert]; 3441 3442 /* Init the replaced_transfers list */ 3443 INIT_LIST_HEAD(&rxfer->replaced_transfers); 3444 3445 /* 3446 * Assign the list_entry after which we should reinsert 3447 * the @replaced_transfers - it may be spi_message.messages! 3448 */ 3449 rxfer->replaced_after = xfer_first->transfer_list.prev; 3450 3451 /* Remove the requested number of transfers */ 3452 for (i = 0; i < remove; i++) { 3453 /* 3454 * If the entry after replaced_after it is msg->transfers 3455 * then we have been requested to remove more transfers 3456 * than are in the list. 3457 */ 3458 if (rxfer->replaced_after->next == &msg->transfers) { 3459 dev_err(&msg->spi->dev, 3460 "requested to remove more spi_transfers than are available\n"); 3461 /* Insert replaced transfers back into the message */ 3462 list_splice(&rxfer->replaced_transfers, 3463 rxfer->replaced_after); 3464 3465 /* Free the spi_replace_transfer structure... */ 3466 spi_res_free(rxfer); 3467 3468 /* ...and return with an error */ 3469 return ERR_PTR(-EINVAL); 3470 } 3471 3472 /* 3473 * Remove the entry after replaced_after from list of 3474 * transfers and add it to list of replaced_transfers. 3475 */ 3476 list_move_tail(rxfer->replaced_after->next, 3477 &rxfer->replaced_transfers); 3478 } 3479 3480 /* 3481 * Create copy of the given xfer with identical settings 3482 * based on the first transfer to get removed. 3483 */ 3484 for (i = 0; i < insert; i++) { 3485 /* We need to run in reverse order */ 3486 xfer = &rxfer->inserted_transfers[insert - 1 - i]; 3487 3488 /* Copy all spi_transfer data */ 3489 memcpy(xfer, xfer_first, sizeof(*xfer)); 3490 3491 /* Add to list */ 3492 list_add(&xfer->transfer_list, rxfer->replaced_after); 3493 3494 /* Clear cs_change and delay for all but the last */ 3495 if (i) { 3496 xfer->cs_change = false; 3497 xfer->delay.value = 0; 3498 } 3499 } 3500 3501 /* Set up inserted... */ 3502 rxfer->inserted = insert; 3503 3504 /* ...and register it with spi_res/spi_message */ 3505 spi_res_add(msg, rxfer); 3506 3507 return rxfer; 3508 } 3509 3510 static int __spi_split_transfer_maxsize(struct spi_controller *ctlr, 3511 struct spi_message *msg, 3512 struct spi_transfer **xferp, 3513 size_t maxsize, 3514 gfp_t gfp) 3515 { 3516 struct spi_transfer *xfer = *xferp, *xfers; 3517 struct spi_replaced_transfers *srt; 3518 size_t offset; 3519 size_t count, i; 3520 3521 /* Calculate how many we have to replace */ 3522 count = DIV_ROUND_UP(xfer->len, maxsize); 3523 3524 /* Create replacement */ 3525 srt = spi_replace_transfers(msg, xfer, 1, count, NULL, 0, gfp); 3526 if (IS_ERR(srt)) 3527 return PTR_ERR(srt); 3528 xfers = srt->inserted_transfers; 3529 3530 /* 3531 * Now handle each of those newly inserted spi_transfers. 3532 * Note that the replacements spi_transfers all are preset 3533 * to the same values as *xferp, so tx_buf, rx_buf and len 3534 * are all identical (as well as most others) 3535 * so we just have to fix up len and the pointers. 3536 * 3537 * This also includes support for the depreciated 3538 * spi_message.is_dma_mapped interface. 3539 */ 3540 3541 /* 3542 * The first transfer just needs the length modified, so we 3543 * run it outside the loop. 3544 */ 3545 xfers[0].len = min_t(size_t, maxsize, xfer[0].len); 3546 3547 /* All the others need rx_buf/tx_buf also set */ 3548 for (i = 1, offset = maxsize; i < count; offset += maxsize, i++) { 3549 /* Update rx_buf, tx_buf and dma */ 3550 if (xfers[i].rx_buf) 3551 xfers[i].rx_buf += offset; 3552 if (xfers[i].rx_dma) 3553 xfers[i].rx_dma += offset; 3554 if (xfers[i].tx_buf) 3555 xfers[i].tx_buf += offset; 3556 if (xfers[i].tx_dma) 3557 xfers[i].tx_dma += offset; 3558 3559 /* Update length */ 3560 xfers[i].len = min(maxsize, xfers[i].len - offset); 3561 } 3562 3563 /* 3564 * We set up xferp to the last entry we have inserted, 3565 * so that we skip those already split transfers. 3566 */ 3567 *xferp = &xfers[count - 1]; 3568 3569 /* Increment statistics counters */ 3570 SPI_STATISTICS_INCREMENT_FIELD(ctlr->pcpu_statistics, 3571 transfers_split_maxsize); 3572 SPI_STATISTICS_INCREMENT_FIELD(msg->spi->pcpu_statistics, 3573 transfers_split_maxsize); 3574 3575 return 0; 3576 } 3577 3578 /** 3579 * spi_split_transfers_maxsize - split spi transfers into multiple transfers 3580 * when an individual transfer exceeds a 3581 * certain size 3582 * @ctlr: the @spi_controller for this transfer 3583 * @msg: the @spi_message to transform 3584 * @maxsize: the maximum when to apply this 3585 * @gfp: GFP allocation flags 3586 * 3587 * Return: status of transformation 3588 */ 3589 int spi_split_transfers_maxsize(struct spi_controller *ctlr, 3590 struct spi_message *msg, 3591 size_t maxsize, 3592 gfp_t gfp) 3593 { 3594 struct spi_transfer *xfer; 3595 int ret; 3596 3597 /* 3598 * Iterate over the transfer_list, 3599 * but note that xfer is advanced to the last transfer inserted 3600 * to avoid checking sizes again unnecessarily (also xfer does 3601 * potentially belong to a different list by the time the 3602 * replacement has happened). 3603 */ 3604 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 3605 if (xfer->len > maxsize) { 3606 ret = __spi_split_transfer_maxsize(ctlr, msg, &xfer, 3607 maxsize, gfp); 3608 if (ret) 3609 return ret; 3610 } 3611 } 3612 3613 return 0; 3614 } 3615 EXPORT_SYMBOL_GPL(spi_split_transfers_maxsize); 3616 3617 /*-------------------------------------------------------------------------*/ 3618 3619 /* Core methods for SPI controller protocol drivers. Some of the 3620 * other core methods are currently defined as inline functions. 3621 */ 3622 3623 static int __spi_validate_bits_per_word(struct spi_controller *ctlr, 3624 u8 bits_per_word) 3625 { 3626 if (ctlr->bits_per_word_mask) { 3627 /* Only 32 bits fit in the mask */ 3628 if (bits_per_word > 32) 3629 return -EINVAL; 3630 if (!(ctlr->bits_per_word_mask & SPI_BPW_MASK(bits_per_word))) 3631 return -EINVAL; 3632 } 3633 3634 return 0; 3635 } 3636 3637 /** 3638 * spi_set_cs_timing - configure CS setup, hold, and inactive delays 3639 * @spi: the device that requires specific CS timing configuration 3640 * 3641 * Return: zero on success, else a negative error code. 3642 */ 3643 static int spi_set_cs_timing(struct spi_device *spi) 3644 { 3645 struct device *parent = spi->controller->dev.parent; 3646 int status = 0; 3647 3648 if (spi->controller->set_cs_timing && !spi->cs_gpiod) { 3649 if (spi->controller->auto_runtime_pm) { 3650 status = pm_runtime_get_sync(parent); 3651 if (status < 0) { 3652 pm_runtime_put_noidle(parent); 3653 dev_err(&spi->controller->dev, "Failed to power device: %d\n", 3654 status); 3655 return status; 3656 } 3657 3658 status = spi->controller->set_cs_timing(spi); 3659 pm_runtime_mark_last_busy(parent); 3660 pm_runtime_put_autosuspend(parent); 3661 } else { 3662 status = spi->controller->set_cs_timing(spi); 3663 } 3664 } 3665 return status; 3666 } 3667 3668 /** 3669 * spi_setup - setup SPI mode and clock rate 3670 * @spi: the device whose settings are being modified 3671 * Context: can sleep, and no requests are queued to the device 3672 * 3673 * SPI protocol drivers may need to update the transfer mode if the 3674 * device doesn't work with its default. They may likewise need 3675 * to update clock rates or word sizes from initial values. This function 3676 * changes those settings, and must be called from a context that can sleep. 3677 * Except for SPI_CS_HIGH, which takes effect immediately, the changes take 3678 * effect the next time the device is selected and data is transferred to 3679 * or from it. When this function returns, the spi device is deselected. 3680 * 3681 * Note that this call will fail if the protocol driver specifies an option 3682 * that the underlying controller or its driver does not support. For 3683 * example, not all hardware supports wire transfers using nine bit words, 3684 * LSB-first wire encoding, or active-high chipselects. 3685 * 3686 * Return: zero on success, else a negative error code. 3687 */ 3688 int spi_setup(struct spi_device *spi) 3689 { 3690 unsigned bad_bits, ugly_bits; 3691 int status = 0; 3692 3693 /* 3694 * Check mode to prevent that any two of DUAL, QUAD and NO_MOSI/MISO 3695 * are set at the same time. 3696 */ 3697 if ((hweight_long(spi->mode & 3698 (SPI_TX_DUAL | SPI_TX_QUAD | SPI_NO_TX)) > 1) || 3699 (hweight_long(spi->mode & 3700 (SPI_RX_DUAL | SPI_RX_QUAD | SPI_NO_RX)) > 1)) { 3701 dev_err(&spi->dev, 3702 "setup: can not select any two of dual, quad and no-rx/tx at the same time\n"); 3703 return -EINVAL; 3704 } 3705 /* If it is SPI_3WIRE mode, DUAL and QUAD should be forbidden */ 3706 if ((spi->mode & SPI_3WIRE) && (spi->mode & 3707 (SPI_TX_DUAL | SPI_TX_QUAD | SPI_TX_OCTAL | 3708 SPI_RX_DUAL | SPI_RX_QUAD | SPI_RX_OCTAL))) 3709 return -EINVAL; 3710 /* 3711 * Help drivers fail *cleanly* when they need options 3712 * that aren't supported with their current controller. 3713 * SPI_CS_WORD has a fallback software implementation, 3714 * so it is ignored here. 3715 */ 3716 bad_bits = spi->mode & ~(spi->controller->mode_bits | SPI_CS_WORD | 3717 SPI_NO_TX | SPI_NO_RX); 3718 ugly_bits = bad_bits & 3719 (SPI_TX_DUAL | SPI_TX_QUAD | SPI_TX_OCTAL | 3720 SPI_RX_DUAL | SPI_RX_QUAD | SPI_RX_OCTAL); 3721 if (ugly_bits) { 3722 dev_warn(&spi->dev, 3723 "setup: ignoring unsupported mode bits %x\n", 3724 ugly_bits); 3725 spi->mode &= ~ugly_bits; 3726 bad_bits &= ~ugly_bits; 3727 } 3728 if (bad_bits) { 3729 dev_err(&spi->dev, "setup: unsupported mode bits %x\n", 3730 bad_bits); 3731 return -EINVAL; 3732 } 3733 3734 if (!spi->bits_per_word) { 3735 spi->bits_per_word = 8; 3736 } else { 3737 /* 3738 * Some controllers may not support the default 8 bits-per-word 3739 * so only perform the check when this is explicitly provided. 3740 */ 3741 status = __spi_validate_bits_per_word(spi->controller, 3742 spi->bits_per_word); 3743 if (status) 3744 return status; 3745 } 3746 3747 if (spi->controller->max_speed_hz && 3748 (!spi->max_speed_hz || 3749 spi->max_speed_hz > spi->controller->max_speed_hz)) 3750 spi->max_speed_hz = spi->controller->max_speed_hz; 3751 3752 mutex_lock(&spi->controller->io_mutex); 3753 3754 if (spi->controller->setup) { 3755 status = spi->controller->setup(spi); 3756 if (status) { 3757 mutex_unlock(&spi->controller->io_mutex); 3758 dev_err(&spi->controller->dev, "Failed to setup device: %d\n", 3759 status); 3760 return status; 3761 } 3762 } 3763 3764 status = spi_set_cs_timing(spi); 3765 if (status) { 3766 mutex_unlock(&spi->controller->io_mutex); 3767 return status; 3768 } 3769 3770 if (spi->controller->auto_runtime_pm && spi->controller->set_cs) { 3771 status = pm_runtime_resume_and_get(spi->controller->dev.parent); 3772 if (status < 0) { 3773 mutex_unlock(&spi->controller->io_mutex); 3774 dev_err(&spi->controller->dev, "Failed to power device: %d\n", 3775 status); 3776 return status; 3777 } 3778 3779 /* 3780 * We do not want to return positive value from pm_runtime_get, 3781 * there are many instances of devices calling spi_setup() and 3782 * checking for a non-zero return value instead of a negative 3783 * return value. 3784 */ 3785 status = 0; 3786 3787 spi_set_cs(spi, false, true); 3788 pm_runtime_mark_last_busy(spi->controller->dev.parent); 3789 pm_runtime_put_autosuspend(spi->controller->dev.parent); 3790 } else { 3791 spi_set_cs(spi, false, true); 3792 } 3793 3794 mutex_unlock(&spi->controller->io_mutex); 3795 3796 if (spi->rt && !spi->controller->rt) { 3797 spi->controller->rt = true; 3798 spi_set_thread_rt(spi->controller); 3799 } 3800 3801 trace_spi_setup(spi, status); 3802 3803 dev_dbg(&spi->dev, "setup mode %lu, %s%s%s%s%u bits/w, %u Hz max --> %d\n", 3804 spi->mode & SPI_MODE_X_MASK, 3805 (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "", 3806 (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "", 3807 (spi->mode & SPI_3WIRE) ? "3wire, " : "", 3808 (spi->mode & SPI_LOOP) ? "loopback, " : "", 3809 spi->bits_per_word, spi->max_speed_hz, 3810 status); 3811 3812 return status; 3813 } 3814 EXPORT_SYMBOL_GPL(spi_setup); 3815 3816 static int _spi_xfer_word_delay_update(struct spi_transfer *xfer, 3817 struct spi_device *spi) 3818 { 3819 int delay1, delay2; 3820 3821 delay1 = spi_delay_to_ns(&xfer->word_delay, xfer); 3822 if (delay1 < 0) 3823 return delay1; 3824 3825 delay2 = spi_delay_to_ns(&spi->word_delay, xfer); 3826 if (delay2 < 0) 3827 return delay2; 3828 3829 if (delay1 < delay2) 3830 memcpy(&xfer->word_delay, &spi->word_delay, 3831 sizeof(xfer->word_delay)); 3832 3833 return 0; 3834 } 3835 3836 static int __spi_validate(struct spi_device *spi, struct spi_message *message) 3837 { 3838 struct spi_controller *ctlr = spi->controller; 3839 struct spi_transfer *xfer; 3840 int w_size; 3841 3842 if (list_empty(&message->transfers)) 3843 return -EINVAL; 3844 3845 /* 3846 * If an SPI controller does not support toggling the CS line on each 3847 * transfer (indicated by the SPI_CS_WORD flag) or we are using a GPIO 3848 * for the CS line, we can emulate the CS-per-word hardware function by 3849 * splitting transfers into one-word transfers and ensuring that 3850 * cs_change is set for each transfer. 3851 */ 3852 if ((spi->mode & SPI_CS_WORD) && (!(ctlr->mode_bits & SPI_CS_WORD) || 3853 spi->cs_gpiod)) { 3854 size_t maxsize; 3855 int ret; 3856 3857 maxsize = (spi->bits_per_word + 7) / 8; 3858 3859 /* spi_split_transfers_maxsize() requires message->spi */ 3860 message->spi = spi; 3861 3862 ret = spi_split_transfers_maxsize(ctlr, message, maxsize, 3863 GFP_KERNEL); 3864 if (ret) 3865 return ret; 3866 3867 list_for_each_entry(xfer, &message->transfers, transfer_list) { 3868 /* Don't change cs_change on the last entry in the list */ 3869 if (list_is_last(&xfer->transfer_list, &message->transfers)) 3870 break; 3871 xfer->cs_change = 1; 3872 } 3873 } 3874 3875 /* 3876 * Half-duplex links include original MicroWire, and ones with 3877 * only one data pin like SPI_3WIRE (switches direction) or where 3878 * either MOSI or MISO is missing. They can also be caused by 3879 * software limitations. 3880 */ 3881 if ((ctlr->flags & SPI_CONTROLLER_HALF_DUPLEX) || 3882 (spi->mode & SPI_3WIRE)) { 3883 unsigned flags = ctlr->flags; 3884 3885 list_for_each_entry(xfer, &message->transfers, transfer_list) { 3886 if (xfer->rx_buf && xfer->tx_buf) 3887 return -EINVAL; 3888 if ((flags & SPI_CONTROLLER_NO_TX) && xfer->tx_buf) 3889 return -EINVAL; 3890 if ((flags & SPI_CONTROLLER_NO_RX) && xfer->rx_buf) 3891 return -EINVAL; 3892 } 3893 } 3894 3895 /* 3896 * Set transfer bits_per_word and max speed as spi device default if 3897 * it is not set for this transfer. 3898 * Set transfer tx_nbits and rx_nbits as single transfer default 3899 * (SPI_NBITS_SINGLE) if it is not set for this transfer. 3900 * Ensure transfer word_delay is at least as long as that required by 3901 * device itself. 3902 */ 3903 message->frame_length = 0; 3904 list_for_each_entry(xfer, &message->transfers, transfer_list) { 3905 xfer->effective_speed_hz = 0; 3906 message->frame_length += xfer->len; 3907 if (!xfer->bits_per_word) 3908 xfer->bits_per_word = spi->bits_per_word; 3909 3910 if (!xfer->speed_hz) 3911 xfer->speed_hz = spi->max_speed_hz; 3912 3913 if (ctlr->max_speed_hz && xfer->speed_hz > ctlr->max_speed_hz) 3914 xfer->speed_hz = ctlr->max_speed_hz; 3915 3916 if (__spi_validate_bits_per_word(ctlr, xfer->bits_per_word)) 3917 return -EINVAL; 3918 3919 /* 3920 * SPI transfer length should be multiple of SPI word size 3921 * where SPI word size should be power-of-two multiple. 3922 */ 3923 if (xfer->bits_per_word <= 8) 3924 w_size = 1; 3925 else if (xfer->bits_per_word <= 16) 3926 w_size = 2; 3927 else 3928 w_size = 4; 3929 3930 /* No partial transfers accepted */ 3931 if (xfer->len % w_size) 3932 return -EINVAL; 3933 3934 if (xfer->speed_hz && ctlr->min_speed_hz && 3935 xfer->speed_hz < ctlr->min_speed_hz) 3936 return -EINVAL; 3937 3938 if (xfer->tx_buf && !xfer->tx_nbits) 3939 xfer->tx_nbits = SPI_NBITS_SINGLE; 3940 if (xfer->rx_buf && !xfer->rx_nbits) 3941 xfer->rx_nbits = SPI_NBITS_SINGLE; 3942 /* 3943 * Check transfer tx/rx_nbits: 3944 * 1. check the value matches one of single, dual and quad 3945 * 2. check tx/rx_nbits match the mode in spi_device 3946 */ 3947 if (xfer->tx_buf) { 3948 if (spi->mode & SPI_NO_TX) 3949 return -EINVAL; 3950 if (xfer->tx_nbits != SPI_NBITS_SINGLE && 3951 xfer->tx_nbits != SPI_NBITS_DUAL && 3952 xfer->tx_nbits != SPI_NBITS_QUAD) 3953 return -EINVAL; 3954 if ((xfer->tx_nbits == SPI_NBITS_DUAL) && 3955 !(spi->mode & (SPI_TX_DUAL | SPI_TX_QUAD))) 3956 return -EINVAL; 3957 if ((xfer->tx_nbits == SPI_NBITS_QUAD) && 3958 !(spi->mode & SPI_TX_QUAD)) 3959 return -EINVAL; 3960 } 3961 /* Check transfer rx_nbits */ 3962 if (xfer->rx_buf) { 3963 if (spi->mode & SPI_NO_RX) 3964 return -EINVAL; 3965 if (xfer->rx_nbits != SPI_NBITS_SINGLE && 3966 xfer->rx_nbits != SPI_NBITS_DUAL && 3967 xfer->rx_nbits != SPI_NBITS_QUAD) 3968 return -EINVAL; 3969 if ((xfer->rx_nbits == SPI_NBITS_DUAL) && 3970 !(spi->mode & (SPI_RX_DUAL | SPI_RX_QUAD))) 3971 return -EINVAL; 3972 if ((xfer->rx_nbits == SPI_NBITS_QUAD) && 3973 !(spi->mode & SPI_RX_QUAD)) 3974 return -EINVAL; 3975 } 3976 3977 if (_spi_xfer_word_delay_update(xfer, spi)) 3978 return -EINVAL; 3979 } 3980 3981 message->status = -EINPROGRESS; 3982 3983 return 0; 3984 } 3985 3986 static int __spi_async(struct spi_device *spi, struct spi_message *message) 3987 { 3988 struct spi_controller *ctlr = spi->controller; 3989 struct spi_transfer *xfer; 3990 3991 /* 3992 * Some controllers do not support doing regular SPI transfers. Return 3993 * ENOTSUPP when this is the case. 3994 */ 3995 if (!ctlr->transfer) 3996 return -ENOTSUPP; 3997 3998 message->spi = spi; 3999 4000 SPI_STATISTICS_INCREMENT_FIELD(ctlr->pcpu_statistics, spi_async); 4001 SPI_STATISTICS_INCREMENT_FIELD(spi->pcpu_statistics, spi_async); 4002 4003 trace_spi_message_submit(message); 4004 4005 if (!ctlr->ptp_sts_supported) { 4006 list_for_each_entry(xfer, &message->transfers, transfer_list) { 4007 xfer->ptp_sts_word_pre = 0; 4008 ptp_read_system_prets(xfer->ptp_sts); 4009 } 4010 } 4011 4012 return ctlr->transfer(spi, message); 4013 } 4014 4015 /** 4016 * spi_async - asynchronous SPI transfer 4017 * @spi: device with which data will be exchanged 4018 * @message: describes the data transfers, including completion callback 4019 * Context: any (irqs may be blocked, etc) 4020 * 4021 * This call may be used in_irq and other contexts which can't sleep, 4022 * as well as from task contexts which can sleep. 4023 * 4024 * The completion callback is invoked in a context which can't sleep. 4025 * Before that invocation, the value of message->status is undefined. 4026 * When the callback is issued, message->status holds either zero (to 4027 * indicate complete success) or a negative error code. After that 4028 * callback returns, the driver which issued the transfer request may 4029 * deallocate the associated memory; it's no longer in use by any SPI 4030 * core or controller driver code. 4031 * 4032 * Note that although all messages to a spi_device are handled in 4033 * FIFO order, messages may go to different devices in other orders. 4034 * Some device might be higher priority, or have various "hard" access 4035 * time requirements, for example. 4036 * 4037 * On detection of any fault during the transfer, processing of 4038 * the entire message is aborted, and the device is deselected. 4039 * Until returning from the associated message completion callback, 4040 * no other spi_message queued to that device will be processed. 4041 * (This rule applies equally to all the synchronous transfer calls, 4042 * which are wrappers around this core asynchronous primitive.) 4043 * 4044 * Return: zero on success, else a negative error code. 4045 */ 4046 int spi_async(struct spi_device *spi, struct spi_message *message) 4047 { 4048 struct spi_controller *ctlr = spi->controller; 4049 int ret; 4050 unsigned long flags; 4051 4052 ret = __spi_validate(spi, message); 4053 if (ret != 0) 4054 return ret; 4055 4056 spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags); 4057 4058 if (ctlr->bus_lock_flag) 4059 ret = -EBUSY; 4060 else 4061 ret = __spi_async(spi, message); 4062 4063 spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags); 4064 4065 return ret; 4066 } 4067 EXPORT_SYMBOL_GPL(spi_async); 4068 4069 /** 4070 * spi_async_locked - version of spi_async with exclusive bus usage 4071 * @spi: device with which data will be exchanged 4072 * @message: describes the data transfers, including completion callback 4073 * Context: any (irqs may be blocked, etc) 4074 * 4075 * This call may be used in_irq and other contexts which can't sleep, 4076 * as well as from task contexts which can sleep. 4077 * 4078 * The completion callback is invoked in a context which can't sleep. 4079 * Before that invocation, the value of message->status is undefined. 4080 * When the callback is issued, message->status holds either zero (to 4081 * indicate complete success) or a negative error code. After that 4082 * callback returns, the driver which issued the transfer request may 4083 * deallocate the associated memory; it's no longer in use by any SPI 4084 * core or controller driver code. 4085 * 4086 * Note that although all messages to a spi_device are handled in 4087 * FIFO order, messages may go to different devices in other orders. 4088 * Some device might be higher priority, or have various "hard" access 4089 * time requirements, for example. 4090 * 4091 * On detection of any fault during the transfer, processing of 4092 * the entire message is aborted, and the device is deselected. 4093 * Until returning from the associated message completion callback, 4094 * no other spi_message queued to that device will be processed. 4095 * (This rule applies equally to all the synchronous transfer calls, 4096 * which are wrappers around this core asynchronous primitive.) 4097 * 4098 * Return: zero on success, else a negative error code. 4099 */ 4100 static int spi_async_locked(struct spi_device *spi, struct spi_message *message) 4101 { 4102 struct spi_controller *ctlr = spi->controller; 4103 int ret; 4104 unsigned long flags; 4105 4106 ret = __spi_validate(spi, message); 4107 if (ret != 0) 4108 return ret; 4109 4110 spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags); 4111 4112 ret = __spi_async(spi, message); 4113 4114 spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags); 4115 4116 return ret; 4117 4118 } 4119 4120 static void __spi_transfer_message_noqueue(struct spi_controller *ctlr, struct spi_message *msg) 4121 { 4122 bool was_busy; 4123 int ret; 4124 4125 mutex_lock(&ctlr->io_mutex); 4126 4127 was_busy = ctlr->busy; 4128 4129 ctlr->cur_msg = msg; 4130 ret = __spi_pump_transfer_message(ctlr, msg, was_busy); 4131 if (ret) 4132 goto out; 4133 4134 ctlr->cur_msg = NULL; 4135 ctlr->fallback = false; 4136 4137 if (!was_busy) { 4138 kfree(ctlr->dummy_rx); 4139 ctlr->dummy_rx = NULL; 4140 kfree(ctlr->dummy_tx); 4141 ctlr->dummy_tx = NULL; 4142 if (ctlr->unprepare_transfer_hardware && 4143 ctlr->unprepare_transfer_hardware(ctlr)) 4144 dev_err(&ctlr->dev, 4145 "failed to unprepare transfer hardware\n"); 4146 spi_idle_runtime_pm(ctlr); 4147 } 4148 4149 out: 4150 mutex_unlock(&ctlr->io_mutex); 4151 } 4152 4153 /*-------------------------------------------------------------------------*/ 4154 4155 /* 4156 * Utility methods for SPI protocol drivers, layered on 4157 * top of the core. Some other utility methods are defined as 4158 * inline functions. 4159 */ 4160 4161 static void spi_complete(void *arg) 4162 { 4163 complete(arg); 4164 } 4165 4166 static int __spi_sync(struct spi_device *spi, struct spi_message *message) 4167 { 4168 DECLARE_COMPLETION_ONSTACK(done); 4169 int status; 4170 struct spi_controller *ctlr = spi->controller; 4171 4172 status = __spi_validate(spi, message); 4173 if (status != 0) 4174 return status; 4175 4176 message->spi = spi; 4177 4178 SPI_STATISTICS_INCREMENT_FIELD(ctlr->pcpu_statistics, spi_sync); 4179 SPI_STATISTICS_INCREMENT_FIELD(spi->pcpu_statistics, spi_sync); 4180 4181 /* 4182 * Checking queue_empty here only guarantees async/sync message 4183 * ordering when coming from the same context. It does not need to 4184 * guard against reentrancy from a different context. The io_mutex 4185 * will catch those cases. 4186 */ 4187 if (READ_ONCE(ctlr->queue_empty) && !ctlr->must_async) { 4188 message->actual_length = 0; 4189 message->status = -EINPROGRESS; 4190 4191 trace_spi_message_submit(message); 4192 4193 SPI_STATISTICS_INCREMENT_FIELD(ctlr->pcpu_statistics, spi_sync_immediate); 4194 SPI_STATISTICS_INCREMENT_FIELD(spi->pcpu_statistics, spi_sync_immediate); 4195 4196 __spi_transfer_message_noqueue(ctlr, message); 4197 4198 return message->status; 4199 } 4200 4201 /* 4202 * There are messages in the async queue that could have originated 4203 * from the same context, so we need to preserve ordering. 4204 * Therefor we send the message to the async queue and wait until they 4205 * are completed. 4206 */ 4207 message->complete = spi_complete; 4208 message->context = &done; 4209 status = spi_async_locked(spi, message); 4210 if (status == 0) { 4211 wait_for_completion(&done); 4212 status = message->status; 4213 } 4214 message->context = NULL; 4215 4216 return status; 4217 } 4218 4219 /** 4220 * spi_sync - blocking/synchronous SPI data transfers 4221 * @spi: device with which data will be exchanged 4222 * @message: describes the data transfers 4223 * Context: can sleep 4224 * 4225 * This call may only be used from a context that may sleep. The sleep 4226 * is non-interruptible, and has no timeout. Low-overhead controller 4227 * drivers may DMA directly into and out of the message buffers. 4228 * 4229 * Note that the SPI device's chip select is active during the message, 4230 * and then is normally disabled between messages. Drivers for some 4231 * frequently-used devices may want to minimize costs of selecting a chip, 4232 * by leaving it selected in anticipation that the next message will go 4233 * to the same chip. (That may increase power usage.) 4234 * 4235 * Also, the caller is guaranteeing that the memory associated with the 4236 * message will not be freed before this call returns. 4237 * 4238 * Return: zero on success, else a negative error code. 4239 */ 4240 int spi_sync(struct spi_device *spi, struct spi_message *message) 4241 { 4242 int ret; 4243 4244 mutex_lock(&spi->controller->bus_lock_mutex); 4245 ret = __spi_sync(spi, message); 4246 mutex_unlock(&spi->controller->bus_lock_mutex); 4247 4248 return ret; 4249 } 4250 EXPORT_SYMBOL_GPL(spi_sync); 4251 4252 /** 4253 * spi_sync_locked - version of spi_sync with exclusive bus usage 4254 * @spi: device with which data will be exchanged 4255 * @message: describes the data transfers 4256 * Context: can sleep 4257 * 4258 * This call may only be used from a context that may sleep. The sleep 4259 * is non-interruptible, and has no timeout. Low-overhead controller 4260 * drivers may DMA directly into and out of the message buffers. 4261 * 4262 * This call should be used by drivers that require exclusive access to the 4263 * SPI bus. It has to be preceded by a spi_bus_lock call. The SPI bus must 4264 * be released by a spi_bus_unlock call when the exclusive access is over. 4265 * 4266 * Return: zero on success, else a negative error code. 4267 */ 4268 int spi_sync_locked(struct spi_device *spi, struct spi_message *message) 4269 { 4270 return __spi_sync(spi, message); 4271 } 4272 EXPORT_SYMBOL_GPL(spi_sync_locked); 4273 4274 /** 4275 * spi_bus_lock - obtain a lock for exclusive SPI bus usage 4276 * @ctlr: SPI bus master that should be locked for exclusive bus access 4277 * Context: can sleep 4278 * 4279 * This call may only be used from a context that may sleep. The sleep 4280 * is non-interruptible, and has no timeout. 4281 * 4282 * This call should be used by drivers that require exclusive access to the 4283 * SPI bus. The SPI bus must be released by a spi_bus_unlock call when the 4284 * exclusive access is over. Data transfer must be done by spi_sync_locked 4285 * and spi_async_locked calls when the SPI bus lock is held. 4286 * 4287 * Return: always zero. 4288 */ 4289 int spi_bus_lock(struct spi_controller *ctlr) 4290 { 4291 unsigned long flags; 4292 4293 mutex_lock(&ctlr->bus_lock_mutex); 4294 4295 spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags); 4296 ctlr->bus_lock_flag = 1; 4297 spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags); 4298 4299 /* Mutex remains locked until spi_bus_unlock() is called */ 4300 4301 return 0; 4302 } 4303 EXPORT_SYMBOL_GPL(spi_bus_lock); 4304 4305 /** 4306 * spi_bus_unlock - release the lock for exclusive SPI bus usage 4307 * @ctlr: SPI bus master that was locked for exclusive bus access 4308 * Context: can sleep 4309 * 4310 * This call may only be used from a context that may sleep. The sleep 4311 * is non-interruptible, and has no timeout. 4312 * 4313 * This call releases an SPI bus lock previously obtained by an spi_bus_lock 4314 * call. 4315 * 4316 * Return: always zero. 4317 */ 4318 int spi_bus_unlock(struct spi_controller *ctlr) 4319 { 4320 ctlr->bus_lock_flag = 0; 4321 4322 mutex_unlock(&ctlr->bus_lock_mutex); 4323 4324 return 0; 4325 } 4326 EXPORT_SYMBOL_GPL(spi_bus_unlock); 4327 4328 /* Portable code must never pass more than 32 bytes */ 4329 #define SPI_BUFSIZ max(32, SMP_CACHE_BYTES) 4330 4331 static u8 *buf; 4332 4333 /** 4334 * spi_write_then_read - SPI synchronous write followed by read 4335 * @spi: device with which data will be exchanged 4336 * @txbuf: data to be written (need not be dma-safe) 4337 * @n_tx: size of txbuf, in bytes 4338 * @rxbuf: buffer into which data will be read (need not be dma-safe) 4339 * @n_rx: size of rxbuf, in bytes 4340 * Context: can sleep 4341 * 4342 * This performs a half duplex MicroWire style transaction with the 4343 * device, sending txbuf and then reading rxbuf. The return value 4344 * is zero for success, else a negative errno status code. 4345 * This call may only be used from a context that may sleep. 4346 * 4347 * Parameters to this routine are always copied using a small buffer. 4348 * Performance-sensitive or bulk transfer code should instead use 4349 * spi_{async,sync}() calls with dma-safe buffers. 4350 * 4351 * Return: zero on success, else a negative error code. 4352 */ 4353 int spi_write_then_read(struct spi_device *spi, 4354 const void *txbuf, unsigned n_tx, 4355 void *rxbuf, unsigned n_rx) 4356 { 4357 static DEFINE_MUTEX(lock); 4358 4359 int status; 4360 struct spi_message message; 4361 struct spi_transfer x[2]; 4362 u8 *local_buf; 4363 4364 /* 4365 * Use preallocated DMA-safe buffer if we can. We can't avoid 4366 * copying here, (as a pure convenience thing), but we can 4367 * keep heap costs out of the hot path unless someone else is 4368 * using the pre-allocated buffer or the transfer is too large. 4369 */ 4370 if ((n_tx + n_rx) > SPI_BUFSIZ || !mutex_trylock(&lock)) { 4371 local_buf = kmalloc(max((unsigned)SPI_BUFSIZ, n_tx + n_rx), 4372 GFP_KERNEL | GFP_DMA); 4373 if (!local_buf) 4374 return -ENOMEM; 4375 } else { 4376 local_buf = buf; 4377 } 4378 4379 spi_message_init(&message); 4380 memset(x, 0, sizeof(x)); 4381 if (n_tx) { 4382 x[0].len = n_tx; 4383 spi_message_add_tail(&x[0], &message); 4384 } 4385 if (n_rx) { 4386 x[1].len = n_rx; 4387 spi_message_add_tail(&x[1], &message); 4388 } 4389 4390 memcpy(local_buf, txbuf, n_tx); 4391 x[0].tx_buf = local_buf; 4392 x[1].rx_buf = local_buf + n_tx; 4393 4394 /* Do the i/o */ 4395 status = spi_sync(spi, &message); 4396 if (status == 0) 4397 memcpy(rxbuf, x[1].rx_buf, n_rx); 4398 4399 if (x[0].tx_buf == buf) 4400 mutex_unlock(&lock); 4401 else 4402 kfree(local_buf); 4403 4404 return status; 4405 } 4406 EXPORT_SYMBOL_GPL(spi_write_then_read); 4407 4408 /*-------------------------------------------------------------------------*/ 4409 4410 #if IS_ENABLED(CONFIG_OF_DYNAMIC) 4411 /* Must call put_device() when done with returned spi_device device */ 4412 static struct spi_device *of_find_spi_device_by_node(struct device_node *node) 4413 { 4414 struct device *dev = bus_find_device_by_of_node(&spi_bus_type, node); 4415 4416 return dev ? to_spi_device(dev) : NULL; 4417 } 4418 4419 /* The spi controllers are not using spi_bus, so we find it with another way */ 4420 static struct spi_controller *of_find_spi_controller_by_node(struct device_node *node) 4421 { 4422 struct device *dev; 4423 4424 dev = class_find_device_by_of_node(&spi_master_class, node); 4425 if (!dev && IS_ENABLED(CONFIG_SPI_SLAVE)) 4426 dev = class_find_device_by_of_node(&spi_slave_class, node); 4427 if (!dev) 4428 return NULL; 4429 4430 /* Reference got in class_find_device */ 4431 return container_of(dev, struct spi_controller, dev); 4432 } 4433 4434 static int of_spi_notify(struct notifier_block *nb, unsigned long action, 4435 void *arg) 4436 { 4437 struct of_reconfig_data *rd = arg; 4438 struct spi_controller *ctlr; 4439 struct spi_device *spi; 4440 4441 switch (of_reconfig_get_state_change(action, arg)) { 4442 case OF_RECONFIG_CHANGE_ADD: 4443 ctlr = of_find_spi_controller_by_node(rd->dn->parent); 4444 if (ctlr == NULL) 4445 return NOTIFY_OK; /* Not for us */ 4446 4447 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) { 4448 put_device(&ctlr->dev); 4449 return NOTIFY_OK; 4450 } 4451 4452 spi = of_register_spi_device(ctlr, rd->dn); 4453 put_device(&ctlr->dev); 4454 4455 if (IS_ERR(spi)) { 4456 pr_err("%s: failed to create for '%pOF'\n", 4457 __func__, rd->dn); 4458 of_node_clear_flag(rd->dn, OF_POPULATED); 4459 return notifier_from_errno(PTR_ERR(spi)); 4460 } 4461 break; 4462 4463 case OF_RECONFIG_CHANGE_REMOVE: 4464 /* Already depopulated? */ 4465 if (!of_node_check_flag(rd->dn, OF_POPULATED)) 4466 return NOTIFY_OK; 4467 4468 /* Find our device by node */ 4469 spi = of_find_spi_device_by_node(rd->dn); 4470 if (spi == NULL) 4471 return NOTIFY_OK; /* No? not meant for us */ 4472 4473 /* Unregister takes one ref away */ 4474 spi_unregister_device(spi); 4475 4476 /* And put the reference of the find */ 4477 put_device(&spi->dev); 4478 break; 4479 } 4480 4481 return NOTIFY_OK; 4482 } 4483 4484 static struct notifier_block spi_of_notifier = { 4485 .notifier_call = of_spi_notify, 4486 }; 4487 #else /* IS_ENABLED(CONFIG_OF_DYNAMIC) */ 4488 extern struct notifier_block spi_of_notifier; 4489 #endif /* IS_ENABLED(CONFIG_OF_DYNAMIC) */ 4490 4491 #if IS_ENABLED(CONFIG_ACPI) 4492 static int spi_acpi_controller_match(struct device *dev, const void *data) 4493 { 4494 return ACPI_COMPANION(dev->parent) == data; 4495 } 4496 4497 static struct spi_controller *acpi_spi_find_controller_by_adev(struct acpi_device *adev) 4498 { 4499 struct device *dev; 4500 4501 dev = class_find_device(&spi_master_class, NULL, adev, 4502 spi_acpi_controller_match); 4503 if (!dev && IS_ENABLED(CONFIG_SPI_SLAVE)) 4504 dev = class_find_device(&spi_slave_class, NULL, adev, 4505 spi_acpi_controller_match); 4506 if (!dev) 4507 return NULL; 4508 4509 return container_of(dev, struct spi_controller, dev); 4510 } 4511 4512 static struct spi_device *acpi_spi_find_device_by_adev(struct acpi_device *adev) 4513 { 4514 struct device *dev; 4515 4516 dev = bus_find_device_by_acpi_dev(&spi_bus_type, adev); 4517 return to_spi_device(dev); 4518 } 4519 4520 static int acpi_spi_notify(struct notifier_block *nb, unsigned long value, 4521 void *arg) 4522 { 4523 struct acpi_device *adev = arg; 4524 struct spi_controller *ctlr; 4525 struct spi_device *spi; 4526 4527 switch (value) { 4528 case ACPI_RECONFIG_DEVICE_ADD: 4529 ctlr = acpi_spi_find_controller_by_adev(acpi_dev_parent(adev)); 4530 if (!ctlr) 4531 break; 4532 4533 acpi_register_spi_device(ctlr, adev); 4534 put_device(&ctlr->dev); 4535 break; 4536 case ACPI_RECONFIG_DEVICE_REMOVE: 4537 if (!acpi_device_enumerated(adev)) 4538 break; 4539 4540 spi = acpi_spi_find_device_by_adev(adev); 4541 if (!spi) 4542 break; 4543 4544 spi_unregister_device(spi); 4545 put_device(&spi->dev); 4546 break; 4547 } 4548 4549 return NOTIFY_OK; 4550 } 4551 4552 static struct notifier_block spi_acpi_notifier = { 4553 .notifier_call = acpi_spi_notify, 4554 }; 4555 #else 4556 extern struct notifier_block spi_acpi_notifier; 4557 #endif 4558 4559 static int __init spi_init(void) 4560 { 4561 int status; 4562 4563 buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL); 4564 if (!buf) { 4565 status = -ENOMEM; 4566 goto err0; 4567 } 4568 4569 status = bus_register(&spi_bus_type); 4570 if (status < 0) 4571 goto err1; 4572 4573 status = class_register(&spi_master_class); 4574 if (status < 0) 4575 goto err2; 4576 4577 if (IS_ENABLED(CONFIG_SPI_SLAVE)) { 4578 status = class_register(&spi_slave_class); 4579 if (status < 0) 4580 goto err3; 4581 } 4582 4583 if (IS_ENABLED(CONFIG_OF_DYNAMIC)) 4584 WARN_ON(of_reconfig_notifier_register(&spi_of_notifier)); 4585 if (IS_ENABLED(CONFIG_ACPI)) 4586 WARN_ON(acpi_reconfig_notifier_register(&spi_acpi_notifier)); 4587 4588 return 0; 4589 4590 err3: 4591 class_unregister(&spi_master_class); 4592 err2: 4593 bus_unregister(&spi_bus_type); 4594 err1: 4595 kfree(buf); 4596 buf = NULL; 4597 err0: 4598 return status; 4599 } 4600 4601 /* 4602 * A board_info is normally registered in arch_initcall(), 4603 * but even essential drivers wait till later. 4604 * 4605 * REVISIT only boardinfo really needs static linking. The rest (device and 4606 * driver registration) _could_ be dynamically linked (modular) ... Costs 4607 * include needing to have boardinfo data structures be much more public. 4608 */ 4609 postcore_initcall(spi_init); 4610