1 /* 2 * SPI init/core code 3 * 4 * Copyright (C) 2005 David Brownell 5 * Copyright (C) 2008 Secret Lab Technologies Ltd. 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 #include <linux/kernel.h> 23 #include <linux/kmod.h> 24 #include <linux/device.h> 25 #include <linux/init.h> 26 #include <linux/cache.h> 27 #include <linux/dma-mapping.h> 28 #include <linux/dmaengine.h> 29 #include <linux/mutex.h> 30 #include <linux/of_device.h> 31 #include <linux/of_irq.h> 32 #include <linux/slab.h> 33 #include <linux/mod_devicetable.h> 34 #include <linux/spi/spi.h> 35 #include <linux/of_gpio.h> 36 #include <linux/pm_runtime.h> 37 #include <linux/export.h> 38 #include <linux/sched/rt.h> 39 #include <linux/delay.h> 40 #include <linux/kthread.h> 41 #include <linux/ioport.h> 42 #include <linux/acpi.h> 43 44 #define CREATE_TRACE_POINTS 45 #include <trace/events/spi.h> 46 47 static void spidev_release(struct device *dev) 48 { 49 struct spi_device *spi = to_spi_device(dev); 50 51 /* spi masters may cleanup for released devices */ 52 if (spi->master->cleanup) 53 spi->master->cleanup(spi); 54 55 spi_master_put(spi->master); 56 kfree(spi); 57 } 58 59 static ssize_t 60 modalias_show(struct device *dev, struct device_attribute *a, char *buf) 61 { 62 const struct spi_device *spi = to_spi_device(dev); 63 int len; 64 65 len = acpi_device_modalias(dev, buf, PAGE_SIZE - 1); 66 if (len != -ENODEV) 67 return len; 68 69 return sprintf(buf, "%s%s\n", SPI_MODULE_PREFIX, spi->modalias); 70 } 71 static DEVICE_ATTR_RO(modalias); 72 73 static struct attribute *spi_dev_attrs[] = { 74 &dev_attr_modalias.attr, 75 NULL, 76 }; 77 ATTRIBUTE_GROUPS(spi_dev); 78 79 /* modalias support makes "modprobe $MODALIAS" new-style hotplug work, 80 * and the sysfs version makes coldplug work too. 81 */ 82 83 static const struct spi_device_id *spi_match_id(const struct spi_device_id *id, 84 const struct spi_device *sdev) 85 { 86 while (id->name[0]) { 87 if (!strcmp(sdev->modalias, id->name)) 88 return id; 89 id++; 90 } 91 return NULL; 92 } 93 94 const struct spi_device_id *spi_get_device_id(const struct spi_device *sdev) 95 { 96 const struct spi_driver *sdrv = to_spi_driver(sdev->dev.driver); 97 98 return spi_match_id(sdrv->id_table, sdev); 99 } 100 EXPORT_SYMBOL_GPL(spi_get_device_id); 101 102 static int spi_match_device(struct device *dev, struct device_driver *drv) 103 { 104 const struct spi_device *spi = to_spi_device(dev); 105 const struct spi_driver *sdrv = to_spi_driver(drv); 106 107 /* Attempt an OF style match */ 108 if (of_driver_match_device(dev, drv)) 109 return 1; 110 111 /* Then try ACPI */ 112 if (acpi_driver_match_device(dev, drv)) 113 return 1; 114 115 if (sdrv->id_table) 116 return !!spi_match_id(sdrv->id_table, spi); 117 118 return strcmp(spi->modalias, drv->name) == 0; 119 } 120 121 static int spi_uevent(struct device *dev, struct kobj_uevent_env *env) 122 { 123 const struct spi_device *spi = to_spi_device(dev); 124 int rc; 125 126 rc = acpi_device_uevent_modalias(dev, env); 127 if (rc != -ENODEV) 128 return rc; 129 130 add_uevent_var(env, "MODALIAS=%s%s", SPI_MODULE_PREFIX, spi->modalias); 131 return 0; 132 } 133 134 #ifdef CONFIG_PM_SLEEP 135 static int spi_legacy_suspend(struct device *dev, pm_message_t message) 136 { 137 int value = 0; 138 struct spi_driver *drv = to_spi_driver(dev->driver); 139 140 /* suspend will stop irqs and dma; no more i/o */ 141 if (drv) { 142 if (drv->suspend) 143 value = drv->suspend(to_spi_device(dev), message); 144 else 145 dev_dbg(dev, "... can't suspend\n"); 146 } 147 return value; 148 } 149 150 static int spi_legacy_resume(struct device *dev) 151 { 152 int value = 0; 153 struct spi_driver *drv = to_spi_driver(dev->driver); 154 155 /* resume may restart the i/o queue */ 156 if (drv) { 157 if (drv->resume) 158 value = drv->resume(to_spi_device(dev)); 159 else 160 dev_dbg(dev, "... can't resume\n"); 161 } 162 return value; 163 } 164 165 static int spi_pm_suspend(struct device *dev) 166 { 167 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 168 169 if (pm) 170 return pm_generic_suspend(dev); 171 else 172 return spi_legacy_suspend(dev, PMSG_SUSPEND); 173 } 174 175 static int spi_pm_resume(struct device *dev) 176 { 177 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 178 179 if (pm) 180 return pm_generic_resume(dev); 181 else 182 return spi_legacy_resume(dev); 183 } 184 185 static int spi_pm_freeze(struct device *dev) 186 { 187 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 188 189 if (pm) 190 return pm_generic_freeze(dev); 191 else 192 return spi_legacy_suspend(dev, PMSG_FREEZE); 193 } 194 195 static int spi_pm_thaw(struct device *dev) 196 { 197 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 198 199 if (pm) 200 return pm_generic_thaw(dev); 201 else 202 return spi_legacy_resume(dev); 203 } 204 205 static int spi_pm_poweroff(struct device *dev) 206 { 207 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 208 209 if (pm) 210 return pm_generic_poweroff(dev); 211 else 212 return spi_legacy_suspend(dev, PMSG_HIBERNATE); 213 } 214 215 static int spi_pm_restore(struct device *dev) 216 { 217 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 218 219 if (pm) 220 return pm_generic_restore(dev); 221 else 222 return spi_legacy_resume(dev); 223 } 224 #else 225 #define spi_pm_suspend NULL 226 #define spi_pm_resume NULL 227 #define spi_pm_freeze NULL 228 #define spi_pm_thaw NULL 229 #define spi_pm_poweroff NULL 230 #define spi_pm_restore NULL 231 #endif 232 233 static const struct dev_pm_ops spi_pm = { 234 .suspend = spi_pm_suspend, 235 .resume = spi_pm_resume, 236 .freeze = spi_pm_freeze, 237 .thaw = spi_pm_thaw, 238 .poweroff = spi_pm_poweroff, 239 .restore = spi_pm_restore, 240 SET_RUNTIME_PM_OPS( 241 pm_generic_runtime_suspend, 242 pm_generic_runtime_resume, 243 NULL 244 ) 245 }; 246 247 struct bus_type spi_bus_type = { 248 .name = "spi", 249 .dev_groups = spi_dev_groups, 250 .match = spi_match_device, 251 .uevent = spi_uevent, 252 .pm = &spi_pm, 253 }; 254 EXPORT_SYMBOL_GPL(spi_bus_type); 255 256 257 static int spi_drv_probe(struct device *dev) 258 { 259 const struct spi_driver *sdrv = to_spi_driver(dev->driver); 260 int ret; 261 262 acpi_dev_pm_attach(dev, true); 263 ret = sdrv->probe(to_spi_device(dev)); 264 if (ret) 265 acpi_dev_pm_detach(dev, true); 266 267 return ret; 268 } 269 270 static int spi_drv_remove(struct device *dev) 271 { 272 const struct spi_driver *sdrv = to_spi_driver(dev->driver); 273 int ret; 274 275 ret = sdrv->remove(to_spi_device(dev)); 276 acpi_dev_pm_detach(dev, true); 277 278 return ret; 279 } 280 281 static void spi_drv_shutdown(struct device *dev) 282 { 283 const struct spi_driver *sdrv = to_spi_driver(dev->driver); 284 285 sdrv->shutdown(to_spi_device(dev)); 286 } 287 288 /** 289 * spi_register_driver - register a SPI driver 290 * @sdrv: the driver to register 291 * Context: can sleep 292 */ 293 int spi_register_driver(struct spi_driver *sdrv) 294 { 295 sdrv->driver.bus = &spi_bus_type; 296 if (sdrv->probe) 297 sdrv->driver.probe = spi_drv_probe; 298 if (sdrv->remove) 299 sdrv->driver.remove = spi_drv_remove; 300 if (sdrv->shutdown) 301 sdrv->driver.shutdown = spi_drv_shutdown; 302 return driver_register(&sdrv->driver); 303 } 304 EXPORT_SYMBOL_GPL(spi_register_driver); 305 306 /*-------------------------------------------------------------------------*/ 307 308 /* SPI devices should normally not be created by SPI device drivers; that 309 * would make them board-specific. Similarly with SPI master drivers. 310 * Device registration normally goes into like arch/.../mach.../board-YYY.c 311 * with other readonly (flashable) information about mainboard devices. 312 */ 313 314 struct boardinfo { 315 struct list_head list; 316 struct spi_board_info board_info; 317 }; 318 319 static LIST_HEAD(board_list); 320 static LIST_HEAD(spi_master_list); 321 322 /* 323 * Used to protect add/del opertion for board_info list and 324 * spi_master list, and their matching process 325 */ 326 static DEFINE_MUTEX(board_lock); 327 328 /** 329 * spi_alloc_device - Allocate a new SPI device 330 * @master: Controller to which device is connected 331 * Context: can sleep 332 * 333 * Allows a driver to allocate and initialize a spi_device without 334 * registering it immediately. This allows a driver to directly 335 * fill the spi_device with device parameters before calling 336 * spi_add_device() on it. 337 * 338 * Caller is responsible to call spi_add_device() on the returned 339 * spi_device structure to add it to the SPI master. If the caller 340 * needs to discard the spi_device without adding it, then it should 341 * call spi_dev_put() on it. 342 * 343 * Returns a pointer to the new device, or NULL. 344 */ 345 struct spi_device *spi_alloc_device(struct spi_master *master) 346 { 347 struct spi_device *spi; 348 struct device *dev = master->dev.parent; 349 350 if (!spi_master_get(master)) 351 return NULL; 352 353 spi = kzalloc(sizeof(*spi), GFP_KERNEL); 354 if (!spi) { 355 dev_err(dev, "cannot alloc spi_device\n"); 356 spi_master_put(master); 357 return NULL; 358 } 359 360 spi->master = master; 361 spi->dev.parent = &master->dev; 362 spi->dev.bus = &spi_bus_type; 363 spi->dev.release = spidev_release; 364 spi->cs_gpio = -ENOENT; 365 device_initialize(&spi->dev); 366 return spi; 367 } 368 EXPORT_SYMBOL_GPL(spi_alloc_device); 369 370 static void spi_dev_set_name(struct spi_device *spi) 371 { 372 struct acpi_device *adev = ACPI_COMPANION(&spi->dev); 373 374 if (adev) { 375 dev_set_name(&spi->dev, "spi-%s", acpi_dev_name(adev)); 376 return; 377 } 378 379 dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev), 380 spi->chip_select); 381 } 382 383 static int spi_dev_check(struct device *dev, void *data) 384 { 385 struct spi_device *spi = to_spi_device(dev); 386 struct spi_device *new_spi = data; 387 388 if (spi->master == new_spi->master && 389 spi->chip_select == new_spi->chip_select) 390 return -EBUSY; 391 return 0; 392 } 393 394 /** 395 * spi_add_device - Add spi_device allocated with spi_alloc_device 396 * @spi: spi_device to register 397 * 398 * Companion function to spi_alloc_device. Devices allocated with 399 * spi_alloc_device can be added onto the spi bus with this function. 400 * 401 * Returns 0 on success; negative errno on failure 402 */ 403 int spi_add_device(struct spi_device *spi) 404 { 405 static DEFINE_MUTEX(spi_add_lock); 406 struct spi_master *master = spi->master; 407 struct device *dev = master->dev.parent; 408 int status; 409 410 /* Chipselects are numbered 0..max; validate. */ 411 if (spi->chip_select >= master->num_chipselect) { 412 dev_err(dev, "cs%d >= max %d\n", 413 spi->chip_select, 414 master->num_chipselect); 415 return -EINVAL; 416 } 417 418 /* Set the bus ID string */ 419 spi_dev_set_name(spi); 420 421 /* We need to make sure there's no other device with this 422 * chipselect **BEFORE** we call setup(), else we'll trash 423 * its configuration. Lock against concurrent add() calls. 424 */ 425 mutex_lock(&spi_add_lock); 426 427 status = bus_for_each_dev(&spi_bus_type, NULL, spi, spi_dev_check); 428 if (status) { 429 dev_err(dev, "chipselect %d already in use\n", 430 spi->chip_select); 431 goto done; 432 } 433 434 if (master->cs_gpios) 435 spi->cs_gpio = master->cs_gpios[spi->chip_select]; 436 437 /* Drivers may modify this initial i/o setup, but will 438 * normally rely on the device being setup. Devices 439 * using SPI_CS_HIGH can't coexist well otherwise... 440 */ 441 status = spi_setup(spi); 442 if (status < 0) { 443 dev_err(dev, "can't setup %s, status %d\n", 444 dev_name(&spi->dev), status); 445 goto done; 446 } 447 448 /* Device may be bound to an active driver when this returns */ 449 status = device_add(&spi->dev); 450 if (status < 0) 451 dev_err(dev, "can't add %s, status %d\n", 452 dev_name(&spi->dev), status); 453 else 454 dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev)); 455 456 done: 457 mutex_unlock(&spi_add_lock); 458 return status; 459 } 460 EXPORT_SYMBOL_GPL(spi_add_device); 461 462 /** 463 * spi_new_device - instantiate one new SPI device 464 * @master: Controller to which device is connected 465 * @chip: Describes the SPI device 466 * Context: can sleep 467 * 468 * On typical mainboards, this is purely internal; and it's not needed 469 * after board init creates the hard-wired devices. Some development 470 * platforms may not be able to use spi_register_board_info though, and 471 * this is exported so that for example a USB or parport based adapter 472 * driver could add devices (which it would learn about out-of-band). 473 * 474 * Returns the new device, or NULL. 475 */ 476 struct spi_device *spi_new_device(struct spi_master *master, 477 struct spi_board_info *chip) 478 { 479 struct spi_device *proxy; 480 int status; 481 482 /* NOTE: caller did any chip->bus_num checks necessary. 483 * 484 * Also, unless we change the return value convention to use 485 * error-or-pointer (not NULL-or-pointer), troubleshootability 486 * suggests syslogged diagnostics are best here (ugh). 487 */ 488 489 proxy = spi_alloc_device(master); 490 if (!proxy) 491 return NULL; 492 493 WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias)); 494 495 proxy->chip_select = chip->chip_select; 496 proxy->max_speed_hz = chip->max_speed_hz; 497 proxy->mode = chip->mode; 498 proxy->irq = chip->irq; 499 strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias)); 500 proxy->dev.platform_data = (void *) chip->platform_data; 501 proxy->controller_data = chip->controller_data; 502 proxy->controller_state = NULL; 503 504 status = spi_add_device(proxy); 505 if (status < 0) { 506 spi_dev_put(proxy); 507 return NULL; 508 } 509 510 return proxy; 511 } 512 EXPORT_SYMBOL_GPL(spi_new_device); 513 514 static void spi_match_master_to_boardinfo(struct spi_master *master, 515 struct spi_board_info *bi) 516 { 517 struct spi_device *dev; 518 519 if (master->bus_num != bi->bus_num) 520 return; 521 522 dev = spi_new_device(master, bi); 523 if (!dev) 524 dev_err(master->dev.parent, "can't create new device for %s\n", 525 bi->modalias); 526 } 527 528 /** 529 * spi_register_board_info - register SPI devices for a given board 530 * @info: array of chip descriptors 531 * @n: how many descriptors are provided 532 * Context: can sleep 533 * 534 * Board-specific early init code calls this (probably during arch_initcall) 535 * with segments of the SPI device table. Any device nodes are created later, 536 * after the relevant parent SPI controller (bus_num) is defined. We keep 537 * this table of devices forever, so that reloading a controller driver will 538 * not make Linux forget about these hard-wired devices. 539 * 540 * Other code can also call this, e.g. a particular add-on board might provide 541 * SPI devices through its expansion connector, so code initializing that board 542 * would naturally declare its SPI devices. 543 * 544 * The board info passed can safely be __initdata ... but be careful of 545 * any embedded pointers (platform_data, etc), they're copied as-is. 546 */ 547 int spi_register_board_info(struct spi_board_info const *info, unsigned n) 548 { 549 struct boardinfo *bi; 550 int i; 551 552 bi = kzalloc(n * sizeof(*bi), GFP_KERNEL); 553 if (!bi) 554 return -ENOMEM; 555 556 for (i = 0; i < n; i++, bi++, info++) { 557 struct spi_master *master; 558 559 memcpy(&bi->board_info, info, sizeof(*info)); 560 mutex_lock(&board_lock); 561 list_add_tail(&bi->list, &board_list); 562 list_for_each_entry(master, &spi_master_list, list) 563 spi_match_master_to_boardinfo(master, &bi->board_info); 564 mutex_unlock(&board_lock); 565 } 566 567 return 0; 568 } 569 570 /*-------------------------------------------------------------------------*/ 571 572 static void spi_set_cs(struct spi_device *spi, bool enable) 573 { 574 if (spi->mode & SPI_CS_HIGH) 575 enable = !enable; 576 577 if (spi->cs_gpio >= 0) 578 gpio_set_value(spi->cs_gpio, !enable); 579 else if (spi->master->set_cs) 580 spi->master->set_cs(spi, !enable); 581 } 582 583 #ifdef CONFIG_HAS_DMA 584 static int spi_map_buf(struct spi_master *master, struct device *dev, 585 struct sg_table *sgt, void *buf, size_t len, 586 enum dma_data_direction dir) 587 { 588 const bool vmalloced_buf = is_vmalloc_addr(buf); 589 const int desc_len = vmalloced_buf ? PAGE_SIZE : master->max_dma_len; 590 const int sgs = DIV_ROUND_UP(len, desc_len); 591 struct page *vm_page; 592 void *sg_buf; 593 size_t min; 594 int i, ret; 595 596 ret = sg_alloc_table(sgt, sgs, GFP_KERNEL); 597 if (ret != 0) 598 return ret; 599 600 for (i = 0; i < sgs; i++) { 601 min = min_t(size_t, len, desc_len); 602 603 if (vmalloced_buf) { 604 vm_page = vmalloc_to_page(buf); 605 if (!vm_page) { 606 sg_free_table(sgt); 607 return -ENOMEM; 608 } 609 sg_buf = page_address(vm_page) + 610 ((size_t)buf & ~PAGE_MASK); 611 } else { 612 sg_buf = buf; 613 } 614 615 sg_set_buf(&sgt->sgl[i], sg_buf, min); 616 617 buf += min; 618 len -= min; 619 } 620 621 ret = dma_map_sg(dev, sgt->sgl, sgt->nents, dir); 622 if (ret < 0) { 623 sg_free_table(sgt); 624 return ret; 625 } 626 627 sgt->nents = ret; 628 629 return 0; 630 } 631 632 static void spi_unmap_buf(struct spi_master *master, struct device *dev, 633 struct sg_table *sgt, enum dma_data_direction dir) 634 { 635 if (sgt->orig_nents) { 636 dma_unmap_sg(dev, sgt->sgl, sgt->orig_nents, dir); 637 sg_free_table(sgt); 638 } 639 } 640 641 static int __spi_map_msg(struct spi_master *master, struct spi_message *msg) 642 { 643 struct device *tx_dev, *rx_dev; 644 struct spi_transfer *xfer; 645 int ret; 646 647 if (!master->can_dma) 648 return 0; 649 650 tx_dev = &master->dma_tx->dev->device; 651 rx_dev = &master->dma_rx->dev->device; 652 653 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 654 if (!master->can_dma(master, msg->spi, xfer)) 655 continue; 656 657 if (xfer->tx_buf != NULL) { 658 ret = spi_map_buf(master, tx_dev, &xfer->tx_sg, 659 (void *)xfer->tx_buf, xfer->len, 660 DMA_TO_DEVICE); 661 if (ret != 0) 662 return ret; 663 } 664 665 if (xfer->rx_buf != NULL) { 666 ret = spi_map_buf(master, rx_dev, &xfer->rx_sg, 667 xfer->rx_buf, xfer->len, 668 DMA_FROM_DEVICE); 669 if (ret != 0) { 670 spi_unmap_buf(master, tx_dev, &xfer->tx_sg, 671 DMA_TO_DEVICE); 672 return ret; 673 } 674 } 675 } 676 677 master->cur_msg_mapped = true; 678 679 return 0; 680 } 681 682 static int spi_unmap_msg(struct spi_master *master, struct spi_message *msg) 683 { 684 struct spi_transfer *xfer; 685 struct device *tx_dev, *rx_dev; 686 687 if (!master->cur_msg_mapped || !master->can_dma) 688 return 0; 689 690 tx_dev = &master->dma_tx->dev->device; 691 rx_dev = &master->dma_rx->dev->device; 692 693 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 694 if (!master->can_dma(master, msg->spi, xfer)) 695 continue; 696 697 spi_unmap_buf(master, rx_dev, &xfer->rx_sg, DMA_FROM_DEVICE); 698 spi_unmap_buf(master, tx_dev, &xfer->tx_sg, DMA_TO_DEVICE); 699 } 700 701 return 0; 702 } 703 #else /* !CONFIG_HAS_DMA */ 704 static inline int __spi_map_msg(struct spi_master *master, 705 struct spi_message *msg) 706 { 707 return 0; 708 } 709 710 static inline int spi_unmap_msg(struct spi_master *master, 711 struct spi_message *msg) 712 { 713 return 0; 714 } 715 #endif /* !CONFIG_HAS_DMA */ 716 717 static int spi_map_msg(struct spi_master *master, struct spi_message *msg) 718 { 719 struct spi_transfer *xfer; 720 void *tmp; 721 unsigned int max_tx, max_rx; 722 723 if (master->flags & (SPI_MASTER_MUST_RX | SPI_MASTER_MUST_TX)) { 724 max_tx = 0; 725 max_rx = 0; 726 727 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 728 if ((master->flags & SPI_MASTER_MUST_TX) && 729 !xfer->tx_buf) 730 max_tx = max(xfer->len, max_tx); 731 if ((master->flags & SPI_MASTER_MUST_RX) && 732 !xfer->rx_buf) 733 max_rx = max(xfer->len, max_rx); 734 } 735 736 if (max_tx) { 737 tmp = krealloc(master->dummy_tx, max_tx, 738 GFP_KERNEL | GFP_DMA); 739 if (!tmp) 740 return -ENOMEM; 741 master->dummy_tx = tmp; 742 memset(tmp, 0, max_tx); 743 } 744 745 if (max_rx) { 746 tmp = krealloc(master->dummy_rx, max_rx, 747 GFP_KERNEL | GFP_DMA); 748 if (!tmp) 749 return -ENOMEM; 750 master->dummy_rx = tmp; 751 } 752 753 if (max_tx || max_rx) { 754 list_for_each_entry(xfer, &msg->transfers, 755 transfer_list) { 756 if (!xfer->tx_buf) 757 xfer->tx_buf = master->dummy_tx; 758 if (!xfer->rx_buf) 759 xfer->rx_buf = master->dummy_rx; 760 } 761 } 762 } 763 764 return __spi_map_msg(master, msg); 765 } 766 767 /* 768 * spi_transfer_one_message - Default implementation of transfer_one_message() 769 * 770 * This is a standard implementation of transfer_one_message() for 771 * drivers which impelment a transfer_one() operation. It provides 772 * standard handling of delays and chip select management. 773 */ 774 static int spi_transfer_one_message(struct spi_master *master, 775 struct spi_message *msg) 776 { 777 struct spi_transfer *xfer; 778 bool keep_cs = false; 779 int ret = 0; 780 int ms = 1; 781 782 spi_set_cs(msg->spi, true); 783 784 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 785 trace_spi_transfer_start(msg, xfer); 786 787 reinit_completion(&master->xfer_completion); 788 789 ret = master->transfer_one(master, msg->spi, xfer); 790 if (ret < 0) { 791 dev_err(&msg->spi->dev, 792 "SPI transfer failed: %d\n", ret); 793 goto out; 794 } 795 796 if (ret > 0) { 797 ret = 0; 798 ms = xfer->len * 8 * 1000 / xfer->speed_hz; 799 ms += ms + 100; /* some tolerance */ 800 801 ms = wait_for_completion_timeout(&master->xfer_completion, 802 msecs_to_jiffies(ms)); 803 } 804 805 if (ms == 0) { 806 dev_err(&msg->spi->dev, "SPI transfer timed out\n"); 807 msg->status = -ETIMEDOUT; 808 } 809 810 trace_spi_transfer_stop(msg, xfer); 811 812 if (msg->status != -EINPROGRESS) 813 goto out; 814 815 if (xfer->delay_usecs) 816 udelay(xfer->delay_usecs); 817 818 if (xfer->cs_change) { 819 if (list_is_last(&xfer->transfer_list, 820 &msg->transfers)) { 821 keep_cs = true; 822 } else { 823 spi_set_cs(msg->spi, false); 824 udelay(10); 825 spi_set_cs(msg->spi, true); 826 } 827 } 828 829 msg->actual_length += xfer->len; 830 } 831 832 out: 833 if (ret != 0 || !keep_cs) 834 spi_set_cs(msg->spi, false); 835 836 if (msg->status == -EINPROGRESS) 837 msg->status = ret; 838 839 spi_finalize_current_message(master); 840 841 return ret; 842 } 843 844 /** 845 * spi_finalize_current_transfer - report completion of a transfer 846 * 847 * Called by SPI drivers using the core transfer_one_message() 848 * implementation to notify it that the current interrupt driven 849 * transfer has finished and the next one may be scheduled. 850 */ 851 void spi_finalize_current_transfer(struct spi_master *master) 852 { 853 complete(&master->xfer_completion); 854 } 855 EXPORT_SYMBOL_GPL(spi_finalize_current_transfer); 856 857 /** 858 * spi_pump_messages - kthread work function which processes spi message queue 859 * @work: pointer to kthread work struct contained in the master struct 860 * 861 * This function checks if there is any spi message in the queue that 862 * needs processing and if so call out to the driver to initialize hardware 863 * and transfer each message. 864 * 865 */ 866 static void spi_pump_messages(struct kthread_work *work) 867 { 868 struct spi_master *master = 869 container_of(work, struct spi_master, pump_messages); 870 unsigned long flags; 871 bool was_busy = false; 872 int ret; 873 874 /* Lock queue and check for queue work */ 875 spin_lock_irqsave(&master->queue_lock, flags); 876 if (list_empty(&master->queue) || !master->running) { 877 if (!master->busy) { 878 spin_unlock_irqrestore(&master->queue_lock, flags); 879 return; 880 } 881 master->busy = false; 882 spin_unlock_irqrestore(&master->queue_lock, flags); 883 kfree(master->dummy_rx); 884 master->dummy_rx = NULL; 885 kfree(master->dummy_tx); 886 master->dummy_tx = NULL; 887 if (master->unprepare_transfer_hardware && 888 master->unprepare_transfer_hardware(master)) 889 dev_err(&master->dev, 890 "failed to unprepare transfer hardware\n"); 891 if (master->auto_runtime_pm) { 892 pm_runtime_mark_last_busy(master->dev.parent); 893 pm_runtime_put_autosuspend(master->dev.parent); 894 } 895 trace_spi_master_idle(master); 896 return; 897 } 898 899 /* Make sure we are not already running a message */ 900 if (master->cur_msg) { 901 spin_unlock_irqrestore(&master->queue_lock, flags); 902 return; 903 } 904 /* Extract head of queue */ 905 master->cur_msg = 906 list_first_entry(&master->queue, struct spi_message, queue); 907 908 list_del_init(&master->cur_msg->queue); 909 if (master->busy) 910 was_busy = true; 911 else 912 master->busy = true; 913 spin_unlock_irqrestore(&master->queue_lock, flags); 914 915 if (!was_busy && master->auto_runtime_pm) { 916 ret = pm_runtime_get_sync(master->dev.parent); 917 if (ret < 0) { 918 dev_err(&master->dev, "Failed to power device: %d\n", 919 ret); 920 return; 921 } 922 } 923 924 if (!was_busy) 925 trace_spi_master_busy(master); 926 927 if (!was_busy && master->prepare_transfer_hardware) { 928 ret = master->prepare_transfer_hardware(master); 929 if (ret) { 930 dev_err(&master->dev, 931 "failed to prepare transfer hardware\n"); 932 933 if (master->auto_runtime_pm) 934 pm_runtime_put(master->dev.parent); 935 return; 936 } 937 } 938 939 trace_spi_message_start(master->cur_msg); 940 941 if (master->prepare_message) { 942 ret = master->prepare_message(master, master->cur_msg); 943 if (ret) { 944 dev_err(&master->dev, 945 "failed to prepare message: %d\n", ret); 946 master->cur_msg->status = ret; 947 spi_finalize_current_message(master); 948 return; 949 } 950 master->cur_msg_prepared = true; 951 } 952 953 ret = spi_map_msg(master, master->cur_msg); 954 if (ret) { 955 master->cur_msg->status = ret; 956 spi_finalize_current_message(master); 957 return; 958 } 959 960 ret = master->transfer_one_message(master, master->cur_msg); 961 if (ret) { 962 dev_err(&master->dev, 963 "failed to transfer one message from queue\n"); 964 return; 965 } 966 } 967 968 static int spi_init_queue(struct spi_master *master) 969 { 970 struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 }; 971 972 INIT_LIST_HEAD(&master->queue); 973 spin_lock_init(&master->queue_lock); 974 975 master->running = false; 976 master->busy = false; 977 978 init_kthread_worker(&master->kworker); 979 master->kworker_task = kthread_run(kthread_worker_fn, 980 &master->kworker, "%s", 981 dev_name(&master->dev)); 982 if (IS_ERR(master->kworker_task)) { 983 dev_err(&master->dev, "failed to create message pump task\n"); 984 return -ENOMEM; 985 } 986 init_kthread_work(&master->pump_messages, spi_pump_messages); 987 988 /* 989 * Master config will indicate if this controller should run the 990 * message pump with high (realtime) priority to reduce the transfer 991 * latency on the bus by minimising the delay between a transfer 992 * request and the scheduling of the message pump thread. Without this 993 * setting the message pump thread will remain at default priority. 994 */ 995 if (master->rt) { 996 dev_info(&master->dev, 997 "will run message pump with realtime priority\n"); 998 sched_setscheduler(master->kworker_task, SCHED_FIFO, ¶m); 999 } 1000 1001 return 0; 1002 } 1003 1004 /** 1005 * spi_get_next_queued_message() - called by driver to check for queued 1006 * messages 1007 * @master: the master to check for queued messages 1008 * 1009 * If there are more messages in the queue, the next message is returned from 1010 * this call. 1011 */ 1012 struct spi_message *spi_get_next_queued_message(struct spi_master *master) 1013 { 1014 struct spi_message *next; 1015 unsigned long flags; 1016 1017 /* get a pointer to the next message, if any */ 1018 spin_lock_irqsave(&master->queue_lock, flags); 1019 next = list_first_entry_or_null(&master->queue, struct spi_message, 1020 queue); 1021 spin_unlock_irqrestore(&master->queue_lock, flags); 1022 1023 return next; 1024 } 1025 EXPORT_SYMBOL_GPL(spi_get_next_queued_message); 1026 1027 /** 1028 * spi_finalize_current_message() - the current message is complete 1029 * @master: the master to return the message to 1030 * 1031 * Called by the driver to notify the core that the message in the front of the 1032 * queue is complete and can be removed from the queue. 1033 */ 1034 void spi_finalize_current_message(struct spi_master *master) 1035 { 1036 struct spi_message *mesg; 1037 unsigned long flags; 1038 int ret; 1039 1040 spin_lock_irqsave(&master->queue_lock, flags); 1041 mesg = master->cur_msg; 1042 master->cur_msg = NULL; 1043 1044 queue_kthread_work(&master->kworker, &master->pump_messages); 1045 spin_unlock_irqrestore(&master->queue_lock, flags); 1046 1047 spi_unmap_msg(master, mesg); 1048 1049 if (master->cur_msg_prepared && master->unprepare_message) { 1050 ret = master->unprepare_message(master, mesg); 1051 if (ret) { 1052 dev_err(&master->dev, 1053 "failed to unprepare message: %d\n", ret); 1054 } 1055 } 1056 master->cur_msg_prepared = false; 1057 1058 mesg->state = NULL; 1059 if (mesg->complete) 1060 mesg->complete(mesg->context); 1061 1062 trace_spi_message_done(mesg); 1063 } 1064 EXPORT_SYMBOL_GPL(spi_finalize_current_message); 1065 1066 static int spi_start_queue(struct spi_master *master) 1067 { 1068 unsigned long flags; 1069 1070 spin_lock_irqsave(&master->queue_lock, flags); 1071 1072 if (master->running || master->busy) { 1073 spin_unlock_irqrestore(&master->queue_lock, flags); 1074 return -EBUSY; 1075 } 1076 1077 master->running = true; 1078 master->cur_msg = NULL; 1079 spin_unlock_irqrestore(&master->queue_lock, flags); 1080 1081 queue_kthread_work(&master->kworker, &master->pump_messages); 1082 1083 return 0; 1084 } 1085 1086 static int spi_stop_queue(struct spi_master *master) 1087 { 1088 unsigned long flags; 1089 unsigned limit = 500; 1090 int ret = 0; 1091 1092 spin_lock_irqsave(&master->queue_lock, flags); 1093 1094 /* 1095 * This is a bit lame, but is optimized for the common execution path. 1096 * A wait_queue on the master->busy could be used, but then the common 1097 * execution path (pump_messages) would be required to call wake_up or 1098 * friends on every SPI message. Do this instead. 1099 */ 1100 while ((!list_empty(&master->queue) || master->busy) && limit--) { 1101 spin_unlock_irqrestore(&master->queue_lock, flags); 1102 usleep_range(10000, 11000); 1103 spin_lock_irqsave(&master->queue_lock, flags); 1104 } 1105 1106 if (!list_empty(&master->queue) || master->busy) 1107 ret = -EBUSY; 1108 else 1109 master->running = false; 1110 1111 spin_unlock_irqrestore(&master->queue_lock, flags); 1112 1113 if (ret) { 1114 dev_warn(&master->dev, 1115 "could not stop message queue\n"); 1116 return ret; 1117 } 1118 return ret; 1119 } 1120 1121 static int spi_destroy_queue(struct spi_master *master) 1122 { 1123 int ret; 1124 1125 ret = spi_stop_queue(master); 1126 1127 /* 1128 * flush_kthread_worker will block until all work is done. 1129 * If the reason that stop_queue timed out is that the work will never 1130 * finish, then it does no good to call flush/stop thread, so 1131 * return anyway. 1132 */ 1133 if (ret) { 1134 dev_err(&master->dev, "problem destroying queue\n"); 1135 return ret; 1136 } 1137 1138 flush_kthread_worker(&master->kworker); 1139 kthread_stop(master->kworker_task); 1140 1141 return 0; 1142 } 1143 1144 /** 1145 * spi_queued_transfer - transfer function for queued transfers 1146 * @spi: spi device which is requesting transfer 1147 * @msg: spi message which is to handled is queued to driver queue 1148 */ 1149 static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg) 1150 { 1151 struct spi_master *master = spi->master; 1152 unsigned long flags; 1153 1154 spin_lock_irqsave(&master->queue_lock, flags); 1155 1156 if (!master->running) { 1157 spin_unlock_irqrestore(&master->queue_lock, flags); 1158 return -ESHUTDOWN; 1159 } 1160 msg->actual_length = 0; 1161 msg->status = -EINPROGRESS; 1162 1163 list_add_tail(&msg->queue, &master->queue); 1164 if (!master->busy) 1165 queue_kthread_work(&master->kworker, &master->pump_messages); 1166 1167 spin_unlock_irqrestore(&master->queue_lock, flags); 1168 return 0; 1169 } 1170 1171 static int spi_master_initialize_queue(struct spi_master *master) 1172 { 1173 int ret; 1174 1175 master->transfer = spi_queued_transfer; 1176 if (!master->transfer_one_message) 1177 master->transfer_one_message = spi_transfer_one_message; 1178 1179 /* Initialize and start queue */ 1180 ret = spi_init_queue(master); 1181 if (ret) { 1182 dev_err(&master->dev, "problem initializing queue\n"); 1183 goto err_init_queue; 1184 } 1185 master->queued = true; 1186 ret = spi_start_queue(master); 1187 if (ret) { 1188 dev_err(&master->dev, "problem starting queue\n"); 1189 goto err_start_queue; 1190 } 1191 1192 return 0; 1193 1194 err_start_queue: 1195 spi_destroy_queue(master); 1196 err_init_queue: 1197 return ret; 1198 } 1199 1200 /*-------------------------------------------------------------------------*/ 1201 1202 #if defined(CONFIG_OF) 1203 /** 1204 * of_register_spi_devices() - Register child devices onto the SPI bus 1205 * @master: Pointer to spi_master device 1206 * 1207 * Registers an spi_device for each child node of master node which has a 'reg' 1208 * property. 1209 */ 1210 static void of_register_spi_devices(struct spi_master *master) 1211 { 1212 struct spi_device *spi; 1213 struct device_node *nc; 1214 int rc; 1215 u32 value; 1216 1217 if (!master->dev.of_node) 1218 return; 1219 1220 for_each_available_child_of_node(master->dev.of_node, nc) { 1221 /* Alloc an spi_device */ 1222 spi = spi_alloc_device(master); 1223 if (!spi) { 1224 dev_err(&master->dev, "spi_device alloc error for %s\n", 1225 nc->full_name); 1226 spi_dev_put(spi); 1227 continue; 1228 } 1229 1230 /* Select device driver */ 1231 if (of_modalias_node(nc, spi->modalias, 1232 sizeof(spi->modalias)) < 0) { 1233 dev_err(&master->dev, "cannot find modalias for %s\n", 1234 nc->full_name); 1235 spi_dev_put(spi); 1236 continue; 1237 } 1238 1239 /* Device address */ 1240 rc = of_property_read_u32(nc, "reg", &value); 1241 if (rc) { 1242 dev_err(&master->dev, "%s has no valid 'reg' property (%d)\n", 1243 nc->full_name, rc); 1244 spi_dev_put(spi); 1245 continue; 1246 } 1247 spi->chip_select = value; 1248 1249 /* Mode (clock phase/polarity/etc.) */ 1250 if (of_find_property(nc, "spi-cpha", NULL)) 1251 spi->mode |= SPI_CPHA; 1252 if (of_find_property(nc, "spi-cpol", NULL)) 1253 spi->mode |= SPI_CPOL; 1254 if (of_find_property(nc, "spi-cs-high", NULL)) 1255 spi->mode |= SPI_CS_HIGH; 1256 if (of_find_property(nc, "spi-3wire", NULL)) 1257 spi->mode |= SPI_3WIRE; 1258 if (of_find_property(nc, "spi-lsb-first", NULL)) 1259 spi->mode |= SPI_LSB_FIRST; 1260 1261 /* Device DUAL/QUAD mode */ 1262 if (!of_property_read_u32(nc, "spi-tx-bus-width", &value)) { 1263 switch (value) { 1264 case 1: 1265 break; 1266 case 2: 1267 spi->mode |= SPI_TX_DUAL; 1268 break; 1269 case 4: 1270 spi->mode |= SPI_TX_QUAD; 1271 break; 1272 default: 1273 dev_warn(&master->dev, 1274 "spi-tx-bus-width %d not supported\n", 1275 value); 1276 break; 1277 } 1278 } 1279 1280 if (!of_property_read_u32(nc, "spi-rx-bus-width", &value)) { 1281 switch (value) { 1282 case 1: 1283 break; 1284 case 2: 1285 spi->mode |= SPI_RX_DUAL; 1286 break; 1287 case 4: 1288 spi->mode |= SPI_RX_QUAD; 1289 break; 1290 default: 1291 dev_warn(&master->dev, 1292 "spi-rx-bus-width %d not supported\n", 1293 value); 1294 break; 1295 } 1296 } 1297 1298 /* Device speed */ 1299 rc = of_property_read_u32(nc, "spi-max-frequency", &value); 1300 if (rc) { 1301 dev_err(&master->dev, "%s has no valid 'spi-max-frequency' property (%d)\n", 1302 nc->full_name, rc); 1303 spi_dev_put(spi); 1304 continue; 1305 } 1306 spi->max_speed_hz = value; 1307 1308 /* IRQ */ 1309 spi->irq = irq_of_parse_and_map(nc, 0); 1310 1311 /* Store a pointer to the node in the device structure */ 1312 of_node_get(nc); 1313 spi->dev.of_node = nc; 1314 1315 /* Register the new device */ 1316 request_module("%s%s", SPI_MODULE_PREFIX, spi->modalias); 1317 rc = spi_add_device(spi); 1318 if (rc) { 1319 dev_err(&master->dev, "spi_device register error %s\n", 1320 nc->full_name); 1321 spi_dev_put(spi); 1322 } 1323 1324 } 1325 } 1326 #else 1327 static void of_register_spi_devices(struct spi_master *master) { } 1328 #endif 1329 1330 #ifdef CONFIG_ACPI 1331 static int acpi_spi_add_resource(struct acpi_resource *ares, void *data) 1332 { 1333 struct spi_device *spi = data; 1334 1335 if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) { 1336 struct acpi_resource_spi_serialbus *sb; 1337 1338 sb = &ares->data.spi_serial_bus; 1339 if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_SPI) { 1340 spi->chip_select = sb->device_selection; 1341 spi->max_speed_hz = sb->connection_speed; 1342 1343 if (sb->clock_phase == ACPI_SPI_SECOND_PHASE) 1344 spi->mode |= SPI_CPHA; 1345 if (sb->clock_polarity == ACPI_SPI_START_HIGH) 1346 spi->mode |= SPI_CPOL; 1347 if (sb->device_polarity == ACPI_SPI_ACTIVE_HIGH) 1348 spi->mode |= SPI_CS_HIGH; 1349 } 1350 } else if (spi->irq < 0) { 1351 struct resource r; 1352 1353 if (acpi_dev_resource_interrupt(ares, 0, &r)) 1354 spi->irq = r.start; 1355 } 1356 1357 /* Always tell the ACPI core to skip this resource */ 1358 return 1; 1359 } 1360 1361 static acpi_status acpi_spi_add_device(acpi_handle handle, u32 level, 1362 void *data, void **return_value) 1363 { 1364 struct spi_master *master = data; 1365 struct list_head resource_list; 1366 struct acpi_device *adev; 1367 struct spi_device *spi; 1368 int ret; 1369 1370 if (acpi_bus_get_device(handle, &adev)) 1371 return AE_OK; 1372 if (acpi_bus_get_status(adev) || !adev->status.present) 1373 return AE_OK; 1374 1375 spi = spi_alloc_device(master); 1376 if (!spi) { 1377 dev_err(&master->dev, "failed to allocate SPI device for %s\n", 1378 dev_name(&adev->dev)); 1379 return AE_NO_MEMORY; 1380 } 1381 1382 ACPI_COMPANION_SET(&spi->dev, adev); 1383 spi->irq = -1; 1384 1385 INIT_LIST_HEAD(&resource_list); 1386 ret = acpi_dev_get_resources(adev, &resource_list, 1387 acpi_spi_add_resource, spi); 1388 acpi_dev_free_resource_list(&resource_list); 1389 1390 if (ret < 0 || !spi->max_speed_hz) { 1391 spi_dev_put(spi); 1392 return AE_OK; 1393 } 1394 1395 adev->power.flags.ignore_parent = true; 1396 strlcpy(spi->modalias, acpi_device_hid(adev), sizeof(spi->modalias)); 1397 if (spi_add_device(spi)) { 1398 adev->power.flags.ignore_parent = false; 1399 dev_err(&master->dev, "failed to add SPI device %s from ACPI\n", 1400 dev_name(&adev->dev)); 1401 spi_dev_put(spi); 1402 } 1403 1404 return AE_OK; 1405 } 1406 1407 static void acpi_register_spi_devices(struct spi_master *master) 1408 { 1409 acpi_status status; 1410 acpi_handle handle; 1411 1412 handle = ACPI_HANDLE(master->dev.parent); 1413 if (!handle) 1414 return; 1415 1416 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1, 1417 acpi_spi_add_device, NULL, 1418 master, NULL); 1419 if (ACPI_FAILURE(status)) 1420 dev_warn(&master->dev, "failed to enumerate SPI slaves\n"); 1421 } 1422 #else 1423 static inline void acpi_register_spi_devices(struct spi_master *master) {} 1424 #endif /* CONFIG_ACPI */ 1425 1426 static void spi_master_release(struct device *dev) 1427 { 1428 struct spi_master *master; 1429 1430 master = container_of(dev, struct spi_master, dev); 1431 kfree(master); 1432 } 1433 1434 static struct class spi_master_class = { 1435 .name = "spi_master", 1436 .owner = THIS_MODULE, 1437 .dev_release = spi_master_release, 1438 }; 1439 1440 1441 1442 /** 1443 * spi_alloc_master - allocate SPI master controller 1444 * @dev: the controller, possibly using the platform_bus 1445 * @size: how much zeroed driver-private data to allocate; the pointer to this 1446 * memory is in the driver_data field of the returned device, 1447 * accessible with spi_master_get_devdata(). 1448 * Context: can sleep 1449 * 1450 * This call is used only by SPI master controller drivers, which are the 1451 * only ones directly touching chip registers. It's how they allocate 1452 * an spi_master structure, prior to calling spi_register_master(). 1453 * 1454 * This must be called from context that can sleep. It returns the SPI 1455 * master structure on success, else NULL. 1456 * 1457 * The caller is responsible for assigning the bus number and initializing 1458 * the master's methods before calling spi_register_master(); and (after errors 1459 * adding the device) calling spi_master_put() and kfree() to prevent a memory 1460 * leak. 1461 */ 1462 struct spi_master *spi_alloc_master(struct device *dev, unsigned size) 1463 { 1464 struct spi_master *master; 1465 1466 if (!dev) 1467 return NULL; 1468 1469 master = kzalloc(size + sizeof(*master), GFP_KERNEL); 1470 if (!master) 1471 return NULL; 1472 1473 device_initialize(&master->dev); 1474 master->bus_num = -1; 1475 master->num_chipselect = 1; 1476 master->dev.class = &spi_master_class; 1477 master->dev.parent = get_device(dev); 1478 spi_master_set_devdata(master, &master[1]); 1479 1480 return master; 1481 } 1482 EXPORT_SYMBOL_GPL(spi_alloc_master); 1483 1484 #ifdef CONFIG_OF 1485 static int of_spi_register_master(struct spi_master *master) 1486 { 1487 int nb, i, *cs; 1488 struct device_node *np = master->dev.of_node; 1489 1490 if (!np) 1491 return 0; 1492 1493 nb = of_gpio_named_count(np, "cs-gpios"); 1494 master->num_chipselect = max_t(int, nb, master->num_chipselect); 1495 1496 /* Return error only for an incorrectly formed cs-gpios property */ 1497 if (nb == 0 || nb == -ENOENT) 1498 return 0; 1499 else if (nb < 0) 1500 return nb; 1501 1502 cs = devm_kzalloc(&master->dev, 1503 sizeof(int) * master->num_chipselect, 1504 GFP_KERNEL); 1505 master->cs_gpios = cs; 1506 1507 if (!master->cs_gpios) 1508 return -ENOMEM; 1509 1510 for (i = 0; i < master->num_chipselect; i++) 1511 cs[i] = -ENOENT; 1512 1513 for (i = 0; i < nb; i++) 1514 cs[i] = of_get_named_gpio(np, "cs-gpios", i); 1515 1516 return 0; 1517 } 1518 #else 1519 static int of_spi_register_master(struct spi_master *master) 1520 { 1521 return 0; 1522 } 1523 #endif 1524 1525 /** 1526 * spi_register_master - register SPI master controller 1527 * @master: initialized master, originally from spi_alloc_master() 1528 * Context: can sleep 1529 * 1530 * SPI master controllers connect to their drivers using some non-SPI bus, 1531 * such as the platform bus. The final stage of probe() in that code 1532 * includes calling spi_register_master() to hook up to this SPI bus glue. 1533 * 1534 * SPI controllers use board specific (often SOC specific) bus numbers, 1535 * and board-specific addressing for SPI devices combines those numbers 1536 * with chip select numbers. Since SPI does not directly support dynamic 1537 * device identification, boards need configuration tables telling which 1538 * chip is at which address. 1539 * 1540 * This must be called from context that can sleep. It returns zero on 1541 * success, else a negative error code (dropping the master's refcount). 1542 * After a successful return, the caller is responsible for calling 1543 * spi_unregister_master(). 1544 */ 1545 int spi_register_master(struct spi_master *master) 1546 { 1547 static atomic_t dyn_bus_id = ATOMIC_INIT((1<<15) - 1); 1548 struct device *dev = master->dev.parent; 1549 struct boardinfo *bi; 1550 int status = -ENODEV; 1551 int dynamic = 0; 1552 1553 if (!dev) 1554 return -ENODEV; 1555 1556 status = of_spi_register_master(master); 1557 if (status) 1558 return status; 1559 1560 /* even if it's just one always-selected device, there must 1561 * be at least one chipselect 1562 */ 1563 if (master->num_chipselect == 0) 1564 return -EINVAL; 1565 1566 if ((master->bus_num < 0) && master->dev.of_node) 1567 master->bus_num = of_alias_get_id(master->dev.of_node, "spi"); 1568 1569 /* convention: dynamically assigned bus IDs count down from the max */ 1570 if (master->bus_num < 0) { 1571 /* FIXME switch to an IDR based scheme, something like 1572 * I2C now uses, so we can't run out of "dynamic" IDs 1573 */ 1574 master->bus_num = atomic_dec_return(&dyn_bus_id); 1575 dynamic = 1; 1576 } 1577 1578 spin_lock_init(&master->bus_lock_spinlock); 1579 mutex_init(&master->bus_lock_mutex); 1580 master->bus_lock_flag = 0; 1581 init_completion(&master->xfer_completion); 1582 if (!master->max_dma_len) 1583 master->max_dma_len = INT_MAX; 1584 1585 /* register the device, then userspace will see it. 1586 * registration fails if the bus ID is in use. 1587 */ 1588 dev_set_name(&master->dev, "spi%u", master->bus_num); 1589 status = device_add(&master->dev); 1590 if (status < 0) 1591 goto done; 1592 dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev), 1593 dynamic ? " (dynamic)" : ""); 1594 1595 /* If we're using a queued driver, start the queue */ 1596 if (master->transfer) 1597 dev_info(dev, "master is unqueued, this is deprecated\n"); 1598 else { 1599 status = spi_master_initialize_queue(master); 1600 if (status) { 1601 device_del(&master->dev); 1602 goto done; 1603 } 1604 } 1605 1606 mutex_lock(&board_lock); 1607 list_add_tail(&master->list, &spi_master_list); 1608 list_for_each_entry(bi, &board_list, list) 1609 spi_match_master_to_boardinfo(master, &bi->board_info); 1610 mutex_unlock(&board_lock); 1611 1612 /* Register devices from the device tree and ACPI */ 1613 of_register_spi_devices(master); 1614 acpi_register_spi_devices(master); 1615 done: 1616 return status; 1617 } 1618 EXPORT_SYMBOL_GPL(spi_register_master); 1619 1620 static void devm_spi_unregister(struct device *dev, void *res) 1621 { 1622 spi_unregister_master(*(struct spi_master **)res); 1623 } 1624 1625 /** 1626 * dev_spi_register_master - register managed SPI master controller 1627 * @dev: device managing SPI master 1628 * @master: initialized master, originally from spi_alloc_master() 1629 * Context: can sleep 1630 * 1631 * Register a SPI device as with spi_register_master() which will 1632 * automatically be unregister 1633 */ 1634 int devm_spi_register_master(struct device *dev, struct spi_master *master) 1635 { 1636 struct spi_master **ptr; 1637 int ret; 1638 1639 ptr = devres_alloc(devm_spi_unregister, sizeof(*ptr), GFP_KERNEL); 1640 if (!ptr) 1641 return -ENOMEM; 1642 1643 ret = spi_register_master(master); 1644 if (!ret) { 1645 *ptr = master; 1646 devres_add(dev, ptr); 1647 } else { 1648 devres_free(ptr); 1649 } 1650 1651 return ret; 1652 } 1653 EXPORT_SYMBOL_GPL(devm_spi_register_master); 1654 1655 static int __unregister(struct device *dev, void *null) 1656 { 1657 spi_unregister_device(to_spi_device(dev)); 1658 return 0; 1659 } 1660 1661 /** 1662 * spi_unregister_master - unregister SPI master controller 1663 * @master: the master being unregistered 1664 * Context: can sleep 1665 * 1666 * This call is used only by SPI master controller drivers, which are the 1667 * only ones directly touching chip registers. 1668 * 1669 * This must be called from context that can sleep. 1670 */ 1671 void spi_unregister_master(struct spi_master *master) 1672 { 1673 int dummy; 1674 1675 if (master->queued) { 1676 if (spi_destroy_queue(master)) 1677 dev_err(&master->dev, "queue remove failed\n"); 1678 } 1679 1680 mutex_lock(&board_lock); 1681 list_del(&master->list); 1682 mutex_unlock(&board_lock); 1683 1684 dummy = device_for_each_child(&master->dev, NULL, __unregister); 1685 device_unregister(&master->dev); 1686 } 1687 EXPORT_SYMBOL_GPL(spi_unregister_master); 1688 1689 int spi_master_suspend(struct spi_master *master) 1690 { 1691 int ret; 1692 1693 /* Basically no-ops for non-queued masters */ 1694 if (!master->queued) 1695 return 0; 1696 1697 ret = spi_stop_queue(master); 1698 if (ret) 1699 dev_err(&master->dev, "queue stop failed\n"); 1700 1701 return ret; 1702 } 1703 EXPORT_SYMBOL_GPL(spi_master_suspend); 1704 1705 int spi_master_resume(struct spi_master *master) 1706 { 1707 int ret; 1708 1709 if (!master->queued) 1710 return 0; 1711 1712 ret = spi_start_queue(master); 1713 if (ret) 1714 dev_err(&master->dev, "queue restart failed\n"); 1715 1716 return ret; 1717 } 1718 EXPORT_SYMBOL_GPL(spi_master_resume); 1719 1720 static int __spi_master_match(struct device *dev, const void *data) 1721 { 1722 struct spi_master *m; 1723 const u16 *bus_num = data; 1724 1725 m = container_of(dev, struct spi_master, dev); 1726 return m->bus_num == *bus_num; 1727 } 1728 1729 /** 1730 * spi_busnum_to_master - look up master associated with bus_num 1731 * @bus_num: the master's bus number 1732 * Context: can sleep 1733 * 1734 * This call may be used with devices that are registered after 1735 * arch init time. It returns a refcounted pointer to the relevant 1736 * spi_master (which the caller must release), or NULL if there is 1737 * no such master registered. 1738 */ 1739 struct spi_master *spi_busnum_to_master(u16 bus_num) 1740 { 1741 struct device *dev; 1742 struct spi_master *master = NULL; 1743 1744 dev = class_find_device(&spi_master_class, NULL, &bus_num, 1745 __spi_master_match); 1746 if (dev) 1747 master = container_of(dev, struct spi_master, dev); 1748 /* reference got in class_find_device */ 1749 return master; 1750 } 1751 EXPORT_SYMBOL_GPL(spi_busnum_to_master); 1752 1753 1754 /*-------------------------------------------------------------------------*/ 1755 1756 /* Core methods for SPI master protocol drivers. Some of the 1757 * other core methods are currently defined as inline functions. 1758 */ 1759 1760 /** 1761 * spi_setup - setup SPI mode and clock rate 1762 * @spi: the device whose settings are being modified 1763 * Context: can sleep, and no requests are queued to the device 1764 * 1765 * SPI protocol drivers may need to update the transfer mode if the 1766 * device doesn't work with its default. They may likewise need 1767 * to update clock rates or word sizes from initial values. This function 1768 * changes those settings, and must be called from a context that can sleep. 1769 * Except for SPI_CS_HIGH, which takes effect immediately, the changes take 1770 * effect the next time the device is selected and data is transferred to 1771 * or from it. When this function returns, the spi device is deselected. 1772 * 1773 * Note that this call will fail if the protocol driver specifies an option 1774 * that the underlying controller or its driver does not support. For 1775 * example, not all hardware supports wire transfers using nine bit words, 1776 * LSB-first wire encoding, or active-high chipselects. 1777 */ 1778 int spi_setup(struct spi_device *spi) 1779 { 1780 unsigned bad_bits, ugly_bits; 1781 int status = 0; 1782 1783 /* check mode to prevent that DUAL and QUAD set at the same time 1784 */ 1785 if (((spi->mode & SPI_TX_DUAL) && (spi->mode & SPI_TX_QUAD)) || 1786 ((spi->mode & SPI_RX_DUAL) && (spi->mode & SPI_RX_QUAD))) { 1787 dev_err(&spi->dev, 1788 "setup: can not select dual and quad at the same time\n"); 1789 return -EINVAL; 1790 } 1791 /* if it is SPI_3WIRE mode, DUAL and QUAD should be forbidden 1792 */ 1793 if ((spi->mode & SPI_3WIRE) && (spi->mode & 1794 (SPI_TX_DUAL | SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD))) 1795 return -EINVAL; 1796 /* help drivers fail *cleanly* when they need options 1797 * that aren't supported with their current master 1798 */ 1799 bad_bits = spi->mode & ~spi->master->mode_bits; 1800 ugly_bits = bad_bits & 1801 (SPI_TX_DUAL | SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD); 1802 if (ugly_bits) { 1803 dev_warn(&spi->dev, 1804 "setup: ignoring unsupported mode bits %x\n", 1805 ugly_bits); 1806 spi->mode &= ~ugly_bits; 1807 bad_bits &= ~ugly_bits; 1808 } 1809 if (bad_bits) { 1810 dev_err(&spi->dev, "setup: unsupported mode bits %x\n", 1811 bad_bits); 1812 return -EINVAL; 1813 } 1814 1815 if (!spi->bits_per_word) 1816 spi->bits_per_word = 8; 1817 1818 if (!spi->max_speed_hz) 1819 spi->max_speed_hz = spi->master->max_speed_hz; 1820 1821 if (spi->master->setup) 1822 status = spi->master->setup(spi); 1823 1824 dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s%u bits/w, %u Hz max --> %d\n", 1825 (int) (spi->mode & (SPI_CPOL | SPI_CPHA)), 1826 (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "", 1827 (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "", 1828 (spi->mode & SPI_3WIRE) ? "3wire, " : "", 1829 (spi->mode & SPI_LOOP) ? "loopback, " : "", 1830 spi->bits_per_word, spi->max_speed_hz, 1831 status); 1832 1833 return status; 1834 } 1835 EXPORT_SYMBOL_GPL(spi_setup); 1836 1837 static int __spi_validate(struct spi_device *spi, struct spi_message *message) 1838 { 1839 struct spi_master *master = spi->master; 1840 struct spi_transfer *xfer; 1841 int w_size; 1842 1843 if (list_empty(&message->transfers)) 1844 return -EINVAL; 1845 1846 /* Half-duplex links include original MicroWire, and ones with 1847 * only one data pin like SPI_3WIRE (switches direction) or where 1848 * either MOSI or MISO is missing. They can also be caused by 1849 * software limitations. 1850 */ 1851 if ((master->flags & SPI_MASTER_HALF_DUPLEX) 1852 || (spi->mode & SPI_3WIRE)) { 1853 unsigned flags = master->flags; 1854 1855 list_for_each_entry(xfer, &message->transfers, transfer_list) { 1856 if (xfer->rx_buf && xfer->tx_buf) 1857 return -EINVAL; 1858 if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf) 1859 return -EINVAL; 1860 if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf) 1861 return -EINVAL; 1862 } 1863 } 1864 1865 /** 1866 * Set transfer bits_per_word and max speed as spi device default if 1867 * it is not set for this transfer. 1868 * Set transfer tx_nbits and rx_nbits as single transfer default 1869 * (SPI_NBITS_SINGLE) if it is not set for this transfer. 1870 */ 1871 list_for_each_entry(xfer, &message->transfers, transfer_list) { 1872 message->frame_length += xfer->len; 1873 if (!xfer->bits_per_word) 1874 xfer->bits_per_word = spi->bits_per_word; 1875 1876 if (!xfer->speed_hz) 1877 xfer->speed_hz = spi->max_speed_hz; 1878 1879 if (master->max_speed_hz && 1880 xfer->speed_hz > master->max_speed_hz) 1881 xfer->speed_hz = master->max_speed_hz; 1882 1883 if (master->bits_per_word_mask) { 1884 /* Only 32 bits fit in the mask */ 1885 if (xfer->bits_per_word > 32) 1886 return -EINVAL; 1887 if (!(master->bits_per_word_mask & 1888 BIT(xfer->bits_per_word - 1))) 1889 return -EINVAL; 1890 } 1891 1892 /* 1893 * SPI transfer length should be multiple of SPI word size 1894 * where SPI word size should be power-of-two multiple 1895 */ 1896 if (xfer->bits_per_word <= 8) 1897 w_size = 1; 1898 else if (xfer->bits_per_word <= 16) 1899 w_size = 2; 1900 else 1901 w_size = 4; 1902 1903 /* No partial transfers accepted */ 1904 if (xfer->len % w_size) 1905 return -EINVAL; 1906 1907 if (xfer->speed_hz && master->min_speed_hz && 1908 xfer->speed_hz < master->min_speed_hz) 1909 return -EINVAL; 1910 1911 if (xfer->tx_buf && !xfer->tx_nbits) 1912 xfer->tx_nbits = SPI_NBITS_SINGLE; 1913 if (xfer->rx_buf && !xfer->rx_nbits) 1914 xfer->rx_nbits = SPI_NBITS_SINGLE; 1915 /* check transfer tx/rx_nbits: 1916 * 1. check the value matches one of single, dual and quad 1917 * 2. check tx/rx_nbits match the mode in spi_device 1918 */ 1919 if (xfer->tx_buf) { 1920 if (xfer->tx_nbits != SPI_NBITS_SINGLE && 1921 xfer->tx_nbits != SPI_NBITS_DUAL && 1922 xfer->tx_nbits != SPI_NBITS_QUAD) 1923 return -EINVAL; 1924 if ((xfer->tx_nbits == SPI_NBITS_DUAL) && 1925 !(spi->mode & (SPI_TX_DUAL | SPI_TX_QUAD))) 1926 return -EINVAL; 1927 if ((xfer->tx_nbits == SPI_NBITS_QUAD) && 1928 !(spi->mode & SPI_TX_QUAD)) 1929 return -EINVAL; 1930 } 1931 /* check transfer rx_nbits */ 1932 if (xfer->rx_buf) { 1933 if (xfer->rx_nbits != SPI_NBITS_SINGLE && 1934 xfer->rx_nbits != SPI_NBITS_DUAL && 1935 xfer->rx_nbits != SPI_NBITS_QUAD) 1936 return -EINVAL; 1937 if ((xfer->rx_nbits == SPI_NBITS_DUAL) && 1938 !(spi->mode & (SPI_RX_DUAL | SPI_RX_QUAD))) 1939 return -EINVAL; 1940 if ((xfer->rx_nbits == SPI_NBITS_QUAD) && 1941 !(spi->mode & SPI_RX_QUAD)) 1942 return -EINVAL; 1943 } 1944 } 1945 1946 message->status = -EINPROGRESS; 1947 1948 return 0; 1949 } 1950 1951 static int __spi_async(struct spi_device *spi, struct spi_message *message) 1952 { 1953 struct spi_master *master = spi->master; 1954 1955 message->spi = spi; 1956 1957 trace_spi_message_submit(message); 1958 1959 return master->transfer(spi, message); 1960 } 1961 1962 /** 1963 * spi_async - asynchronous SPI transfer 1964 * @spi: device with which data will be exchanged 1965 * @message: describes the data transfers, including completion callback 1966 * Context: any (irqs may be blocked, etc) 1967 * 1968 * This call may be used in_irq and other contexts which can't sleep, 1969 * as well as from task contexts which can sleep. 1970 * 1971 * The completion callback is invoked in a context which can't sleep. 1972 * Before that invocation, the value of message->status is undefined. 1973 * When the callback is issued, message->status holds either zero (to 1974 * indicate complete success) or a negative error code. After that 1975 * callback returns, the driver which issued the transfer request may 1976 * deallocate the associated memory; it's no longer in use by any SPI 1977 * core or controller driver code. 1978 * 1979 * Note that although all messages to a spi_device are handled in 1980 * FIFO order, messages may go to different devices in other orders. 1981 * Some device might be higher priority, or have various "hard" access 1982 * time requirements, for example. 1983 * 1984 * On detection of any fault during the transfer, processing of 1985 * the entire message is aborted, and the device is deselected. 1986 * Until returning from the associated message completion callback, 1987 * no other spi_message queued to that device will be processed. 1988 * (This rule applies equally to all the synchronous transfer calls, 1989 * which are wrappers around this core asynchronous primitive.) 1990 */ 1991 int spi_async(struct spi_device *spi, struct spi_message *message) 1992 { 1993 struct spi_master *master = spi->master; 1994 int ret; 1995 unsigned long flags; 1996 1997 ret = __spi_validate(spi, message); 1998 if (ret != 0) 1999 return ret; 2000 2001 spin_lock_irqsave(&master->bus_lock_spinlock, flags); 2002 2003 if (master->bus_lock_flag) 2004 ret = -EBUSY; 2005 else 2006 ret = __spi_async(spi, message); 2007 2008 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags); 2009 2010 return ret; 2011 } 2012 EXPORT_SYMBOL_GPL(spi_async); 2013 2014 /** 2015 * spi_async_locked - version of spi_async with exclusive bus usage 2016 * @spi: device with which data will be exchanged 2017 * @message: describes the data transfers, including completion callback 2018 * Context: any (irqs may be blocked, etc) 2019 * 2020 * This call may be used in_irq and other contexts which can't sleep, 2021 * as well as from task contexts which can sleep. 2022 * 2023 * The completion callback is invoked in a context which can't sleep. 2024 * Before that invocation, the value of message->status is undefined. 2025 * When the callback is issued, message->status holds either zero (to 2026 * indicate complete success) or a negative error code. After that 2027 * callback returns, the driver which issued the transfer request may 2028 * deallocate the associated memory; it's no longer in use by any SPI 2029 * core or controller driver code. 2030 * 2031 * Note that although all messages to a spi_device are handled in 2032 * FIFO order, messages may go to different devices in other orders. 2033 * Some device might be higher priority, or have various "hard" access 2034 * time requirements, for example. 2035 * 2036 * On detection of any fault during the transfer, processing of 2037 * the entire message is aborted, and the device is deselected. 2038 * Until returning from the associated message completion callback, 2039 * no other spi_message queued to that device will be processed. 2040 * (This rule applies equally to all the synchronous transfer calls, 2041 * which are wrappers around this core asynchronous primitive.) 2042 */ 2043 int spi_async_locked(struct spi_device *spi, struct spi_message *message) 2044 { 2045 struct spi_master *master = spi->master; 2046 int ret; 2047 unsigned long flags; 2048 2049 ret = __spi_validate(spi, message); 2050 if (ret != 0) 2051 return ret; 2052 2053 spin_lock_irqsave(&master->bus_lock_spinlock, flags); 2054 2055 ret = __spi_async(spi, message); 2056 2057 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags); 2058 2059 return ret; 2060 2061 } 2062 EXPORT_SYMBOL_GPL(spi_async_locked); 2063 2064 2065 /*-------------------------------------------------------------------------*/ 2066 2067 /* Utility methods for SPI master protocol drivers, layered on 2068 * top of the core. Some other utility methods are defined as 2069 * inline functions. 2070 */ 2071 2072 static void spi_complete(void *arg) 2073 { 2074 complete(arg); 2075 } 2076 2077 static int __spi_sync(struct spi_device *spi, struct spi_message *message, 2078 int bus_locked) 2079 { 2080 DECLARE_COMPLETION_ONSTACK(done); 2081 int status; 2082 struct spi_master *master = spi->master; 2083 2084 message->complete = spi_complete; 2085 message->context = &done; 2086 2087 if (!bus_locked) 2088 mutex_lock(&master->bus_lock_mutex); 2089 2090 status = spi_async_locked(spi, message); 2091 2092 if (!bus_locked) 2093 mutex_unlock(&master->bus_lock_mutex); 2094 2095 if (status == 0) { 2096 wait_for_completion(&done); 2097 status = message->status; 2098 } 2099 message->context = NULL; 2100 return status; 2101 } 2102 2103 /** 2104 * spi_sync - blocking/synchronous SPI data transfers 2105 * @spi: device with which data will be exchanged 2106 * @message: describes the data transfers 2107 * Context: can sleep 2108 * 2109 * This call may only be used from a context that may sleep. The sleep 2110 * is non-interruptible, and has no timeout. Low-overhead controller 2111 * drivers may DMA directly into and out of the message buffers. 2112 * 2113 * Note that the SPI device's chip select is active during the message, 2114 * and then is normally disabled between messages. Drivers for some 2115 * frequently-used devices may want to minimize costs of selecting a chip, 2116 * by leaving it selected in anticipation that the next message will go 2117 * to the same chip. (That may increase power usage.) 2118 * 2119 * Also, the caller is guaranteeing that the memory associated with the 2120 * message will not be freed before this call returns. 2121 * 2122 * It returns zero on success, else a negative error code. 2123 */ 2124 int spi_sync(struct spi_device *spi, struct spi_message *message) 2125 { 2126 return __spi_sync(spi, message, 0); 2127 } 2128 EXPORT_SYMBOL_GPL(spi_sync); 2129 2130 /** 2131 * spi_sync_locked - version of spi_sync with exclusive bus usage 2132 * @spi: device with which data will be exchanged 2133 * @message: describes the data transfers 2134 * Context: can sleep 2135 * 2136 * This call may only be used from a context that may sleep. The sleep 2137 * is non-interruptible, and has no timeout. Low-overhead controller 2138 * drivers may DMA directly into and out of the message buffers. 2139 * 2140 * This call should be used by drivers that require exclusive access to the 2141 * SPI bus. It has to be preceded by a spi_bus_lock call. The SPI bus must 2142 * be released by a spi_bus_unlock call when the exclusive access is over. 2143 * 2144 * It returns zero on success, else a negative error code. 2145 */ 2146 int spi_sync_locked(struct spi_device *spi, struct spi_message *message) 2147 { 2148 return __spi_sync(spi, message, 1); 2149 } 2150 EXPORT_SYMBOL_GPL(spi_sync_locked); 2151 2152 /** 2153 * spi_bus_lock - obtain a lock for exclusive SPI bus usage 2154 * @master: SPI bus master that should be locked for exclusive bus access 2155 * Context: can sleep 2156 * 2157 * This call may only be used from a context that may sleep. The sleep 2158 * is non-interruptible, and has no timeout. 2159 * 2160 * This call should be used by drivers that require exclusive access to the 2161 * SPI bus. The SPI bus must be released by a spi_bus_unlock call when the 2162 * exclusive access is over. Data transfer must be done by spi_sync_locked 2163 * and spi_async_locked calls when the SPI bus lock is held. 2164 * 2165 * It returns zero on success, else a negative error code. 2166 */ 2167 int spi_bus_lock(struct spi_master *master) 2168 { 2169 unsigned long flags; 2170 2171 mutex_lock(&master->bus_lock_mutex); 2172 2173 spin_lock_irqsave(&master->bus_lock_spinlock, flags); 2174 master->bus_lock_flag = 1; 2175 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags); 2176 2177 /* mutex remains locked until spi_bus_unlock is called */ 2178 2179 return 0; 2180 } 2181 EXPORT_SYMBOL_GPL(spi_bus_lock); 2182 2183 /** 2184 * spi_bus_unlock - release the lock for exclusive SPI bus usage 2185 * @master: SPI bus master that was locked for exclusive bus access 2186 * Context: can sleep 2187 * 2188 * This call may only be used from a context that may sleep. The sleep 2189 * is non-interruptible, and has no timeout. 2190 * 2191 * This call releases an SPI bus lock previously obtained by an spi_bus_lock 2192 * call. 2193 * 2194 * It returns zero on success, else a negative error code. 2195 */ 2196 int spi_bus_unlock(struct spi_master *master) 2197 { 2198 master->bus_lock_flag = 0; 2199 2200 mutex_unlock(&master->bus_lock_mutex); 2201 2202 return 0; 2203 } 2204 EXPORT_SYMBOL_GPL(spi_bus_unlock); 2205 2206 /* portable code must never pass more than 32 bytes */ 2207 #define SPI_BUFSIZ max(32, SMP_CACHE_BYTES) 2208 2209 static u8 *buf; 2210 2211 /** 2212 * spi_write_then_read - SPI synchronous write followed by read 2213 * @spi: device with which data will be exchanged 2214 * @txbuf: data to be written (need not be dma-safe) 2215 * @n_tx: size of txbuf, in bytes 2216 * @rxbuf: buffer into which data will be read (need not be dma-safe) 2217 * @n_rx: size of rxbuf, in bytes 2218 * Context: can sleep 2219 * 2220 * This performs a half duplex MicroWire style transaction with the 2221 * device, sending txbuf and then reading rxbuf. The return value 2222 * is zero for success, else a negative errno status code. 2223 * This call may only be used from a context that may sleep. 2224 * 2225 * Parameters to this routine are always copied using a small buffer; 2226 * portable code should never use this for more than 32 bytes. 2227 * Performance-sensitive or bulk transfer code should instead use 2228 * spi_{async,sync}() calls with dma-safe buffers. 2229 */ 2230 int spi_write_then_read(struct spi_device *spi, 2231 const void *txbuf, unsigned n_tx, 2232 void *rxbuf, unsigned n_rx) 2233 { 2234 static DEFINE_MUTEX(lock); 2235 2236 int status; 2237 struct spi_message message; 2238 struct spi_transfer x[2]; 2239 u8 *local_buf; 2240 2241 /* Use preallocated DMA-safe buffer if we can. We can't avoid 2242 * copying here, (as a pure convenience thing), but we can 2243 * keep heap costs out of the hot path unless someone else is 2244 * using the pre-allocated buffer or the transfer is too large. 2245 */ 2246 if ((n_tx + n_rx) > SPI_BUFSIZ || !mutex_trylock(&lock)) { 2247 local_buf = kmalloc(max((unsigned)SPI_BUFSIZ, n_tx + n_rx), 2248 GFP_KERNEL | GFP_DMA); 2249 if (!local_buf) 2250 return -ENOMEM; 2251 } else { 2252 local_buf = buf; 2253 } 2254 2255 spi_message_init(&message); 2256 memset(x, 0, sizeof(x)); 2257 if (n_tx) { 2258 x[0].len = n_tx; 2259 spi_message_add_tail(&x[0], &message); 2260 } 2261 if (n_rx) { 2262 x[1].len = n_rx; 2263 spi_message_add_tail(&x[1], &message); 2264 } 2265 2266 memcpy(local_buf, txbuf, n_tx); 2267 x[0].tx_buf = local_buf; 2268 x[1].rx_buf = local_buf + n_tx; 2269 2270 /* do the i/o */ 2271 status = spi_sync(spi, &message); 2272 if (status == 0) 2273 memcpy(rxbuf, x[1].rx_buf, n_rx); 2274 2275 if (x[0].tx_buf == buf) 2276 mutex_unlock(&lock); 2277 else 2278 kfree(local_buf); 2279 2280 return status; 2281 } 2282 EXPORT_SYMBOL_GPL(spi_write_then_read); 2283 2284 /*-------------------------------------------------------------------------*/ 2285 2286 static int __init spi_init(void) 2287 { 2288 int status; 2289 2290 buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL); 2291 if (!buf) { 2292 status = -ENOMEM; 2293 goto err0; 2294 } 2295 2296 status = bus_register(&spi_bus_type); 2297 if (status < 0) 2298 goto err1; 2299 2300 status = class_register(&spi_master_class); 2301 if (status < 0) 2302 goto err2; 2303 return 0; 2304 2305 err2: 2306 bus_unregister(&spi_bus_type); 2307 err1: 2308 kfree(buf); 2309 buf = NULL; 2310 err0: 2311 return status; 2312 } 2313 2314 /* board_info is normally registered in arch_initcall(), 2315 * but even essential drivers wait till later 2316 * 2317 * REVISIT only boardinfo really needs static linking. the rest (device and 2318 * driver registration) _could_ be dynamically linked (modular) ... costs 2319 * include needing to have boardinfo data structures be much more public. 2320 */ 2321 postcore_initcall(spi_init); 2322 2323