projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
kthread: kthread worker API cleanup
[deliverable/linux.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>
b1b8153c 40#include <linux/highmem.h>
8ae12a0d 41
56ec1978
MB		 42#define CREATE_TRACE_POINTS
43#include <trace/events/spi.h>
44
8ae12a0d
DB		 45static void spidev_release(struct device *dev)
46{
0ffa0285 47 struct spi_device *spi = to_spi_device(dev);
8ae12a0d
DB		 48
49 /* spi masters may cleanup for released devices */
50 if (spi->master->cleanup)
51 spi->master->cleanup(spi);
52
0c868461 53 spi_master_put(spi->master);
07a389fe 54 kfree(spi);
8ae12a0d
DB		 55}
56
57static ssize_t
58modalias_show(struct device *dev, struct device_attribute *a, char *buf)
59{
60 const struct spi_device *spi = to_spi_device(dev);
8c4ff6d0
ZR		 61 int len;
62
63 len = acpi_device_modalias(dev, buf, PAGE_SIZE - 1);
64 if (len != -ENODEV)
65 return len;
8ae12a0d 66
d8e328b3 67 return sprintf(buf, "%s%s\n", SPI_MODULE_PREFIX, spi->modalias);
8ae12a0d 68}
aa7da564 69static DEVICE_ATTR_RO(modalias);
8ae12a0d 70
eca2ebc7
MS		 71#define SPI_STATISTICS_ATTRS(field, file) \
72static ssize_t spi_master_##field##_show(struct device *dev, \
73 struct device_attribute *attr, \
74 char *buf) \
75{ \
76 struct spi_master *master = container_of(dev, \
77 struct spi_master, dev); \
78 return spi_statistics_##field##_show(&master->statistics, buf); \
79} \
80static struct device_attribute dev_attr_spi_master_##field = { \
81 .attr = { .name = file, .mode = S_IRUGO }, \
82 .show = spi_master_##field##_show, \
83}; \
84static ssize_t spi_device_##field##_show(struct device *dev, \
85 struct device_attribute *attr, \
86 char *buf) \
87{ \
d1eba93b 88 struct spi_device *spi = to_spi_device(dev); \
eca2ebc7
MS		 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
d9f12122
MS		 148SPI_STATISTICS_SHOW(transfers_split_maxsize, "%lu");
149
aa7da564
GKH		 150static struct attribute *spi_dev_attrs[] = {
151 &dev_attr_modalias.attr,
152 NULL,
8ae12a0d 153};
eca2ebc7
MS		 154
155static const struct attribute_group spi_dev_group = {
156 .attrs = spi_dev_attrs,
157};
158
159static struct attribute *spi_device_statistics_attrs[] = {
160 &dev_attr_spi_device_messages.attr,
161 &dev_attr_spi_device_transfers.attr,
162 &dev_attr_spi_device_errors.attr,
163 &dev_attr_spi_device_timedout.attr,
164 &dev_attr_spi_device_spi_sync.attr,
165 &dev_attr_spi_device_spi_sync_immediate.attr,
166 &dev_attr_spi_device_spi_async.attr,
167 &dev_attr_spi_device_bytes.attr,
168 &dev_attr_spi_device_bytes_rx.attr,
169 &dev_attr_spi_device_bytes_tx.attr,
6b7bc061
MS		 170 &dev_attr_spi_device_transfer_bytes_histo0.attr,
171 &dev_attr_spi_device_transfer_bytes_histo1.attr,
172 &dev_attr_spi_device_transfer_bytes_histo2.attr,
173 &dev_attr_spi_device_transfer_bytes_histo3.attr,
174 &dev_attr_spi_device_transfer_bytes_histo4.attr,
175 &dev_attr_spi_device_transfer_bytes_histo5.attr,
176 &dev_attr_spi_device_transfer_bytes_histo6.attr,
177 &dev_attr_spi_device_transfer_bytes_histo7.attr,
178 &dev_attr_spi_device_transfer_bytes_histo8.attr,
179 &dev_attr_spi_device_transfer_bytes_histo9.attr,
180 &dev_attr_spi_device_transfer_bytes_histo10.attr,
181 &dev_attr_spi_device_transfer_bytes_histo11.attr,
182 &dev_attr_spi_device_transfer_bytes_histo12.attr,
183 &dev_attr_spi_device_transfer_bytes_histo13.attr,
184 &dev_attr_spi_device_transfer_bytes_histo14.attr,
185 &dev_attr_spi_device_transfer_bytes_histo15.attr,
186 &dev_attr_spi_device_transfer_bytes_histo16.attr,
d9f12122 187 &dev_attr_spi_device_transfers_split_maxsize.attr,
eca2ebc7
MS		 188 NULL,
189};
190
191static const struct attribute_group spi_device_statistics_group = {
192 .name = "statistics",
193 .attrs = spi_device_statistics_attrs,
194};
195
196static const struct attribute_group *spi_dev_groups[] = {
197 &spi_dev_group,
198 &spi_device_statistics_group,
199 NULL,
200};
201
202static struct attribute *spi_master_statistics_attrs[] = {
203 &dev_attr_spi_master_messages.attr,
204 &dev_attr_spi_master_transfers.attr,
205 &dev_attr_spi_master_errors.attr,
206 &dev_attr_spi_master_timedout.attr,
207 &dev_attr_spi_master_spi_sync.attr,
208 &dev_attr_spi_master_spi_sync_immediate.attr,
209 &dev_attr_spi_master_spi_async.attr,
210 &dev_attr_spi_master_bytes.attr,
211 &dev_attr_spi_master_bytes_rx.attr,
212 &dev_attr_spi_master_bytes_tx.attr,
6b7bc061
MS		 213 &dev_attr_spi_master_transfer_bytes_histo0.attr,
214 &dev_attr_spi_master_transfer_bytes_histo1.attr,
215 &dev_attr_spi_master_transfer_bytes_histo2.attr,
216 &dev_attr_spi_master_transfer_bytes_histo3.attr,
217 &dev_attr_spi_master_transfer_bytes_histo4.attr,
218 &dev_attr_spi_master_transfer_bytes_histo5.attr,
219 &dev_attr_spi_master_transfer_bytes_histo6.attr,
220 &dev_attr_spi_master_transfer_bytes_histo7.attr,
221 &dev_attr_spi_master_transfer_bytes_histo8.attr,
222 &dev_attr_spi_master_transfer_bytes_histo9.attr,
223 &dev_attr_spi_master_transfer_bytes_histo10.attr,
224 &dev_attr_spi_master_transfer_bytes_histo11.attr,
225 &dev_attr_spi_master_transfer_bytes_histo12.attr,
226 &dev_attr_spi_master_transfer_bytes_histo13.attr,
227 &dev_attr_spi_master_transfer_bytes_histo14.attr,
228 &dev_attr_spi_master_transfer_bytes_histo15.attr,
229 &dev_attr_spi_master_transfer_bytes_histo16.attr,
d9f12122 230 &dev_attr_spi_master_transfers_split_maxsize.attr,
eca2ebc7
MS		 231 NULL,
232};
233
234static const struct attribute_group spi_master_statistics_group = {
235 .name = "statistics",
236 .attrs = spi_master_statistics_attrs,
237};
238
239static const struct attribute_group *spi_master_groups[] = {
240 &spi_master_statistics_group,
241 NULL,
242};
243
244void spi_statistics_add_transfer_stats(struct spi_statistics *stats,
245 struct spi_transfer *xfer,
246 struct spi_master *master)
247{
248 unsigned long flags;
6b7bc061
MS		 249 int l2len = min(fls(xfer->len), SPI_STATISTICS_HISTO_SIZE) - 1;
250
251 if (l2len < 0)
252 l2len = 0;
eca2ebc7
MS		 253
254 spin_lock_irqsave(&stats->lock, flags);
255
256 stats->transfers++;
6b7bc061 257 stats->transfer_bytes_histo[l2len]++;
eca2ebc7
MS		 258
259 stats->bytes += xfer->len;
260 if ((xfer->tx_buf) &&
261 (xfer->tx_buf != master->dummy_tx))
262 stats->bytes_tx += xfer->len;
263 if ((xfer->rx_buf) &&
264 (xfer->rx_buf != master->dummy_rx))
265 stats->bytes_rx += xfer->len;
266
267 spin_unlock_irqrestore(&stats->lock, flags);
268}
269EXPORT_SYMBOL_GPL(spi_statistics_add_transfer_stats);
8ae12a0d
DB		 270
271/* modalias support makes "modprobe $MODALIAS" new-style hotplug work,
272 * and the sysfs version makes coldplug work too.
273 */
274
75368bf6
AV		 275static const struct spi_device_id *spi_match_id(const struct spi_device_id *id,
276 const struct spi_device *sdev)
277{
278 while (id->name[0]) {
279 if (!strcmp(sdev->modalias, id->name))
280 return id;
281 id++;
282 }
283 return NULL;
284}
285
286const struct spi_device_id *spi_get_device_id(const struct spi_device *sdev)
287{
288 const struct spi_driver *sdrv = to_spi_driver(sdev->dev.driver);
289
290 return spi_match_id(sdrv->id_table, sdev);
291}
292EXPORT_SYMBOL_GPL(spi_get_device_id);
293
8ae12a0d
DB		 294static int spi_match_device(struct device *dev, struct device_driver *drv)
295{
296 const struct spi_device *spi = to_spi_device(dev);
75368bf6
AV		 297 const struct spi_driver *sdrv = to_spi_driver(drv);
298
2b7a32f7
SA		 299 /* Attempt an OF style match */
300 if (of_driver_match_device(dev, drv))
301 return 1;
302
64bee4d2
MW		 303 /* Then try ACPI */
304 if (acpi_driver_match_device(dev, drv))
305 return 1;
306
75368bf6
AV		 307 if (sdrv->id_table)
308 return !!spi_match_id(sdrv->id_table, spi);
8ae12a0d 309
35f74fca 310 return strcmp(spi->modalias, drv->name) == 0;
8ae12a0d
DB		 311}
312
7eff2e7a 313static int spi_uevent(struct device *dev, struct kobj_uevent_env *env)
8ae12a0d
DB		 314{
315 const struct spi_device *spi = to_spi_device(dev);
8c4ff6d0
ZR		 316 int rc;
317
318 rc = acpi_device_uevent_modalias(dev, env);
319 if (rc != -ENODEV)
320 return rc;
8ae12a0d 321
e0626e38 322 add_uevent_var(env, "MODALIAS=%s%s", SPI_MODULE_PREFIX, spi->modalias);
8ae12a0d
DB		 323 return 0;
324}
325
8ae12a0d
DB		 326struct bus_type spi_bus_type = {
327 .name = "spi",
aa7da564 328 .dev_groups = spi_dev_groups,
8ae12a0d
DB		 329 .match = spi_match_device,
330 .uevent = spi_uevent,
8ae12a0d
DB		 331};
332EXPORT_SYMBOL_GPL(spi_bus_type);
333
b885244e
DB		 334
335static int spi_drv_probe(struct device *dev)
336{
337 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
44af7927 338 struct spi_device *spi = to_spi_device(dev);
33cf00e5
MW		 339 int ret;
340
86be408b
SN		 341 ret = of_clk_set_defaults(dev->of_node, false);
342 if (ret)
343 return ret;
344
44af7927
JH		 345 if (dev->of_node) {
346 spi->irq = of_irq_get(dev->of_node, 0);
347 if (spi->irq == -EPROBE_DEFER)
348 return -EPROBE_DEFER;
349 if (spi->irq < 0)
350 spi->irq = 0;
351 }
352
676e7c25
UH		 353 ret = dev_pm_domain_attach(dev, true);
354 if (ret != -EPROBE_DEFER) {
44af7927 355 ret = sdrv->probe(spi);
676e7c25
UH		 356 if (ret)
357 dev_pm_domain_detach(dev, true);
358 }
b885244e 359
33cf00e5 360 return ret;
b885244e
DB		 361}
362
363static int spi_drv_remove(struct device *dev)
364{
365 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
33cf00e5
MW		 366 int ret;
367
aec35f4e 368 ret = sdrv->remove(to_spi_device(dev));
676e7c25 369 dev_pm_domain_detach(dev, true);
b885244e 370
33cf00e5 371 return ret;
b885244e
DB		 372}
373
374static void spi_drv_shutdown(struct device *dev)
375{
376 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
377
378 sdrv->shutdown(to_spi_device(dev));
379}
380
33e34dc6 381/**
ca5d2485 382 * __spi_register_driver - register a SPI driver
88c9321d 383 * @owner: owner module of the driver to register
33e34dc6
DB		 384 * @sdrv: the driver to register
385 * Context: can sleep
97d56dc6
JMC		 386 *
387 * Return: zero on success, else a negative error code.
33e34dc6 388 */
ca5d2485 389int __spi_register_driver(struct module *owner, struct spi_driver *sdrv)
b885244e 390{
ca5d2485 391 sdrv->driver.owner = owner;
b885244e
DB		 392 sdrv->driver.bus = &spi_bus_type;
393 if (sdrv->probe)
394 sdrv->driver.probe = spi_drv_probe;
395 if (sdrv->remove)
396 sdrv->driver.remove = spi_drv_remove;
397 if (sdrv->shutdown)
398 sdrv->driver.shutdown = spi_drv_shutdown;
399 return driver_register(&sdrv->driver);
400}
ca5d2485 401EXPORT_SYMBOL_GPL(__spi_register_driver);
b885244e 402
8ae12a0d
DB		 403/*-------------------------------------------------------------------------*/
404
405/* SPI devices should normally not be created by SPI device drivers; that
406 * would make them board-specific. Similarly with SPI master drivers.
407 * Device registration normally goes into like arch/.../mach.../board-YYY.c
408 * with other readonly (flashable) information about mainboard devices.
409 */
410
411struct boardinfo {
412 struct list_head list;
2b9603a0 413 struct spi_board_info board_info;
8ae12a0d
DB		 414};
415
416static LIST_HEAD(board_list);
2b9603a0
FT		 417static LIST_HEAD(spi_master_list);
418
419/*
420 * Used to protect add/del opertion for board_info list and
421 * spi_master list, and their matching process
422 */
94040828 423static DEFINE_MUTEX(board_lock);
8ae12a0d 424
dc87c98e
GL		 425/**
426 * spi_alloc_device - Allocate a new SPI device
427 * @master: Controller to which device is connected
428 * Context: can sleep
429 *
430 * Allows a driver to allocate and initialize a spi_device without
431 * registering it immediately. This allows a driver to directly
432 * fill the spi_device with device parameters before calling
433 * spi_add_device() on it.
434 *
435 * Caller is responsible to call spi_add_device() on the returned
436 * spi_device structure to add it to the SPI master. If the caller
437 * needs to discard the spi_device without adding it, then it should
438 * call spi_dev_put() on it.
439 *
97d56dc6 440 * Return: a pointer to the new device, or NULL.
dc87c98e
GL		 441 */
442struct spi_device *spi_alloc_device(struct spi_master *master)
443{
444 struct spi_device *spi;
dc87c98e
GL		 445
446 if (!spi_master_get(master))
447 return NULL;
448
5fe5f05e 449 spi = kzalloc(sizeof(*spi), GFP_KERNEL);
dc87c98e 450 if (!spi) {
dc87c98e
GL		 451 spi_master_put(master);
452 return NULL;
453 }
454
455 spi->master = master;
178db7d3 456 spi->dev.parent = &master->dev;
dc87c98e
GL		 457 spi->dev.bus = &spi_bus_type;
458 spi->dev.release = spidev_release;
446411e1 459 spi->cs_gpio = -ENOENT;
eca2ebc7
MS		 460
461 spin_lock_init(&spi->statistics.lock);
462
dc87c98e
GL		 463 device_initialize(&spi->dev);
464 return spi;
465}
466EXPORT_SYMBOL_GPL(spi_alloc_device);
467
e13ac47b
JN		 468static void spi_dev_set_name(struct spi_device *spi)
469{
470 struct acpi_device *adev = ACPI_COMPANION(&spi->dev);
471
472 if (adev) {
473 dev_set_name(&spi->dev, "spi-%s", acpi_dev_name(adev));
474 return;
475 }
476
477 dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),
478 spi->chip_select);
479}
480
b6fb8d3a
MW		 481static int spi_dev_check(struct device *dev, void *data)
482{
483 struct spi_device *spi = to_spi_device(dev);
484 struct spi_device *new_spi = data;
485
486 if (spi->master == new_spi->master &&
487 spi->chip_select == new_spi->chip_select)
488 return -EBUSY;
489 return 0;
490}
491
dc87c98e
GL		 492/**
493 * spi_add_device - Add spi_device allocated with spi_alloc_device
494 * @spi: spi_device to register
495 *
496 * Companion function to spi_alloc_device. Devices allocated with
497 * spi_alloc_device can be added onto the spi bus with this function.
498 *
97d56dc6 499 * Return: 0 on success; negative errno on failure
dc87c98e
GL		 500 */
501int spi_add_device(struct spi_device *spi)
502{
e48880e0 503 static DEFINE_MUTEX(spi_add_lock);
74317984
JCPV		 504 struct spi_master *master = spi->master;
505 struct device *dev = master->dev.parent;
dc87c98e
GL		 506 int status;
507
508 /* Chipselects are numbered 0..max; validate. */
74317984 509 if (spi->chip_select >= master->num_chipselect) {
dc87c98e
GL		 510 dev_err(dev, "cs%d >= max %d\n",
511 spi->chip_select,
74317984 512 master->num_chipselect);
dc87c98e
GL		 513 return -EINVAL;
514 }
515
516 /* Set the bus ID string */
e13ac47b 517 spi_dev_set_name(spi);
e48880e0
DB		 518
519 /* We need to make sure there's no other device with this
520 * chipselect **BEFORE** we call setup(), else we'll trash
521 * its configuration. Lock against concurrent add() calls.
522 */
523 mutex_lock(&spi_add_lock);
524
b6fb8d3a
MW		 525 status = bus_for_each_dev(&spi_bus_type, NULL, spi, spi_dev_check);
526 if (status) {
e48880e0
DB		 527 dev_err(dev, "chipselect %d already in use\n",
528 spi->chip_select);
e48880e0
DB		 529 goto done;
530 }
531
74317984
JCPV		 532 if (master->cs_gpios)
533 spi->cs_gpio = master->cs_gpios[spi->chip_select];
534
e48880e0
DB		 535 /* Drivers may modify this initial i/o setup, but will
536 * normally rely on the device being setup. Devices
537 * using SPI_CS_HIGH can't coexist well otherwise...
538 */
7d077197 539 status = spi_setup(spi);
dc87c98e 540 if (status < 0) {
eb288a1f
LW		 541 dev_err(dev, "can't setup %s, status %d\n",
542 dev_name(&spi->dev), status);
e48880e0 543 goto done;
dc87c98e
GL		 544 }
545
e48880e0 546 /* Device may be bound to an active driver when this returns */
dc87c98e 547 status = device_add(&spi->dev);
e48880e0 548 if (status < 0)
eb288a1f
LW		 549 dev_err(dev, "can't add %s, status %d\n",
550 dev_name(&spi->dev), status);
e48880e0 551 else
35f74fca 552 dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));
dc87c98e 553
e48880e0
DB		 554done:
555 mutex_unlock(&spi_add_lock);
556 return status;
dc87c98e
GL		 557}
558EXPORT_SYMBOL_GPL(spi_add_device);
8ae12a0d 559
33e34dc6
DB		 560/**
561 * spi_new_device - instantiate one new SPI device
562 * @master: Controller to which device is connected
563 * @chip: Describes the SPI device
564 * Context: can sleep
565 *
566 * On typical mainboards, this is purely internal; and it's not needed
8ae12a0d
DB		 567 * after board init creates the hard-wired devices. Some development
568 * platforms may not be able to use spi_register_board_info though, and
569 * this is exported so that for example a USB or parport based adapter
570 * driver could add devices (which it would learn about out-of-band).
082c8cb4 571 *
97d56dc6 572 * Return: the new device, or NULL.
8ae12a0d 573 */
e9d5a461
AB		 574struct spi_device *spi_new_device(struct spi_master *master,
575 struct spi_board_info *chip)
8ae12a0d
DB		 576{
577 struct spi_device *proxy;
8ae12a0d
DB		 578 int status;
579
082c8cb4
DB		 580 /* NOTE: caller did any chip->bus_num checks necessary.
581 *
582 * Also, unless we change the return value convention to use
583 * error-or-pointer (not NULL-or-pointer), troubleshootability
584 * suggests syslogged diagnostics are best here (ugh).
585 */
586
dc87c98e
GL		 587 proxy = spi_alloc_device(master);
588 if (!proxy)
8ae12a0d
DB		 589 return NULL;
590
102eb975
GL		 591 WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
592
8ae12a0d
DB		 593 proxy->chip_select = chip->chip_select;
594 proxy->max_speed_hz = chip->max_speed_hz;
980a01c9 595 proxy->mode = chip->mode;
8ae12a0d 596 proxy->irq = chip->irq;
102eb975 597 strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));
8ae12a0d
DB		 598 proxy->dev.platform_data = (void *) chip->platform_data;
599 proxy->controller_data = chip->controller_data;
600 proxy->controller_state = NULL;
8ae12a0d 601
dc87c98e 602 status = spi_add_device(proxy);
8ae12a0d 603 if (status < 0) {
dc87c98e
GL		 604 spi_dev_put(proxy);
605 return NULL;
8ae12a0d
DB		 606 }
607
8ae12a0d
DB		 608 return proxy;
609}
610EXPORT_SYMBOL_GPL(spi_new_device);
611
3b1884c2
GU		 612/**
613 * spi_unregister_device - unregister a single SPI device
614 * @spi: spi_device to unregister
615 *
616 * Start making the passed SPI device vanish. Normally this would be handled
617 * by spi_unregister_master().
618 */
619void spi_unregister_device(struct spi_device *spi)
620{
bd6c1644
GU		 621 if (!spi)
622 return;
623
624 if (spi->dev.of_node)
625 of_node_clear_flag(spi->dev.of_node, OF_POPULATED);
7f24467f
OP		 626 if (ACPI_COMPANION(&spi->dev))
627 acpi_device_clear_enumerated(ACPI_COMPANION(&spi->dev));
bd6c1644 628 device_unregister(&spi->dev);
3b1884c2
GU		 629}
630EXPORT_SYMBOL_GPL(spi_unregister_device);
631
2b9603a0
FT		 632static void spi_match_master_to_boardinfo(struct spi_master *master,
633 struct spi_board_info *bi)
634{
635 struct spi_device *dev;
636
637 if (master->bus_num != bi->bus_num)
638 return;
639
640 dev = spi_new_device(master, bi);
641 if (!dev)
642 dev_err(master->dev.parent, "can't create new device for %s\n",
643 bi->modalias);
644}
645
33e34dc6
DB		 646/**
647 * spi_register_board_info - register SPI devices for a given board
648 * @info: array of chip descriptors
649 * @n: how many descriptors are provided
650 * Context: can sleep
651 *
8ae12a0d
DB		 652 * Board-specific early init code calls this (probably during arch_initcall)
653 * with segments of the SPI device table. Any device nodes are created later,
654 * after the relevant parent SPI controller (bus_num) is defined. We keep
655 * this table of devices forever, so that reloading a controller driver will
656 * not make Linux forget about these hard-wired devices.
657 *
658 * Other code can also call this, e.g. a particular add-on board might provide
659 * SPI devices through its expansion connector, so code initializing that board
660 * would naturally declare its SPI devices.
661 *
662 * The board info passed can safely be __initdata ... but be careful of
663 * any embedded pointers (platform_data, etc), they're copied as-is.
97d56dc6
JMC		 664 *
665 * Return: zero on success, else a negative error code.
8ae12a0d 666 */
fd4a319b 667int spi_register_board_info(struct spi_board_info const *info, unsigned n)
8ae12a0d 668{
2b9603a0
FT		 669 struct boardinfo *bi;
670 int i;
8ae12a0d 671
c7908a37
XL		 672 if (!n)
673 return -EINVAL;
674
2b9603a0 675 bi = kzalloc(n * sizeof(*bi), GFP_KERNEL);
8ae12a0d
DB		 676 if (!bi)
677 return -ENOMEM;
8ae12a0d 678
2b9603a0
FT		 679 for (i = 0; i < n; i++, bi++, info++) {
680 struct spi_master *master;
8ae12a0d 681
2b9603a0
FT		 682 memcpy(&bi->board_info, info, sizeof(*info));
683 mutex_lock(&board_lock);
684 list_add_tail(&bi->list, &board_list);
685 list_for_each_entry(master, &spi_master_list, list)
686 spi_match_master_to_boardinfo(master, &bi->board_info);
687 mutex_unlock(&board_lock);
8ae12a0d 688 }
2b9603a0
FT		 689
690 return 0;
8ae12a0d
DB		 691}
692
693/*-------------------------------------------------------------------------*/
694
b158935f
MB		 695static void spi_set_cs(struct spi_device *spi, bool enable)
696{
697 if (spi->mode & SPI_CS_HIGH)
698 enable = !enable;
699
243f07be 700 if (gpio_is_valid(spi->cs_gpio))
b158935f
MB		 701 gpio_set_value(spi->cs_gpio, !enable);
702 else if (spi->master->set_cs)
703 spi->master->set_cs(spi, !enable);
704}
705
2de440f5 706#ifdef CONFIG_HAS_DMA
6ad45a27
MB		 707static int spi_map_buf(struct spi_master *master, struct device *dev,
708 struct sg_table *sgt, void *buf, size_t len,
709 enum dma_data_direction dir)
710{
711 const bool vmalloced_buf = is_vmalloc_addr(buf);
df88e91b 712 unsigned int max_seg_size = dma_get_max_seg_size(dev);
b1b8153c
V		 713#ifdef CONFIG_HIGHMEM
714 const bool kmap_buf = ((unsigned long)buf >= PKMAP_BASE &&
715 (unsigned long)buf < (PKMAP_BASE +
716 (LAST_PKMAP * PAGE_SIZE)));
717#else
718 const bool kmap_buf = false;
719#endif
65598c13
AG		 720 int desc_len;
721 int sgs;
6ad45a27
MB		 722 struct page *vm_page;
723 void *sg_buf;
724 size_t min;
725 int i, ret;
726
b1b8153c 727 if (vmalloced_buf || kmap_buf) {
df88e91b 728 desc_len = min_t(int, max_seg_size, PAGE_SIZE);
65598c13 729 sgs = DIV_ROUND_UP(len + offset_in_page(buf), desc_len);
0569a88f 730 } else if (virt_addr_valid(buf)) {
df88e91b 731 desc_len = min_t(int, max_seg_size, master->max_dma_len);
65598c13 732 sgs = DIV_ROUND_UP(len, desc_len);
0569a88f
V		 733 } else {
734 return -EINVAL;
65598c13
AG		 735 }
736
6ad45a27
MB		 737 ret = sg_alloc_table(sgt, sgs, GFP_KERNEL);
738 if (ret != 0)
739 return ret;
740
741 for (i = 0; i < sgs; i++) {
6ad45a27 742
b1b8153c 743 if (vmalloced_buf || kmap_buf) {
65598c13
AG		 744 min = min_t(size_t,
745 len, desc_len - offset_in_page(buf));
b1b8153c
V		 746 if (vmalloced_buf)
747 vm_page = vmalloc_to_page(buf);
748 else
749 vm_page = kmap_to_page(buf);
6ad45a27
MB		 750 if (!vm_page) {
751 sg_free_table(sgt);
752 return -ENOMEM;
753 }
c1aefbdd
CK		 754 sg_set_page(&sgt->sgl[i], vm_page,
755 min, offset_in_page(buf));
6ad45a27 756 } else {
65598c13 757 min = min_t(size_t, len, desc_len);
6ad45a27 758 sg_buf = buf;
c1aefbdd 759 sg_set_buf(&sgt->sgl[i], sg_buf, min);
6ad45a27
MB		 760 }
761
6ad45a27
MB		 762 buf += min;
763 len -= min;
764 }
765
766 ret = dma_map_sg(dev, sgt->sgl, sgt->nents, dir);
89e4b66a
GU		 767 if (!ret)
768 ret = -ENOMEM;
6ad45a27
MB		 769 if (ret < 0) {
770 sg_free_table(sgt);
771 return ret;
772 }
773
774 sgt->nents = ret;
775
776 return 0;
777}
778
779static void spi_unmap_buf(struct spi_master *master, struct device *dev,
780 struct sg_table *sgt, enum dma_data_direction dir)
781{
782 if (sgt->orig_nents) {
783 dma_unmap_sg(dev, sgt->sgl, sgt->orig_nents, dir);
784 sg_free_table(sgt);
785 }
786}
787
2de440f5 788static int __spi_map_msg(struct spi_master *master, struct spi_message *msg)
99adef31 789{
99adef31
MB		 790 struct device *tx_dev, *rx_dev;
791 struct spi_transfer *xfer;
6ad45a27 792 int ret;
3a2eba9b 793
6ad45a27 794 if (!master->can_dma)
99adef31
MB		 795 return 0;
796
c37f45b5
LL		 797 if (master->dma_tx)
798 tx_dev = master->dma_tx->device->dev;
799 else
800 tx_dev = &master->dev;
801
802 if (master->dma_rx)
803 rx_dev = master->dma_rx->device->dev;
804 else
805 rx_dev = &master->dev;
99adef31
MB		 806
807 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
808 if (!master->can_dma(master, msg->spi, xfer))
809 continue;
810
811 if (xfer->tx_buf != NULL) {
6ad45a27
MB		 812 ret = spi_map_buf(master, tx_dev, &xfer->tx_sg,
813 (void *)xfer->tx_buf, xfer->len,
814 DMA_TO_DEVICE);
815 if (ret != 0)
816 return ret;
99adef31
MB		 817 }
818
819 if (xfer->rx_buf != NULL) {
6ad45a27
MB		 820 ret = spi_map_buf(master, rx_dev, &xfer->rx_sg,
821 xfer->rx_buf, xfer->len,
822 DMA_FROM_DEVICE);
823 if (ret != 0) {
824 spi_unmap_buf(master, tx_dev, &xfer->tx_sg,
825 DMA_TO_DEVICE);
826 return ret;
99adef31
MB		 827 }
828 }
829 }
830
831 master->cur_msg_mapped = true;
832
833 return 0;
834}
835
4b786458 836static int __spi_unmap_msg(struct spi_master *master, struct spi_message *msg)
99adef31
MB		 837{
838 struct spi_transfer *xfer;
839 struct device *tx_dev, *rx_dev;
840
6ad45a27 841 if (!master->cur_msg_mapped || !master->can_dma)
99adef31
MB		 842 return 0;
843
c37f45b5
LL		 844 if (master->dma_tx)
845 tx_dev = master->dma_tx->device->dev;
846 else
847 tx_dev = &master->dev;
848
849 if (master->dma_rx)
850 rx_dev = master->dma_rx->device->dev;
851 else
852 rx_dev = &master->dev;
99adef31
MB		 853
854 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
855 if (!master->can_dma(master, msg->spi, xfer))
856 continue;
857
6ad45a27
MB		 858 spi_unmap_buf(master, rx_dev, &xfer->rx_sg, DMA_FROM_DEVICE);
859 spi_unmap_buf(master, tx_dev, &xfer->tx_sg, DMA_TO_DEVICE);
99adef31
MB		 860 }
861
862 return 0;
863}
2de440f5 864#else /* !CONFIG_HAS_DMA */
f4502dd1
V		 865static inline int spi_map_buf(struct spi_master *master,
866 struct device *dev, struct sg_table *sgt,
867 void *buf, size_t len,
868 enum dma_data_direction dir)
869{
870 return -EINVAL;
871}
872
873static inline void spi_unmap_buf(struct spi_master *master,
874 struct device *dev, struct sg_table *sgt,
875 enum dma_data_direction dir)
876{
877}
878
2de440f5
GU		 879static inline int __spi_map_msg(struct spi_master *master,
880 struct spi_message *msg)
881{
882 return 0;
883}
884
4b786458
MS		 885static inline int __spi_unmap_msg(struct spi_master *master,
886 struct spi_message *msg)
2de440f5
GU		 887{
888 return 0;
889}
890#endif /* !CONFIG_HAS_DMA */
891
4b786458
MS		 892static inline int spi_unmap_msg(struct spi_master *master,
893 struct spi_message *msg)
894{
895 struct spi_transfer *xfer;
896
897 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
898 /*
899 * Restore the original value of tx_buf or rx_buf if they are
900 * NULL.
901 */
902 if (xfer->tx_buf == master->dummy_tx)
903 xfer->tx_buf = NULL;
904 if (xfer->rx_buf == master->dummy_rx)
905 xfer->rx_buf = NULL;
906 }
907
908 return __spi_unmap_msg(master, msg);
909}
910
2de440f5
GU		 911static int spi_map_msg(struct spi_master *master, struct spi_message *msg)
912{
913 struct spi_transfer *xfer;
914 void *tmp;
915 unsigned int max_tx, max_rx;
916
917 if (master->flags & (SPI_MASTER_MUST_RX | SPI_MASTER_MUST_TX)) {
918 max_tx = 0;
919 max_rx = 0;
920
921 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
922 if ((master->flags & SPI_MASTER_MUST_TX) &&
923 !xfer->tx_buf)
924 max_tx = max(xfer->len, max_tx);
925 if ((master->flags & SPI_MASTER_MUST_RX) &&
926 !xfer->rx_buf)
927 max_rx = max(xfer->len, max_rx);
928 }
929
930 if (max_tx) {
931 tmp = krealloc(master->dummy_tx, max_tx,
932 GFP_KERNEL | GFP_DMA);
933 if (!tmp)
934 return -ENOMEM;
935 master->dummy_tx = tmp;
936 memset(tmp, 0, max_tx);
937 }
938
939 if (max_rx) {
940 tmp = krealloc(master->dummy_rx, max_rx,
941 GFP_KERNEL | GFP_DMA);
942 if (!tmp)
943 return -ENOMEM;
944 master->dummy_rx = tmp;
945 }
946
947 if (max_tx || max_rx) {
948 list_for_each_entry(xfer, &msg->transfers,
949 transfer_list) {
950 if (!xfer->tx_buf)
951 xfer->tx_buf = master->dummy_tx;
952 if (!xfer->rx_buf)
953 xfer->rx_buf = master->dummy_rx;
954 }
955 }
956 }
957
958 return __spi_map_msg(master, msg);
959}
99adef31 960
b158935f
MB		 961/*
962 * spi_transfer_one_message - Default implementation of transfer_one_message()
963 *
964 * This is a standard implementation of transfer_one_message() for
8ba811a7 965 * drivers which implement a transfer_one() operation. It provides
b158935f
MB		 966 * standard handling of delays and chip select management.
967 */
968static int spi_transfer_one_message(struct spi_master *master,
969 struct spi_message *msg)
970{
971 struct spi_transfer *xfer;
b158935f
MB		 972 bool keep_cs = false;
973 int ret = 0;
d0716dde 974 unsigned long long ms = 1;
eca2ebc7
MS		 975 struct spi_statistics *statm = &master->statistics;
976 struct spi_statistics *stats = &msg->spi->statistics;
b158935f
MB		 977
978 spi_set_cs(msg->spi, true);
979
eca2ebc7
MS		 980 SPI_STATISTICS_INCREMENT_FIELD(statm, messages);
981 SPI_STATISTICS_INCREMENT_FIELD(stats, messages);
982
b158935f
MB		 983 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
984 trace_spi_transfer_start(msg, xfer);
985
eca2ebc7
MS		 986 spi_statistics_add_transfer_stats(statm, xfer, master);
987 spi_statistics_add_transfer_stats(stats, xfer, master);
988
38ec10f6
MB		 989 if (xfer->tx_buf || xfer->rx_buf) {
990 reinit_completion(&master->xfer_completion);
b158935f 991
38ec10f6
MB		 992 ret = master->transfer_one(master, msg->spi, xfer);
993 if (ret < 0) {
eca2ebc7
MS		 994 SPI_STATISTICS_INCREMENT_FIELD(statm,
995 errors);
996 SPI_STATISTICS_INCREMENT_FIELD(stats,
997 errors);
38ec10f6
MB		 998 dev_err(&msg->spi->dev,
999 "SPI transfer failed: %d\n", ret);
1000 goto out;
1001 }
b158935f 1002
38ec10f6
MB		 1003 if (ret > 0) {
1004 ret = 0;
d0716dde
SW		 1005 ms = 8LL * 1000LL * xfer->len;
1006 do_div(ms, xfer->speed_hz);
38ec10f6 1007 ms += ms + 100; /* some tolerance */
16a0ce4e 1008
d0716dde
SW		 1009 if (ms > UINT_MAX)
1010 ms = UINT_MAX;
1011
38ec10f6
MB		 1012 ms = wait_for_completion_timeout(&master->xfer_completion,
1013 msecs_to_jiffies(ms));
1014 }
16a0ce4e 1015
38ec10f6 1016 if (ms == 0) {
eca2ebc7
MS		 1017 SPI_STATISTICS_INCREMENT_FIELD(statm,
1018 timedout);
1019 SPI_STATISTICS_INCREMENT_FIELD(stats,
1020 timedout);
38ec10f6
MB		 1021 dev_err(&msg->spi->dev,
1022 "SPI transfer timed out\n");
1023 msg->status = -ETIMEDOUT;
1024 }
1025 } else {
1026 if (xfer->len)
1027 dev_err(&msg->spi->dev,
1028 "Bufferless transfer has length %u\n",
1029 xfer->len);
13a42798 1030 }
b158935f
MB		 1031
1032 trace_spi_transfer_stop(msg, xfer);
1033
1034 if (msg->status != -EINPROGRESS)
1035 goto out;
1036
1037 if (xfer->delay_usecs)
1038 udelay(xfer->delay_usecs);
1039
1040 if (xfer->cs_change) {
1041 if (list_is_last(&xfer->transfer_list,
1042 &msg->transfers)) {
1043 keep_cs = true;
1044 } else {
0b73aa63
MB		 1045 spi_set_cs(msg->spi, false);
1046 udelay(10);
1047 spi_set_cs(msg->spi, true);
b158935f
MB		 1048 }
1049 }
1050
1051 msg->actual_length += xfer->len;
1052 }
1053
1054out:
1055 if (ret != 0 || !keep_cs)
1056 spi_set_cs(msg->spi, false);
1057
1058 if (msg->status == -EINPROGRESS)
1059 msg->status = ret;
1060
ff61eb42 1061 if (msg->status && master->handle_err)
b716c4ff
AS		 1062 master->handle_err(master, msg);
1063
d780c371
MS		 1064 spi_res_release(master, msg);
1065
b158935f
MB		 1066 spi_finalize_current_message(master);
1067
1068 return ret;
1069}
1070
1071/**
1072 * spi_finalize_current_transfer - report completion of a transfer
2c675689 1073 * @master: the master reporting completion
b158935f
MB		 1074 *
1075 * Called by SPI drivers using the core transfer_one_message()
1076 * implementation to notify it that the current interrupt driven
9e8f4882 1077 * transfer has finished and the next one may be scheduled.
b158935f
MB		 1078 */
1079void spi_finalize_current_transfer(struct spi_master *master)
1080{
1081 complete(&master->xfer_completion);
1082}
1083EXPORT_SYMBOL_GPL(spi_finalize_current_transfer);
1084
ffbbdd21 1085/**
fc9e0f71
MB		 1086 * __spi_pump_messages - function which processes spi message queue
1087 * @master: master to process queue for
1088 * @in_kthread: true if we are in the context of the message pump thread
ffbbdd21
LW		 1089 *
1090 * This function checks if there is any spi message in the queue that
1091 * needs processing and if so call out to the driver to initialize hardware
1092 * and transfer each message.
1093 *
0461a414
MB		 1094 * Note that it is called both from the kthread itself and also from
1095 * inside spi_sync(); the queue extraction handling at the top of the
1096 * function should deal with this safely.
ffbbdd21 1097 */
ef4d96ec 1098static void __spi_pump_messages(struct spi_master *master, bool in_kthread)
ffbbdd21 1099{
ffbbdd21
LW		 1100 unsigned long flags;
1101 bool was_busy = false;
1102 int ret;
1103
983aee5d 1104 /* Lock queue */
ffbbdd21 1105 spin_lock_irqsave(&master->queue_lock, flags);
983aee5d
MB		 1106
1107 /* Make sure we are not already running a message */
1108 if (master->cur_msg) {
1109 spin_unlock_irqrestore(&master->queue_lock, flags);
1110 return;
1111 }
1112
0461a414
MB		 1113 /* If another context is idling the device then defer */
1114 if (master->idling) {
8c03cbe6 1115 kthread_queue_work(&master->kworker, &master->pump_messages);
0461a414
MB		 1116 spin_unlock_irqrestore(&master->queue_lock, flags);
1117 return;
1118 }
1119
983aee5d 1120 /* Check if the queue is idle */
ffbbdd21 1121 if (list_empty(&master->queue) || !master->running) {
b0b36b86
BF		 1122 if (!master->busy) {
1123 spin_unlock_irqrestore(&master->queue_lock, flags);
1124 return;
ffbbdd21 1125 }
fc9e0f71
MB		 1126
1127 /* Only do teardown in the thread */
1128 if (!in_kthread) {
8c03cbe6 1129 kthread_queue_work(&master->kworker,
fc9e0f71
MB		 1130 &master->pump_messages);
1131 spin_unlock_irqrestore(&master->queue_lock, flags);
1132 return;
1133 }
1134
ffbbdd21 1135 master->busy = false;
0461a414 1136 master->idling = true;
ffbbdd21 1137 spin_unlock_irqrestore(&master->queue_lock, flags);
0461a414 1138
3a2eba9b
MB		 1139 kfree(master->dummy_rx);
1140 master->dummy_rx = NULL;
1141 kfree(master->dummy_tx);
1142 master->dummy_tx = NULL;
b0b36b86
BF		 1143 if (master->unprepare_transfer_hardware &&
1144 master->unprepare_transfer_hardware(master))
1145 dev_err(&master->dev,
1146 "failed to unprepare transfer hardware\n");
49834de2
MB		 1147 if (master->auto_runtime_pm) {
1148 pm_runtime_mark_last_busy(master->dev.parent);
1149 pm_runtime_put_autosuspend(master->dev.parent);
1150 }
56ec1978 1151 trace_spi_master_idle(master);
ffbbdd21 1152
0461a414
MB		 1153 spin_lock_irqsave(&master->queue_lock, flags);
1154 master->idling = false;
ffbbdd21
LW		 1155 spin_unlock_irqrestore(&master->queue_lock, flags);
1156 return;
1157 }
ffbbdd21 1158
ffbbdd21
LW		 1159 /* Extract head of queue */
1160 master->cur_msg =
a89e2d27 1161 list_first_entry(&master->queue, struct spi_message, queue);
ffbbdd21
LW		 1162
1163 list_del_init(&master->cur_msg->queue);
1164 if (master->busy)
1165 was_busy = true;
1166 else
1167 master->busy = true;
1168 spin_unlock_irqrestore(&master->queue_lock, flags);
1169
ef4d96ec
MB		 1170 mutex_lock(&master->io_mutex);
1171
49834de2
MB		 1172 if (!was_busy && master->auto_runtime_pm) {
1173 ret = pm_runtime_get_sync(master->dev.parent);
1174 if (ret < 0) {
1175 dev_err(&master->dev, "Failed to power device: %d\n",
1176 ret);
764f2166 1177 mutex_unlock(&master->io_mutex);
49834de2
MB		 1178 return;
1179 }
1180 }
1181
56ec1978
MB		 1182 if (!was_busy)
1183 trace_spi_master_busy(master);
1184
7dfd2bd7 1185 if (!was_busy && master->prepare_transfer_hardware) {
ffbbdd21
LW		 1186 ret = master->prepare_transfer_hardware(master);
1187 if (ret) {
1188 dev_err(&master->dev,
1189 "failed to prepare transfer hardware\n");
49834de2
MB		 1190
1191 if (master->auto_runtime_pm)
1192 pm_runtime_put(master->dev.parent);
764f2166 1193 mutex_unlock(&master->io_mutex);
ffbbdd21
LW		 1194 return;
1195 }
1196 }
1197
56ec1978
MB		 1198 trace_spi_message_start(master->cur_msg);
1199
2841a5fc
MB		 1200 if (master->prepare_message) {
1201 ret = master->prepare_message(master, master->cur_msg);
1202 if (ret) {
1203 dev_err(&master->dev,
1204 "failed to prepare message: %d\n", ret);
1205 master->cur_msg->status = ret;
1206 spi_finalize_current_message(master);
49023d2e 1207 goto out;
2841a5fc
MB		 1208 }
1209 master->cur_msg_prepared = true;
1210 }
1211
99adef31
MB		 1212 ret = spi_map_msg(master, master->cur_msg);
1213 if (ret) {
1214 master->cur_msg->status = ret;
1215 spi_finalize_current_message(master);
49023d2e 1216 goto out;
99adef31
MB		 1217 }
1218
ffbbdd21
LW		 1219 ret = master->transfer_one_message(master, master->cur_msg);
1220 if (ret) {
1221 dev_err(&master->dev,
1f802f82 1222 "failed to transfer one message from queue\n");
49023d2e 1223 goto out;
ffbbdd21 1224 }
49023d2e
JH		 1225
1226out:
ef4d96ec 1227 mutex_unlock(&master->io_mutex);
62826970
MB		 1228
1229 /* Prod the scheduler in case transfer_one() was busy waiting */
49023d2e
JH		 1230 if (!ret)
1231 cond_resched();
ffbbdd21
LW		 1232}
1233
fc9e0f71
MB		 1234/**
1235 * spi_pump_messages - kthread work function which processes spi message queue
1236 * @work: pointer to kthread work struct contained in the master struct
1237 */
1238static void spi_pump_messages(struct kthread_work *work)
1239{
1240 struct spi_master *master =
1241 container_of(work, struct spi_master, pump_messages);
1242
ef4d96ec 1243 __spi_pump_messages(master, true);
fc9e0f71
MB		 1244}
1245
ffbbdd21
LW		 1246static int spi_init_queue(struct spi_master *master)
1247{
1248 struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
1249
ffbbdd21
LW		 1250 master->running = false;
1251 master->busy = false;
1252
8c03cbe6 1253 kthread_init_worker(&master->kworker);
ffbbdd21 1254 master->kworker_task = kthread_run(kthread_worker_fn,
f170168b 1255 &master->kworker, "%s",
ffbbdd21
LW		 1256 dev_name(&master->dev));
1257 if (IS_ERR(master->kworker_task)) {
1258 dev_err(&master->dev, "failed to create message pump task\n");
98a8f5a0 1259 return PTR_ERR(master->kworker_task);
ffbbdd21 1260 }
8c03cbe6 1261 kthread_init_work(&master->pump_messages, spi_pump_messages);
ffbbdd21
LW		 1262
1263 /*
1264 * Master config will indicate if this controller should run the
1265 * message pump with high (realtime) priority to reduce the transfer
1266 * latency on the bus by minimising the delay between a transfer
1267 * request and the scheduling of the message pump thread. Without this
1268 * setting the message pump thread will remain at default priority.
1269 */
1270 if (master->rt) {
1271 dev_info(&master->dev,
1272 "will run message pump with realtime priority\n");
1273 sched_setscheduler(master->kworker_task, SCHED_FIFO, &param);
1274 }
1275
1276 return 0;
1277}
1278
1279/**
1280 * spi_get_next_queued_message() - called by driver to check for queued
1281 * messages
1282 * @master: the master to check for queued messages
1283 *
1284 * If there are more messages in the queue, the next message is returned from
1285 * this call.
97d56dc6
JMC		 1286 *
1287 * Return: the next message in the queue, else NULL if the queue is empty.
ffbbdd21
LW		 1288 */
1289struct spi_message *spi_get_next_queued_message(struct spi_master *master)
1290{
1291 struct spi_message *next;
1292 unsigned long flags;
1293
1294 /* get a pointer to the next message, if any */
1295 spin_lock_irqsave(&master->queue_lock, flags);
1cfd97f9
AL		 1296 next = list_first_entry_or_null(&master->queue, struct spi_message,
1297 queue);
ffbbdd21
LW		 1298 spin_unlock_irqrestore(&master->queue_lock, flags);
1299
1300 return next;
1301}
1302EXPORT_SYMBOL_GPL(spi_get_next_queued_message);
1303
1304/**
1305 * spi_finalize_current_message() - the current message is complete
1306 * @master: the master to return the message to
1307 *
1308 * Called by the driver to notify the core that the message in the front of the
1309 * queue is complete and can be removed from the queue.
1310 */
1311void spi_finalize_current_message(struct spi_master *master)
1312{
1313 struct spi_message *mesg;
1314 unsigned long flags;
2841a5fc 1315 int ret;
ffbbdd21
LW		 1316
1317 spin_lock_irqsave(&master->queue_lock, flags);
1318 mesg = master->cur_msg;
ffbbdd21
LW		 1319 spin_unlock_irqrestore(&master->queue_lock, flags);
1320
99adef31
MB		 1321 spi_unmap_msg(master, mesg);
1322
2841a5fc
MB		 1323 if (master->cur_msg_prepared && master->unprepare_message) {
1324 ret = master->unprepare_message(master, mesg);
1325 if (ret) {
1326 dev_err(&master->dev,
1327 "failed to unprepare message: %d\n", ret);
1328 }
1329 }
391949b6 1330
8e76ef88
MS		 1331 spin_lock_irqsave(&master->queue_lock, flags);
1332 master->cur_msg = NULL;
2841a5fc 1333 master->cur_msg_prepared = false;
8c03cbe6 1334 kthread_queue_work(&master->kworker, &master->pump_messages);
8e76ef88
MS		 1335 spin_unlock_irqrestore(&master->queue_lock, flags);
1336
1337 trace_spi_message_done(mesg);
2841a5fc 1338
ffbbdd21
LW		 1339 mesg->state = NULL;
1340 if (mesg->complete)
1341 mesg->complete(mesg->context);
1342}
1343EXPORT_SYMBOL_GPL(spi_finalize_current_message);
1344
1345static int spi_start_queue(struct spi_master *master)
1346{
1347 unsigned long flags;
1348
1349 spin_lock_irqsave(&master->queue_lock, flags);
1350
1351 if (master->running || master->busy) {
1352 spin_unlock_irqrestore(&master->queue_lock, flags);
1353 return -EBUSY;
1354 }
1355
1356 master->running = true;
1357 master->cur_msg = NULL;
1358 spin_unlock_irqrestore(&master->queue_lock, flags);
1359
8c03cbe6 1360 kthread_queue_work(&master->kworker, &master->pump_messages);
ffbbdd21
LW		 1361
1362 return 0;
1363}
1364
1365static int spi_stop_queue(struct spi_master *master)
1366{
1367 unsigned long flags;
1368 unsigned limit = 500;
1369 int ret = 0;
1370
1371 spin_lock_irqsave(&master->queue_lock, flags);
1372
1373 /*
1374 * This is a bit lame, but is optimized for the common execution path.
1375 * A wait_queue on the master->busy could be used, but then the common
1376 * execution path (pump_messages) would be required to call wake_up or
1377 * friends on every SPI message. Do this instead.
1378 */
1379 while ((!list_empty(&master->queue) || master->busy) && limit--) {
1380 spin_unlock_irqrestore(&master->queue_lock, flags);
f97b26b0 1381 usleep_range(10000, 11000);
ffbbdd21
LW		 1382 spin_lock_irqsave(&master->queue_lock, flags);
1383 }
1384
1385 if (!list_empty(&master->queue) || master->busy)
1386 ret = -EBUSY;
1387 else
1388 master->running = false;
1389
1390 spin_unlock_irqrestore(&master->queue_lock, flags);
1391
1392 if (ret) {
1393 dev_warn(&master->dev,
1394 "could not stop message queue\n");
1395 return ret;
1396 }
1397 return ret;
1398}
1399
1400static int spi_destroy_queue(struct spi_master *master)
1401{
1402 int ret;
1403
1404 ret = spi_stop_queue(master);
1405
1406 /*
8c03cbe6 1407 * kthread_flush_worker will block until all work is done.
ffbbdd21
LW		 1408 * If the reason that stop_queue timed out is that the work will never
1409 * finish, then it does no good to call flush/stop thread, so
1410 * return anyway.
1411 */
1412 if (ret) {
1413 dev_err(&master->dev, "problem destroying queue\n");
1414 return ret;
1415 }
1416
8c03cbe6 1417 kthread_flush_worker(&master->kworker);
ffbbdd21
LW		 1418 kthread_stop(master->kworker_task);
1419
1420 return 0;
1421}
1422
0461a414
MB		 1423static int __spi_queued_transfer(struct spi_device *spi,
1424 struct spi_message *msg,
1425 bool need_pump)
ffbbdd21
LW		 1426{
1427 struct spi_master *master = spi->master;
1428 unsigned long flags;
1429
1430 spin_lock_irqsave(&master->queue_lock, flags);
1431
1432 if (!master->running) {
1433 spin_unlock_irqrestore(&master->queue_lock, flags);
1434 return -ESHUTDOWN;
1435 }
1436 msg->actual_length = 0;
1437 msg->status = -EINPROGRESS;
1438
1439 list_add_tail(&msg->queue, &master->queue);
0461a414 1440 if (!master->busy && need_pump)
8c03cbe6 1441 kthread_queue_work(&master->kworker, &master->pump_messages);
ffbbdd21
LW		 1442
1443 spin_unlock_irqrestore(&master->queue_lock, flags);
1444 return 0;
1445}
1446
0461a414
MB		 1447/**
1448 * spi_queued_transfer - transfer function for queued transfers
1449 * @spi: spi device which is requesting transfer
1450 * @msg: spi message which is to handled is queued to driver queue
97d56dc6
JMC		 1451 *
1452 * Return: zero on success, else a negative error code.
0461a414
MB		 1453 */
1454static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
1455{
1456 return __spi_queued_transfer(spi, msg, true);
1457}
1458
ffbbdd21
LW		 1459static int spi_master_initialize_queue(struct spi_master *master)
1460{
1461 int ret;
1462
ffbbdd21 1463 master->transfer = spi_queued_transfer;
b158935f
MB		 1464 if (!master->transfer_one_message)
1465 master->transfer_one_message = spi_transfer_one_message;
ffbbdd21
LW		 1466
1467 /* Initialize and start queue */
1468 ret = spi_init_queue(master);
1469 if (ret) {
1470 dev_err(&master->dev, "problem initializing queue\n");
1471 goto err_init_queue;
1472 }
c3676d5c 1473 master->queued = true;
ffbbdd21
LW		 1474 ret = spi_start_queue(master);
1475 if (ret) {
1476 dev_err(&master->dev, "problem starting queue\n");
1477 goto err_start_queue;
1478 }
1479
1480 return 0;
1481
1482err_start_queue:
ffbbdd21 1483 spi_destroy_queue(master);
c3676d5c 1484err_init_queue:
ffbbdd21
LW		 1485 return ret;
1486}
1487
1488/*-------------------------------------------------------------------------*/
1489
7cb94361 1490#if defined(CONFIG_OF)
aff5e3f8
PA		 1491static struct spi_device *
1492of_register_spi_device(struct spi_master *master, struct device_node *nc)
1493{
1494 struct spi_device *spi;
1495 int rc;
1496 u32 value;
1497
1498 /* Alloc an spi_device */
1499 spi = spi_alloc_device(master);
1500 if (!spi) {
1501 dev_err(&master->dev, "spi_device alloc error for %s\n",
1502 nc->full_name);
1503 rc = -ENOMEM;
1504 goto err_out;
1505 }
1506
1507 /* Select device driver */
1508 rc = of_modalias_node(nc, spi->modalias,
1509 sizeof(spi->modalias));
1510 if (rc < 0) {
1511 dev_err(&master->dev, "cannot find modalias for %s\n",
1512 nc->full_name);
1513 goto err_out;
1514 }
1515
1516 /* Device address */
1517 rc = of_property_read_u32(nc, "reg", &value);
1518 if (rc) {
1519 dev_err(&master->dev, "%s has no valid 'reg' property (%d)\n",
1520 nc->full_name, rc);
1521 goto err_out;
1522 }
1523 spi->chip_select = value;
1524
1525 /* Mode (clock phase/polarity/etc.) */
1526 if (of_find_property(nc, "spi-cpha", NULL))
1527 spi->mode |= SPI_CPHA;
1528 if (of_find_property(nc, "spi-cpol", NULL))
1529 spi->mode |= SPI_CPOL;
1530 if (of_find_property(nc, "spi-cs-high", NULL))
1531 spi->mode |= SPI_CS_HIGH;
1532 if (of_find_property(nc, "spi-3wire", NULL))
1533 spi->mode |= SPI_3WIRE;
1534 if (of_find_property(nc, "spi-lsb-first", NULL))
1535 spi->mode |= SPI_LSB_FIRST;
1536
1537 /* Device DUAL/QUAD mode */
1538 if (!of_property_read_u32(nc, "spi-tx-bus-width", &value)) {
1539 switch (value) {
1540 case 1:
1541 break;
1542 case 2:
1543 spi->mode |= SPI_TX_DUAL;
1544 break;
1545 case 4:
1546 spi->mode |= SPI_TX_QUAD;
1547 break;
1548 default:
1549 dev_warn(&master->dev,
1550 "spi-tx-bus-width %d not supported\n",
1551 value);
1552 break;
1553 }
1554 }
1555
1556 if (!of_property_read_u32(nc, "spi-rx-bus-width", &value)) {
1557 switch (value) {
1558 case 1:
1559 break;
1560 case 2:
1561 spi->mode |= SPI_RX_DUAL;
1562 break;
1563 case 4:
1564 spi->mode |= SPI_RX_QUAD;
1565 break;
1566 default:
1567 dev_warn(&master->dev,
1568 "spi-rx-bus-width %d not supported\n",
1569 value);
1570 break;
1571 }
1572 }
1573
1574 /* Device speed */
1575 rc = of_property_read_u32(nc, "spi-max-frequency", &value);
1576 if (rc) {
1577 dev_err(&master->dev, "%s has no valid 'spi-max-frequency' property (%d)\n",
1578 nc->full_name, rc);
1579 goto err_out;
1580 }
1581 spi->max_speed_hz = value;
1582
aff5e3f8
PA		 1583 /* Store a pointer to the node in the device structure */
1584 of_node_get(nc);
1585 spi->dev.of_node = nc;
1586
1587 /* Register the new device */
aff5e3f8
PA		 1588 rc = spi_add_device(spi);
1589 if (rc) {
1590 dev_err(&master->dev, "spi_device register error %s\n",
1591 nc->full_name);
1592 goto err_out;
1593 }
1594
1595 return spi;
1596
1597err_out:
1598 spi_dev_put(spi);
1599 return ERR_PTR(rc);
1600}
1601
d57a4282
GL		 1602/**
1603 * of_register_spi_devices() - Register child devices onto the SPI bus
1604 * @master: Pointer to spi_master device
1605 *
1606 * Registers an spi_device for each child node of master node which has a 'reg'
1607 * property.
1608 */
1609static void of_register_spi_devices(struct spi_master *master)
1610{
1611 struct spi_device *spi;
1612 struct device_node *nc;
d57a4282
GL		 1613
1614 if (!master->dev.of_node)
1615 return;
1616
f3b6159e 1617 for_each_available_child_of_node(master->dev.of_node, nc) {
bd6c1644
GU		 1618 if (of_node_test_and_set_flag(nc, OF_POPULATED))
1619 continue;
aff5e3f8
PA		 1620 spi = of_register_spi_device(master, nc);
1621 if (IS_ERR(spi))
1622 dev_warn(&master->dev, "Failed to create SPI device for %s\n",
d57a4282 1623 nc->full_name);
d57a4282
GL		 1624 }
1625}
1626#else
1627static void of_register_spi_devices(struct spi_master *master) { }
1628#endif
1629
64bee4d2
MW		 1630#ifdef CONFIG_ACPI
1631static int acpi_spi_add_resource(struct acpi_resource *ares, void *data)
1632{
1633 struct spi_device *spi = data;
a0a90718 1634 struct spi_master *master = spi->master;
64bee4d2
MW		 1635
1636 if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
1637 struct acpi_resource_spi_serialbus *sb;
1638
1639 sb = &ares->data.spi_serial_bus;
1640 if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_SPI) {
a0a90718
MW		 1641 /*
1642 * ACPI DeviceSelection numbering is handled by the
1643 * host controller driver in Windows and can vary
1644 * from driver to driver. In Linux we always expect
1645 * 0 .. max - 1 so we need to ask the driver to
1646 * translate between the two schemes.
1647 */
1648 if (master->fw_translate_cs) {
1649 int cs = master->fw_translate_cs(master,
1650 sb->device_selection);
1651 if (cs < 0)
1652 return cs;
1653 spi->chip_select = cs;
1654 } else {
1655 spi->chip_select = sb->device_selection;
1656 }
1657
64bee4d2
MW		 1658 spi->max_speed_hz = sb->connection_speed;
1659
1660 if (sb->clock_phase == ACPI_SPI_SECOND_PHASE)
1661 spi->mode |= SPI_CPHA;
1662 if (sb->clock_polarity == ACPI_SPI_START_HIGH)
1663 spi->mode |= SPI_CPOL;
1664 if (sb->device_polarity == ACPI_SPI_ACTIVE_HIGH)
1665 spi->mode |= SPI_CS_HIGH;
1666 }
1667 } else if (spi->irq < 0) {
1668 struct resource r;
1669
1670 if (acpi_dev_resource_interrupt(ares, 0, &r))
1671 spi->irq = r.start;
1672 }
1673
1674 /* Always tell the ACPI core to skip this resource */
1675 return 1;
1676}
1677
7f24467f
OP		 1678static acpi_status acpi_register_spi_device(struct spi_master *master,
1679 struct acpi_device *adev)
64bee4d2 1680{
64bee4d2 1681 struct list_head resource_list;
64bee4d2
MW		 1682 struct spi_device *spi;
1683 int ret;
1684
7f24467f
OP		 1685 if (acpi_bus_get_status(adev) || !adev->status.present ||
1686 acpi_device_enumerated(adev))
64bee4d2
MW		 1687 return AE_OK;
1688
1689 spi = spi_alloc_device(master);
1690 if (!spi) {
1691 dev_err(&master->dev, "failed to allocate SPI device for %s\n",
1692 dev_name(&adev->dev));
1693 return AE_NO_MEMORY;
1694 }
1695
7b199811 1696 ACPI_COMPANION_SET(&spi->dev, adev);
64bee4d2
MW		 1697 spi->irq = -1;
1698
1699 INIT_LIST_HEAD(&resource_list);
1700 ret = acpi_dev_get_resources(adev, &resource_list,
1701 acpi_spi_add_resource, spi);
1702 acpi_dev_free_resource_list(&resource_list);
1703
1704 if (ret < 0 || !spi->max_speed_hz) {
1705 spi_dev_put(spi);
1706 return AE_OK;
1707 }
1708
33ada67d
CR		 1709 if (spi->irq < 0)
1710 spi->irq = acpi_dev_gpio_irq_get(adev, 0);
1711
7f24467f
OP		 1712 acpi_device_set_enumerated(adev);
1713
33cf00e5 1714 adev->power.flags.ignore_parent = true;
cf9eb39c 1715 strlcpy(spi->modalias, acpi_device_hid(adev), sizeof(spi->modalias));
64bee4d2 1716 if (spi_add_device(spi)) {
33cf00e5 1717 adev->power.flags.ignore_parent = false;
64bee4d2
MW		 1718 dev_err(&master->dev, "failed to add SPI device %s from ACPI\n",
1719 dev_name(&adev->dev));
1720 spi_dev_put(spi);
1721 }
1722
1723 return AE_OK;
1724}
1725
7f24467f
OP		 1726static acpi_status acpi_spi_add_device(acpi_handle handle, u32 level,
1727 void *data, void **return_value)
1728{
1729 struct spi_master *master = data;
1730 struct acpi_device *adev;
1731
1732 if (acpi_bus_get_device(handle, &adev))
1733 return AE_OK;
1734
1735 return acpi_register_spi_device(master, adev);
1736}
1737
64bee4d2
MW		 1738static void acpi_register_spi_devices(struct spi_master *master)
1739{
1740 acpi_status status;
1741 acpi_handle handle;
1742
29896178 1743 handle = ACPI_HANDLE(master->dev.parent);
64bee4d2
MW		 1744 if (!handle)
1745 return;
1746
1747 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
1748 acpi_spi_add_device, NULL,
1749 master, NULL);
1750 if (ACPI_FAILURE(status))
1751 dev_warn(&master->dev, "failed to enumerate SPI slaves\n");
1752}
1753#else
1754static inline void acpi_register_spi_devices(struct spi_master *master) {}
1755#endif /* CONFIG_ACPI */
1756
49dce689 1757static void spi_master_release(struct device *dev)
8ae12a0d
DB		 1758{
1759 struct spi_master *master;
1760
49dce689 1761 master = container_of(dev, struct spi_master, dev);
8ae12a0d
DB		 1762 kfree(master);
1763}
1764
1765static struct class spi_master_class = {
1766 .name = "spi_master",
1767 .owner = THIS_MODULE,
49dce689 1768 .dev_release = spi_master_release,
eca2ebc7 1769 .dev_groups = spi_master_groups,
8ae12a0d
DB		 1770};
1771
1772
1773/**
1774 * spi_alloc_master - allocate SPI master controller
1775 * @dev: the controller, possibly using the platform_bus
33e34dc6 1776 * @size: how much zeroed driver-private data to allocate; the pointer to this
49dce689 1777 * memory is in the driver_data field of the returned device,
0c868461 1778 * accessible with spi_master_get_devdata().
33e34dc6 1779 * Context: can sleep
8ae12a0d
DB		 1780 *
1781 * This call is used only by SPI master controller drivers, which are the
1782 * only ones directly touching chip registers. It's how they allocate
ba1a0513 1783 * an spi_master structure, prior to calling spi_register_master().
8ae12a0d 1784 *
97d56dc6 1785 * This must be called from context that can sleep.
8ae12a0d
DB		 1786 *
1787 * The caller is responsible for assigning the bus number and initializing
ba1a0513 1788 * the master's methods before calling spi_register_master(); and (after errors
a394d635 1789 * adding the device) calling spi_master_put() to prevent a memory leak.
97d56dc6
JMC		 1790 *
1791 * Return: the SPI master structure on success, else NULL.
8ae12a0d 1792 */
e9d5a461 1793struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
8ae12a0d
DB		 1794{
1795 struct spi_master *master;
1796
0c868461
DB		 1797 if (!dev)
1798 return NULL;
1799
5fe5f05e 1800 master = kzalloc(size + sizeof(*master), GFP_KERNEL);
8ae12a0d
DB		 1801 if (!master)
1802 return NULL;
1803
49dce689 1804 device_initialize(&master->dev);
1e8a52e1
GL		 1805 master->bus_num = -1;
1806 master->num_chipselect = 1;
49dce689 1807 master->dev.class = &spi_master_class;
157f38f9 1808 master->dev.parent = dev;
d7e2ee25 1809 pm_suspend_ignore_children(&master->dev, true);
0c868461 1810 spi_master_set_devdata(master, &master[1]);
8ae12a0d
DB		 1811
1812 return master;
1813}
1814EXPORT_SYMBOL_GPL(spi_alloc_master);
1815
74317984
JCPV		 1816#ifdef CONFIG_OF
1817static int of_spi_register_master(struct spi_master *master)
1818{
e80beb27 1819 int nb, i, *cs;
74317984
JCPV		 1820 struct device_node *np = master->dev.of_node;
1821
1822 if (!np)
1823 return 0;
1824
1825 nb = of_gpio_named_count(np, "cs-gpios");
5fe5f05e 1826 master->num_chipselect = max_t(int, nb, master->num_chipselect);
74317984 1827
8ec5d84e
AL		 1828 /* Return error only for an incorrectly formed cs-gpios property */
1829 if (nb == 0 || nb == -ENOENT)
74317984 1830 return 0;
8ec5d84e
AL		 1831 else if (nb < 0)
1832 return nb;
74317984
JCPV		 1833
1834 cs = devm_kzalloc(&master->dev,
1835 sizeof(int) * master->num_chipselect,
1836 GFP_KERNEL);
1837 master->cs_gpios = cs;
1838
1839 if (!master->cs_gpios)
1840 return -ENOMEM;
1841
0da83bb1 1842 for (i = 0; i < master->num_chipselect; i++)
446411e1 1843 cs[i] = -ENOENT;
74317984
JCPV		 1844
1845 for (i = 0; i < nb; i++)
1846 cs[i] = of_get_named_gpio(np, "cs-gpios", i);
1847
1848 return 0;
1849}
1850#else
1851static int of_spi_register_master(struct spi_master *master)
1852{
1853 return 0;
1854}
1855#endif
1856
8ae12a0d
DB		 1857/**
1858 * spi_register_master - register SPI master controller
1859 * @master: initialized master, originally from spi_alloc_master()
33e34dc6 1860 * Context: can sleep
8ae12a0d
DB		 1861 *
1862 * SPI master controllers connect to their drivers using some non-SPI bus,
1863 * such as the platform bus. The final stage of probe() in that code
1864 * includes calling spi_register_master() to hook up to this SPI bus glue.
1865 *
1866 * SPI controllers use board specific (often SOC specific) bus numbers,
1867 * and board-specific addressing for SPI devices combines those numbers
1868 * with chip select numbers. Since SPI does not directly support dynamic
1869 * device identification, boards need configuration tables telling which
1870 * chip is at which address.
1871 *
1872 * This must be called from context that can sleep. It returns zero on
1873 * success, else a negative error code (dropping the master's refcount).
0c868461
DB		 1874 * After a successful return, the caller is responsible for calling
1875 * spi_unregister_master().
97d56dc6
JMC		 1876 *
1877 * Return: zero on success, else a negative error code.
8ae12a0d 1878 */
e9d5a461 1879int spi_register_master(struct spi_master *master)
8ae12a0d 1880{
e44a45ae 1881 static atomic_t dyn_bus_id = ATOMIC_INIT((1<<15) - 1);
49dce689 1882 struct device *dev = master->dev.parent;
2b9603a0 1883 struct boardinfo *bi;
8ae12a0d
DB		 1884 int status = -ENODEV;
1885 int dynamic = 0;
1886
0c868461
DB		 1887 if (!dev)
1888 return -ENODEV;
1889
74317984
JCPV		 1890 status = of_spi_register_master(master);
1891 if (status)
1892 return status;
1893
082c8cb4
DB		 1894 /* even if it's just one always-selected device, there must
1895 * be at least one chipselect
1896 */
1897 if (master->num_chipselect == 0)
1898 return -EINVAL;
1899
bb29785e
GL		 1900 if ((master->bus_num < 0) && master->dev.of_node)
1901 master->bus_num = of_alias_get_id(master->dev.of_node, "spi");
1902
8ae12a0d 1903 /* convention: dynamically assigned bus IDs count down from the max */
a020ed75 1904 if (master->bus_num < 0) {
082c8cb4
DB		 1905 /* FIXME switch to an IDR based scheme, something like
1906 * I2C now uses, so we can't run out of "dynamic" IDs
1907 */
8ae12a0d 1908 master->bus_num = atomic_dec_return(&dyn_bus_id);
b885244e 1909 dynamic = 1;
8ae12a0d
DB		 1910 }
1911
5424d43e
MB		 1912 INIT_LIST_HEAD(&master->queue);
1913 spin_lock_init(&master->queue_lock);
cf32b71e
ES		 1914 spin_lock_init(&master->bus_lock_spinlock);
1915 mutex_init(&master->bus_lock_mutex);
ef4d96ec 1916 mutex_init(&master->io_mutex);
cf32b71e 1917 master->bus_lock_flag = 0;
b158935f 1918 init_completion(&master->xfer_completion);
6ad45a27
MB		 1919 if (!master->max_dma_len)
1920 master->max_dma_len = INT_MAX;
cf32b71e 1921
8ae12a0d
DB		 1922 /* register the device, then userspace will see it.
1923 * registration fails if the bus ID is in use.
1924 */
35f74fca 1925 dev_set_name(&master->dev, "spi%u", master->bus_num);
49dce689 1926 status = device_add(&master->dev);
b885244e 1927 if (status < 0)
8ae12a0d 1928 goto done;
35f74fca 1929 dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev),
8ae12a0d
DB		 1930 dynamic ? " (dynamic)" : "");
1931
ffbbdd21
LW		 1932 /* If we're using a queued driver, start the queue */
1933 if (master->transfer)
1934 dev_info(dev, "master is unqueued, this is deprecated\n");
1935 else {
1936 status = spi_master_initialize_queue(master);
1937 if (status) {
e93b0724 1938 device_del(&master->dev);
ffbbdd21
LW		 1939 goto done;
1940 }
1941 }
eca2ebc7
MS		 1942 /* add statistics */
1943 spin_lock_init(&master->statistics.lock);
ffbbdd21 1944
2b9603a0
FT		 1945 mutex_lock(&board_lock);
1946 list_add_tail(&master->list, &spi_master_list);
1947 list_for_each_entry(bi, &board_list, list)
1948 spi_match_master_to_boardinfo(master, &bi->board_info);
1949 mutex_unlock(&board_lock);
1950
64bee4d2 1951 /* Register devices from the device tree and ACPI */
12b15e83 1952 of_register_spi_devices(master);
64bee4d2 1953 acpi_register_spi_devices(master);
8ae12a0d
DB		 1954done:
1955 return status;
1956}
1957EXPORT_SYMBOL_GPL(spi_register_master);
1958
666d5b4c
MB		 1959static void devm_spi_unregister(struct device *dev, void *res)
1960{
1961 spi_unregister_master(*(struct spi_master **)res);
1962}
1963
1964/**
1965 * dev_spi_register_master - register managed SPI master controller
1966 * @dev: device managing SPI master
1967 * @master: initialized master, originally from spi_alloc_master()
1968 * Context: can sleep
1969 *
1970 * Register a SPI device as with spi_register_master() which will
1971 * automatically be unregister
97d56dc6
JMC		 1972 *
1973 * Return: zero on success, else a negative error code.
666d5b4c
MB		 1974 */
1975int devm_spi_register_master(struct device *dev, struct spi_master *master)
1976{
1977 struct spi_master **ptr;
1978 int ret;
1979
1980 ptr = devres_alloc(devm_spi_unregister, sizeof(*ptr), GFP_KERNEL);
1981 if (!ptr)
1982 return -ENOMEM;
1983
1984 ret = spi_register_master(master);
4b92894e 1985 if (!ret) {
666d5b4c
MB		 1986 *ptr = master;
1987 devres_add(dev, ptr);
1988 } else {
1989 devres_free(ptr);
1990 }
1991
1992 return ret;
1993}
1994EXPORT_SYMBOL_GPL(devm_spi_register_master);
1995
34860089 1996static int __unregister(struct device *dev, void *null)
8ae12a0d 1997{
34860089 1998 spi_unregister_device(to_spi_device(dev));
8ae12a0d
DB		 1999 return 0;
2000}
2001
2002/**
2003 * spi_unregister_master - unregister SPI master controller
2004 * @master: the master being unregistered
33e34dc6 2005 * Context: can sleep
8ae12a0d
DB		 2006 *
2007 * This call is used only by SPI master controller drivers, which are the
2008 * only ones directly touching chip registers.
2009 *
2010 * This must be called from context that can sleep.
2011 */
2012void spi_unregister_master(struct spi_master *master)
2013{
89fc9a1a
JG		 2014 int dummy;
2015
ffbbdd21
LW		 2016 if (master->queued) {
2017 if (spi_destroy_queue(master))
2018 dev_err(&master->dev, "queue remove failed\n");
2019 }
2020
2b9603a0
FT		 2021 mutex_lock(&board_lock);
2022 list_del(&master->list);
2023 mutex_unlock(&board_lock);
2024
97dbf37d 2025 dummy = device_for_each_child(&master->dev, NULL, __unregister);
49dce689 2026 device_unregister(&master->dev);
8ae12a0d
DB		 2027}
2028EXPORT_SYMBOL_GPL(spi_unregister_master);
2029
ffbbdd21
LW		 2030int spi_master_suspend(struct spi_master *master)
2031{
2032 int ret;
2033
2034 /* Basically no-ops for non-queued masters */
2035 if (!master->queued)
2036 return 0;
2037
2038 ret = spi_stop_queue(master);
2039 if (ret)
2040 dev_err(&master->dev, "queue stop failed\n");
2041
2042 return ret;
2043}
2044EXPORT_SYMBOL_GPL(spi_master_suspend);
2045
2046int spi_master_resume(struct spi_master *master)
2047{
2048 int ret;
2049
2050 if (!master->queued)
2051 return 0;
2052
2053 ret = spi_start_queue(master);
2054 if (ret)
2055 dev_err(&master->dev, "queue restart failed\n");
2056
2057 return ret;
2058}
2059EXPORT_SYMBOL_GPL(spi_master_resume);
2060
9f3b795a 2061static int __spi_master_match(struct device *dev, const void *data)
5ed2c832
DY		 2062{
2063 struct spi_master *m;
9f3b795a 2064 const u16 *bus_num = data;
5ed2c832
DY		 2065
2066 m = container_of(dev, struct spi_master, dev);
2067 return m->bus_num == *bus_num;
2068}
2069
8ae12a0d
DB		 2070/**
2071 * spi_busnum_to_master - look up master associated with bus_num
2072 * @bus_num: the master's bus number
33e34dc6 2073 * Context: can sleep
8ae12a0d
DB		 2074 *
2075 * This call may be used with devices that are registered after
2076 * arch init time. It returns a refcounted pointer to the relevant
2077 * spi_master (which the caller must release), or NULL if there is
2078 * no such master registered.
97d56dc6
JMC		 2079 *
2080 * Return: the SPI master structure on success, else NULL.
8ae12a0d
DB		 2081 */
2082struct spi_master *spi_busnum_to_master(u16 bus_num)
2083{
49dce689 2084 struct device *dev;
1e9a51dc 2085 struct spi_master *master = NULL;
5ed2c832 2086
695794ae 2087 dev = class_find_device(&spi_master_class, NULL, &bus_num,
5ed2c832
DY		 2088 __spi_master_match);
2089 if (dev)
2090 master = container_of(dev, struct spi_master, dev);
2091 /* reference got in class_find_device */
1e9a51dc 2092 return master;
8ae12a0d
DB		 2093}
2094EXPORT_SYMBOL_GPL(spi_busnum_to_master);
2095
d780c371
MS		 2096/*-------------------------------------------------------------------------*/
2097
2098/* Core methods for SPI resource management */
2099
2100/**
2101 * spi_res_alloc - allocate a spi resource that is life-cycle managed
2102 * during the processing of a spi_message while using
2103 * spi_transfer_one
2104 * @spi: the spi device for which we allocate memory
2105 * @release: the release code to execute for this resource
2106 * @size: size to alloc and return
2107 * @gfp: GFP allocation flags
2108 *
2109 * Return: the pointer to the allocated data
2110 *
2111 * This may get enhanced in the future to allocate from a memory pool
2112 * of the @spi_device or @spi_master to avoid repeated allocations.
2113 */
2114void *spi_res_alloc(struct spi_device *spi,
2115 spi_res_release_t release,
2116 size_t size, gfp_t gfp)
2117{
2118 struct spi_res *sres;
2119
2120 sres = kzalloc(sizeof(*sres) + size, gfp);
2121 if (!sres)
2122 return NULL;
2123
2124 INIT_LIST_HEAD(&sres->entry);
2125 sres->release = release;
2126
2127 return sres->data;
2128}
2129EXPORT_SYMBOL_GPL(spi_res_alloc);
2130
2131/**
2132 * spi_res_free - free an spi resource
2133 * @res: pointer to the custom data of a resource
2134 *
2135 */
2136void spi_res_free(void *res)
2137{
2138 struct spi_res *sres = container_of(res, struct spi_res, data);
2139
2140 if (!res)
2141 return;
2142
2143 WARN_ON(!list_empty(&sres->entry));
2144 kfree(sres);
2145}
2146EXPORT_SYMBOL_GPL(spi_res_free);
2147
2148/**
2149 * spi_res_add - add a spi_res to the spi_message
2150 * @message: the spi message
2151 * @res: the spi_resource
2152 */
2153void spi_res_add(struct spi_message *message, void *res)
2154{
2155 struct spi_res *sres = container_of(res, struct spi_res, data);
2156
2157 WARN_ON(!list_empty(&sres->entry));
2158 list_add_tail(&sres->entry, &message->resources);
2159}
2160EXPORT_SYMBOL_GPL(spi_res_add);
2161
2162/**
2163 * spi_res_release - release all spi resources for this message
2164 * @master: the @spi_master
2165 * @message: the @spi_message
2166 */
2167void spi_res_release(struct spi_master *master,
2168 struct spi_message *message)
2169{
2170 struct spi_res *res;
2171
2172 while (!list_empty(&message->resources)) {
2173 res = list_last_entry(&message->resources,
2174 struct spi_res, entry);
2175
2176 if (res->release)
2177 res->release(master, message, res->data);
2178
2179 list_del(&res->entry);
2180
2181 kfree(res);
2182 }
2183}
2184EXPORT_SYMBOL_GPL(spi_res_release);
8ae12a0d
DB		 2185
2186/*-------------------------------------------------------------------------*/
2187
523baf5a
MS		 2188/* Core methods for spi_message alterations */
2189
2190static void __spi_replace_transfers_release(struct spi_master *master,
2191 struct spi_message *msg,
2192 void *res)
2193{
2194 struct spi_replaced_transfers *rxfer = res;
2195 size_t i;
2196
2197 /* call extra callback if requested */
2198 if (rxfer->release)
2199 rxfer->release(master, msg, res);
2200
2201 /* insert replaced transfers back into the message */
2202 list_splice(&rxfer->replaced_transfers, rxfer->replaced_after);
2203
2204 /* remove the formerly inserted entries */
2205 for (i = 0; i < rxfer->inserted; i++)
2206 list_del(&rxfer->inserted_transfers[i].transfer_list);
2207}
2208
2209/**
2210 * spi_replace_transfers - replace transfers with several transfers
2211 * and register change with spi_message.resources
2212 * @msg: the spi_message we work upon
2213 * @xfer_first: the first spi_transfer we want to replace
2214 * @remove: number of transfers to remove
2215 * @insert: the number of transfers we want to insert instead
2216 * @release: extra release code necessary in some circumstances
2217 * @extradatasize: extra data to allocate (with alignment guarantees
2218 * of struct @spi_transfer)
05885397 2219 * @gfp: gfp flags
523baf5a
MS		 2220 *
2221 * Returns: pointer to @spi_replaced_transfers,
2222 * PTR_ERR(...) in case of errors.
2223 */
2224struct spi_replaced_transfers *spi_replace_transfers(
2225 struct spi_message *msg,
2226 struct spi_transfer *xfer_first,
2227 size_t remove,
2228 size_t insert,
2229 spi_replaced_release_t release,
2230 size_t extradatasize,
2231 gfp_t gfp)
2232{
2233 struct spi_replaced_transfers *rxfer;
2234 struct spi_transfer *xfer;
2235 size_t i;
2236
2237 /* allocate the structure using spi_res */
2238 rxfer = spi_res_alloc(msg->spi, __spi_replace_transfers_release,
2239 insert * sizeof(struct spi_transfer)
2240 + sizeof(struct spi_replaced_transfers)
2241 + extradatasize,
2242 gfp);
2243 if (!rxfer)
2244 return ERR_PTR(-ENOMEM);
2245
2246 /* the release code to invoke before running the generic release */
2247 rxfer->release = release;
2248
2249 /* assign extradata */
2250 if (extradatasize)
2251 rxfer->extradata =
2252 &rxfer->inserted_transfers[insert];
2253
2254 /* init the replaced_transfers list */
2255 INIT_LIST_HEAD(&rxfer->replaced_transfers);
2256
2257 /* assign the list_entry after which we should reinsert
2258 * the @replaced_transfers - it may be spi_message.messages!
2259 */
2260 rxfer->replaced_after = xfer_first->transfer_list.prev;
2261
2262 /* remove the requested number of transfers */
2263 for (i = 0; i < remove; i++) {
2264 /* if the entry after replaced_after it is msg->transfers
2265 * then we have been requested to remove more transfers
2266 * than are in the list
2267 */
2268 if (rxfer->replaced_after->next == &msg->transfers) {
2269 dev_err(&msg->spi->dev,
2270 "requested to remove more spi_transfers than are available\n");
2271 /* insert replaced transfers back into the message */
2272 list_splice(&rxfer->replaced_transfers,
2273 rxfer->replaced_after);
2274
2275 /* free the spi_replace_transfer structure */
2276 spi_res_free(rxfer);
2277
2278 /* and return with an error */
2279 return ERR_PTR(-EINVAL);
2280 }
2281
2282 /* remove the entry after replaced_after from list of
2283 * transfers and add it to list of replaced_transfers
2284 */
2285 list_move_tail(rxfer->replaced_after->next,
2286 &rxfer->replaced_transfers);
2287 }
2288
2289 /* create copy of the given xfer with identical settings
2290 * based on the first transfer to get removed
2291 */
2292 for (i = 0; i < insert; i++) {
2293 /* we need to run in reverse order */
2294 xfer = &rxfer->inserted_transfers[insert - 1 - i];
2295
2296 /* copy all spi_transfer data */
2297 memcpy(xfer, xfer_first, sizeof(*xfer));
2298
2299 /* add to list */
2300 list_add(&xfer->transfer_list, rxfer->replaced_after);
2301
2302 /* clear cs_change and delay_usecs for all but the last */
2303 if (i) {
2304 xfer->cs_change = false;
2305 xfer->delay_usecs = 0;
2306 }
2307 }
2308
2309 /* set up inserted */
2310 rxfer->inserted = insert;
2311
2312 /* and register it with spi_res/spi_message */
2313 spi_res_add(msg, rxfer);
2314
2315 return rxfer;
2316}
2317EXPORT_SYMBOL_GPL(spi_replace_transfers);
2318
08933418
FE		 2319static int __spi_split_transfer_maxsize(struct spi_master *master,
2320 struct spi_message *msg,
2321 struct spi_transfer **xferp,
2322 size_t maxsize,
2323 gfp_t gfp)
d9f12122
MS		 2324{
2325 struct spi_transfer *xfer = *xferp, *xfers;
2326 struct spi_replaced_transfers *srt;
2327 size_t offset;
2328 size_t count, i;
2329
2330 /* warn once about this fact that we are splitting a transfer */
2331 dev_warn_once(&msg->spi->dev,
7d62f51e 2332 "spi_transfer of length %i exceed max length of %zu - needed to split transfers\n",
d9f12122
MS		 2333 xfer->len, maxsize);
2334
2335 /* calculate how many we have to replace */
2336 count = DIV_ROUND_UP(xfer->len, maxsize);
2337
2338 /* create replacement */
2339 srt = spi_replace_transfers(msg, xfer, 1, count, NULL, 0, gfp);
657d32ef
DC		 2340 if (IS_ERR(srt))
2341 return PTR_ERR(srt);
d9f12122
MS		 2342 xfers = srt->inserted_transfers;
2343
2344 /* now handle each of those newly inserted spi_transfers
2345 * note that the replacements spi_transfers all are preset
2346 * to the same values as *xferp, so tx_buf, rx_buf and len
2347 * are all identical (as well as most others)
2348 * so we just have to fix up len and the pointers.
2349 *
2350 * this also includes support for the depreciated
2351 * spi_message.is_dma_mapped interface
2352 */
2353
2354 /* the first transfer just needs the length modified, so we
2355 * run it outside the loop
2356 */
c8dab77a 2357 xfers[0].len = min_t(size_t, maxsize, xfer[0].len);
d9f12122
MS		 2358
2359 /* all the others need rx_buf/tx_buf also set */
2360 for (i = 1, offset = maxsize; i < count; offset += maxsize, i++) {
2361 /* update rx_buf, tx_buf and dma */
2362 if (xfers[i].rx_buf)
2363 xfers[i].rx_buf += offset;
2364 if (xfers[i].rx_dma)
2365 xfers[i].rx_dma += offset;
2366 if (xfers[i].tx_buf)
2367 xfers[i].tx_buf += offset;
2368 if (xfers[i].tx_dma)
2369 xfers[i].tx_dma += offset;
2370
2371 /* update length */
2372 xfers[i].len = min(maxsize, xfers[i].len - offset);
2373 }
2374
2375 /* we set up xferp to the last entry we have inserted,
2376 * so that we skip those already split transfers
2377 */
2378 *xferp = &xfers[count - 1];
2379
2380 /* increment statistics counters */
2381 SPI_STATISTICS_INCREMENT_FIELD(&master->statistics,
2382 transfers_split_maxsize);
2383 SPI_STATISTICS_INCREMENT_FIELD(&msg->spi->statistics,
2384 transfers_split_maxsize);
2385
2386 return 0;
2387}
2388
2389/**
2390 * spi_split_tranfers_maxsize - split spi transfers into multiple transfers
2391 * when an individual transfer exceeds a
2392 * certain size
2393 * @master: the @spi_master for this transfer
3700ce95
MI		 2394 * @msg: the @spi_message to transform
2395 * @maxsize: the maximum when to apply this
10f11a22 2396 * @gfp: GFP allocation flags
d9f12122
MS		 2397 *
2398 * Return: status of transformation
2399 */
2400int spi_split_transfers_maxsize(struct spi_master *master,
2401 struct spi_message *msg,
2402 size_t maxsize,
2403 gfp_t gfp)
2404{
2405 struct spi_transfer *xfer;
2406 int ret;
2407
2408 /* iterate over the transfer_list,
2409 * but note that xfer is advanced to the last transfer inserted
2410 * to avoid checking sizes again unnecessarily (also xfer does
2411 * potentiall belong to a different list by the time the
2412 * replacement has happened
2413 */
2414 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
2415 if (xfer->len > maxsize) {
2416 ret = __spi_split_transfer_maxsize(
2417 master, msg, &xfer, maxsize, gfp);
2418 if (ret)
2419 return ret;
2420 }
2421 }
2422
2423 return 0;
2424}
2425EXPORT_SYMBOL_GPL(spi_split_transfers_maxsize);
8ae12a0d
DB		 2426
2427/*-------------------------------------------------------------------------*/
2428
7d077197
DB		 2429/* Core methods for SPI master protocol drivers. Some of the
2430 * other core methods are currently defined as inline functions.
2431 */
2432
63ab645f
SB		 2433static int __spi_validate_bits_per_word(struct spi_master *master, u8 bits_per_word)
2434{
2435 if (master->bits_per_word_mask) {
2436 /* Only 32 bits fit in the mask */
2437 if (bits_per_word > 32)
2438 return -EINVAL;
2439 if (!(master->bits_per_word_mask &
2440 SPI_BPW_MASK(bits_per_word)))
2441 return -EINVAL;
2442 }
2443
2444 return 0;
2445}
2446
7d077197
DB		 2447/**
2448 * spi_setup - setup SPI mode and clock rate
2449 * @spi: the device whose settings are being modified
2450 * Context: can sleep, and no requests are queued to the device
2451 *
2452 * SPI protocol drivers may need to update the transfer mode if the
2453 * device doesn't work with its default. They may likewise need
2454 * to update clock rates or word sizes from initial values. This function
2455 * changes those settings, and must be called from a context that can sleep.
2456 * Except for SPI_CS_HIGH, which takes effect immediately, the changes take
2457 * effect the next time the device is selected and data is transferred to
2458 * or from it. When this function returns, the spi device is deselected.
2459 *
2460 * Note that this call will fail if the protocol driver specifies an option
2461 * that the underlying controller or its driver does not support. For
2462 * example, not all hardware supports wire transfers using nine bit words,
2463 * LSB-first wire encoding, or active-high chipselects.
97d56dc6
JMC		 2464 *
2465 * Return: zero on success, else a negative error code.
7d077197
DB		 2466 */
2467int spi_setup(struct spi_device *spi)
2468{
83596fbe 2469 unsigned bad_bits, ugly_bits;
5ab8d262 2470 int status;
7d077197 2471
f477b7fb 2472 /* check mode to prevent that DUAL and QUAD set at the same time
2473 */
2474 if (((spi->mode & SPI_TX_DUAL) && (spi->mode & SPI_TX_QUAD)) ||
2475 ((spi->mode & SPI_RX_DUAL) && (spi->mode & SPI_RX_QUAD))) {
2476 dev_err(&spi->dev,
2477 "setup: can not select dual and quad at the same time\n");
2478 return -EINVAL;
2479 }
2480 /* if it is SPI_3WIRE mode, DUAL and QUAD should be forbidden
2481 */
2482 if ((spi->mode & SPI_3WIRE) && (spi->mode &
2483 (SPI_TX_DUAL | SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD)))
2484 return -EINVAL;
e7db06b5
DB		 2485 /* help drivers fail *cleanly* when they need options
2486 * that aren't supported with their current master
2487 */
2488 bad_bits = spi->mode & ~spi->master->mode_bits;
83596fbe
GU		 2489 ugly_bits = bad_bits &
2490 (SPI_TX_DUAL | SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD);
2491 if (ugly_bits) {
2492 dev_warn(&spi->dev,
2493 "setup: ignoring unsupported mode bits %x\n",
2494 ugly_bits);
2495 spi->mode &= ~ugly_bits;
2496 bad_bits &= ~ugly_bits;
2497 }
e7db06b5 2498 if (bad_bits) {
eb288a1f 2499 dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
e7db06b5
DB		 2500 bad_bits);
2501 return -EINVAL;
2502 }
2503
7d077197
DB		 2504 if (!spi->bits_per_word)
2505 spi->bits_per_word = 8;
2506
5ab8d262
AS		 2507 status = __spi_validate_bits_per_word(spi->master, spi->bits_per_word);
2508 if (status)
2509 return status;
63ab645f 2510
052eb2d4
AL		 2511 if (!spi->max_speed_hz)
2512 spi->max_speed_hz = spi->master->max_speed_hz;
2513
caae070c
LD		 2514 if (spi->master->setup)
2515 status = spi->master->setup(spi);
7d077197 2516
abeedb01
FCJ		 2517 spi_set_cs(spi, false);
2518
5fe5f05e 2519 dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s%u bits/w, %u Hz max --> %d\n",
7d077197
DB		 2520 (int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
2521 (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
2522 (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
2523 (spi->mode & SPI_3WIRE) ? "3wire, " : "",
2524 (spi->mode & SPI_LOOP) ? "loopback, " : "",
2525 spi->bits_per_word, spi->max_speed_hz,
2526 status);
2527
2528 return status;
2529}
2530EXPORT_SYMBOL_GPL(spi_setup);
2531
90808738 2532static int __spi_validate(struct spi_device *spi, struct spi_message *message)
cf32b71e
ES		 2533{
2534 struct spi_master *master = spi->master;
e6811d1d 2535 struct spi_transfer *xfer;
6ea31293 2536 int w_size;
cf32b71e 2537
24a0013a
MB		 2538 if (list_empty(&message->transfers))
2539 return -EINVAL;
24a0013a 2540
cf32b71e
ES		 2541 /* Half-duplex links include original MicroWire, and ones with
2542 * only one data pin like SPI_3WIRE (switches direction) or where
2543 * either MOSI or MISO is missing. They can also be caused by
2544 * software limitations.
2545 */
2546 if ((master->flags & SPI_MASTER_HALF_DUPLEX)
2547 || (spi->mode & SPI_3WIRE)) {
cf32b71e
ES		 2548 unsigned flags = master->flags;
2549
2550 list_for_each_entry(xfer, &message->transfers, transfer_list) {
2551 if (xfer->rx_buf && xfer->tx_buf)
2552 return -EINVAL;
2553 if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
2554 return -EINVAL;
2555 if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
2556 return -EINVAL;
2557 }
2558 }
2559
e6811d1d 2560 /**
059b8ffe
LD		 2561 * Set transfer bits_per_word and max speed as spi device default if
2562 * it is not set for this transfer.
f477b7fb 2563 * Set transfer tx_nbits and rx_nbits as single transfer default
2564 * (SPI_NBITS_SINGLE) if it is not set for this transfer.
e6811d1d 2565 */
77e80588 2566 message->frame_length = 0;
e6811d1d 2567 list_for_each_entry(xfer, &message->transfers, transfer_list) {
078726ce 2568 message->frame_length += xfer->len;
e6811d1d
LD		 2569 if (!xfer->bits_per_word)
2570 xfer->bits_per_word = spi->bits_per_word;
a6f87fad
AL		 2571
2572 if (!xfer->speed_hz)
059b8ffe 2573 xfer->speed_hz = spi->max_speed_hz;
7dc9fbc3
MB		 2574 if (!xfer->speed_hz)
2575 xfer->speed_hz = master->max_speed_hz;
a6f87fad
AL		 2576
2577 if (master->max_speed_hz &&
2578 xfer->speed_hz > master->max_speed_hz)
2579 xfer->speed_hz = master->max_speed_hz;
56ede94a 2580
63ab645f
SB		 2581 if (__spi_validate_bits_per_word(master, xfer->bits_per_word))
2582 return -EINVAL;
a2fd4f9f 2583
4d94bd21
II		 2584 /*
2585 * SPI transfer length should be multiple of SPI word size
2586 * where SPI word size should be power-of-two multiple
2587 */
2588 if (xfer->bits_per_word <= 8)
2589 w_size = 1;
2590 else if (xfer->bits_per_word <= 16)
2591 w_size = 2;
2592 else
2593 w_size = 4;
2594
4d94bd21 2595 /* No partial transfers accepted */
6ea31293 2596 if (xfer->len % w_size)
4d94bd21
II		 2597 return -EINVAL;
2598
a2fd4f9f
MB		 2599 if (xfer->speed_hz && master->min_speed_hz &&
2600 xfer->speed_hz < master->min_speed_hz)
2601 return -EINVAL;
f477b7fb 2602
2603 if (xfer->tx_buf && !xfer->tx_nbits)
2604 xfer->tx_nbits = SPI_NBITS_SINGLE;
2605 if (xfer->rx_buf && !xfer->rx_nbits)
2606 xfer->rx_nbits = SPI_NBITS_SINGLE;
2607 /* check transfer tx/rx_nbits:
1afd9989
GU		 2608 * 1. check the value matches one of single, dual and quad
2609 * 2. check tx/rx_nbits match the mode in spi_device
f477b7fb 2610 */
db90a441
SP		 2611 if (xfer->tx_buf) {
2612 if (xfer->tx_nbits != SPI_NBITS_SINGLE &&
2613 xfer->tx_nbits != SPI_NBITS_DUAL &&
2614 xfer->tx_nbits != SPI_NBITS_QUAD)
2615 return -EINVAL;
2616 if ((xfer->tx_nbits == SPI_NBITS_DUAL) &&
2617 !(spi->mode & (SPI_TX_DUAL | SPI_TX_QUAD)))
2618 return -EINVAL;
2619 if ((xfer->tx_nbits == SPI_NBITS_QUAD) &&
2620 !(spi->mode & SPI_TX_QUAD))
2621 return -EINVAL;
db90a441 2622 }
f477b7fb 2623 /* check transfer rx_nbits */
db90a441
SP		 2624 if (xfer->rx_buf) {
2625 if (xfer->rx_nbits != SPI_NBITS_SINGLE &&
2626 xfer->rx_nbits != SPI_NBITS_DUAL &&
2627 xfer->rx_nbits != SPI_NBITS_QUAD)
2628 return -EINVAL;
2629 if ((xfer->rx_nbits == SPI_NBITS_DUAL) &&
2630 !(spi->mode & (SPI_RX_DUAL | SPI_RX_QUAD)))
2631 return -EINVAL;
2632 if ((xfer->rx_nbits == SPI_NBITS_QUAD) &&
2633 !(spi->mode & SPI_RX_QUAD))
2634 return -EINVAL;
db90a441 2635 }
e6811d1d
LD		 2636 }
2637
cf32b71e 2638 message->status = -EINPROGRESS;
90808738
MB		 2639
2640 return 0;
2641}
2642
2643static int __spi_async(struct spi_device *spi, struct spi_message *message)
2644{
2645 struct spi_master *master = spi->master;
2646
2647 message->spi = spi;
2648
eca2ebc7
MS		 2649 SPI_STATISTICS_INCREMENT_FIELD(&master->statistics, spi_async);
2650 SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_async);
2651
90808738
MB		 2652 trace_spi_message_submit(message);
2653
cf32b71e
ES		 2654 return master->transfer(spi, message);
2655}
2656
568d0697
DB		 2657/**
2658 * spi_async - asynchronous SPI transfer
2659 * @spi: device with which data will be exchanged
2660 * @message: describes the data transfers, including completion callback
2661 * Context: any (irqs may be blocked, etc)
2662 *
2663 * This call may be used in_irq and other contexts which can't sleep,
2664 * as well as from task contexts which can sleep.
2665 *
2666 * The completion callback is invoked in a context which can't sleep.
2667 * Before that invocation, the value of message->status is undefined.
2668 * When the callback is issued, message->status holds either zero (to
2669 * indicate complete success) or a negative error code. After that
2670 * callback returns, the driver which issued the transfer request may
2671 * deallocate the associated memory; it's no longer in use by any SPI
2672 * core or controller driver code.
2673 *
2674 * Note that although all messages to a spi_device are handled in
2675 * FIFO order, messages may go to different devices in other orders.
2676 * Some device might be higher priority, or have various "hard" access
2677 * time requirements, for example.
2678 *
2679 * On detection of any fault during the transfer, processing of
2680 * the entire message is aborted, and the device is deselected.
2681 * Until returning from the associated message completion callback,
2682 * no other spi_message queued to that device will be processed.
2683 * (This rule applies equally to all the synchronous transfer calls,
2684 * which are wrappers around this core asynchronous primitive.)
97d56dc6
JMC		 2685 *
2686 * Return: zero on success, else a negative error code.
568d0697
DB		 2687 */
2688int spi_async(struct spi_device *spi, struct spi_message *message)
2689{
2690 struct spi_master *master = spi->master;
cf32b71e
ES		 2691 int ret;
2692 unsigned long flags;
568d0697 2693
90808738
MB		 2694 ret = __spi_validate(spi, message);
2695 if (ret != 0)
2696 return ret;
2697
cf32b71e 2698 spin_lock_irqsave(&master->bus_lock_spinlock, flags);
568d0697 2699
cf32b71e
ES		 2700 if (master->bus_lock_flag)
2701 ret = -EBUSY;
2702 else
2703 ret = __spi_async(spi, message);
568d0697 2704
cf32b71e
ES		 2705 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
2706
2707 return ret;
568d0697
DB		 2708}
2709EXPORT_SYMBOL_GPL(spi_async);
2710
cf32b71e
ES		 2711/**
2712 * spi_async_locked - version of spi_async with exclusive bus usage
2713 * @spi: device with which data will be exchanged
2714 * @message: describes the data transfers, including completion callback
2715 * Context: any (irqs may be blocked, etc)
2716 *
2717 * This call may be used in_irq and other contexts which can't sleep,
2718 * as well as from task contexts which can sleep.
2719 *
2720 * The completion callback is invoked in a context which can't sleep.
2721 * Before that invocation, the value of message->status is undefined.
2722 * When the callback is issued, message->status holds either zero (to
2723 * indicate complete success) or a negative error code. After that
2724 * callback returns, the driver which issued the transfer request may
2725 * deallocate the associated memory; it's no longer in use by any SPI
2726 * core or controller driver code.
2727 *
2728 * Note that although all messages to a spi_device are handled in
2729 * FIFO order, messages may go to different devices in other orders.
2730 * Some device might be higher priority, or have various "hard" access
2731 * time requirements, for example.
2732 *
2733 * On detection of any fault during the transfer, processing of
2734 * the entire message is aborted, and the device is deselected.
2735 * Until returning from the associated message completion callback,
2736 * no other spi_message queued to that device will be processed.
2737 * (This rule applies equally to all the synchronous transfer calls,
2738 * which are wrappers around this core asynchronous primitive.)
97d56dc6
JMC		 2739 *
2740 * Return: zero on success, else a negative error code.
cf32b71e
ES		 2741 */
2742int spi_async_locked(struct spi_device *spi, struct spi_message *message)
2743{
2744 struct spi_master *master = spi->master;
2745 int ret;
2746 unsigned long flags;
2747
90808738
MB		 2748 ret = __spi_validate(spi, message);
2749 if (ret != 0)
2750 return ret;
2751
cf32b71e
ES		 2752 spin_lock_irqsave(&master->bus_lock_spinlock, flags);
2753
2754 ret = __spi_async(spi, message);
2755
2756 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
2757
2758 return ret;
2759
2760}
2761EXPORT_SYMBOL_GPL(spi_async_locked);
2762
7d077197 2763
556351f1
V		 2764int spi_flash_read(struct spi_device *spi,
2765 struct spi_flash_read_message *msg)
2766
2767{
2768 struct spi_master *master = spi->master;
f4502dd1 2769 struct device *rx_dev = NULL;
556351f1
V		 2770 int ret;
2771
2772 if ((msg->opcode_nbits == SPI_NBITS_DUAL ||
2773 msg->addr_nbits == SPI_NBITS_DUAL) &&
2774 !(spi->mode & (SPI_TX_DUAL | SPI_TX_QUAD)))
2775 return -EINVAL;
2776 if ((msg->opcode_nbits == SPI_NBITS_QUAD ||
2777 msg->addr_nbits == SPI_NBITS_QUAD) &&
2778 !(spi->mode & SPI_TX_QUAD))
2779 return -EINVAL;
2780 if (msg->data_nbits == SPI_NBITS_DUAL &&
2781 !(spi->mode & (SPI_RX_DUAL | SPI_RX_QUAD)))
2782 return -EINVAL;
2783 if (msg->data_nbits == SPI_NBITS_QUAD &&
2784 !(spi->mode & SPI_RX_QUAD))
2785 return -EINVAL;
2786
2787 if (master->auto_runtime_pm) {
2788 ret = pm_runtime_get_sync(master->dev.parent);
2789 if (ret < 0) {
2790 dev_err(&master->dev, "Failed to power device: %d\n",
2791 ret);
2792 return ret;
2793 }
2794 }
f4502dd1 2795
556351f1 2796 mutex_lock(&master->bus_lock_mutex);
ef4d96ec 2797 mutex_lock(&master->io_mutex);
f4502dd1
V		 2798 if (master->dma_rx) {
2799 rx_dev = master->dma_rx->device->dev;
2800 ret = spi_map_buf(master, rx_dev, &msg->rx_sg,
2801 msg->buf, msg->len,
2802 DMA_FROM_DEVICE);
2803 if (!ret)
2804 msg->cur_msg_mapped = true;
2805 }
556351f1 2806 ret = master->spi_flash_read(spi, msg);
f4502dd1
V		 2807 if (msg->cur_msg_mapped)
2808 spi_unmap_buf(master, rx_dev, &msg->rx_sg,
2809 DMA_FROM_DEVICE);
ef4d96ec 2810 mutex_unlock(&master->io_mutex);
556351f1 2811 mutex_unlock(&master->bus_lock_mutex);
f4502dd1 2812
556351f1
V		 2813 if (master->auto_runtime_pm)
2814 pm_runtime_put(master->dev.parent);
2815
2816 return ret;
2817}
2818EXPORT_SYMBOL_GPL(spi_flash_read);
2819
7d077197
DB		 2820/*-------------------------------------------------------------------------*/
2821
2822/* Utility methods for SPI master protocol drivers, layered on
2823 * top of the core. Some other utility methods are defined as
2824 * inline functions.
2825 */
2826
5d870c8e
AM		 2827static void spi_complete(void *arg)
2828{
2829 complete(arg);
2830}
2831
ef4d96ec 2832static int __spi_sync(struct spi_device *spi, struct spi_message *message)
cf32b71e
ES		 2833{
2834 DECLARE_COMPLETION_ONSTACK(done);
2835 int status;
2836 struct spi_master *master = spi->master;
0461a414
MB		 2837 unsigned long flags;
2838
2839 status = __spi_validate(spi, message);
2840 if (status != 0)
2841 return status;
cf32b71e
ES		 2842
2843 message->complete = spi_complete;
2844 message->context = &done;
0461a414 2845 message->spi = spi;
cf32b71e 2846
eca2ebc7
MS		 2847 SPI_STATISTICS_INCREMENT_FIELD(&master->statistics, spi_sync);
2848 SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_sync);
2849
0461a414
MB		 2850 /* If we're not using the legacy transfer method then we will
2851 * try to transfer in the calling context so special case.
2852 * This code would be less tricky if we could remove the
2853 * support for driver implemented message queues.
2854 */
2855 if (master->transfer == spi_queued_transfer) {
2856 spin_lock_irqsave(&master->bus_lock_spinlock, flags);
2857
2858 trace_spi_message_submit(message);
2859
2860 status = __spi_queued_transfer(spi, message, false);
2861
2862 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
2863 } else {
2864 status = spi_async_locked(spi, message);
2865 }
cf32b71e 2866
cf32b71e 2867 if (status == 0) {
0461a414
MB		 2868 /* Push out the messages in the calling context if we
2869 * can.
2870 */
eca2ebc7
MS		 2871 if (master->transfer == spi_queued_transfer) {
2872 SPI_STATISTICS_INCREMENT_FIELD(&master->statistics,
2873 spi_sync_immediate);
2874 SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics,
2875 spi_sync_immediate);
ef4d96ec 2876 __spi_pump_messages(master, false);
eca2ebc7 2877 }
0461a414 2878
cf32b71e
ES		 2879 wait_for_completion(&done);
2880 status = message->status;
2881 }
2882 message->context = NULL;
2883 return status;
2884}
2885
8ae12a0d
DB		 2886/**
2887 * spi_sync - blocking/synchronous SPI data transfers
2888 * @spi: device with which data will be exchanged
2889 * @message: describes the data transfers
33e34dc6 2890 * Context: can sleep
8ae12a0d
DB		 2891 *
2892 * This call may only be used from a context that may sleep. The sleep
2893 * is non-interruptible, and has no timeout. Low-overhead controller
2894 * drivers may DMA directly into and out of the message buffers.
2895 *
2896 * Note that the SPI device's chip select is active during the message,
2897 * and then is normally disabled between messages. Drivers for some
2898 * frequently-used devices may want to minimize costs of selecting a chip,
2899 * by leaving it selected in anticipation that the next message will go
2900 * to the same chip. (That may increase power usage.)
2901 *
0c868461
DB		 2902 * Also, the caller is guaranteeing that the memory associated with the
2903 * message will not be freed before this call returns.
2904 *
97d56dc6 2905 * Return: zero on success, else a negative error code.
8ae12a0d
DB		 2906 */
2907int spi_sync(struct spi_device *spi, struct spi_message *message)
2908{
ef4d96ec
MB		 2909 int ret;
2910
2911 mutex_lock(&spi->master->bus_lock_mutex);
2912 ret = __spi_sync(spi, message);
2913 mutex_unlock(&spi->master->bus_lock_mutex);
2914
2915 return ret;
8ae12a0d
DB		 2916}
2917EXPORT_SYMBOL_GPL(spi_sync);
2918
cf32b71e
ES		 2919/**
2920 * spi_sync_locked - version of spi_sync with exclusive bus usage
2921 * @spi: device with which data will be exchanged
2922 * @message: describes the data transfers
2923 * Context: can sleep
2924 *
2925 * This call may only be used from a context that may sleep. The sleep
2926 * is non-interruptible, and has no timeout. Low-overhead controller
2927 * drivers may DMA directly into and out of the message buffers.
2928 *
2929 * This call should be used by drivers that require exclusive access to the
25985edc 2930 * SPI bus. It has to be preceded by a spi_bus_lock call. The SPI bus must
cf32b71e
ES		 2931 * be released by a spi_bus_unlock call when the exclusive access is over.
2932 *
97d56dc6 2933 * Return: zero on success, else a negative error code.
cf32b71e
ES		 2934 */
2935int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
2936{
ef4d96ec 2937 return __spi_sync(spi, message);
cf32b71e
ES		 2938}
2939EXPORT_SYMBOL_GPL(spi_sync_locked);
2940
2941/**
2942 * spi_bus_lock - obtain a lock for exclusive SPI bus usage
2943 * @master: SPI bus master that should be locked for exclusive bus access
2944 * Context: can sleep
2945 *
2946 * This call may only be used from a context that may sleep. The sleep
2947 * is non-interruptible, and has no timeout.
2948 *
2949 * This call should be used by drivers that require exclusive access to the
2950 * SPI bus. The SPI bus must be released by a spi_bus_unlock call when the
2951 * exclusive access is over. Data transfer must be done by spi_sync_locked
2952 * and spi_async_locked calls when the SPI bus lock is held.
2953 *
97d56dc6 2954 * Return: always zero.
cf32b71e
ES		 2955 */
2956int spi_bus_lock(struct spi_master *master)
2957{
2958 unsigned long flags;
2959
2960 mutex_lock(&master->bus_lock_mutex);
2961
2962 spin_lock_irqsave(&master->bus_lock_spinlock, flags);
2963 master->bus_lock_flag = 1;
2964 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
2965
2966 /* mutex remains locked until spi_bus_unlock is called */
2967
2968 return 0;
2969}
2970EXPORT_SYMBOL_GPL(spi_bus_lock);
2971
2972/**
2973 * spi_bus_unlock - release the lock for exclusive SPI bus usage
2974 * @master: SPI bus master that was locked for exclusive bus access
2975 * Context: can sleep
2976 *
2977 * This call may only be used from a context that may sleep. The sleep
2978 * is non-interruptible, and has no timeout.
2979 *
2980 * This call releases an SPI bus lock previously obtained by an spi_bus_lock
2981 * call.
2982 *
97d56dc6 2983 * Return: always zero.
cf32b71e
ES		 2984 */
2985int spi_bus_unlock(struct spi_master *master)
2986{
2987 master->bus_lock_flag = 0;
2988
2989 mutex_unlock(&master->bus_lock_mutex);
2990
2991 return 0;
2992}
2993EXPORT_SYMBOL_GPL(spi_bus_unlock);
2994
a9948b61 2995/* portable code must never pass more than 32 bytes */
5fe5f05e 2996#define SPI_BUFSIZ max(32, SMP_CACHE_BYTES)
8ae12a0d
DB		 2997
2998static u8 *buf;
2999
3000/**
3001 * spi_write_then_read - SPI synchronous write followed by read
3002 * @spi: device with which data will be exchanged
3003 * @txbuf: data to be written (need not be dma-safe)
3004 * @n_tx: size of txbuf, in bytes
27570497
JP		 3005 * @rxbuf: buffer into which data will be read (need not be dma-safe)
3006 * @n_rx: size of rxbuf, in bytes
33e34dc6 3007 * Context: can sleep
8ae12a0d
DB		 3008 *
3009 * This performs a half duplex MicroWire style transaction with the
3010 * device, sending txbuf and then reading rxbuf. The return value
3011 * is zero for success, else a negative errno status code.
b885244e 3012 * This call may only be used from a context that may sleep.
8ae12a0d 3013 *
0c868461 3014 * Parameters to this routine are always copied using a small buffer;
33e34dc6
DB		 3015 * portable code should never use this for more than 32 bytes.
3016 * Performance-sensitive or bulk transfer code should instead use
0c868461 3017 * spi_{async,sync}() calls with dma-safe buffers.
97d56dc6
JMC		 3018 *
3019 * Return: zero on success, else a negative error code.
8ae12a0d
DB		 3020 */
3021int spi_write_then_read(struct spi_device *spi,
0c4a1590
MB		 3022 const void *txbuf, unsigned n_tx,
3023 void *rxbuf, unsigned n_rx)
8ae12a0d 3024{
068f4070 3025 static DEFINE_MUTEX(lock);
8ae12a0d
DB		 3026
3027 int status;
3028 struct spi_message message;
bdff549e 3029 struct spi_transfer x[2];
8ae12a0d
DB		 3030 u8 *local_buf;
3031
b3a223ee
MB		 3032 /* Use preallocated DMA-safe buffer if we can. We can't avoid
3033 * copying here, (as a pure convenience thing), but we can
3034 * keep heap costs out of the hot path unless someone else is
3035 * using the pre-allocated buffer or the transfer is too large.
8ae12a0d 3036 */
b3a223ee 3037 if ((n_tx + n_rx) > SPI_BUFSIZ || !mutex_trylock(&lock)) {
2cd94c8a
MB		 3038 local_buf = kmalloc(max((unsigned)SPI_BUFSIZ, n_tx + n_rx),
3039 GFP_KERNEL | GFP_DMA);
b3a223ee
MB		 3040 if (!local_buf)
3041 return -ENOMEM;
3042 } else {
3043 local_buf = buf;
3044 }
8ae12a0d 3045
8275c642 3046 spi_message_init(&message);
5fe5f05e 3047 memset(x, 0, sizeof(x));
bdff549e
DB		 3048 if (n_tx) {
3049 x[0].len = n_tx;
3050 spi_message_add_tail(&x[0], &message);
3051 }
3052 if (n_rx) {
3053 x[1].len = n_rx;
3054 spi_message_add_tail(&x[1], &message);
3055 }
8275c642 3056
8ae12a0d 3057 memcpy(local_buf, txbuf, n_tx);
bdff549e
DB		 3058 x[0].tx_buf = local_buf;
3059 x[1].rx_buf = local_buf + n_tx;
8ae12a0d
DB		 3060
3061 /* do the i/o */
8ae12a0d 3062 status = spi_sync(spi, &message);
9b938b74 3063 if (status == 0)
bdff549e 3064 memcpy(rxbuf, x[1].rx_buf, n_rx);
8ae12a0d 3065
bdff549e 3066 if (x[0].tx_buf == buf)
068f4070 3067 mutex_unlock(&lock);
8ae12a0d
DB		 3068 else
3069 kfree(local_buf);
3070
3071 return status;
3072}
3073EXPORT_SYMBOL_GPL(spi_write_then_read);
3074
3075/*-------------------------------------------------------------------------*/
3076
ce79d54a
PA		 3077#if IS_ENABLED(CONFIG_OF_DYNAMIC)
3078static int __spi_of_device_match(struct device *dev, void *data)
3079{
3080 return dev->of_node == data;
3081}
3082
3083/* must call put_device() when done with returned spi_device device */
3084static struct spi_device *of_find_spi_device_by_node(struct device_node *node)
3085{
3086 struct device *dev = bus_find_device(&spi_bus_type, NULL, node,
3087 __spi_of_device_match);
3088 return dev ? to_spi_device(dev) : NULL;
3089}
3090
3091static int __spi_of_master_match(struct device *dev, const void *data)
3092{
3093 return dev->of_node == data;
3094}
3095
3096/* the spi masters are not using spi_bus, so we find it with another way */
3097static struct spi_master *of_find_spi_master_by_node(struct device_node *node)
3098{
3099 struct device *dev;
3100
3101 dev = class_find_device(&spi_master_class, NULL, node,
3102 __spi_of_master_match);
3103 if (!dev)
3104 return NULL;
3105
3106 /* reference got in class_find_device */
3107 return container_of(dev, struct spi_master, dev);
3108}
3109
3110static int of_spi_notify(struct notifier_block *nb, unsigned long action,
3111 void *arg)
3112{
3113 struct of_reconfig_data *rd = arg;
3114 struct spi_master *master;
3115 struct spi_device *spi;
3116
3117 switch (of_reconfig_get_state_change(action, arg)) {
3118 case OF_RECONFIG_CHANGE_ADD:
3119 master = of_find_spi_master_by_node(rd->dn->parent);
3120 if (master == NULL)
3121 return NOTIFY_OK; /* not for us */
3122
bd6c1644
GU		 3123 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
3124 put_device(&master->dev);
3125 return NOTIFY_OK;
3126 }
3127
ce79d54a
PA		 3128 spi = of_register_spi_device(master, rd->dn);
3129 put_device(&master->dev);
3130
3131 if (IS_ERR(spi)) {
3132 pr_err("%s: failed to create for '%s'\n",
3133 __func__, rd->dn->full_name);
3134 return notifier_from_errno(PTR_ERR(spi));
3135 }
3136 break;
3137
3138 case OF_RECONFIG_CHANGE_REMOVE:
bd6c1644
GU		 3139 /* already depopulated? */
3140 if (!of_node_check_flag(rd->dn, OF_POPULATED))
3141 return NOTIFY_OK;
3142
ce79d54a
PA		 3143 /* find our device by node */
3144 spi = of_find_spi_device_by_node(rd->dn);
3145 if (spi == NULL)
3146 return NOTIFY_OK; /* no? not meant for us */
3147
3148 /* unregister takes one ref away */
3149 spi_unregister_device(spi);
3150
3151 /* and put the reference of the find */
3152 put_device(&spi->dev);
3153 break;
3154 }
3155
3156 return NOTIFY_OK;
3157}
3158
3159static struct notifier_block spi_of_notifier = {
3160 .notifier_call = of_spi_notify,
3161};
3162#else /* IS_ENABLED(CONFIG_OF_DYNAMIC) */
3163extern struct notifier_block spi_of_notifier;
3164#endif /* IS_ENABLED(CONFIG_OF_DYNAMIC) */
3165
7f24467f
OP		 3166#if IS_ENABLED(CONFIG_ACPI)
3167static int spi_acpi_master_match(struct device *dev, const void *data)
3168{
3169 return ACPI_COMPANION(dev->parent) == data;
3170}
3171
3172static int spi_acpi_device_match(struct device *dev, void *data)
3173{
3174 return ACPI_COMPANION(dev) == data;
3175}
3176
3177static struct spi_master *acpi_spi_find_master_by_adev(struct acpi_device *adev)
3178{
3179 struct device *dev;
3180
3181 dev = class_find_device(&spi_master_class, NULL, adev,
3182 spi_acpi_master_match);
3183 if (!dev)
3184 return NULL;
3185
3186 return container_of(dev, struct spi_master, dev);
3187}
3188
3189static struct spi_device *acpi_spi_find_device_by_adev(struct acpi_device *adev)
3190{
3191 struct device *dev;
3192
3193 dev = bus_find_device(&spi_bus_type, NULL, adev, spi_acpi_device_match);
3194
3195 return dev ? to_spi_device(dev) : NULL;
3196}
3197
3198static int acpi_spi_notify(struct notifier_block *nb, unsigned long value,
3199 void *arg)
3200{
3201 struct acpi_device *adev = arg;
3202 struct spi_master *master;
3203 struct spi_device *spi;
3204
3205 switch (value) {
3206 case ACPI_RECONFIG_DEVICE_ADD:
3207 master = acpi_spi_find_master_by_adev(adev->parent);
3208 if (!master)
3209 break;
3210
3211 acpi_register_spi_device(master, adev);
3212 put_device(&master->dev);
3213 break;
3214 case ACPI_RECONFIG_DEVICE_REMOVE:
3215 if (!acpi_device_enumerated(adev))
3216 break;
3217
3218 spi = acpi_spi_find_device_by_adev(adev);
3219 if (!spi)
3220 break;
3221
3222 spi_unregister_device(spi);
3223 put_device(&spi->dev);
3224 break;
3225 }
3226
3227 return NOTIFY_OK;
3228}
3229
3230static struct notifier_block spi_acpi_notifier = {
3231 .notifier_call = acpi_spi_notify,
3232};
3233#else
3234extern struct notifier_block spi_acpi_notifier;
3235#endif
3236
8ae12a0d
DB		 3237static int __init spi_init(void)
3238{
b885244e
DB		 3239 int status;
3240
e94b1766 3241 buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
b885244e
DB		 3242 if (!buf) {
3243 status = -ENOMEM;
3244 goto err0;
3245 }
3246
3247 status = bus_register(&spi_bus_type);
3248 if (status < 0)
3249 goto err1;
8ae12a0d 3250
b885244e
DB		 3251 status = class_register(&spi_master_class);
3252 if (status < 0)
3253 goto err2;
ce79d54a 3254
5267720e 3255 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
ce79d54a 3256 WARN_ON(of_reconfig_notifier_register(&spi_of_notifier));
7f24467f
OP		 3257 if (IS_ENABLED(CONFIG_ACPI))
3258 WARN_ON(acpi_reconfig_notifier_register(&spi_acpi_notifier));
ce79d54a 3259
8ae12a0d 3260 return 0;
b885244e
DB		 3261
3262err2:
3263 bus_unregister(&spi_bus_type);
3264err1:
3265 kfree(buf);
3266 buf = NULL;
3267err0:
3268 return status;
8ae12a0d 3269}
b885244e 3270
8ae12a0d
DB		 3271/* board_info is normally registered in arch_initcall(),
3272 * but even essential drivers wait till later
b885244e
DB		 3273 *
3274 * REVISIT only boardinfo really needs static linking. the rest (device and
3275 * driver registration) _could_ be dynamically linked (modular) ... costs
3276 * include needing to have boardinfo data structures be much more public.
8ae12a0d 3277 */
673c0c00 3278postcore_initcall(spi_init);
8ae12a0d 3279
Linux kernel - Deliverables
This page took 1.35065 seconds and 5 git commands to generate.