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