projects / GitHub / exynos8895 / android_kernel_samsung_universal8895.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
am437x-vpfe: always assign bpp variable
[GitHub/exynos8895/android_kernel_samsung_universal8895.git] / drivers / spi / spi.c
CommitLineData
8ae12a0d 1/*
ca632f55 2 * SPI init/core code
8ae12a0d
DB		 3 *
4 * Copyright (C) 2005 David Brownell
d57a4282 5 * Copyright (C) 2008 Secret Lab Technologies Ltd.
8ae12a0d
DB		 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.
8ae12a0d
DB		 16 */
17
8ae12a0d
DB		 18#include <linux/kernel.h>
19#include <linux/device.h>
20#include <linux/init.h>
21#include <linux/cache.h>
99adef31
MB		 22#include <linux/dma-mapping.h>
23#include <linux/dmaengine.h>
94040828 24#include <linux/mutex.h>
2b7a32f7 25#include <linux/of_device.h>
d57a4282 26#include <linux/of_irq.h>
86be408b 27#include <linux/clk/clk-conf.h>
5a0e3ad6 28#include <linux/slab.h>
e0626e38 29#include <linux/mod_devicetable.h>
8ae12a0d 30#include <linux/spi/spi.h>
74317984 31#include <linux/of_gpio.h>
3ae22e8c 32#include <linux/pm_runtime.h>
f48c767c 33#include <linux/pm_domain.h>
025ed130 34#include <linux/export.h>
8bd75c77 35#include <linux/sched/rt.h>
ffbbdd21
LW		 36#include <linux/delay.h>
37#include <linux/kthread.h>
64bee4d2
MW		 38#include <linux/ioport.h>
39#include <linux/acpi.h>
8ae12a0d 40
56ec1978
MB		 41#define CREATE_TRACE_POINTS
42#include <trace/events/spi.h>
43
8ae12a0d
DB		 44static void spidev_release(struct device *dev)
45{
0ffa0285 46 struct spi_device *spi = to_spi_device(dev);
8ae12a0d
DB		 47
48 /* spi masters may cleanup for released devices */
49 if (spi->master->cleanup)
50 spi->master->cleanup(spi);
51
0c868461 52 spi_master_put(spi->master);
07a389fe 53 kfree(spi);
8ae12a0d
DB		 54}
55
56static ssize_t
57modalias_show(struct device *dev, struct device_attribute *a, char *buf)
58{
59 const struct spi_device *spi = to_spi_device(dev);
8c4ff6d0
ZR		 60 int len;
61
62 len = acpi_device_modalias(dev, buf, PAGE_SIZE - 1);
63 if (len != -ENODEV)
64 return len;
8ae12a0d 65
d8e328b3 66 return sprintf(buf, "%s%s\n", SPI_MODULE_PREFIX, spi->modalias);
8ae12a0d 67}
aa7da564 68static DEVICE_ATTR_RO(modalias);
8ae12a0d 69
eca2ebc7
MS		 70#define SPI_STATISTICS_ATTRS(field, file) \
71static 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} \
79static struct device_attribute dev_attr_spi_master_##field = { \
80 .attr = { .name = file, .mode = S_IRUGO }, \
81 .show = spi_master_##field##_show, \
82}; \
83static 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} \
91static 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) \
97static 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} \
107SPI_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
113SPI_STATISTICS_SHOW(messages, "%lu");
114SPI_STATISTICS_SHOW(transfers, "%lu");
115SPI_STATISTICS_SHOW(errors, "%lu");
116SPI_STATISTICS_SHOW(timedout, "%lu");
117
118SPI_STATISTICS_SHOW(spi_sync, "%lu");
119SPI_STATISTICS_SHOW(spi_sync_immediate, "%lu");
120SPI_STATISTICS_SHOW(spi_async, "%lu");
121
122SPI_STATISTICS_SHOW(bytes, "%llu");
123SPI_STATISTICS_SHOW(bytes_rx, "%llu");
124SPI_STATISTICS_SHOW(bytes_tx, "%llu");
125
6b7bc061
MS		 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")
130SPI_STATISTICS_TRANSFER_BYTES_HISTO(0, "0-1");
131SPI_STATISTICS_TRANSFER_BYTES_HISTO(1, "2-3");
132SPI_STATISTICS_TRANSFER_BYTES_HISTO(2, "4-7");
133SPI_STATISTICS_TRANSFER_BYTES_HISTO(3, "8-15");
134SPI_STATISTICS_TRANSFER_BYTES_HISTO(4, "16-31");
135SPI_STATISTICS_TRANSFER_BYTES_HISTO(5, "32-63");
136SPI_STATISTICS_TRANSFER_BYTES_HISTO(6, "64-127");
137SPI_STATISTICS_TRANSFER_BYTES_HISTO(7, "128-255");
138SPI_STATISTICS_TRANSFER_BYTES_HISTO(8, "256-511");
139SPI_STATISTICS_TRANSFER_BYTES_HISTO(9, "512-1023");
140SPI_STATISTICS_TRANSFER_BYTES_HISTO(10, "1024-2047");
141SPI_STATISTICS_TRANSFER_BYTES_HISTO(11, "2048-4095");
142SPI_STATISTICS_TRANSFER_BYTES_HISTO(12, "4096-8191");
143SPI_STATISTICS_TRANSFER_BYTES_HISTO(13, "8192-16383");
144SPI_STATISTICS_TRANSFER_BYTES_HISTO(14, "16384-32767");
145SPI_STATISTICS_TRANSFER_BYTES_HISTO(15, "32768-65535");
146SPI_STATISTICS_TRANSFER_BYTES_HISTO(16, "65536+");
147
aa7da564
GKH		 148static struct attribute *spi_dev_attrs[] = {
149 &dev_attr_modalias.attr,
150 NULL,
8ae12a0d 151};
eca2ebc7
MS		 152
153static const struct attribute_group spi_dev_group = {
154 .attrs = spi_dev_attrs,
155};
156
157static 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,
6b7bc061
MS		 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,
eca2ebc7
MS		 185 NULL,
186};
187
188static const struct attribute_group spi_device_statistics_group = {
189 .name = "statistics",
190 .attrs = spi_device_statistics_attrs,
191};
192
193static const struct attribute_group *spi_dev_groups[] = {
194 &spi_dev_group,
195 &spi_device_statistics_group,
196 NULL,
197};
198
199static 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,
6b7bc061
MS		 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,
eca2ebc7
MS		 227 NULL,
228};
229
230static const struct attribute_group spi_master_statistics_group = {
231 .name = "statistics",
232 .attrs = spi_master_statistics_attrs,
233};
234
235static const struct attribute_group *spi_master_groups[] = {
236 &spi_master_statistics_group,
237 NULL,
238};
239
240void spi_statistics_add_transfer_stats(struct spi_statistics *stats,
241 struct spi_transfer *xfer,
242 struct spi_master *master)
243{
244 unsigned long flags;
6b7bc061
MS		 245 int l2len = min(fls(xfer->len), SPI_STATISTICS_HISTO_SIZE) - 1;
246
247 if (l2len < 0)
248 l2len = 0;
eca2ebc7
MS		 249
250 spin_lock_irqsave(&stats->lock, flags);
251
252 stats->transfers++;
6b7bc061 253 stats->transfer_bytes_histo[l2len]++;
eca2ebc7
MS		 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}
265EXPORT_SYMBOL_GPL(spi_statistics_add_transfer_stats);
8ae12a0d
DB		 266
267/* modalias support makes "modprobe $MODALIAS" new-style hotplug work,
268 * and the sysfs version makes coldplug work too.
269 */
270
75368bf6
AV		 271static 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
282const 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}
288EXPORT_SYMBOL_GPL(spi_get_device_id);
289
8ae12a0d
DB		 290static int spi_match_device(struct device *dev, struct device_driver *drv)
291{
292 const struct spi_device *spi = to_spi_device(dev);
75368bf6
AV		 293 const struct spi_driver *sdrv = to_spi_driver(drv);
294
2b7a32f7
SA		 295 /* Attempt an OF style match */
296 if (of_driver_match_device(dev, drv))
297 return 1;
298
64bee4d2
MW		 299 /* Then try ACPI */
300 if (acpi_driver_match_device(dev, drv))
301 return 1;
302
75368bf6
AV		 303 if (sdrv->id_table)
304 return !!spi_match_id(sdrv->id_table, spi);
8ae12a0d 305
35f74fca 306 return strcmp(spi->modalias, drv->name) == 0;
8ae12a0d
DB		 307}
308
7eff2e7a 309static int spi_uevent(struct device *dev, struct kobj_uevent_env *env)
8ae12a0d
DB		 310{
311 const struct spi_device *spi = to_spi_device(dev);
8c4ff6d0
ZR		 312 int rc;
313
314 rc = acpi_device_uevent_modalias(dev, env);
315 if (rc != -ENODEV)
316 return rc;
8ae12a0d 317
e0626e38 318 add_uevent_var(env, "MODALIAS=%s%s", SPI_MODULE_PREFIX, spi->modalias);
8ae12a0d
DB		 319 return 0;
320}
321
8ae12a0d
DB		 322struct bus_type spi_bus_type = {
323 .name = "spi",
aa7da564 324 .dev_groups = spi_dev_groups,
8ae12a0d
DB		 325 .match = spi_match_device,
326 .uevent = spi_uevent,
8ae12a0d
DB		 327};
328EXPORT_SYMBOL_GPL(spi_bus_type);
329
b885244e
DB		 330
331static int spi_drv_probe(struct device *dev)
332{
333 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
44af7927 334 struct spi_device *spi = to_spi_device(dev);
33cf00e5
MW		 335 int ret;
336
86be408b
SN		 337 ret = of_clk_set_defaults(dev->of_node, false);
338 if (ret)
339 return ret;
340
44af7927
JH		 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
676e7c25
UH		 349 ret = dev_pm_domain_attach(dev, true);
350 if (ret != -EPROBE_DEFER) {
44af7927 351 ret = sdrv->probe(spi);
676e7c25
UH		 352 if (ret)
353 dev_pm_domain_detach(dev, true);
354 }
b885244e 355
33cf00e5 356 return ret;
b885244e
DB		 357}
358
359static int spi_drv_remove(struct device *dev)
360{
361 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
33cf00e5
MW		 362 int ret;
363
aec35f4e 364 ret = sdrv->remove(to_spi_device(dev));
676e7c25 365 dev_pm_domain_detach(dev, true);
b885244e 366
33cf00e5 367 return ret;
b885244e
DB		 368}
369
370static 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
33e34dc6 377/**
ca5d2485 378 * __spi_register_driver - register a SPI driver
88c9321d 379 * @owner: owner module of the driver to register
33e34dc6
DB		 380 * @sdrv: the driver to register
381 * Context: can sleep
97d56dc6
JMC		 382 *
383 * Return: zero on success, else a negative error code.
33e34dc6 384 */
ca5d2485 385int __spi_register_driver(struct module *owner, struct spi_driver *sdrv)
b885244e 386{
ca5d2485 387 sdrv->driver.owner = owner;
b885244e
DB		 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}
ca5d2485 397EXPORT_SYMBOL_GPL(__spi_register_driver);
b885244e 398
8ae12a0d
DB		 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
407struct boardinfo {
408 struct list_head list;
2b9603a0 409 struct spi_board_info board_info;
8ae12a0d
DB		 410};
411
412static LIST_HEAD(board_list);
2b9603a0
FT		 413static 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 */
94040828 419static DEFINE_MUTEX(board_lock);
8ae12a0d 420
dc87c98e
GL		 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 *
97d56dc6 436 * Return: a pointer to the new device, or NULL.
dc87c98e
GL		 437 */
438struct spi_device *spi_alloc_device(struct spi_master *master)
439{
440 struct spi_device *spi;
dc87c98e
GL		 441
442 if (!spi_master_get(master))
443 return NULL;
444
5fe5f05e 445 spi = kzalloc(sizeof(*spi), GFP_KERNEL);
dc87c98e 446 if (!spi) {
dc87c98e
GL		 447 spi_master_put(master);
448 return NULL;
449 }
450
451 spi->master = master;
178db7d3 452 spi->dev.parent = &master->dev;
dc87c98e
GL		 453 spi->dev.bus = &spi_bus_type;
454 spi->dev.release = spidev_release;
446411e1 455 spi->cs_gpio = -ENOENT;
eca2ebc7
MS		 456
457 spin_lock_init(&spi->statistics.lock);
458
dc87c98e
GL		 459 device_initialize(&spi->dev);
460 return spi;
461}
462EXPORT_SYMBOL_GPL(spi_alloc_device);
463
e13ac47b
JN		 464static 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
b6fb8d3a
MW		 477static 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
dc87c98e
GL		 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 *
97d56dc6 495 * Return: 0 on success; negative errno on failure
dc87c98e
GL		 496 */
497int spi_add_device(struct spi_device *spi)
498{
e48880e0 499 static DEFINE_MUTEX(spi_add_lock);
74317984
JCPV		 500 struct spi_master *master = spi->master;
501 struct device *dev = master->dev.parent;
dc87c98e
GL		 502 int status;
503
504 /* Chipselects are numbered 0..max; validate. */
74317984 505 if (spi->chip_select >= master->num_chipselect) {
dc87c98e
GL		 506 dev_err(dev, "cs%d >= max %d\n",
507 spi->chip_select,
74317984 508 master->num_chipselect);
dc87c98e
GL		 509 return -EINVAL;
510 }
511
512 /* Set the bus ID string */
e13ac47b 513 spi_dev_set_name(spi);
e48880e0
DB		 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
b6fb8d3a
MW		 521 status = bus_for_each_dev(&spi_bus_type, NULL, spi, spi_dev_check);
522 if (status) {
e48880e0
DB		 523 dev_err(dev, "chipselect %d already in use\n",
524 spi->chip_select);
e48880e0
DB		 525 goto done;
526 }
527
74317984
JCPV		 528 if (master->cs_gpios)
529 spi->cs_gpio = master->cs_gpios[spi->chip_select];
530
e48880e0
DB		 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 */
7d077197 535 status = spi_setup(spi);
dc87c98e 536 if (status < 0) {
eb288a1f
LW		 537 dev_err(dev, "can't setup %s, status %d\n",
538 dev_name(&spi->dev), status);
e48880e0 539 goto done;
dc87c98e
GL		 540 }
541
e48880e0 542 /* Device may be bound to an active driver when this returns */
dc87c98e 543 status = device_add(&spi->dev);
e48880e0 544 if (status < 0)
eb288a1f
LW		 545 dev_err(dev, "can't add %s, status %d\n",
546 dev_name(&spi->dev), status);
e48880e0 547 else
35f74fca 548 dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));
dc87c98e 549
e48880e0
DB		 550done:
551 mutex_unlock(&spi_add_lock);
552 return status;
dc87c98e
GL		 553}
554EXPORT_SYMBOL_GPL(spi_add_device);
8ae12a0d 555
33e34dc6
DB		 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
8ae12a0d
DB		 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).
082c8cb4 567 *
97d56dc6 568 * Return: the new device, or NULL.
8ae12a0d 569 */
e9d5a461
AB		 570struct spi_device *spi_new_device(struct spi_master *master,
571 struct spi_board_info *chip)
8ae12a0d
DB		 572{
573 struct spi_device *proxy;
8ae12a0d
DB		 574 int status;
575
082c8cb4
DB		 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
dc87c98e
GL		 583 proxy = spi_alloc_device(master);
584 if (!proxy)
8ae12a0d
DB		 585 return NULL;
586
102eb975
GL		 587 WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
588
8ae12a0d
DB		 589 proxy->chip_select = chip->chip_select;
590 proxy->max_speed_hz = chip->max_speed_hz;
980a01c9 591 proxy->mode = chip->mode;
8ae12a0d 592 proxy->irq = chip->irq;
102eb975 593 strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));
8ae12a0d
DB		 594 proxy->dev.platform_data = (void *) chip->platform_data;
595 proxy->controller_data = chip->controller_data;
596 proxy->controller_state = NULL;
8ae12a0d 597
dc87c98e 598 status = spi_add_device(proxy);
8ae12a0d 599 if (status < 0) {
dc87c98e
GL		 600 spi_dev_put(proxy);
601 return NULL;
8ae12a0d
DB		 602 }
603
8ae12a0d
DB		 604 return proxy;
605}
606EXPORT_SYMBOL_GPL(spi_new_device);
607
2b9603a0
FT		 608static 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
33e34dc6
DB		 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 *
8ae12a0d
DB		 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.
97d56dc6
JMC		 640 *
641 * Return: zero on success, else a negative error code.
8ae12a0d 642 */
fd4a319b 643int spi_register_board_info(struct spi_board_info const *info, unsigned n)
8ae12a0d 644{
2b9603a0
FT		 645 struct boardinfo *bi;
646 int i;
8ae12a0d 647
c7908a37
XL		 648 if (!n)
649 return -EINVAL;
650
2b9603a0 651 bi = kzalloc(n * sizeof(*bi), GFP_KERNEL);
8ae12a0d
DB		 652 if (!bi)
653 return -ENOMEM;
8ae12a0d 654
2b9603a0
FT		 655 for (i = 0; i < n; i++, bi++, info++) {
656 struct spi_master *master;
8ae12a0d 657
2b9603a0
FT		 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);
8ae12a0d 664 }
2b9603a0
FT		 665
666 return 0;
8ae12a0d
DB		 667}
668
669/*-------------------------------------------------------------------------*/
670
b158935f
MB		 671static void spi_set_cs(struct spi_device *spi, bool enable)
672{
673 if (spi->mode & SPI_CS_HIGH)
674 enable = !enable;
675
243f07be 676 if (gpio_is_valid(spi->cs_gpio))
b158935f
MB		 677 gpio_set_value(spi->cs_gpio, !enable);
678 else if (spi->master->set_cs)
679 spi->master->set_cs(spi, !enable);
680}
681
2de440f5 682#ifdef CONFIG_HAS_DMA
6ad45a27
MB		 683static 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);
65598c13
AG		 688 int desc_len;
689 int sgs;
6ad45a27
MB		 690 struct page *vm_page;
691 void *sg_buf;
692 size_t min;
693 int i, ret;
694
65598c13
AG		 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
6ad45a27
MB		 703 ret = sg_alloc_table(sgt, sgs, GFP_KERNEL);
704 if (ret != 0)
705 return ret;
706
707 for (i = 0; i < sgs; i++) {
6ad45a27
MB		 708
709 if (vmalloced_buf) {
65598c13
AG		 710 min = min_t(size_t,
711 len, desc_len - offset_in_page(buf));
6ad45a27
MB		 712 vm_page = vmalloc_to_page(buf);
713 if (!vm_page) {
714 sg_free_table(sgt);
715 return -ENOMEM;
716 }
c1aefbdd
CK		 717 sg_set_page(&sgt->sgl[i], vm_page,
718 min, offset_in_page(buf));
6ad45a27 719 } else {
65598c13 720 min = min_t(size_t, len, desc_len);
6ad45a27 721 sg_buf = buf;
c1aefbdd 722 sg_set_buf(&sgt->sgl[i], sg_buf, min);
6ad45a27
MB		 723 }
724
6ad45a27
MB		 725
726 buf += min;
727 len -= min;
728 }
729
730 ret = dma_map_sg(dev, sgt->sgl, sgt->nents, dir);
89e4b66a
GU		 731 if (!ret)
732 ret = -ENOMEM;
6ad45a27
MB		 733 if (ret < 0) {
734 sg_free_table(sgt);
735 return ret;
736 }
737
738 sgt->nents = ret;
739
740 return 0;
741}
742
743static 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
2de440f5 752static int __spi_map_msg(struct spi_master *master, struct spi_message *msg)
99adef31 753{
99adef31
MB		 754 struct device *tx_dev, *rx_dev;
755 struct spi_transfer *xfer;
6ad45a27 756 int ret;
3a2eba9b 757
6ad45a27 758 if (!master->can_dma)
99adef31
MB		 759 return 0;
760
c37f45b5
LL		 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;
99adef31
MB		 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) {
6ad45a27
MB		 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;
99adef31
MB		 781 }
782
783 if (xfer->rx_buf != NULL) {
6ad45a27
MB		 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;
99adef31
MB		 791 }
792 }
793 }
794
795 master->cur_msg_mapped = true;
796
797 return 0;
798}
799
4b786458 800static int __spi_unmap_msg(struct spi_master *master, struct spi_message *msg)
99adef31
MB		 801{
802 struct spi_transfer *xfer;
803 struct device *tx_dev, *rx_dev;
804
6ad45a27 805 if (!master->cur_msg_mapped || !master->can_dma)
99adef31
MB		 806 return 0;
807
c37f45b5
LL		 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;
99adef31
MB		 817
818 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
819 if (!master->can_dma(master, msg->spi, xfer))
820 continue;
821
6ad45a27
MB		 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);
99adef31
MB		 824 }
825
826 return 0;
827}
2de440f5
GU		 828#else /* !CONFIG_HAS_DMA */
829static inline int __spi_map_msg(struct spi_master *master,
830 struct spi_message *msg)
831{
832 return 0;
833}
834
4b786458
MS		 835static inline int __spi_unmap_msg(struct spi_master *master,
836 struct spi_message *msg)
2de440f5
GU		 837{
838 return 0;
839}
840#endif /* !CONFIG_HAS_DMA */
841
4b786458
MS		 842static 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
2de440f5
GU		 861static 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}
99adef31 910
b158935f
MB		 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 */
918static int spi_transfer_one_message(struct spi_master *master,
919 struct spi_message *msg)
920{
921 struct spi_transfer *xfer;
b158935f
MB		 922 bool keep_cs = false;
923 int ret = 0;
682a71b2 924 unsigned long ms = 1;
eca2ebc7
MS		 925 struct spi_statistics *statm = &master->statistics;
926 struct spi_statistics *stats = &msg->spi->statistics;
b158935f
MB		 927
928 spi_set_cs(msg->spi, true);
929
eca2ebc7
MS		 930 SPI_STATISTICS_INCREMENT_FIELD(statm, messages);
931 SPI_STATISTICS_INCREMENT_FIELD(stats, messages);
932
b158935f
MB		 933 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
934 trace_spi_transfer_start(msg, xfer);
935
eca2ebc7
MS		 936 spi_statistics_add_transfer_stats(statm, xfer, master);
937 spi_statistics_add_transfer_stats(stats, xfer, master);
938
38ec10f6
MB		 939 if (xfer->tx_buf || xfer->rx_buf) {
940 reinit_completion(&master->xfer_completion);
b158935f 941
38ec10f6
MB		 942 ret = master->transfer_one(master, msg->spi, xfer);
943 if (ret < 0) {
eca2ebc7
MS		 944 SPI_STATISTICS_INCREMENT_FIELD(statm,
945 errors);
946 SPI_STATISTICS_INCREMENT_FIELD(stats,
947 errors);
38ec10f6
MB		 948 dev_err(&msg->spi->dev,
949 "SPI transfer failed: %d\n", ret);
950 goto out;
951 }
b158935f 952
38ec10f6
MB		 953 if (ret > 0) {
954 ret = 0;
955 ms = xfer->len * 8 * 1000 / xfer->speed_hz;
956 ms += ms + 100; /* some tolerance */
16a0ce4e 957
38ec10f6
MB		 958 ms = wait_for_completion_timeout(&master->xfer_completion,
959 msecs_to_jiffies(ms));
960 }
16a0ce4e 961
38ec10f6 962 if (ms == 0) {
eca2ebc7
MS		 963 SPI_STATISTICS_INCREMENT_FIELD(statm,
964 timedout);
965 SPI_STATISTICS_INCREMENT_FIELD(stats,
966 timedout);
38ec10f6
MB		 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);
13a42798 976 }
b158935f
MB		 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 {
0b73aa63
MB		 991 spi_set_cs(msg->spi, false);
992 udelay(10);
993 spi_set_cs(msg->spi, true);
b158935f
MB		 994 }
995 }
996
997 msg->actual_length += xfer->len;
998 }
999
1000out:
1001 if (ret != 0 || !keep_cs)
1002 spi_set_cs(msg->spi, false);
1003
1004 if (msg->status == -EINPROGRESS)
1005 msg->status = ret;
1006
ff61eb42 1007 if (msg->status && master->handle_err)
b716c4ff
AS		 1008 master->handle_err(master, msg);
1009
b158935f
MB		 1010 spi_finalize_current_message(master);
1011
1012 return ret;
1013}
1014
1015/**
1016 * spi_finalize_current_transfer - report completion of a transfer
2c675689 1017 * @master: the master reporting completion
b158935f
MB		 1018 *
1019 * Called by SPI drivers using the core transfer_one_message()
1020 * implementation to notify it that the current interrupt driven
9e8f4882 1021 * transfer has finished and the next one may be scheduled.
b158935f
MB		 1022 */
1023void spi_finalize_current_transfer(struct spi_master *master)
1024{
1025 complete(&master->xfer_completion);
1026}
1027EXPORT_SYMBOL_GPL(spi_finalize_current_transfer);
1028
ffbbdd21 1029/**
fc9e0f71
MB		 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
ffbbdd21
LW		 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 *
0461a414
MB		 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.
ffbbdd21 1041 */
fc9e0f71 1042static void __spi_pump_messages(struct spi_master *master, bool in_kthread)
ffbbdd21 1043{
ffbbdd21
LW		 1044 unsigned long flags;
1045 bool was_busy = false;
1046 int ret;
1047
983aee5d 1048 /* Lock queue */
ffbbdd21 1049 spin_lock_irqsave(&master->queue_lock, flags);
983aee5d
MB		 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
0461a414
MB		 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
983aee5d 1064 /* Check if the queue is idle */
ffbbdd21 1065 if (list_empty(&master->queue) || !master->running) {
b0b36b86
BF		 1066 if (!master->busy) {
1067 spin_unlock_irqrestore(&master->queue_lock, flags);
1068 return;
ffbbdd21 1069 }
fc9e0f71
MB		 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
ffbbdd21 1079 master->busy = false;
0461a414 1080 master->idling = true;
ffbbdd21 1081 spin_unlock_irqrestore(&master->queue_lock, flags);
0461a414 1082
3a2eba9b
MB		 1083 kfree(master->dummy_rx);
1084 master->dummy_rx = NULL;
1085 kfree(master->dummy_tx);
1086 master->dummy_tx = NULL;
b0b36b86
BF		 1087 if (master->unprepare_transfer_hardware &&
1088 master->unprepare_transfer_hardware(master))
1089 dev_err(&master->dev,
1090 "failed to unprepare transfer hardware\n");
49834de2
MB		 1091 if (master->auto_runtime_pm) {
1092 pm_runtime_mark_last_busy(master->dev.parent);
1093 pm_runtime_put_autosuspend(master->dev.parent);
1094 }
56ec1978 1095 trace_spi_master_idle(master);
ffbbdd21 1096
0461a414
MB		 1097 spin_lock_irqsave(&master->queue_lock, flags);
1098 master->idling = false;
ffbbdd21
LW		 1099 spin_unlock_irqrestore(&master->queue_lock, flags);
1100 return;
1101 }
ffbbdd21 1102
ffbbdd21
LW		 1103 /* Extract head of queue */
1104 master->cur_msg =
a89e2d27 1105 list_first_entry(&master->queue, struct spi_message, queue);
ffbbdd21
LW		 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
49834de2
MB		 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
56ec1978
MB		 1123 if (!was_busy)
1124 trace_spi_master_busy(master);
1125
7dfd2bd7 1126 if (!was_busy && master->prepare_transfer_hardware) {
ffbbdd21
LW		 1127 ret = master->prepare_transfer_hardware(master);
1128 if (ret) {
1129 dev_err(&master->dev,
1130 "failed to prepare transfer hardware\n");
49834de2
MB		 1131
1132 if (master->auto_runtime_pm)
1133 pm_runtime_put(master->dev.parent);
ffbbdd21
LW		 1134 return;
1135 }
1136 }
1137
56ec1978
MB		 1138 trace_spi_message_start(master->cur_msg);
1139
2841a5fc
MB		 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
99adef31
MB		 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
ffbbdd21
LW		 1159 ret = master->transfer_one_message(master, master->cur_msg);
1160 if (ret) {
1161 dev_err(&master->dev,
1f802f82 1162 "failed to transfer one message from queue\n");
ffbbdd21
LW		 1163 return;
1164 }
1165}
1166
fc9e0f71
MB		 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 */
1171static 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
ffbbdd21
LW		 1179static int spi_init_queue(struct spi_master *master)
1180{
1181 struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
1182
ffbbdd21
LW		 1183 master->running = false;
1184 master->busy = false;
1185
1186 init_kthread_worker(&master->kworker);
1187 master->kworker_task = kthread_run(kthread_worker_fn,
f170168b 1188 &master->kworker, "%s",
ffbbdd21
LW		 1189 dev_name(&master->dev));
1190 if (IS_ERR(master->kworker_task)) {
1191 dev_err(&master->dev, "failed to create message pump task\n");
98a8f5a0 1192 return PTR_ERR(master->kworker_task);
ffbbdd21
LW		 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, &param);
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.
97d56dc6
JMC		 1219 *
1220 * Return: the next message in the queue, else NULL if the queue is empty.
ffbbdd21
LW		 1221 */
1222struct 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);
1cfd97f9
AL		 1229 next = list_first_entry_or_null(&master->queue, struct spi_message,
1230 queue);
ffbbdd21
LW		 1231 spin_unlock_irqrestore(&master->queue_lock, flags);
1232
1233 return next;
1234}
1235EXPORT_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 */
1244void spi_finalize_current_message(struct spi_master *master)
1245{
1246 struct spi_message *mesg;
1247 unsigned long flags;
2841a5fc 1248 int ret;
ffbbdd21
LW		 1249
1250 spin_lock_irqsave(&master->queue_lock, flags);
1251 mesg = master->cur_msg;
ffbbdd21
LW		 1252 spin_unlock_irqrestore(&master->queue_lock, flags);
1253
99adef31
MB		 1254 spi_unmap_msg(master, mesg);
1255
2841a5fc
MB		 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 }
391949b6 1263
8e76ef88
MS		 1264 spin_lock_irqsave(&master->queue_lock, flags);
1265 master->cur_msg = NULL;
2841a5fc 1266 master->cur_msg_prepared = false;
8e76ef88
MS		 1267 queue_kthread_work(&master->kworker, &master->pump_messages);
1268 spin_unlock_irqrestore(&master->queue_lock, flags);
1269
1270 trace_spi_message_done(mesg);
2841a5fc 1271
ffbbdd21
LW		 1272 mesg->state = NULL;
1273 if (mesg->complete)
1274 mesg->complete(mesg->context);
1275}
1276EXPORT_SYMBOL_GPL(spi_finalize_current_message);
1277
1278static 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
1298static 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);
f97b26b0 1314 usleep_range(10000, 11000);
ffbbdd21
LW		 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
1333static 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
0461a414
MB		 1356static int __spi_queued_transfer(struct spi_device *spi,
1357 struct spi_message *msg,
1358 bool need_pump)
ffbbdd21
LW		 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);
0461a414 1373 if (!master->busy && need_pump)
ffbbdd21
LW		 1374 queue_kthread_work(&master->kworker, &master->pump_messages);
1375
1376 spin_unlock_irqrestore(&master->queue_lock, flags);
1377 return 0;
1378}
1379
0461a414
MB		 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
97d56dc6
JMC		 1384 *
1385 * Return: zero on success, else a negative error code.
0461a414
MB		 1386 */
1387static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
1388{
1389 return __spi_queued_transfer(spi, msg, true);
1390}
1391
ffbbdd21
LW		 1392static int spi_master_initialize_queue(struct spi_master *master)
1393{
1394 int ret;
1395
ffbbdd21 1396 master->transfer = spi_queued_transfer;
b158935f
MB		 1397 if (!master->transfer_one_message)
1398 master->transfer_one_message = spi_transfer_one_message;
ffbbdd21
LW		 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 }
c3676d5c 1406 master->queued = true;
ffbbdd21
LW		 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
1415err_start_queue:
ffbbdd21 1416 spi_destroy_queue(master);
c3676d5c 1417err_init_queue:
ffbbdd21
LW		 1418 return ret;
1419}
1420
1421/*-------------------------------------------------------------------------*/
1422
7cb94361 1423#if defined(CONFIG_OF)
aff5e3f8
PA		 1424static struct spi_device *
1425of_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
aff5e3f8
PA		 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 */
aff5e3f8
PA		 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
1530err_out:
1531 spi_dev_put(spi);
1532 return ERR_PTR(rc);
1533}
1534
d57a4282
GL		 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 */
1542static void of_register_spi_devices(struct spi_master *master)
1543{
1544 struct spi_device *spi;
1545 struct device_node *nc;
d57a4282
GL		 1546
1547 if (!master->dev.of_node)
1548 return;
1549
f3b6159e 1550 for_each_available_child_of_node(master->dev.of_node, nc) {
aff5e3f8
PA		 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",
d57a4282 1554 nc->full_name);
d57a4282
GL		 1555 }
1556}
1557#else
1558static void of_register_spi_devices(struct spi_master *master) { }
1559#endif
1560
64bee4d2
MW		 1561#ifdef CONFIG_ACPI
1562static 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
1592static 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
7b199811 1613 ACPI_COMPANION_SET(&spi->dev, adev);
64bee4d2
MW		 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
33cf00e5 1626 adev->power.flags.ignore_parent = true;
cf9eb39c 1627 strlcpy(spi->modalias, acpi_device_hid(adev), sizeof(spi->modalias));
64bee4d2 1628 if (spi_add_device(spi)) {
33cf00e5 1629 adev->power.flags.ignore_parent = false;
64bee4d2
MW		 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
1638static void acpi_register_spi_devices(struct spi_master *master)
1639{
1640 acpi_status status;
1641 acpi_handle handle;
1642
29896178 1643 handle = ACPI_HANDLE(master->dev.parent);
64bee4d2
MW		 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
1654static inline void acpi_register_spi_devices(struct spi_master *master) {}
1655#endif /* CONFIG_ACPI */
1656
49dce689 1657static void spi_master_release(struct device *dev)
8ae12a0d
DB		 1658{
1659 struct spi_master *master;
1660
49dce689 1661 master = container_of(dev, struct spi_master, dev);
8ae12a0d
DB		 1662 kfree(master);
1663}
1664
1665static struct class spi_master_class = {
1666 .name = "spi_master",
1667 .owner = THIS_MODULE,
49dce689 1668 .dev_release = spi_master_release,
eca2ebc7 1669 .dev_groups = spi_master_groups,
8ae12a0d
DB		 1670};
1671
1672
1673/**
1674 * spi_alloc_master - allocate SPI master controller
1675 * @dev: the controller, possibly using the platform_bus
33e34dc6 1676 * @size: how much zeroed driver-private data to allocate; the pointer to this
49dce689 1677 * memory is in the driver_data field of the returned device,
0c868461 1678 * accessible with spi_master_get_devdata().
33e34dc6 1679 * Context: can sleep
8ae12a0d
DB		 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
ba1a0513 1683 * an spi_master structure, prior to calling spi_register_master().
8ae12a0d 1684 *
97d56dc6 1685 * This must be called from context that can sleep.
8ae12a0d
DB		 1686 *
1687 * The caller is responsible for assigning the bus number and initializing
ba1a0513 1688 * the master's methods before calling spi_register_master(); and (after errors
a394d635 1689 * adding the device) calling spi_master_put() to prevent a memory leak.
97d56dc6
JMC		 1690 *
1691 * Return: the SPI master structure on success, else NULL.
8ae12a0d 1692 */
e9d5a461 1693struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
8ae12a0d
DB		 1694{
1695 struct spi_master *master;
1696
0c868461
DB		 1697 if (!dev)
1698 return NULL;
1699
5fe5f05e 1700 master = kzalloc(size + sizeof(*master), GFP_KERNEL);
8ae12a0d
DB		 1701 if (!master)
1702 return NULL;
1703
49dce689 1704 device_initialize(&master->dev);
1e8a52e1
GL		 1705 master->bus_num = -1;
1706 master->num_chipselect = 1;
49dce689 1707 master->dev.class = &spi_master_class;
157f38f9 1708 master->dev.parent = dev;
0c868461 1709 spi_master_set_devdata(master, &master[1]);
8ae12a0d
DB		 1710
1711 return master;
1712}
1713EXPORT_SYMBOL_GPL(spi_alloc_master);
1714
74317984
JCPV		 1715#ifdef CONFIG_OF
1716static int of_spi_register_master(struct spi_master *master)
1717{
e80beb27 1718 int nb, i, *cs;
74317984
JCPV		 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");
5fe5f05e 1725 master->num_chipselect = max_t(int, nb, master->num_chipselect);
74317984 1726
8ec5d84e
AL		 1727 /* Return error only for an incorrectly formed cs-gpios property */
1728 if (nb == 0 || nb == -ENOENT)
74317984 1729 return 0;
8ec5d84e
AL		 1730 else if (nb < 0)
1731 return nb;
74317984
JCPV		 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
0da83bb1 1741 for (i = 0; i < master->num_chipselect; i++)
446411e1 1742 cs[i] = -ENOENT;
74317984
JCPV		 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
1750static int of_spi_register_master(struct spi_master *master)
1751{
1752 return 0;
1753}
1754#endif
1755
8ae12a0d
DB		 1756/**
1757 * spi_register_master - register SPI master controller
1758 * @master: initialized master, originally from spi_alloc_master()
33e34dc6 1759 * Context: can sleep
8ae12a0d
DB		 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).
0c868461
DB		 1773 * After a successful return, the caller is responsible for calling
1774 * spi_unregister_master().
97d56dc6
JMC		 1775 *
1776 * Return: zero on success, else a negative error code.
8ae12a0d 1777 */
e9d5a461 1778int spi_register_master(struct spi_master *master)
8ae12a0d 1779{
e44a45ae 1780 static atomic_t dyn_bus_id = ATOMIC_INIT((1<<15) - 1);
49dce689 1781 struct device *dev = master->dev.parent;
2b9603a0 1782 struct boardinfo *bi;
8ae12a0d
DB		 1783 int status = -ENODEV;
1784 int dynamic = 0;
1785
0c868461
DB		 1786 if (!dev)
1787 return -ENODEV;
1788
74317984
JCPV		 1789 status = of_spi_register_master(master);
1790 if (status)
1791 return status;
1792
082c8cb4
DB		 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
bb29785e
GL		 1799 if ((master->bus_num < 0) && master->dev.of_node)
1800 master->bus_num = of_alias_get_id(master->dev.of_node, "spi");
1801
8ae12a0d 1802 /* convention: dynamically assigned bus IDs count down from the max */
a020ed75 1803 if (master->bus_num < 0) {
082c8cb4
DB		 1804 /* FIXME switch to an IDR based scheme, something like
1805 * I2C now uses, so we can't run out of "dynamic" IDs
1806 */
8ae12a0d 1807 master->bus_num = atomic_dec_return(&dyn_bus_id);
b885244e 1808 dynamic = 1;
8ae12a0d
DB		 1809 }
1810
5424d43e
MB		 1811 INIT_LIST_HEAD(&master->queue);
1812 spin_lock_init(&master->queue_lock);
cf32b71e
ES		 1813 spin_lock_init(&master->bus_lock_spinlock);
1814 mutex_init(&master->bus_lock_mutex);
1815 master->bus_lock_flag = 0;
b158935f 1816 init_completion(&master->xfer_completion);
6ad45a27
MB		 1817 if (!master->max_dma_len)
1818 master->max_dma_len = INT_MAX;
cf32b71e 1819
8ae12a0d
DB		 1820 /* register the device, then userspace will see it.
1821 * registration fails if the bus ID is in use.
1822 */
35f74fca 1823 dev_set_name(&master->dev, "spi%u", master->bus_num);
49dce689 1824 status = device_add(&master->dev);
b885244e 1825 if (status < 0)
8ae12a0d 1826 goto done;
35f74fca 1827 dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev),
8ae12a0d
DB		 1828 dynamic ? " (dynamic)" : "");
1829
ffbbdd21
LW		 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) {
e93b0724 1836 device_del(&master->dev);
ffbbdd21
LW		 1837 goto done;
1838 }
1839 }
eca2ebc7
MS		 1840 /* add statistics */
1841 spin_lock_init(&master->statistics.lock);
ffbbdd21 1842
2b9603a0
FT		 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
64bee4d2 1849 /* Register devices from the device tree and ACPI */
12b15e83 1850 of_register_spi_devices(master);
64bee4d2 1851 acpi_register_spi_devices(master);
8ae12a0d
DB		 1852done:
1853 return status;
1854}
1855EXPORT_SYMBOL_GPL(spi_register_master);
1856
666d5b4c
MB		 1857static 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
97d56dc6
JMC		 1870 *
1871 * Return: zero on success, else a negative error code.
666d5b4c
MB		 1872 */
1873int 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);
4b92894e 1883 if (!ret) {
666d5b4c
MB		 1884 *ptr = master;
1885 devres_add(dev, ptr);
1886 } else {
1887 devres_free(ptr);
1888 }
1889
1890 return ret;
1891}
1892EXPORT_SYMBOL_GPL(devm_spi_register_master);
1893
34860089 1894static int __unregister(struct device *dev, void *null)
8ae12a0d 1895{
34860089 1896 spi_unregister_device(to_spi_device(dev));
8ae12a0d
DB		 1897 return 0;
1898}
1899
1900/**
1901 * spi_unregister_master - unregister SPI master controller
1902 * @master: the master being unregistered
33e34dc6 1903 * Context: can sleep
8ae12a0d
DB		 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 */
1910void spi_unregister_master(struct spi_master *master)
1911{
89fc9a1a
JG		 1912 int dummy;
1913
ffbbdd21
LW		 1914 if (master->queued) {
1915 if (spi_destroy_queue(master))
1916 dev_err(&master->dev, "queue remove failed\n");
1917 }
1918
2b9603a0
FT		 1919 mutex_lock(&board_lock);
1920 list_del(&master->list);
1921 mutex_unlock(&board_lock);
1922
97dbf37d 1923 dummy = device_for_each_child(&master->dev, NULL, __unregister);
49dce689 1924 device_unregister(&master->dev);
8ae12a0d
DB		 1925}
1926EXPORT_SYMBOL_GPL(spi_unregister_master);
1927
ffbbdd21
LW		 1928int 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}
1942EXPORT_SYMBOL_GPL(spi_master_suspend);
1943
1944int 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}
1957EXPORT_SYMBOL_GPL(spi_master_resume);
1958
9f3b795a 1959static int __spi_master_match(struct device *dev, const void *data)
5ed2c832
DY		 1960{
1961 struct spi_master *m;
9f3b795a 1962 const u16 *bus_num = data;
5ed2c832
DY		 1963
1964 m = container_of(dev, struct spi_master, dev);
1965 return m->bus_num == *bus_num;
1966}
1967
8ae12a0d
DB		 1968/**
1969 * spi_busnum_to_master - look up master associated with bus_num
1970 * @bus_num: the master's bus number
33e34dc6 1971 * Context: can sleep
8ae12a0d
DB		 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.
97d56dc6
JMC		 1977 *
1978 * Return: the SPI master structure on success, else NULL.
8ae12a0d
DB		 1979 */
1980struct spi_master *spi_busnum_to_master(u16 bus_num)
1981{
49dce689 1982 struct device *dev;
1e9a51dc 1983 struct spi_master *master = NULL;
5ed2c832 1984
695794ae 1985 dev = class_find_device(&spi_master_class, NULL, &bus_num,
5ed2c832
DY		 1986 __spi_master_match);
1987 if (dev)
1988 master = container_of(dev, struct spi_master, dev);
1989 /* reference got in class_find_device */
1e9a51dc 1990 return master;
8ae12a0d
DB		 1991}
1992EXPORT_SYMBOL_GPL(spi_busnum_to_master);
1993
1994
1995/*-------------------------------------------------------------------------*/
1996
7d077197
DB		 1997/* Core methods for SPI master protocol drivers. Some of the
1998 * other core methods are currently defined as inline functions.
1999 */
2000
63ab645f
SB		 2001static 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
7d077197
DB		 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.
97d56dc6
JMC		 2032 *
2033 * Return: zero on success, else a negative error code.
7d077197
DB		 2034 */
2035int spi_setup(struct spi_device *spi)
2036{
83596fbe 2037 unsigned bad_bits, ugly_bits;
5ab8d262 2038 int status;
7d077197 2039
f477b7fb 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;
e7db06b5
DB		 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;
83596fbe
GU		 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 }
e7db06b5 2066 if (bad_bits) {
eb288a1f 2067 dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
e7db06b5
DB		 2068 bad_bits);
2069 return -EINVAL;
2070 }
2071
7d077197
DB		 2072 if (!spi->bits_per_word)
2073 spi->bits_per_word = 8;
2074
5ab8d262
AS		 2075 status = __spi_validate_bits_per_word(spi->master, spi->bits_per_word);
2076 if (status)
2077 return status;
63ab645f 2078
052eb2d4
AL		 2079 if (!spi->max_speed_hz)
2080 spi->max_speed_hz = spi->master->max_speed_hz;
2081
caae070c
LD		 2082 if (spi->master->setup)
2083 status = spi->master->setup(spi);
7d077197 2084
abeedb01
FCJ		 2085 spi_set_cs(spi, false);
2086
5fe5f05e 2087 dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s%u bits/w, %u Hz max --> %d\n",
7d077197
DB		 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}
2098EXPORT_SYMBOL_GPL(spi_setup);
2099
90808738 2100static int __spi_validate(struct spi_device *spi, struct spi_message *message)
cf32b71e
ES		 2101{
2102 struct spi_master *master = spi->master;
e6811d1d 2103 struct spi_transfer *xfer;
6ea31293 2104 int w_size;
cf32b71e 2105
24a0013a
MB		 2106 if (list_empty(&message->transfers))
2107 return -EINVAL;
24a0013a 2108
cf32b71e
ES		 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)) {
cf32b71e
ES		 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
e6811d1d 2128 /**
059b8ffe
LD		 2129 * Set transfer bits_per_word and max speed as spi device default if
2130 * it is not set for this transfer.
f477b7fb 2131 * Set transfer tx_nbits and rx_nbits as single transfer default
2132 * (SPI_NBITS_SINGLE) if it is not set for this transfer.
e6811d1d 2133 */
77e80588 2134 message->frame_length = 0;
e6811d1d 2135 list_for_each_entry(xfer, &message->transfers, transfer_list) {
078726ce 2136 message->frame_length += xfer->len;
e6811d1d
LD		 2137 if (!xfer->bits_per_word)
2138 xfer->bits_per_word = spi->bits_per_word;
a6f87fad
AL		 2139
2140 if (!xfer->speed_hz)
059b8ffe 2141 xfer->speed_hz = spi->max_speed_hz;
7dc9fbc3
MB		 2142 if (!xfer->speed_hz)
2143 xfer->speed_hz = master->max_speed_hz;
a6f87fad
AL		 2144
2145 if (master->max_speed_hz &&
2146 xfer->speed_hz > master->max_speed_hz)
2147 xfer->speed_hz = master->max_speed_hz;
56ede94a 2148
63ab645f
SB		 2149 if (__spi_validate_bits_per_word(master, xfer->bits_per_word))
2150 return -EINVAL;
a2fd4f9f 2151
4d94bd21
II		 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
4d94bd21 2163 /* No partial transfers accepted */
6ea31293 2164 if (xfer->len % w_size)
4d94bd21
II		 2165 return -EINVAL;
2166
a2fd4f9f
MB		 2167 if (xfer->speed_hz && master->min_speed_hz &&
2168 xfer->speed_hz < master->min_speed_hz)
2169 return -EINVAL;
f477b7fb 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:
1afd9989
GU		 2176 * 1. check the value matches one of single, dual and quad
2177 * 2. check tx/rx_nbits match the mode in spi_device
f477b7fb 2178 */
db90a441
SP		 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;
db90a441 2190 }
f477b7fb 2191 /* check transfer rx_nbits */
db90a441
SP		 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;
db90a441 2203 }
e6811d1d
LD		 2204 }
2205
cf32b71e 2206 message->status = -EINPROGRESS;
90808738
MB		 2207
2208 return 0;
2209}
2210
2211static 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
eca2ebc7
MS		 2217 SPI_STATISTICS_INCREMENT_FIELD(&master->statistics, spi_async);
2218 SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_async);
2219
90808738
MB		 2220 trace_spi_message_submit(message);
2221
cf32b71e
ES		 2222 return master->transfer(spi, message);
2223}
2224
568d0697
DB		 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.)
97d56dc6
JMC		 2253 *
2254 * Return: zero on success, else a negative error code.
568d0697
DB		 2255 */
2256int spi_async(struct spi_device *spi, struct spi_message *message)
2257{
2258 struct spi_master *master = spi->master;
cf32b71e
ES		 2259 int ret;
2260 unsigned long flags;
568d0697 2261
90808738
MB		 2262 ret = __spi_validate(spi, message);
2263 if (ret != 0)
2264 return ret;
2265
cf32b71e 2266 spin_lock_irqsave(&master->bus_lock_spinlock, flags);
568d0697 2267
cf32b71e
ES		 2268 if (master->bus_lock_flag)
2269 ret = -EBUSY;
2270 else
2271 ret = __spi_async(spi, message);
568d0697 2272
cf32b71e
ES		 2273 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
2274
2275 return ret;
568d0697
DB		 2276}
2277EXPORT_SYMBOL_GPL(spi_async);
2278
cf32b71e
ES		 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.)
97d56dc6
JMC		 2307 *
2308 * Return: zero on success, else a negative error code.
cf32b71e
ES		 2309 */
2310int 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
90808738
MB		 2316 ret = __spi_validate(spi, message);
2317 if (ret != 0)
2318 return ret;
2319
cf32b71e
ES		 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}
2329EXPORT_SYMBOL_GPL(spi_async_locked);
2330
7d077197
DB		 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
5d870c8e
AM		 2339static void spi_complete(void *arg)
2340{
2341 complete(arg);
2342}
2343
cf32b71e
ES		 2344static 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;
0461a414
MB		 2350 unsigned long flags;
2351
2352 status = __spi_validate(spi, message);
2353 if (status != 0)
2354 return status;
cf32b71e
ES		 2355
2356 message->complete = spi_complete;
2357 message->context = &done;
0461a414 2358 message->spi = spi;
cf32b71e 2359
eca2ebc7
MS		 2360 SPI_STATISTICS_INCREMENT_FIELD(&master->statistics, spi_sync);
2361 SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_sync);
2362
cf32b71e
ES		 2363 if (!bus_locked)
2364 mutex_lock(&master->bus_lock_mutex);
2365
0461a414
MB		 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 }
cf32b71e
ES		 2382
2383 if (!bus_locked)
2384 mutex_unlock(&master->bus_lock_mutex);
2385
2386 if (status == 0) {
0461a414
MB		 2387 /* Push out the messages in the calling context if we
2388 * can.
2389 */
eca2ebc7
MS		 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);
fc9e0f71 2395 __spi_pump_messages(master, false);
eca2ebc7 2396 }
0461a414 2397
cf32b71e
ES		 2398 wait_for_completion(&done);
2399 status = message->status;
2400 }
2401 message->context = NULL;
2402 return status;
2403}
2404
8ae12a0d
DB		 2405/**
2406 * spi_sync - blocking/synchronous SPI data transfers
2407 * @spi: device with which data will be exchanged
2408 * @message: describes the data transfers
33e34dc6 2409 * Context: can sleep
8ae12a0d
DB		 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 *
0c868461
DB		 2421 * Also, the caller is guaranteeing that the memory associated with the
2422 * message will not be freed before this call returns.
2423 *
97d56dc6 2424 * Return: zero on success, else a negative error code.
8ae12a0d
DB		 2425 */
2426int spi_sync(struct spi_device *spi, struct spi_message *message)
2427{
cf32b71e 2428 return __spi_sync(spi, message, 0);
8ae12a0d
DB		 2429}
2430EXPORT_SYMBOL_GPL(spi_sync);
2431
cf32b71e
ES		 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
25985edc 2443 * SPI bus. It has to be preceded by a spi_bus_lock call. The SPI bus must
cf32b71e
ES		 2444 * be released by a spi_bus_unlock call when the exclusive access is over.
2445 *
97d56dc6 2446 * Return: zero on success, else a negative error code.
cf32b71e
ES		 2447 */
2448int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
2449{
2450 return __spi_sync(spi, message, 1);
2451}
2452EXPORT_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 *
97d56dc6 2467 * Return: always zero.
cf32b71e
ES		 2468 */
2469int 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}
2483EXPORT_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 *
97d56dc6 2496 * Return: always zero.
cf32b71e
ES		 2497 */
2498int 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}
2506EXPORT_SYMBOL_GPL(spi_bus_unlock);
2507
a9948b61 2508/* portable code must never pass more than 32 bytes */
5fe5f05e 2509#define SPI_BUFSIZ max(32, SMP_CACHE_BYTES)
8ae12a0d
DB		 2510
2511static 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
27570497
JP		 2518 * @rxbuf: buffer into which data will be read (need not be dma-safe)
2519 * @n_rx: size of rxbuf, in bytes
33e34dc6 2520 * Context: can sleep
8ae12a0d
DB		 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.
b885244e 2525 * This call may only be used from a context that may sleep.
8ae12a0d 2526 *
0c868461 2527 * Parameters to this routine are always copied using a small buffer;
33e34dc6
DB		 2528 * portable code should never use this for more than 32 bytes.
2529 * Performance-sensitive or bulk transfer code should instead use
0c868461 2530 * spi_{async,sync}() calls with dma-safe buffers.
97d56dc6
JMC		 2531 *
2532 * Return: zero on success, else a negative error code.
8ae12a0d
DB		 2533 */
2534int spi_write_then_read(struct spi_device *spi,
0c4a1590
MB		 2535 const void *txbuf, unsigned n_tx,
2536 void *rxbuf, unsigned n_rx)
8ae12a0d 2537{
068f4070 2538 static DEFINE_MUTEX(lock);
8ae12a0d
DB		 2539
2540 int status;
2541 struct spi_message message;
bdff549e 2542 struct spi_transfer x[2];
8ae12a0d
DB		 2543 u8 *local_buf;
2544
b3a223ee
MB		 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.
8ae12a0d 2549 */
b3a223ee 2550 if ((n_tx + n_rx) > SPI_BUFSIZ || !mutex_trylock(&lock)) {
2cd94c8a
MB		 2551 local_buf = kmalloc(max((unsigned)SPI_BUFSIZ, n_tx + n_rx),
2552 GFP_KERNEL | GFP_DMA);
b3a223ee
MB		 2553 if (!local_buf)
2554 return -ENOMEM;
2555 } else {
2556 local_buf = buf;
2557 }
8ae12a0d 2558
8275c642 2559 spi_message_init(&message);
5fe5f05e 2560 memset(x, 0, sizeof(x));
bdff549e
DB		 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 }
8275c642 2569
8ae12a0d 2570 memcpy(local_buf, txbuf, n_tx);
bdff549e
DB		 2571 x[0].tx_buf = local_buf;
2572 x[1].rx_buf = local_buf + n_tx;
8ae12a0d
DB		 2573
2574 /* do the i/o */
8ae12a0d 2575 status = spi_sync(spi, &message);
9b938b74 2576 if (status == 0)
bdff549e 2577 memcpy(rxbuf, x[1].rx_buf, n_rx);
8ae12a0d 2578
bdff549e 2579 if (x[0].tx_buf == buf)
068f4070 2580 mutex_unlock(&lock);
8ae12a0d
DB		 2581 else
2582 kfree(local_buf);
2583
2584 return status;
2585}
2586EXPORT_SYMBOL_GPL(spi_write_then_read);
2587
2588/*-------------------------------------------------------------------------*/
2589
ce79d54a
PA		 2590#if IS_ENABLED(CONFIG_OF_DYNAMIC)
2591static 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 */
2597static 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
2604static 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 */
2610static 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
2623static 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
2663static struct notifier_block spi_of_notifier = {
2664 .notifier_call = of_spi_notify,
2665};
2666#else /* IS_ENABLED(CONFIG_OF_DYNAMIC) */
2667extern struct notifier_block spi_of_notifier;
2668#endif /* IS_ENABLED(CONFIG_OF_DYNAMIC) */
2669
8ae12a0d
DB		 2670static int __init spi_init(void)
2671{
b885244e
DB		 2672 int status;
2673
e94b1766 2674 buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
b885244e
DB		 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;
8ae12a0d 2683
b885244e
DB		 2684 status = class_register(&spi_master_class);
2685 if (status < 0)
2686 goto err2;
ce79d54a 2687
5267720e 2688 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
ce79d54a
PA		 2689 WARN_ON(of_reconfig_notifier_register(&spi_of_notifier));
2690
8ae12a0d 2691 return 0;
b885244e
DB		 2692
2693err2:
2694 bus_unregister(&spi_bus_type);
2695err1:
2696 kfree(buf);
2697 buf = NULL;
2698err0:
2699 return status;
8ae12a0d 2700}
b885244e 2701
8ae12a0d
DB		 2702/* board_info is normally registered in arch_initcall(),
2703 * but even essential drivers wait till later
b885244e
DB		 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.
8ae12a0d 2708 */
673c0c00 2709postcore_initcall(spi_init);
8ae12a0d 2710