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