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 static int spi_map_buf(struct spi_master *master, struct device *dev, 584 struct sg_table *sgt, void *buf, size_t len, 585 enum dma_data_direction dir) 586 { 587 const bool vmalloced_buf = is_vmalloc_addr(buf); 588 const int desc_len = vmalloced_buf ? PAGE_SIZE : master->max_dma_len; 589 const int sgs = DIV_ROUND_UP(len, desc_len); 590 struct page *vm_page; 591 void *sg_buf; 592 size_t min; 593 int i, ret; 594 595 ret = sg_alloc_table(sgt, sgs, GFP_KERNEL); 596 if (ret != 0) 597 return ret; 598 599 for (i = 0; i < sgs; i++) { 600 min = min_t(size_t, len, desc_len); 601 602 if (vmalloced_buf) { 603 vm_page = vmalloc_to_page(buf); 604 if (!vm_page) { 605 sg_free_table(sgt); 606 return -ENOMEM; 607 } 608 sg_buf = page_address(vm_page) + 609 ((size_t)buf & ~PAGE_MASK); 610 } else { 611 sg_buf = buf; 612 } 613 614 sg_set_buf(&sgt->sgl[i], sg_buf, min); 615 616 buf += min; 617 len -= min; 618 } 619 620 ret = dma_map_sg(dev, sgt->sgl, sgt->nents, dir); 621 if (ret < 0) { 622 sg_free_table(sgt); 623 return ret; 624 } 625 626 sgt->nents = ret; 627 628 return 0; 629 } 630 631 static void spi_unmap_buf(struct spi_master *master, struct device *dev, 632 struct sg_table *sgt, enum dma_data_direction dir) 633 { 634 if (sgt->orig_nents) { 635 dma_unmap_sg(dev, sgt->sgl, sgt->orig_nents, dir); 636 sg_free_table(sgt); 637 } 638 } 639 640 static int spi_map_msg(struct spi_master *master, struct spi_message *msg) 641 { 642 struct device *tx_dev, *rx_dev; 643 struct spi_transfer *xfer; 644 void *tmp; 645 unsigned int max_tx, max_rx; 646 int ret; 647 648 if (master->flags & (SPI_MASTER_MUST_RX | SPI_MASTER_MUST_TX)) { 649 max_tx = 0; 650 max_rx = 0; 651 652 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 653 if ((master->flags & SPI_MASTER_MUST_TX) && 654 !xfer->tx_buf) 655 max_tx = max(xfer->len, max_tx); 656 if ((master->flags & SPI_MASTER_MUST_RX) && 657 !xfer->rx_buf) 658 max_rx = max(xfer->len, max_rx); 659 } 660 661 if (max_tx) { 662 tmp = krealloc(master->dummy_tx, max_tx, 663 GFP_KERNEL | GFP_DMA); 664 if (!tmp) 665 return -ENOMEM; 666 master->dummy_tx = tmp; 667 memset(tmp, 0, max_tx); 668 } 669 670 if (max_rx) { 671 tmp = krealloc(master->dummy_rx, max_rx, 672 GFP_KERNEL | GFP_DMA); 673 if (!tmp) 674 return -ENOMEM; 675 master->dummy_rx = tmp; 676 } 677 678 if (max_tx || max_rx) { 679 list_for_each_entry(xfer, &msg->transfers, 680 transfer_list) { 681 if (!xfer->tx_buf) 682 xfer->tx_buf = master->dummy_tx; 683 if (!xfer->rx_buf) 684 xfer->rx_buf = master->dummy_rx; 685 } 686 } 687 } 688 689 if (!master->can_dma) 690 return 0; 691 692 tx_dev = &master->dma_tx->dev->device; 693 rx_dev = &master->dma_rx->dev->device; 694 695 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 696 if (!master->can_dma(master, msg->spi, xfer)) 697 continue; 698 699 if (xfer->tx_buf != NULL) { 700 ret = spi_map_buf(master, tx_dev, &xfer->tx_sg, 701 (void *)xfer->tx_buf, xfer->len, 702 DMA_TO_DEVICE); 703 if (ret != 0) 704 return ret; 705 } 706 707 if (xfer->rx_buf != NULL) { 708 ret = spi_map_buf(master, rx_dev, &xfer->rx_sg, 709 xfer->rx_buf, xfer->len, 710 DMA_FROM_DEVICE); 711 if (ret != 0) { 712 spi_unmap_buf(master, tx_dev, &xfer->tx_sg, 713 DMA_TO_DEVICE); 714 return ret; 715 } 716 } 717 } 718 719 master->cur_msg_mapped = true; 720 721 return 0; 722 } 723 724 static int spi_unmap_msg(struct spi_master *master, struct spi_message *msg) 725 { 726 struct spi_transfer *xfer; 727 struct device *tx_dev, *rx_dev; 728 729 if (!master->cur_msg_mapped || !master->can_dma) 730 return 0; 731 732 tx_dev = &master->dma_tx->dev->device; 733 rx_dev = &master->dma_rx->dev->device; 734 735 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 736 if (!master->can_dma(master, msg->spi, xfer)) 737 continue; 738 739 spi_unmap_buf(master, rx_dev, &xfer->rx_sg, DMA_FROM_DEVICE); 740 spi_unmap_buf(master, tx_dev, &xfer->tx_sg, DMA_TO_DEVICE); 741 } 742 743 return 0; 744 } 745 746 /* 747 * spi_transfer_one_message - Default implementation of transfer_one_message() 748 * 749 * This is a standard implementation of transfer_one_message() for 750 * drivers which impelment a transfer_one() operation. It provides 751 * standard handling of delays and chip select management. 752 */ 753 static int spi_transfer_one_message(struct spi_master *master, 754 struct spi_message *msg) 755 { 756 struct spi_transfer *xfer; 757 bool keep_cs = false; 758 int ret = 0; 759 int ms = 1; 760 761 spi_set_cs(msg->spi, true); 762 763 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 764 trace_spi_transfer_start(msg, xfer); 765 766 reinit_completion(&master->xfer_completion); 767 768 ret = master->transfer_one(master, msg->spi, xfer); 769 if (ret < 0) { 770 dev_err(&msg->spi->dev, 771 "SPI transfer failed: %d\n", ret); 772 goto out; 773 } 774 775 if (ret > 0) { 776 ret = 0; 777 ms = xfer->len * 8 * 1000 / xfer->speed_hz; 778 ms += 10; /* some tolerance */ 779 780 ms = wait_for_completion_timeout(&master->xfer_completion, 781 msecs_to_jiffies(ms)); 782 } 783 784 if (ms == 0) { 785 dev_err(&msg->spi->dev, "SPI transfer timed out\n"); 786 msg->status = -ETIMEDOUT; 787 } 788 789 trace_spi_transfer_stop(msg, xfer); 790 791 if (msg->status != -EINPROGRESS) 792 goto out; 793 794 if (xfer->delay_usecs) 795 udelay(xfer->delay_usecs); 796 797 if (xfer->cs_change) { 798 if (list_is_last(&xfer->transfer_list, 799 &msg->transfers)) { 800 keep_cs = true; 801 } else { 802 spi_set_cs(msg->spi, false); 803 udelay(10); 804 spi_set_cs(msg->spi, true); 805 } 806 } 807 808 msg->actual_length += xfer->len; 809 } 810 811 out: 812 if (ret != 0 || !keep_cs) 813 spi_set_cs(msg->spi, false); 814 815 if (msg->status == -EINPROGRESS) 816 msg->status = ret; 817 818 spi_finalize_current_message(master); 819 820 return ret; 821 } 822 823 /** 824 * spi_finalize_current_transfer - report completion of a transfer 825 * 826 * Called by SPI drivers using the core transfer_one_message() 827 * implementation to notify it that the current interrupt driven 828 * transfer has finished and the next one may be scheduled. 829 */ 830 void spi_finalize_current_transfer(struct spi_master *master) 831 { 832 complete(&master->xfer_completion); 833 } 834 EXPORT_SYMBOL_GPL(spi_finalize_current_transfer); 835 836 /** 837 * spi_pump_messages - kthread work function which processes spi message queue 838 * @work: pointer to kthread work struct contained in the master struct 839 * 840 * This function checks if there is any spi message in the queue that 841 * needs processing and if so call out to the driver to initialize hardware 842 * and transfer each message. 843 * 844 */ 845 static void spi_pump_messages(struct kthread_work *work) 846 { 847 struct spi_master *master = 848 container_of(work, struct spi_master, pump_messages); 849 unsigned long flags; 850 bool was_busy = false; 851 int ret; 852 853 /* Lock queue and check for queue work */ 854 spin_lock_irqsave(&master->queue_lock, flags); 855 if (list_empty(&master->queue) || !master->running) { 856 if (!master->busy) { 857 spin_unlock_irqrestore(&master->queue_lock, flags); 858 return; 859 } 860 master->busy = false; 861 spin_unlock_irqrestore(&master->queue_lock, flags); 862 kfree(master->dummy_rx); 863 master->dummy_rx = NULL; 864 kfree(master->dummy_tx); 865 master->dummy_tx = NULL; 866 if (master->unprepare_transfer_hardware && 867 master->unprepare_transfer_hardware(master)) 868 dev_err(&master->dev, 869 "failed to unprepare transfer hardware\n"); 870 if (master->auto_runtime_pm) { 871 pm_runtime_mark_last_busy(master->dev.parent); 872 pm_runtime_put_autosuspend(master->dev.parent); 873 } 874 trace_spi_master_idle(master); 875 return; 876 } 877 878 /* Make sure we are not already running a message */ 879 if (master->cur_msg) { 880 spin_unlock_irqrestore(&master->queue_lock, flags); 881 return; 882 } 883 /* Extract head of queue */ 884 master->cur_msg = 885 list_first_entry(&master->queue, struct spi_message, queue); 886 887 list_del_init(&master->cur_msg->queue); 888 if (master->busy) 889 was_busy = true; 890 else 891 master->busy = true; 892 spin_unlock_irqrestore(&master->queue_lock, flags); 893 894 if (!was_busy && master->auto_runtime_pm) { 895 ret = pm_runtime_get_sync(master->dev.parent); 896 if (ret < 0) { 897 dev_err(&master->dev, "Failed to power device: %d\n", 898 ret); 899 return; 900 } 901 } 902 903 if (!was_busy) 904 trace_spi_master_busy(master); 905 906 if (!was_busy && master->prepare_transfer_hardware) { 907 ret = master->prepare_transfer_hardware(master); 908 if (ret) { 909 dev_err(&master->dev, 910 "failed to prepare transfer hardware\n"); 911 912 if (master->auto_runtime_pm) 913 pm_runtime_put(master->dev.parent); 914 return; 915 } 916 } 917 918 trace_spi_message_start(master->cur_msg); 919 920 if (master->prepare_message) { 921 ret = master->prepare_message(master, master->cur_msg); 922 if (ret) { 923 dev_err(&master->dev, 924 "failed to prepare message: %d\n", ret); 925 master->cur_msg->status = ret; 926 spi_finalize_current_message(master); 927 return; 928 } 929 master->cur_msg_prepared = true; 930 } 931 932 ret = spi_map_msg(master, master->cur_msg); 933 if (ret) { 934 master->cur_msg->status = ret; 935 spi_finalize_current_message(master); 936 return; 937 } 938 939 ret = master->transfer_one_message(master, master->cur_msg); 940 if (ret) { 941 dev_err(&master->dev, 942 "failed to transfer one message from queue\n"); 943 return; 944 } 945 } 946 947 static int spi_init_queue(struct spi_master *master) 948 { 949 struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 }; 950 951 INIT_LIST_HEAD(&master->queue); 952 spin_lock_init(&master->queue_lock); 953 954 master->running = false; 955 master->busy = false; 956 957 init_kthread_worker(&master->kworker); 958 master->kworker_task = kthread_run(kthread_worker_fn, 959 &master->kworker, "%s", 960 dev_name(&master->dev)); 961 if (IS_ERR(master->kworker_task)) { 962 dev_err(&master->dev, "failed to create message pump task\n"); 963 return -ENOMEM; 964 } 965 init_kthread_work(&master->pump_messages, spi_pump_messages); 966 967 /* 968 * Master config will indicate if this controller should run the 969 * message pump with high (realtime) priority to reduce the transfer 970 * latency on the bus by minimising the delay between a transfer 971 * request and the scheduling of the message pump thread. Without this 972 * setting the message pump thread will remain at default priority. 973 */ 974 if (master->rt) { 975 dev_info(&master->dev, 976 "will run message pump with realtime priority\n"); 977 sched_setscheduler(master->kworker_task, SCHED_FIFO, ¶m); 978 } 979 980 return 0; 981 } 982 983 /** 984 * spi_get_next_queued_message() - called by driver to check for queued 985 * messages 986 * @master: the master to check for queued messages 987 * 988 * If there are more messages in the queue, the next message is returned from 989 * this call. 990 */ 991 struct spi_message *spi_get_next_queued_message(struct spi_master *master) 992 { 993 struct spi_message *next; 994 unsigned long flags; 995 996 /* get a pointer to the next message, if any */ 997 spin_lock_irqsave(&master->queue_lock, flags); 998 next = list_first_entry_or_null(&master->queue, struct spi_message, 999 queue); 1000 spin_unlock_irqrestore(&master->queue_lock, flags); 1001 1002 return next; 1003 } 1004 EXPORT_SYMBOL_GPL(spi_get_next_queued_message); 1005 1006 /** 1007 * spi_finalize_current_message() - the current message is complete 1008 * @master: the master to return the message to 1009 * 1010 * Called by the driver to notify the core that the message in the front of the 1011 * queue is complete and can be removed from the queue. 1012 */ 1013 void spi_finalize_current_message(struct spi_master *master) 1014 { 1015 struct spi_message *mesg; 1016 unsigned long flags; 1017 int ret; 1018 1019 spin_lock_irqsave(&master->queue_lock, flags); 1020 mesg = master->cur_msg; 1021 master->cur_msg = NULL; 1022 1023 queue_kthread_work(&master->kworker, &master->pump_messages); 1024 spin_unlock_irqrestore(&master->queue_lock, flags); 1025 1026 spi_unmap_msg(master, mesg); 1027 1028 if (master->cur_msg_prepared && master->unprepare_message) { 1029 ret = master->unprepare_message(master, mesg); 1030 if (ret) { 1031 dev_err(&master->dev, 1032 "failed to unprepare message: %d\n", ret); 1033 } 1034 } 1035 master->cur_msg_prepared = false; 1036 1037 mesg->state = NULL; 1038 if (mesg->complete) 1039 mesg->complete(mesg->context); 1040 1041 trace_spi_message_done(mesg); 1042 } 1043 EXPORT_SYMBOL_GPL(spi_finalize_current_message); 1044 1045 static int spi_start_queue(struct spi_master *master) 1046 { 1047 unsigned long flags; 1048 1049 spin_lock_irqsave(&master->queue_lock, flags); 1050 1051 if (master->running || master->busy) { 1052 spin_unlock_irqrestore(&master->queue_lock, flags); 1053 return -EBUSY; 1054 } 1055 1056 master->running = true; 1057 master->cur_msg = NULL; 1058 spin_unlock_irqrestore(&master->queue_lock, flags); 1059 1060 queue_kthread_work(&master->kworker, &master->pump_messages); 1061 1062 return 0; 1063 } 1064 1065 static int spi_stop_queue(struct spi_master *master) 1066 { 1067 unsigned long flags; 1068 unsigned limit = 500; 1069 int ret = 0; 1070 1071 spin_lock_irqsave(&master->queue_lock, flags); 1072 1073 /* 1074 * This is a bit lame, but is optimized for the common execution path. 1075 * A wait_queue on the master->busy could be used, but then the common 1076 * execution path (pump_messages) would be required to call wake_up or 1077 * friends on every SPI message. Do this instead. 1078 */ 1079 while ((!list_empty(&master->queue) || master->busy) && limit--) { 1080 spin_unlock_irqrestore(&master->queue_lock, flags); 1081 usleep_range(10000, 11000); 1082 spin_lock_irqsave(&master->queue_lock, flags); 1083 } 1084 1085 if (!list_empty(&master->queue) || master->busy) 1086 ret = -EBUSY; 1087 else 1088 master->running = false; 1089 1090 spin_unlock_irqrestore(&master->queue_lock, flags); 1091 1092 if (ret) { 1093 dev_warn(&master->dev, 1094 "could not stop message queue\n"); 1095 return ret; 1096 } 1097 return ret; 1098 } 1099 1100 static int spi_destroy_queue(struct spi_master *master) 1101 { 1102 int ret; 1103 1104 ret = spi_stop_queue(master); 1105 1106 /* 1107 * flush_kthread_worker will block until all work is done. 1108 * If the reason that stop_queue timed out is that the work will never 1109 * finish, then it does no good to call flush/stop thread, so 1110 * return anyway. 1111 */ 1112 if (ret) { 1113 dev_err(&master->dev, "problem destroying queue\n"); 1114 return ret; 1115 } 1116 1117 flush_kthread_worker(&master->kworker); 1118 kthread_stop(master->kworker_task); 1119 1120 return 0; 1121 } 1122 1123 /** 1124 * spi_queued_transfer - transfer function for queued transfers 1125 * @spi: spi device which is requesting transfer 1126 * @msg: spi message which is to handled is queued to driver queue 1127 */ 1128 static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg) 1129 { 1130 struct spi_master *master = spi->master; 1131 unsigned long flags; 1132 1133 spin_lock_irqsave(&master->queue_lock, flags); 1134 1135 if (!master->running) { 1136 spin_unlock_irqrestore(&master->queue_lock, flags); 1137 return -ESHUTDOWN; 1138 } 1139 msg->actual_length = 0; 1140 msg->status = -EINPROGRESS; 1141 1142 list_add_tail(&msg->queue, &master->queue); 1143 if (!master->busy) 1144 queue_kthread_work(&master->kworker, &master->pump_messages); 1145 1146 spin_unlock_irqrestore(&master->queue_lock, flags); 1147 return 0; 1148 } 1149 1150 static int spi_master_initialize_queue(struct spi_master *master) 1151 { 1152 int ret; 1153 1154 master->queued = true; 1155 master->transfer = spi_queued_transfer; 1156 if (!master->transfer_one_message) 1157 master->transfer_one_message = spi_transfer_one_message; 1158 1159 /* Initialize and start queue */ 1160 ret = spi_init_queue(master); 1161 if (ret) { 1162 dev_err(&master->dev, "problem initializing queue\n"); 1163 goto err_init_queue; 1164 } 1165 ret = spi_start_queue(master); 1166 if (ret) { 1167 dev_err(&master->dev, "problem starting queue\n"); 1168 goto err_start_queue; 1169 } 1170 1171 return 0; 1172 1173 err_start_queue: 1174 err_init_queue: 1175 spi_destroy_queue(master); 1176 return ret; 1177 } 1178 1179 /*-------------------------------------------------------------------------*/ 1180 1181 #if defined(CONFIG_OF) 1182 /** 1183 * of_register_spi_devices() - Register child devices onto the SPI bus 1184 * @master: Pointer to spi_master device 1185 * 1186 * Registers an spi_device for each child node of master node which has a 'reg' 1187 * property. 1188 */ 1189 static void of_register_spi_devices(struct spi_master *master) 1190 { 1191 struct spi_device *spi; 1192 struct device_node *nc; 1193 int rc; 1194 u32 value; 1195 1196 if (!master->dev.of_node) 1197 return; 1198 1199 for_each_available_child_of_node(master->dev.of_node, nc) { 1200 /* Alloc an spi_device */ 1201 spi = spi_alloc_device(master); 1202 if (!spi) { 1203 dev_err(&master->dev, "spi_device alloc error for %s\n", 1204 nc->full_name); 1205 spi_dev_put(spi); 1206 continue; 1207 } 1208 1209 /* Select device driver */ 1210 if (of_modalias_node(nc, spi->modalias, 1211 sizeof(spi->modalias)) < 0) { 1212 dev_err(&master->dev, "cannot find modalias for %s\n", 1213 nc->full_name); 1214 spi_dev_put(spi); 1215 continue; 1216 } 1217 1218 /* Device address */ 1219 rc = of_property_read_u32(nc, "reg", &value); 1220 if (rc) { 1221 dev_err(&master->dev, "%s has no valid 'reg' property (%d)\n", 1222 nc->full_name, rc); 1223 spi_dev_put(spi); 1224 continue; 1225 } 1226 spi->chip_select = value; 1227 1228 /* Mode (clock phase/polarity/etc.) */ 1229 if (of_find_property(nc, "spi-cpha", NULL)) 1230 spi->mode |= SPI_CPHA; 1231 if (of_find_property(nc, "spi-cpol", NULL)) 1232 spi->mode |= SPI_CPOL; 1233 if (of_find_property(nc, "spi-cs-high", NULL)) 1234 spi->mode |= SPI_CS_HIGH; 1235 if (of_find_property(nc, "spi-3wire", NULL)) 1236 spi->mode |= SPI_3WIRE; 1237 1238 /* Device DUAL/QUAD mode */ 1239 if (!of_property_read_u32(nc, "spi-tx-bus-width", &value)) { 1240 switch (value) { 1241 case 1: 1242 break; 1243 case 2: 1244 spi->mode |= SPI_TX_DUAL; 1245 break; 1246 case 4: 1247 spi->mode |= SPI_TX_QUAD; 1248 break; 1249 default: 1250 dev_err(&master->dev, 1251 "spi-tx-bus-width %d not supported\n", 1252 value); 1253 spi_dev_put(spi); 1254 continue; 1255 } 1256 } 1257 1258 if (!of_property_read_u32(nc, "spi-rx-bus-width", &value)) { 1259 switch (value) { 1260 case 1: 1261 break; 1262 case 2: 1263 spi->mode |= SPI_RX_DUAL; 1264 break; 1265 case 4: 1266 spi->mode |= SPI_RX_QUAD; 1267 break; 1268 default: 1269 dev_err(&master->dev, 1270 "spi-rx-bus-width %d not supported\n", 1271 value); 1272 spi_dev_put(spi); 1273 continue; 1274 } 1275 } 1276 1277 /* Device speed */ 1278 rc = of_property_read_u32(nc, "spi-max-frequency", &value); 1279 if (rc) { 1280 dev_err(&master->dev, "%s has no valid 'spi-max-frequency' property (%d)\n", 1281 nc->full_name, rc); 1282 spi_dev_put(spi); 1283 continue; 1284 } 1285 spi->max_speed_hz = value; 1286 1287 /* IRQ */ 1288 spi->irq = irq_of_parse_and_map(nc, 0); 1289 1290 /* Store a pointer to the node in the device structure */ 1291 of_node_get(nc); 1292 spi->dev.of_node = nc; 1293 1294 /* Register the new device */ 1295 request_module("%s%s", SPI_MODULE_PREFIX, spi->modalias); 1296 rc = spi_add_device(spi); 1297 if (rc) { 1298 dev_err(&master->dev, "spi_device register error %s\n", 1299 nc->full_name); 1300 spi_dev_put(spi); 1301 } 1302 1303 } 1304 } 1305 #else 1306 static void of_register_spi_devices(struct spi_master *master) { } 1307 #endif 1308 1309 #ifdef CONFIG_ACPI 1310 static int acpi_spi_add_resource(struct acpi_resource *ares, void *data) 1311 { 1312 struct spi_device *spi = data; 1313 1314 if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) { 1315 struct acpi_resource_spi_serialbus *sb; 1316 1317 sb = &ares->data.spi_serial_bus; 1318 if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_SPI) { 1319 spi->chip_select = sb->device_selection; 1320 spi->max_speed_hz = sb->connection_speed; 1321 1322 if (sb->clock_phase == ACPI_SPI_SECOND_PHASE) 1323 spi->mode |= SPI_CPHA; 1324 if (sb->clock_polarity == ACPI_SPI_START_HIGH) 1325 spi->mode |= SPI_CPOL; 1326 if (sb->device_polarity == ACPI_SPI_ACTIVE_HIGH) 1327 spi->mode |= SPI_CS_HIGH; 1328 } 1329 } else if (spi->irq < 0) { 1330 struct resource r; 1331 1332 if (acpi_dev_resource_interrupt(ares, 0, &r)) 1333 spi->irq = r.start; 1334 } 1335 1336 /* Always tell the ACPI core to skip this resource */ 1337 return 1; 1338 } 1339 1340 static acpi_status acpi_spi_add_device(acpi_handle handle, u32 level, 1341 void *data, void **return_value) 1342 { 1343 struct spi_master *master = data; 1344 struct list_head resource_list; 1345 struct acpi_device *adev; 1346 struct spi_device *spi; 1347 int ret; 1348 1349 if (acpi_bus_get_device(handle, &adev)) 1350 return AE_OK; 1351 if (acpi_bus_get_status(adev) || !adev->status.present) 1352 return AE_OK; 1353 1354 spi = spi_alloc_device(master); 1355 if (!spi) { 1356 dev_err(&master->dev, "failed to allocate SPI device for %s\n", 1357 dev_name(&adev->dev)); 1358 return AE_NO_MEMORY; 1359 } 1360 1361 ACPI_COMPANION_SET(&spi->dev, adev); 1362 spi->irq = -1; 1363 1364 INIT_LIST_HEAD(&resource_list); 1365 ret = acpi_dev_get_resources(adev, &resource_list, 1366 acpi_spi_add_resource, spi); 1367 acpi_dev_free_resource_list(&resource_list); 1368 1369 if (ret < 0 || !spi->max_speed_hz) { 1370 spi_dev_put(spi); 1371 return AE_OK; 1372 } 1373 1374 adev->power.flags.ignore_parent = true; 1375 strlcpy(spi->modalias, acpi_device_hid(adev), sizeof(spi->modalias)); 1376 if (spi_add_device(spi)) { 1377 adev->power.flags.ignore_parent = false; 1378 dev_err(&master->dev, "failed to add SPI device %s from ACPI\n", 1379 dev_name(&adev->dev)); 1380 spi_dev_put(spi); 1381 } 1382 1383 return AE_OK; 1384 } 1385 1386 static void acpi_register_spi_devices(struct spi_master *master) 1387 { 1388 acpi_status status; 1389 acpi_handle handle; 1390 1391 handle = ACPI_HANDLE(master->dev.parent); 1392 if (!handle) 1393 return; 1394 1395 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1, 1396 acpi_spi_add_device, NULL, 1397 master, NULL); 1398 if (ACPI_FAILURE(status)) 1399 dev_warn(&master->dev, "failed to enumerate SPI slaves\n"); 1400 } 1401 #else 1402 static inline void acpi_register_spi_devices(struct spi_master *master) {} 1403 #endif /* CONFIG_ACPI */ 1404 1405 static void spi_master_release(struct device *dev) 1406 { 1407 struct spi_master *master; 1408 1409 master = container_of(dev, struct spi_master, dev); 1410 kfree(master); 1411 } 1412 1413 static struct class spi_master_class = { 1414 .name = "spi_master", 1415 .owner = THIS_MODULE, 1416 .dev_release = spi_master_release, 1417 }; 1418 1419 1420 1421 /** 1422 * spi_alloc_master - allocate SPI master controller 1423 * @dev: the controller, possibly using the platform_bus 1424 * @size: how much zeroed driver-private data to allocate; the pointer to this 1425 * memory is in the driver_data field of the returned device, 1426 * accessible with spi_master_get_devdata(). 1427 * Context: can sleep 1428 * 1429 * This call is used only by SPI master controller drivers, which are the 1430 * only ones directly touching chip registers. It's how they allocate 1431 * an spi_master structure, prior to calling spi_register_master(). 1432 * 1433 * This must be called from context that can sleep. It returns the SPI 1434 * master structure on success, else NULL. 1435 * 1436 * The caller is responsible for assigning the bus number and initializing 1437 * the master's methods before calling spi_register_master(); and (after errors 1438 * adding the device) calling spi_master_put() and kfree() to prevent a memory 1439 * leak. 1440 */ 1441 struct spi_master *spi_alloc_master(struct device *dev, unsigned size) 1442 { 1443 struct spi_master *master; 1444 1445 if (!dev) 1446 return NULL; 1447 1448 master = kzalloc(size + sizeof(*master), GFP_KERNEL); 1449 if (!master) 1450 return NULL; 1451 1452 device_initialize(&master->dev); 1453 master->bus_num = -1; 1454 master->num_chipselect = 1; 1455 master->dev.class = &spi_master_class; 1456 master->dev.parent = get_device(dev); 1457 spi_master_set_devdata(master, &master[1]); 1458 1459 return master; 1460 } 1461 EXPORT_SYMBOL_GPL(spi_alloc_master); 1462 1463 #ifdef CONFIG_OF 1464 static int of_spi_register_master(struct spi_master *master) 1465 { 1466 int nb, i, *cs; 1467 struct device_node *np = master->dev.of_node; 1468 1469 if (!np) 1470 return 0; 1471 1472 nb = of_gpio_named_count(np, "cs-gpios"); 1473 master->num_chipselect = max_t(int, nb, master->num_chipselect); 1474 1475 /* Return error only for an incorrectly formed cs-gpios property */ 1476 if (nb == 0 || nb == -ENOENT) 1477 return 0; 1478 else if (nb < 0) 1479 return nb; 1480 1481 cs = devm_kzalloc(&master->dev, 1482 sizeof(int) * master->num_chipselect, 1483 GFP_KERNEL); 1484 master->cs_gpios = cs; 1485 1486 if (!master->cs_gpios) 1487 return -ENOMEM; 1488 1489 for (i = 0; i < master->num_chipselect; i++) 1490 cs[i] = -ENOENT; 1491 1492 for (i = 0; i < nb; i++) 1493 cs[i] = of_get_named_gpio(np, "cs-gpios", i); 1494 1495 return 0; 1496 } 1497 #else 1498 static int of_spi_register_master(struct spi_master *master) 1499 { 1500 return 0; 1501 } 1502 #endif 1503 1504 /** 1505 * spi_register_master - register SPI master controller 1506 * @master: initialized master, originally from spi_alloc_master() 1507 * Context: can sleep 1508 * 1509 * SPI master controllers connect to their drivers using some non-SPI bus, 1510 * such as the platform bus. The final stage of probe() in that code 1511 * includes calling spi_register_master() to hook up to this SPI bus glue. 1512 * 1513 * SPI controllers use board specific (often SOC specific) bus numbers, 1514 * and board-specific addressing for SPI devices combines those numbers 1515 * with chip select numbers. Since SPI does not directly support dynamic 1516 * device identification, boards need configuration tables telling which 1517 * chip is at which address. 1518 * 1519 * This must be called from context that can sleep. It returns zero on 1520 * success, else a negative error code (dropping the master's refcount). 1521 * After a successful return, the caller is responsible for calling 1522 * spi_unregister_master(). 1523 */ 1524 int spi_register_master(struct spi_master *master) 1525 { 1526 static atomic_t dyn_bus_id = ATOMIC_INIT((1<<15) - 1); 1527 struct device *dev = master->dev.parent; 1528 struct boardinfo *bi; 1529 int status = -ENODEV; 1530 int dynamic = 0; 1531 1532 if (!dev) 1533 return -ENODEV; 1534 1535 status = of_spi_register_master(master); 1536 if (status) 1537 return status; 1538 1539 /* even if it's just one always-selected device, there must 1540 * be at least one chipselect 1541 */ 1542 if (master->num_chipselect == 0) 1543 return -EINVAL; 1544 1545 if ((master->bus_num < 0) && master->dev.of_node) 1546 master->bus_num = of_alias_get_id(master->dev.of_node, "spi"); 1547 1548 /* convention: dynamically assigned bus IDs count down from the max */ 1549 if (master->bus_num < 0) { 1550 /* FIXME switch to an IDR based scheme, something like 1551 * I2C now uses, so we can't run out of "dynamic" IDs 1552 */ 1553 master->bus_num = atomic_dec_return(&dyn_bus_id); 1554 dynamic = 1; 1555 } 1556 1557 spin_lock_init(&master->bus_lock_spinlock); 1558 mutex_init(&master->bus_lock_mutex); 1559 master->bus_lock_flag = 0; 1560 init_completion(&master->xfer_completion); 1561 if (!master->max_dma_len) 1562 master->max_dma_len = INT_MAX; 1563 1564 /* register the device, then userspace will see it. 1565 * registration fails if the bus ID is in use. 1566 */ 1567 dev_set_name(&master->dev, "spi%u", master->bus_num); 1568 status = device_add(&master->dev); 1569 if (status < 0) 1570 goto done; 1571 dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev), 1572 dynamic ? " (dynamic)" : ""); 1573 1574 /* If we're using a queued driver, start the queue */ 1575 if (master->transfer) 1576 dev_info(dev, "master is unqueued, this is deprecated\n"); 1577 else { 1578 status = spi_master_initialize_queue(master); 1579 if (status) { 1580 device_del(&master->dev); 1581 goto done; 1582 } 1583 } 1584 1585 mutex_lock(&board_lock); 1586 list_add_tail(&master->list, &spi_master_list); 1587 list_for_each_entry(bi, &board_list, list) 1588 spi_match_master_to_boardinfo(master, &bi->board_info); 1589 mutex_unlock(&board_lock); 1590 1591 /* Register devices from the device tree and ACPI */ 1592 of_register_spi_devices(master); 1593 acpi_register_spi_devices(master); 1594 done: 1595 return status; 1596 } 1597 EXPORT_SYMBOL_GPL(spi_register_master); 1598 1599 static void devm_spi_unregister(struct device *dev, void *res) 1600 { 1601 spi_unregister_master(*(struct spi_master **)res); 1602 } 1603 1604 /** 1605 * dev_spi_register_master - register managed SPI master controller 1606 * @dev: device managing SPI master 1607 * @master: initialized master, originally from spi_alloc_master() 1608 * Context: can sleep 1609 * 1610 * Register a SPI device as with spi_register_master() which will 1611 * automatically be unregister 1612 */ 1613 int devm_spi_register_master(struct device *dev, struct spi_master *master) 1614 { 1615 struct spi_master **ptr; 1616 int ret; 1617 1618 ptr = devres_alloc(devm_spi_unregister, sizeof(*ptr), GFP_KERNEL); 1619 if (!ptr) 1620 return -ENOMEM; 1621 1622 ret = spi_register_master(master); 1623 if (!ret) { 1624 *ptr = master; 1625 devres_add(dev, ptr); 1626 } else { 1627 devres_free(ptr); 1628 } 1629 1630 return ret; 1631 } 1632 EXPORT_SYMBOL_GPL(devm_spi_register_master); 1633 1634 static int __unregister(struct device *dev, void *null) 1635 { 1636 spi_unregister_device(to_spi_device(dev)); 1637 return 0; 1638 } 1639 1640 /** 1641 * spi_unregister_master - unregister SPI master controller 1642 * @master: the master being unregistered 1643 * Context: can sleep 1644 * 1645 * This call is used only by SPI master controller drivers, which are the 1646 * only ones directly touching chip registers. 1647 * 1648 * This must be called from context that can sleep. 1649 */ 1650 void spi_unregister_master(struct spi_master *master) 1651 { 1652 int dummy; 1653 1654 if (master->queued) { 1655 if (spi_destroy_queue(master)) 1656 dev_err(&master->dev, "queue remove failed\n"); 1657 } 1658 1659 mutex_lock(&board_lock); 1660 list_del(&master->list); 1661 mutex_unlock(&board_lock); 1662 1663 dummy = device_for_each_child(&master->dev, NULL, __unregister); 1664 device_unregister(&master->dev); 1665 } 1666 EXPORT_SYMBOL_GPL(spi_unregister_master); 1667 1668 int spi_master_suspend(struct spi_master *master) 1669 { 1670 int ret; 1671 1672 /* Basically no-ops for non-queued masters */ 1673 if (!master->queued) 1674 return 0; 1675 1676 ret = spi_stop_queue(master); 1677 if (ret) 1678 dev_err(&master->dev, "queue stop failed\n"); 1679 1680 return ret; 1681 } 1682 EXPORT_SYMBOL_GPL(spi_master_suspend); 1683 1684 int spi_master_resume(struct spi_master *master) 1685 { 1686 int ret; 1687 1688 if (!master->queued) 1689 return 0; 1690 1691 ret = spi_start_queue(master); 1692 if (ret) 1693 dev_err(&master->dev, "queue restart failed\n"); 1694 1695 return ret; 1696 } 1697 EXPORT_SYMBOL_GPL(spi_master_resume); 1698 1699 static int __spi_master_match(struct device *dev, const void *data) 1700 { 1701 struct spi_master *m; 1702 const u16 *bus_num = data; 1703 1704 m = container_of(dev, struct spi_master, dev); 1705 return m->bus_num == *bus_num; 1706 } 1707 1708 /** 1709 * spi_busnum_to_master - look up master associated with bus_num 1710 * @bus_num: the master's bus number 1711 * Context: can sleep 1712 * 1713 * This call may be used with devices that are registered after 1714 * arch init time. It returns a refcounted pointer to the relevant 1715 * spi_master (which the caller must release), or NULL if there is 1716 * no such master registered. 1717 */ 1718 struct spi_master *spi_busnum_to_master(u16 bus_num) 1719 { 1720 struct device *dev; 1721 struct spi_master *master = NULL; 1722 1723 dev = class_find_device(&spi_master_class, NULL, &bus_num, 1724 __spi_master_match); 1725 if (dev) 1726 master = container_of(dev, struct spi_master, dev); 1727 /* reference got in class_find_device */ 1728 return master; 1729 } 1730 EXPORT_SYMBOL_GPL(spi_busnum_to_master); 1731 1732 1733 /*-------------------------------------------------------------------------*/ 1734 1735 /* Core methods for SPI master protocol drivers. Some of the 1736 * other core methods are currently defined as inline functions. 1737 */ 1738 1739 /** 1740 * spi_setup - setup SPI mode and clock rate 1741 * @spi: the device whose settings are being modified 1742 * Context: can sleep, and no requests are queued to the device 1743 * 1744 * SPI protocol drivers may need to update the transfer mode if the 1745 * device doesn't work with its default. They may likewise need 1746 * to update clock rates or word sizes from initial values. This function 1747 * changes those settings, and must be called from a context that can sleep. 1748 * Except for SPI_CS_HIGH, which takes effect immediately, the changes take 1749 * effect the next time the device is selected and data is transferred to 1750 * or from it. When this function returns, the spi device is deselected. 1751 * 1752 * Note that this call will fail if the protocol driver specifies an option 1753 * that the underlying controller or its driver does not support. For 1754 * example, not all hardware supports wire transfers using nine bit words, 1755 * LSB-first wire encoding, or active-high chipselects. 1756 */ 1757 int spi_setup(struct spi_device *spi) 1758 { 1759 unsigned bad_bits; 1760 int status = 0; 1761 1762 /* check mode to prevent that DUAL and QUAD set at the same time 1763 */ 1764 if (((spi->mode & SPI_TX_DUAL) && (spi->mode & SPI_TX_QUAD)) || 1765 ((spi->mode & SPI_RX_DUAL) && (spi->mode & SPI_RX_QUAD))) { 1766 dev_err(&spi->dev, 1767 "setup: can not select dual and quad at the same time\n"); 1768 return -EINVAL; 1769 } 1770 /* if it is SPI_3WIRE mode, DUAL and QUAD should be forbidden 1771 */ 1772 if ((spi->mode & SPI_3WIRE) && (spi->mode & 1773 (SPI_TX_DUAL | SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD))) 1774 return -EINVAL; 1775 /* help drivers fail *cleanly* when they need options 1776 * that aren't supported with their current master 1777 */ 1778 bad_bits = spi->mode & ~spi->master->mode_bits; 1779 if (bad_bits) { 1780 dev_err(&spi->dev, "setup: unsupported mode bits %x\n", 1781 bad_bits); 1782 return -EINVAL; 1783 } 1784 1785 if (!spi->bits_per_word) 1786 spi->bits_per_word = 8; 1787 1788 if (!spi->max_speed_hz) 1789 spi->max_speed_hz = spi->master->max_speed_hz; 1790 1791 if (spi->master->setup) 1792 status = spi->master->setup(spi); 1793 1794 dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s%u bits/w, %u Hz max --> %d\n", 1795 (int) (spi->mode & (SPI_CPOL | SPI_CPHA)), 1796 (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "", 1797 (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "", 1798 (spi->mode & SPI_3WIRE) ? "3wire, " : "", 1799 (spi->mode & SPI_LOOP) ? "loopback, " : "", 1800 spi->bits_per_word, spi->max_speed_hz, 1801 status); 1802 1803 return status; 1804 } 1805 EXPORT_SYMBOL_GPL(spi_setup); 1806 1807 static int __spi_validate(struct spi_device *spi, struct spi_message *message) 1808 { 1809 struct spi_master *master = spi->master; 1810 struct spi_transfer *xfer; 1811 int w_size; 1812 1813 if (list_empty(&message->transfers)) 1814 return -EINVAL; 1815 1816 /* Half-duplex links include original MicroWire, and ones with 1817 * only one data pin like SPI_3WIRE (switches direction) or where 1818 * either MOSI or MISO is missing. They can also be caused by 1819 * software limitations. 1820 */ 1821 if ((master->flags & SPI_MASTER_HALF_DUPLEX) 1822 || (spi->mode & SPI_3WIRE)) { 1823 unsigned flags = master->flags; 1824 1825 list_for_each_entry(xfer, &message->transfers, transfer_list) { 1826 if (xfer->rx_buf && xfer->tx_buf) 1827 return -EINVAL; 1828 if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf) 1829 return -EINVAL; 1830 if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf) 1831 return -EINVAL; 1832 } 1833 } 1834 1835 /** 1836 * Set transfer bits_per_word and max speed as spi device default if 1837 * it is not set for this transfer. 1838 * Set transfer tx_nbits and rx_nbits as single transfer default 1839 * (SPI_NBITS_SINGLE) if it is not set for this transfer. 1840 */ 1841 list_for_each_entry(xfer, &message->transfers, transfer_list) { 1842 message->frame_length += xfer->len; 1843 if (!xfer->bits_per_word) 1844 xfer->bits_per_word = spi->bits_per_word; 1845 1846 if (!xfer->speed_hz) 1847 xfer->speed_hz = spi->max_speed_hz; 1848 1849 if (master->max_speed_hz && 1850 xfer->speed_hz > master->max_speed_hz) 1851 xfer->speed_hz = master->max_speed_hz; 1852 1853 if (master->bits_per_word_mask) { 1854 /* Only 32 bits fit in the mask */ 1855 if (xfer->bits_per_word > 32) 1856 return -EINVAL; 1857 if (!(master->bits_per_word_mask & 1858 BIT(xfer->bits_per_word - 1))) 1859 return -EINVAL; 1860 } 1861 1862 /* 1863 * SPI transfer length should be multiple of SPI word size 1864 * where SPI word size should be power-of-two multiple 1865 */ 1866 if (xfer->bits_per_word <= 8) 1867 w_size = 1; 1868 else if (xfer->bits_per_word <= 16) 1869 w_size = 2; 1870 else 1871 w_size = 4; 1872 1873 /* No partial transfers accepted */ 1874 if (xfer->len % w_size) 1875 return -EINVAL; 1876 1877 if (xfer->speed_hz && master->min_speed_hz && 1878 xfer->speed_hz < master->min_speed_hz) 1879 return -EINVAL; 1880 1881 if (xfer->tx_buf && !xfer->tx_nbits) 1882 xfer->tx_nbits = SPI_NBITS_SINGLE; 1883 if (xfer->rx_buf && !xfer->rx_nbits) 1884 xfer->rx_nbits = SPI_NBITS_SINGLE; 1885 /* check transfer tx/rx_nbits: 1886 * 1. check the value matches one of single, dual and quad 1887 * 2. check tx/rx_nbits match the mode in spi_device 1888 */ 1889 if (xfer->tx_buf) { 1890 if (xfer->tx_nbits != SPI_NBITS_SINGLE && 1891 xfer->tx_nbits != SPI_NBITS_DUAL && 1892 xfer->tx_nbits != SPI_NBITS_QUAD) 1893 return -EINVAL; 1894 if ((xfer->tx_nbits == SPI_NBITS_DUAL) && 1895 !(spi->mode & (SPI_TX_DUAL | SPI_TX_QUAD))) 1896 return -EINVAL; 1897 if ((xfer->tx_nbits == SPI_NBITS_QUAD) && 1898 !(spi->mode & SPI_TX_QUAD)) 1899 return -EINVAL; 1900 } 1901 /* check transfer rx_nbits */ 1902 if (xfer->rx_buf) { 1903 if (xfer->rx_nbits != SPI_NBITS_SINGLE && 1904 xfer->rx_nbits != SPI_NBITS_DUAL && 1905 xfer->rx_nbits != SPI_NBITS_QUAD) 1906 return -EINVAL; 1907 if ((xfer->rx_nbits == SPI_NBITS_DUAL) && 1908 !(spi->mode & (SPI_RX_DUAL | SPI_RX_QUAD))) 1909 return -EINVAL; 1910 if ((xfer->rx_nbits == SPI_NBITS_QUAD) && 1911 !(spi->mode & SPI_RX_QUAD)) 1912 return -EINVAL; 1913 } 1914 } 1915 1916 message->status = -EINPROGRESS; 1917 1918 return 0; 1919 } 1920 1921 static int __spi_async(struct spi_device *spi, struct spi_message *message) 1922 { 1923 struct spi_master *master = spi->master; 1924 1925 message->spi = spi; 1926 1927 trace_spi_message_submit(message); 1928 1929 return master->transfer(spi, message); 1930 } 1931 1932 /** 1933 * spi_async - asynchronous SPI transfer 1934 * @spi: device with which data will be exchanged 1935 * @message: describes the data transfers, including completion callback 1936 * Context: any (irqs may be blocked, etc) 1937 * 1938 * This call may be used in_irq and other contexts which can't sleep, 1939 * as well as from task contexts which can sleep. 1940 * 1941 * The completion callback is invoked in a context which can't sleep. 1942 * Before that invocation, the value of message->status is undefined. 1943 * When the callback is issued, message->status holds either zero (to 1944 * indicate complete success) or a negative error code. After that 1945 * callback returns, the driver which issued the transfer request may 1946 * deallocate the associated memory; it's no longer in use by any SPI 1947 * core or controller driver code. 1948 * 1949 * Note that although all messages to a spi_device are handled in 1950 * FIFO order, messages may go to different devices in other orders. 1951 * Some device might be higher priority, or have various "hard" access 1952 * time requirements, for example. 1953 * 1954 * On detection of any fault during the transfer, processing of 1955 * the entire message is aborted, and the device is deselected. 1956 * Until returning from the associated message completion callback, 1957 * no other spi_message queued to that device will be processed. 1958 * (This rule applies equally to all the synchronous transfer calls, 1959 * which are wrappers around this core asynchronous primitive.) 1960 */ 1961 int spi_async(struct spi_device *spi, struct spi_message *message) 1962 { 1963 struct spi_master *master = spi->master; 1964 int ret; 1965 unsigned long flags; 1966 1967 ret = __spi_validate(spi, message); 1968 if (ret != 0) 1969 return ret; 1970 1971 spin_lock_irqsave(&master->bus_lock_spinlock, flags); 1972 1973 if (master->bus_lock_flag) 1974 ret = -EBUSY; 1975 else 1976 ret = __spi_async(spi, message); 1977 1978 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags); 1979 1980 return ret; 1981 } 1982 EXPORT_SYMBOL_GPL(spi_async); 1983 1984 /** 1985 * spi_async_locked - version of spi_async with exclusive bus usage 1986 * @spi: device with which data will be exchanged 1987 * @message: describes the data transfers, including completion callback 1988 * Context: any (irqs may be blocked, etc) 1989 * 1990 * This call may be used in_irq and other contexts which can't sleep, 1991 * as well as from task contexts which can sleep. 1992 * 1993 * The completion callback is invoked in a context which can't sleep. 1994 * Before that invocation, the value of message->status is undefined. 1995 * When the callback is issued, message->status holds either zero (to 1996 * indicate complete success) or a negative error code. After that 1997 * callback returns, the driver which issued the transfer request may 1998 * deallocate the associated memory; it's no longer in use by any SPI 1999 * core or controller driver code. 2000 * 2001 * Note that although all messages to a spi_device are handled in 2002 * FIFO order, messages may go to different devices in other orders. 2003 * Some device might be higher priority, or have various "hard" access 2004 * time requirements, for example. 2005 * 2006 * On detection of any fault during the transfer, processing of 2007 * the entire message is aborted, and the device is deselected. 2008 * Until returning from the associated message completion callback, 2009 * no other spi_message queued to that device will be processed. 2010 * (This rule applies equally to all the synchronous transfer calls, 2011 * which are wrappers around this core asynchronous primitive.) 2012 */ 2013 int spi_async_locked(struct spi_device *spi, struct spi_message *message) 2014 { 2015 struct spi_master *master = spi->master; 2016 int ret; 2017 unsigned long flags; 2018 2019 ret = __spi_validate(spi, message); 2020 if (ret != 0) 2021 return ret; 2022 2023 spin_lock_irqsave(&master->bus_lock_spinlock, flags); 2024 2025 ret = __spi_async(spi, message); 2026 2027 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags); 2028 2029 return ret; 2030 2031 } 2032 EXPORT_SYMBOL_GPL(spi_async_locked); 2033 2034 2035 /*-------------------------------------------------------------------------*/ 2036 2037 /* Utility methods for SPI master protocol drivers, layered on 2038 * top of the core. Some other utility methods are defined as 2039 * inline functions. 2040 */ 2041 2042 static void spi_complete(void *arg) 2043 { 2044 complete(arg); 2045 } 2046 2047 static int __spi_sync(struct spi_device *spi, struct spi_message *message, 2048 int bus_locked) 2049 { 2050 DECLARE_COMPLETION_ONSTACK(done); 2051 int status; 2052 struct spi_master *master = spi->master; 2053 2054 message->complete = spi_complete; 2055 message->context = &done; 2056 2057 if (!bus_locked) 2058 mutex_lock(&master->bus_lock_mutex); 2059 2060 status = spi_async_locked(spi, message); 2061 2062 if (!bus_locked) 2063 mutex_unlock(&master->bus_lock_mutex); 2064 2065 if (status == 0) { 2066 wait_for_completion(&done); 2067 status = message->status; 2068 } 2069 message->context = NULL; 2070 return status; 2071 } 2072 2073 /** 2074 * spi_sync - blocking/synchronous SPI data transfers 2075 * @spi: device with which data will be exchanged 2076 * @message: describes the data transfers 2077 * Context: can sleep 2078 * 2079 * This call may only be used from a context that may sleep. The sleep 2080 * is non-interruptible, and has no timeout. Low-overhead controller 2081 * drivers may DMA directly into and out of the message buffers. 2082 * 2083 * Note that the SPI device's chip select is active during the message, 2084 * and then is normally disabled between messages. Drivers for some 2085 * frequently-used devices may want to minimize costs of selecting a chip, 2086 * by leaving it selected in anticipation that the next message will go 2087 * to the same chip. (That may increase power usage.) 2088 * 2089 * Also, the caller is guaranteeing that the memory associated with the 2090 * message will not be freed before this call returns. 2091 * 2092 * It returns zero on success, else a negative error code. 2093 */ 2094 int spi_sync(struct spi_device *spi, struct spi_message *message) 2095 { 2096 return __spi_sync(spi, message, 0); 2097 } 2098 EXPORT_SYMBOL_GPL(spi_sync); 2099 2100 /** 2101 * spi_sync_locked - version of spi_sync with exclusive bus usage 2102 * @spi: device with which data will be exchanged 2103 * @message: describes the data transfers 2104 * Context: can sleep 2105 * 2106 * This call may only be used from a context that may sleep. The sleep 2107 * is non-interruptible, and has no timeout. Low-overhead controller 2108 * drivers may DMA directly into and out of the message buffers. 2109 * 2110 * This call should be used by drivers that require exclusive access to the 2111 * SPI bus. It has to be preceded by a spi_bus_lock call. The SPI bus must 2112 * be released by a spi_bus_unlock call when the exclusive access is over. 2113 * 2114 * It returns zero on success, else a negative error code. 2115 */ 2116 int spi_sync_locked(struct spi_device *spi, struct spi_message *message) 2117 { 2118 return __spi_sync(spi, message, 1); 2119 } 2120 EXPORT_SYMBOL_GPL(spi_sync_locked); 2121 2122 /** 2123 * spi_bus_lock - obtain a lock for exclusive SPI bus usage 2124 * @master: SPI bus master that should be locked for exclusive bus access 2125 * Context: can sleep 2126 * 2127 * This call may only be used from a context that may sleep. The sleep 2128 * is non-interruptible, and has no timeout. 2129 * 2130 * This call should be used by drivers that require exclusive access to the 2131 * SPI bus. The SPI bus must be released by a spi_bus_unlock call when the 2132 * exclusive access is over. Data transfer must be done by spi_sync_locked 2133 * and spi_async_locked calls when the SPI bus lock is held. 2134 * 2135 * It returns zero on success, else a negative error code. 2136 */ 2137 int spi_bus_lock(struct spi_master *master) 2138 { 2139 unsigned long flags; 2140 2141 mutex_lock(&master->bus_lock_mutex); 2142 2143 spin_lock_irqsave(&master->bus_lock_spinlock, flags); 2144 master->bus_lock_flag = 1; 2145 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags); 2146 2147 /* mutex remains locked until spi_bus_unlock is called */ 2148 2149 return 0; 2150 } 2151 EXPORT_SYMBOL_GPL(spi_bus_lock); 2152 2153 /** 2154 * spi_bus_unlock - release the lock for exclusive SPI bus usage 2155 * @master: SPI bus master that was locked for exclusive bus access 2156 * Context: can sleep 2157 * 2158 * This call may only be used from a context that may sleep. The sleep 2159 * is non-interruptible, and has no timeout. 2160 * 2161 * This call releases an SPI bus lock previously obtained by an spi_bus_lock 2162 * call. 2163 * 2164 * It returns zero on success, else a negative error code. 2165 */ 2166 int spi_bus_unlock(struct spi_master *master) 2167 { 2168 master->bus_lock_flag = 0; 2169 2170 mutex_unlock(&master->bus_lock_mutex); 2171 2172 return 0; 2173 } 2174 EXPORT_SYMBOL_GPL(spi_bus_unlock); 2175 2176 /* portable code must never pass more than 32 bytes */ 2177 #define SPI_BUFSIZ max(32, SMP_CACHE_BYTES) 2178 2179 static u8 *buf; 2180 2181 /** 2182 * spi_write_then_read - SPI synchronous write followed by read 2183 * @spi: device with which data will be exchanged 2184 * @txbuf: data to be written (need not be dma-safe) 2185 * @n_tx: size of txbuf, in bytes 2186 * @rxbuf: buffer into which data will be read (need not be dma-safe) 2187 * @n_rx: size of rxbuf, in bytes 2188 * Context: can sleep 2189 * 2190 * This performs a half duplex MicroWire style transaction with the 2191 * device, sending txbuf and then reading rxbuf. The return value 2192 * is zero for success, else a negative errno status code. 2193 * This call may only be used from a context that may sleep. 2194 * 2195 * Parameters to this routine are always copied using a small buffer; 2196 * portable code should never use this for more than 32 bytes. 2197 * Performance-sensitive or bulk transfer code should instead use 2198 * spi_{async,sync}() calls with dma-safe buffers. 2199 */ 2200 int spi_write_then_read(struct spi_device *spi, 2201 const void *txbuf, unsigned n_tx, 2202 void *rxbuf, unsigned n_rx) 2203 { 2204 static DEFINE_MUTEX(lock); 2205 2206 int status; 2207 struct spi_message message; 2208 struct spi_transfer x[2]; 2209 u8 *local_buf; 2210 2211 /* Use preallocated DMA-safe buffer if we can. We can't avoid 2212 * copying here, (as a pure convenience thing), but we can 2213 * keep heap costs out of the hot path unless someone else is 2214 * using the pre-allocated buffer or the transfer is too large. 2215 */ 2216 if ((n_tx + n_rx) > SPI_BUFSIZ || !mutex_trylock(&lock)) { 2217 local_buf = kmalloc(max((unsigned)SPI_BUFSIZ, n_tx + n_rx), 2218 GFP_KERNEL | GFP_DMA); 2219 if (!local_buf) 2220 return -ENOMEM; 2221 } else { 2222 local_buf = buf; 2223 } 2224 2225 spi_message_init(&message); 2226 memset(x, 0, sizeof(x)); 2227 if (n_tx) { 2228 x[0].len = n_tx; 2229 spi_message_add_tail(&x[0], &message); 2230 } 2231 if (n_rx) { 2232 x[1].len = n_rx; 2233 spi_message_add_tail(&x[1], &message); 2234 } 2235 2236 memcpy(local_buf, txbuf, n_tx); 2237 x[0].tx_buf = local_buf; 2238 x[1].rx_buf = local_buf + n_tx; 2239 2240 /* do the i/o */ 2241 status = spi_sync(spi, &message); 2242 if (status == 0) 2243 memcpy(rxbuf, x[1].rx_buf, n_rx); 2244 2245 if (x[0].tx_buf == buf) 2246 mutex_unlock(&lock); 2247 else 2248 kfree(local_buf); 2249 2250 return status; 2251 } 2252 EXPORT_SYMBOL_GPL(spi_write_then_read); 2253 2254 /*-------------------------------------------------------------------------*/ 2255 2256 static int __init spi_init(void) 2257 { 2258 int status; 2259 2260 buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL); 2261 if (!buf) { 2262 status = -ENOMEM; 2263 goto err0; 2264 } 2265 2266 status = bus_register(&spi_bus_type); 2267 if (status < 0) 2268 goto err1; 2269 2270 status = class_register(&spi_master_class); 2271 if (status < 0) 2272 goto err2; 2273 return 0; 2274 2275 err2: 2276 bus_unregister(&spi_bus_type); 2277 err1: 2278 kfree(buf); 2279 buf = NULL; 2280 err0: 2281 return status; 2282 } 2283 2284 /* board_info is normally registered in arch_initcall(), 2285 * but even essential drivers wait till later 2286 * 2287 * REVISIT only boardinfo really needs static linking. the rest (device and 2288 * driver registration) _could_ be dynamically linked (modular) ... costs 2289 * include needing to have boardinfo data structures be much more public. 2290 */ 2291 postcore_initcall(spi_init); 2292 2293