xref: /openbmc/linux/drivers/spi/spi.c (revision f17f06a0)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 // SPI init/core code
3 //
4 // Copyright (C) 2005 David Brownell
5 // Copyright (C) 2008 Secret Lab Technologies Ltd.
6 
7 #include <linux/kernel.h>
8 #include <linux/device.h>
9 #include <linux/init.h>
10 #include <linux/cache.h>
11 #include <linux/dma-mapping.h>
12 #include <linux/dmaengine.h>
13 #include <linux/mutex.h>
14 #include <linux/of_device.h>
15 #include <linux/of_irq.h>
16 #include <linux/clk/clk-conf.h>
17 #include <linux/slab.h>
18 #include <linux/mod_devicetable.h>
19 #include <linux/spi/spi.h>
20 #include <linux/spi/spi-mem.h>
21 #include <linux/of_gpio.h>
22 #include <linux/gpio/consumer.h>
23 #include <linux/pm_runtime.h>
24 #include <linux/pm_domain.h>
25 #include <linux/property.h>
26 #include <linux/export.h>
27 #include <linux/sched/rt.h>
28 #include <uapi/linux/sched/types.h>
29 #include <linux/delay.h>
30 #include <linux/kthread.h>
31 #include <linux/ioport.h>
32 #include <linux/acpi.h>
33 #include <linux/highmem.h>
34 #include <linux/idr.h>
35 #include <linux/platform_data/x86/apple.h>
36 
37 #define CREATE_TRACE_POINTS
38 #include <trace/events/spi.h>
39 EXPORT_TRACEPOINT_SYMBOL(spi_transfer_start);
40 EXPORT_TRACEPOINT_SYMBOL(spi_transfer_stop);
41 
42 #include "internals.h"
43 
44 static DEFINE_IDR(spi_master_idr);
45 
46 static void spidev_release(struct device *dev)
47 {
48 	struct spi_device	*spi = to_spi_device(dev);
49 
50 	/* spi controllers may cleanup for released devices */
51 	if (spi->controller->cleanup)
52 		spi->controller->cleanup(spi);
53 
54 	spi_controller_put(spi->controller);
55 	kfree(spi->driver_override);
56 	kfree(spi);
57 }
58 
59 static ssize_t
60 modalias_show(struct device *dev, struct device_attribute *a, char *buf)
61 {
62 	const struct spi_device	*spi = to_spi_device(dev);
63 	int len;
64 
65 	len = acpi_device_modalias(dev, buf, PAGE_SIZE - 1);
66 	if (len != -ENODEV)
67 		return len;
68 
69 	return sprintf(buf, "%s%s\n", SPI_MODULE_PREFIX, spi->modalias);
70 }
71 static DEVICE_ATTR_RO(modalias);
72 
73 static ssize_t driver_override_store(struct device *dev,
74 				     struct device_attribute *a,
75 				     const char *buf, size_t count)
76 {
77 	struct spi_device *spi = to_spi_device(dev);
78 	const char *end = memchr(buf, '\n', count);
79 	const size_t len = end ? end - buf : count;
80 	const char *driver_override, *old;
81 
82 	/* We need to keep extra room for a newline when displaying value */
83 	if (len >= (PAGE_SIZE - 1))
84 		return -EINVAL;
85 
86 	driver_override = kstrndup(buf, len, GFP_KERNEL);
87 	if (!driver_override)
88 		return -ENOMEM;
89 
90 	device_lock(dev);
91 	old = spi->driver_override;
92 	if (len) {
93 		spi->driver_override = driver_override;
94 	} else {
95 		/* Empty string, disable driver override */
96 		spi->driver_override = NULL;
97 		kfree(driver_override);
98 	}
99 	device_unlock(dev);
100 	kfree(old);
101 
102 	return count;
103 }
104 
105 static ssize_t driver_override_show(struct device *dev,
106 				    struct device_attribute *a, char *buf)
107 {
108 	const struct spi_device *spi = to_spi_device(dev);
109 	ssize_t len;
110 
111 	device_lock(dev);
112 	len = snprintf(buf, PAGE_SIZE, "%s\n", spi->driver_override ? : "");
113 	device_unlock(dev);
114 	return len;
115 }
116 static DEVICE_ATTR_RW(driver_override);
117 
118 #define SPI_STATISTICS_ATTRS(field, file)				\
119 static ssize_t spi_controller_##field##_show(struct device *dev,	\
120 					     struct device_attribute *attr, \
121 					     char *buf)			\
122 {									\
123 	struct spi_controller *ctlr = container_of(dev,			\
124 					 struct spi_controller, dev);	\
125 	return spi_statistics_##field##_show(&ctlr->statistics, buf);	\
126 }									\
127 static struct device_attribute dev_attr_spi_controller_##field = {	\
128 	.attr = { .name = file, .mode = 0444 },				\
129 	.show = spi_controller_##field##_show,				\
130 };									\
131 static ssize_t spi_device_##field##_show(struct device *dev,		\
132 					 struct device_attribute *attr,	\
133 					char *buf)			\
134 {									\
135 	struct spi_device *spi = to_spi_device(dev);			\
136 	return spi_statistics_##field##_show(&spi->statistics, buf);	\
137 }									\
138 static struct device_attribute dev_attr_spi_device_##field = {		\
139 	.attr = { .name = file, .mode = 0444 },				\
140 	.show = spi_device_##field##_show,				\
141 }
142 
143 #define SPI_STATISTICS_SHOW_NAME(name, file, field, format_string)	\
144 static ssize_t spi_statistics_##name##_show(struct spi_statistics *stat, \
145 					    char *buf)			\
146 {									\
147 	unsigned long flags;						\
148 	ssize_t len;							\
149 	spin_lock_irqsave(&stat->lock, flags);				\
150 	len = sprintf(buf, format_string, stat->field);			\
151 	spin_unlock_irqrestore(&stat->lock, flags);			\
152 	return len;							\
153 }									\
154 SPI_STATISTICS_ATTRS(name, file)
155 
156 #define SPI_STATISTICS_SHOW(field, format_string)			\
157 	SPI_STATISTICS_SHOW_NAME(field, __stringify(field),		\
158 				 field, format_string)
159 
160 SPI_STATISTICS_SHOW(messages, "%lu");
161 SPI_STATISTICS_SHOW(transfers, "%lu");
162 SPI_STATISTICS_SHOW(errors, "%lu");
163 SPI_STATISTICS_SHOW(timedout, "%lu");
164 
165 SPI_STATISTICS_SHOW(spi_sync, "%lu");
166 SPI_STATISTICS_SHOW(spi_sync_immediate, "%lu");
167 SPI_STATISTICS_SHOW(spi_async, "%lu");
168 
169 SPI_STATISTICS_SHOW(bytes, "%llu");
170 SPI_STATISTICS_SHOW(bytes_rx, "%llu");
171 SPI_STATISTICS_SHOW(bytes_tx, "%llu");
172 
173 #define SPI_STATISTICS_TRANSFER_BYTES_HISTO(index, number)		\
174 	SPI_STATISTICS_SHOW_NAME(transfer_bytes_histo##index,		\
175 				 "transfer_bytes_histo_" number,	\
176 				 transfer_bytes_histo[index],  "%lu")
177 SPI_STATISTICS_TRANSFER_BYTES_HISTO(0,  "0-1");
178 SPI_STATISTICS_TRANSFER_BYTES_HISTO(1,  "2-3");
179 SPI_STATISTICS_TRANSFER_BYTES_HISTO(2,  "4-7");
180 SPI_STATISTICS_TRANSFER_BYTES_HISTO(3,  "8-15");
181 SPI_STATISTICS_TRANSFER_BYTES_HISTO(4,  "16-31");
182 SPI_STATISTICS_TRANSFER_BYTES_HISTO(5,  "32-63");
183 SPI_STATISTICS_TRANSFER_BYTES_HISTO(6,  "64-127");
184 SPI_STATISTICS_TRANSFER_BYTES_HISTO(7,  "128-255");
185 SPI_STATISTICS_TRANSFER_BYTES_HISTO(8,  "256-511");
186 SPI_STATISTICS_TRANSFER_BYTES_HISTO(9,  "512-1023");
187 SPI_STATISTICS_TRANSFER_BYTES_HISTO(10, "1024-2047");
188 SPI_STATISTICS_TRANSFER_BYTES_HISTO(11, "2048-4095");
189 SPI_STATISTICS_TRANSFER_BYTES_HISTO(12, "4096-8191");
190 SPI_STATISTICS_TRANSFER_BYTES_HISTO(13, "8192-16383");
191 SPI_STATISTICS_TRANSFER_BYTES_HISTO(14, "16384-32767");
192 SPI_STATISTICS_TRANSFER_BYTES_HISTO(15, "32768-65535");
193 SPI_STATISTICS_TRANSFER_BYTES_HISTO(16, "65536+");
194 
195 SPI_STATISTICS_SHOW(transfers_split_maxsize, "%lu");
196 
197 static struct attribute *spi_dev_attrs[] = {
198 	&dev_attr_modalias.attr,
199 	&dev_attr_driver_override.attr,
200 	NULL,
201 };
202 
203 static const struct attribute_group spi_dev_group = {
204 	.attrs  = spi_dev_attrs,
205 };
206 
207 static struct attribute *spi_device_statistics_attrs[] = {
208 	&dev_attr_spi_device_messages.attr,
209 	&dev_attr_spi_device_transfers.attr,
210 	&dev_attr_spi_device_errors.attr,
211 	&dev_attr_spi_device_timedout.attr,
212 	&dev_attr_spi_device_spi_sync.attr,
213 	&dev_attr_spi_device_spi_sync_immediate.attr,
214 	&dev_attr_spi_device_spi_async.attr,
215 	&dev_attr_spi_device_bytes.attr,
216 	&dev_attr_spi_device_bytes_rx.attr,
217 	&dev_attr_spi_device_bytes_tx.attr,
218 	&dev_attr_spi_device_transfer_bytes_histo0.attr,
219 	&dev_attr_spi_device_transfer_bytes_histo1.attr,
220 	&dev_attr_spi_device_transfer_bytes_histo2.attr,
221 	&dev_attr_spi_device_transfer_bytes_histo3.attr,
222 	&dev_attr_spi_device_transfer_bytes_histo4.attr,
223 	&dev_attr_spi_device_transfer_bytes_histo5.attr,
224 	&dev_attr_spi_device_transfer_bytes_histo6.attr,
225 	&dev_attr_spi_device_transfer_bytes_histo7.attr,
226 	&dev_attr_spi_device_transfer_bytes_histo8.attr,
227 	&dev_attr_spi_device_transfer_bytes_histo9.attr,
228 	&dev_attr_spi_device_transfer_bytes_histo10.attr,
229 	&dev_attr_spi_device_transfer_bytes_histo11.attr,
230 	&dev_attr_spi_device_transfer_bytes_histo12.attr,
231 	&dev_attr_spi_device_transfer_bytes_histo13.attr,
232 	&dev_attr_spi_device_transfer_bytes_histo14.attr,
233 	&dev_attr_spi_device_transfer_bytes_histo15.attr,
234 	&dev_attr_spi_device_transfer_bytes_histo16.attr,
235 	&dev_attr_spi_device_transfers_split_maxsize.attr,
236 	NULL,
237 };
238 
239 static const struct attribute_group spi_device_statistics_group = {
240 	.name  = "statistics",
241 	.attrs  = spi_device_statistics_attrs,
242 };
243 
244 static const struct attribute_group *spi_dev_groups[] = {
245 	&spi_dev_group,
246 	&spi_device_statistics_group,
247 	NULL,
248 };
249 
250 static struct attribute *spi_controller_statistics_attrs[] = {
251 	&dev_attr_spi_controller_messages.attr,
252 	&dev_attr_spi_controller_transfers.attr,
253 	&dev_attr_spi_controller_errors.attr,
254 	&dev_attr_spi_controller_timedout.attr,
255 	&dev_attr_spi_controller_spi_sync.attr,
256 	&dev_attr_spi_controller_spi_sync_immediate.attr,
257 	&dev_attr_spi_controller_spi_async.attr,
258 	&dev_attr_spi_controller_bytes.attr,
259 	&dev_attr_spi_controller_bytes_rx.attr,
260 	&dev_attr_spi_controller_bytes_tx.attr,
261 	&dev_attr_spi_controller_transfer_bytes_histo0.attr,
262 	&dev_attr_spi_controller_transfer_bytes_histo1.attr,
263 	&dev_attr_spi_controller_transfer_bytes_histo2.attr,
264 	&dev_attr_spi_controller_transfer_bytes_histo3.attr,
265 	&dev_attr_spi_controller_transfer_bytes_histo4.attr,
266 	&dev_attr_spi_controller_transfer_bytes_histo5.attr,
267 	&dev_attr_spi_controller_transfer_bytes_histo6.attr,
268 	&dev_attr_spi_controller_transfer_bytes_histo7.attr,
269 	&dev_attr_spi_controller_transfer_bytes_histo8.attr,
270 	&dev_attr_spi_controller_transfer_bytes_histo9.attr,
271 	&dev_attr_spi_controller_transfer_bytes_histo10.attr,
272 	&dev_attr_spi_controller_transfer_bytes_histo11.attr,
273 	&dev_attr_spi_controller_transfer_bytes_histo12.attr,
274 	&dev_attr_spi_controller_transfer_bytes_histo13.attr,
275 	&dev_attr_spi_controller_transfer_bytes_histo14.attr,
276 	&dev_attr_spi_controller_transfer_bytes_histo15.attr,
277 	&dev_attr_spi_controller_transfer_bytes_histo16.attr,
278 	&dev_attr_spi_controller_transfers_split_maxsize.attr,
279 	NULL,
280 };
281 
282 static const struct attribute_group spi_controller_statistics_group = {
283 	.name  = "statistics",
284 	.attrs  = spi_controller_statistics_attrs,
285 };
286 
287 static const struct attribute_group *spi_master_groups[] = {
288 	&spi_controller_statistics_group,
289 	NULL,
290 };
291 
292 void spi_statistics_add_transfer_stats(struct spi_statistics *stats,
293 				       struct spi_transfer *xfer,
294 				       struct spi_controller *ctlr)
295 {
296 	unsigned long flags;
297 	int l2len = min(fls(xfer->len), SPI_STATISTICS_HISTO_SIZE) - 1;
298 
299 	if (l2len < 0)
300 		l2len = 0;
301 
302 	spin_lock_irqsave(&stats->lock, flags);
303 
304 	stats->transfers++;
305 	stats->transfer_bytes_histo[l2len]++;
306 
307 	stats->bytes += xfer->len;
308 	if ((xfer->tx_buf) &&
309 	    (xfer->tx_buf != ctlr->dummy_tx))
310 		stats->bytes_tx += xfer->len;
311 	if ((xfer->rx_buf) &&
312 	    (xfer->rx_buf != ctlr->dummy_rx))
313 		stats->bytes_rx += xfer->len;
314 
315 	spin_unlock_irqrestore(&stats->lock, flags);
316 }
317 EXPORT_SYMBOL_GPL(spi_statistics_add_transfer_stats);
318 
319 /* modalias support makes "modprobe $MODALIAS" new-style hotplug work,
320  * and the sysfs version makes coldplug work too.
321  */
322 
323 static const struct spi_device_id *spi_match_id(const struct spi_device_id *id,
324 						const struct spi_device *sdev)
325 {
326 	while (id->name[0]) {
327 		if (!strcmp(sdev->modalias, id->name))
328 			return id;
329 		id++;
330 	}
331 	return NULL;
332 }
333 
334 const struct spi_device_id *spi_get_device_id(const struct spi_device *sdev)
335 {
336 	const struct spi_driver *sdrv = to_spi_driver(sdev->dev.driver);
337 
338 	return spi_match_id(sdrv->id_table, sdev);
339 }
340 EXPORT_SYMBOL_GPL(spi_get_device_id);
341 
342 static int spi_match_device(struct device *dev, struct device_driver *drv)
343 {
344 	const struct spi_device	*spi = to_spi_device(dev);
345 	const struct spi_driver	*sdrv = to_spi_driver(drv);
346 
347 	/* Check override first, and if set, only use the named driver */
348 	if (spi->driver_override)
349 		return strcmp(spi->driver_override, drv->name) == 0;
350 
351 	/* Attempt an OF style match */
352 	if (of_driver_match_device(dev, drv))
353 		return 1;
354 
355 	/* Then try ACPI */
356 	if (acpi_driver_match_device(dev, drv))
357 		return 1;
358 
359 	if (sdrv->id_table)
360 		return !!spi_match_id(sdrv->id_table, spi);
361 
362 	return strcmp(spi->modalias, drv->name) == 0;
363 }
364 
365 static int spi_uevent(struct device *dev, struct kobj_uevent_env *env)
366 {
367 	const struct spi_device		*spi = to_spi_device(dev);
368 	int rc;
369 
370 	rc = acpi_device_uevent_modalias(dev, env);
371 	if (rc != -ENODEV)
372 		return rc;
373 
374 	return add_uevent_var(env, "MODALIAS=%s%s", SPI_MODULE_PREFIX, spi->modalias);
375 }
376 
377 struct bus_type spi_bus_type = {
378 	.name		= "spi",
379 	.dev_groups	= spi_dev_groups,
380 	.match		= spi_match_device,
381 	.uevent		= spi_uevent,
382 };
383 EXPORT_SYMBOL_GPL(spi_bus_type);
384 
385 
386 static int spi_drv_probe(struct device *dev)
387 {
388 	const struct spi_driver		*sdrv = to_spi_driver(dev->driver);
389 	struct spi_device		*spi = to_spi_device(dev);
390 	int ret;
391 
392 	ret = of_clk_set_defaults(dev->of_node, false);
393 	if (ret)
394 		return ret;
395 
396 	if (dev->of_node) {
397 		spi->irq = of_irq_get(dev->of_node, 0);
398 		if (spi->irq == -EPROBE_DEFER)
399 			return -EPROBE_DEFER;
400 		if (spi->irq < 0)
401 			spi->irq = 0;
402 	}
403 
404 	ret = dev_pm_domain_attach(dev, true);
405 	if (ret)
406 		return ret;
407 
408 	ret = sdrv->probe(spi);
409 	if (ret)
410 		dev_pm_domain_detach(dev, true);
411 
412 	return ret;
413 }
414 
415 static int spi_drv_remove(struct device *dev)
416 {
417 	const struct spi_driver		*sdrv = to_spi_driver(dev->driver);
418 	int ret;
419 
420 	ret = sdrv->remove(to_spi_device(dev));
421 	dev_pm_domain_detach(dev, true);
422 
423 	return ret;
424 }
425 
426 static void spi_drv_shutdown(struct device *dev)
427 {
428 	const struct spi_driver		*sdrv = to_spi_driver(dev->driver);
429 
430 	sdrv->shutdown(to_spi_device(dev));
431 }
432 
433 /**
434  * __spi_register_driver - register a SPI driver
435  * @owner: owner module of the driver to register
436  * @sdrv: the driver to register
437  * Context: can sleep
438  *
439  * Return: zero on success, else a negative error code.
440  */
441 int __spi_register_driver(struct module *owner, struct spi_driver *sdrv)
442 {
443 	sdrv->driver.owner = owner;
444 	sdrv->driver.bus = &spi_bus_type;
445 	if (sdrv->probe)
446 		sdrv->driver.probe = spi_drv_probe;
447 	if (sdrv->remove)
448 		sdrv->driver.remove = spi_drv_remove;
449 	if (sdrv->shutdown)
450 		sdrv->driver.shutdown = spi_drv_shutdown;
451 	return driver_register(&sdrv->driver);
452 }
453 EXPORT_SYMBOL_GPL(__spi_register_driver);
454 
455 /*-------------------------------------------------------------------------*/
456 
457 /* SPI devices should normally not be created by SPI device drivers; that
458  * would make them board-specific.  Similarly with SPI controller drivers.
459  * Device registration normally goes into like arch/.../mach.../board-YYY.c
460  * with other readonly (flashable) information about mainboard devices.
461  */
462 
463 struct boardinfo {
464 	struct list_head	list;
465 	struct spi_board_info	board_info;
466 };
467 
468 static LIST_HEAD(board_list);
469 static LIST_HEAD(spi_controller_list);
470 
471 /*
472  * Used to protect add/del operation for board_info list and
473  * spi_controller list, and their matching process
474  * also used to protect object of type struct idr
475  */
476 static DEFINE_MUTEX(board_lock);
477 
478 /**
479  * spi_alloc_device - Allocate a new SPI device
480  * @ctlr: Controller to which device is connected
481  * Context: can sleep
482  *
483  * Allows a driver to allocate and initialize a spi_device without
484  * registering it immediately.  This allows a driver to directly
485  * fill the spi_device with device parameters before calling
486  * spi_add_device() on it.
487  *
488  * Caller is responsible to call spi_add_device() on the returned
489  * spi_device structure to add it to the SPI controller.  If the caller
490  * needs to discard the spi_device without adding it, then it should
491  * call spi_dev_put() on it.
492  *
493  * Return: a pointer to the new device, or NULL.
494  */
495 struct spi_device *spi_alloc_device(struct spi_controller *ctlr)
496 {
497 	struct spi_device	*spi;
498 
499 	if (!spi_controller_get(ctlr))
500 		return NULL;
501 
502 	spi = kzalloc(sizeof(*spi), GFP_KERNEL);
503 	if (!spi) {
504 		spi_controller_put(ctlr);
505 		return NULL;
506 	}
507 
508 	spi->master = spi->controller = ctlr;
509 	spi->dev.parent = &ctlr->dev;
510 	spi->dev.bus = &spi_bus_type;
511 	spi->dev.release = spidev_release;
512 	spi->cs_gpio = -ENOENT;
513 
514 	spin_lock_init(&spi->statistics.lock);
515 
516 	device_initialize(&spi->dev);
517 	return spi;
518 }
519 EXPORT_SYMBOL_GPL(spi_alloc_device);
520 
521 static void spi_dev_set_name(struct spi_device *spi)
522 {
523 	struct acpi_device *adev = ACPI_COMPANION(&spi->dev);
524 
525 	if (adev) {
526 		dev_set_name(&spi->dev, "spi-%s", acpi_dev_name(adev));
527 		return;
528 	}
529 
530 	dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->controller->dev),
531 		     spi->chip_select);
532 }
533 
534 static int spi_dev_check(struct device *dev, void *data)
535 {
536 	struct spi_device *spi = to_spi_device(dev);
537 	struct spi_device *new_spi = data;
538 
539 	if (spi->controller == new_spi->controller &&
540 	    spi->chip_select == new_spi->chip_select)
541 		return -EBUSY;
542 	return 0;
543 }
544 
545 /**
546  * spi_add_device - Add spi_device allocated with spi_alloc_device
547  * @spi: spi_device to register
548  *
549  * Companion function to spi_alloc_device.  Devices allocated with
550  * spi_alloc_device can be added onto the spi bus with this function.
551  *
552  * Return: 0 on success; negative errno on failure
553  */
554 int spi_add_device(struct spi_device *spi)
555 {
556 	static DEFINE_MUTEX(spi_add_lock);
557 	struct spi_controller *ctlr = spi->controller;
558 	struct device *dev = ctlr->dev.parent;
559 	int status;
560 
561 	/* Chipselects are numbered 0..max; validate. */
562 	if (spi->chip_select >= ctlr->num_chipselect) {
563 		dev_err(dev, "cs%d >= max %d\n", spi->chip_select,
564 			ctlr->num_chipselect);
565 		return -EINVAL;
566 	}
567 
568 	/* Set the bus ID string */
569 	spi_dev_set_name(spi);
570 
571 	/* We need to make sure there's no other device with this
572 	 * chipselect **BEFORE** we call setup(), else we'll trash
573 	 * its configuration.  Lock against concurrent add() calls.
574 	 */
575 	mutex_lock(&spi_add_lock);
576 
577 	status = bus_for_each_dev(&spi_bus_type, NULL, spi, spi_dev_check);
578 	if (status) {
579 		dev_err(dev, "chipselect %d already in use\n",
580 				spi->chip_select);
581 		goto done;
582 	}
583 
584 	/* Descriptors take precedence */
585 	if (ctlr->cs_gpiods)
586 		spi->cs_gpiod = ctlr->cs_gpiods[spi->chip_select];
587 	else if (ctlr->cs_gpios)
588 		spi->cs_gpio = ctlr->cs_gpios[spi->chip_select];
589 
590 	/* Drivers may modify this initial i/o setup, but will
591 	 * normally rely on the device being setup.  Devices
592 	 * using SPI_CS_HIGH can't coexist well otherwise...
593 	 */
594 	status = spi_setup(spi);
595 	if (status < 0) {
596 		dev_err(dev, "can't setup %s, status %d\n",
597 				dev_name(&spi->dev), status);
598 		goto done;
599 	}
600 
601 	/* Device may be bound to an active driver when this returns */
602 	status = device_add(&spi->dev);
603 	if (status < 0)
604 		dev_err(dev, "can't add %s, status %d\n",
605 				dev_name(&spi->dev), status);
606 	else
607 		dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));
608 
609 done:
610 	mutex_unlock(&spi_add_lock);
611 	return status;
612 }
613 EXPORT_SYMBOL_GPL(spi_add_device);
614 
615 /**
616  * spi_new_device - instantiate one new SPI device
617  * @ctlr: Controller to which device is connected
618  * @chip: Describes the SPI device
619  * Context: can sleep
620  *
621  * On typical mainboards, this is purely internal; and it's not needed
622  * after board init creates the hard-wired devices.  Some development
623  * platforms may not be able to use spi_register_board_info though, and
624  * this is exported so that for example a USB or parport based adapter
625  * driver could add devices (which it would learn about out-of-band).
626  *
627  * Return: the new device, or NULL.
628  */
629 struct spi_device *spi_new_device(struct spi_controller *ctlr,
630 				  struct spi_board_info *chip)
631 {
632 	struct spi_device	*proxy;
633 	int			status;
634 
635 	/* NOTE:  caller did any chip->bus_num checks necessary.
636 	 *
637 	 * Also, unless we change the return value convention to use
638 	 * error-or-pointer (not NULL-or-pointer), troubleshootability
639 	 * suggests syslogged diagnostics are best here (ugh).
640 	 */
641 
642 	proxy = spi_alloc_device(ctlr);
643 	if (!proxy)
644 		return NULL;
645 
646 	WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
647 
648 	proxy->chip_select = chip->chip_select;
649 	proxy->max_speed_hz = chip->max_speed_hz;
650 	proxy->mode = chip->mode;
651 	proxy->irq = chip->irq;
652 	strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));
653 	proxy->dev.platform_data = (void *) chip->platform_data;
654 	proxy->controller_data = chip->controller_data;
655 	proxy->controller_state = NULL;
656 
657 	if (chip->properties) {
658 		status = device_add_properties(&proxy->dev, chip->properties);
659 		if (status) {
660 			dev_err(&ctlr->dev,
661 				"failed to add properties to '%s': %d\n",
662 				chip->modalias, status);
663 			goto err_dev_put;
664 		}
665 	}
666 
667 	status = spi_add_device(proxy);
668 	if (status < 0)
669 		goto err_remove_props;
670 
671 	return proxy;
672 
673 err_remove_props:
674 	if (chip->properties)
675 		device_remove_properties(&proxy->dev);
676 err_dev_put:
677 	spi_dev_put(proxy);
678 	return NULL;
679 }
680 EXPORT_SYMBOL_GPL(spi_new_device);
681 
682 /**
683  * spi_unregister_device - unregister a single SPI device
684  * @spi: spi_device to unregister
685  *
686  * Start making the passed SPI device vanish. Normally this would be handled
687  * by spi_unregister_controller().
688  */
689 void spi_unregister_device(struct spi_device *spi)
690 {
691 	if (!spi)
692 		return;
693 
694 	if (spi->dev.of_node) {
695 		of_node_clear_flag(spi->dev.of_node, OF_POPULATED);
696 		of_node_put(spi->dev.of_node);
697 	}
698 	if (ACPI_COMPANION(&spi->dev))
699 		acpi_device_clear_enumerated(ACPI_COMPANION(&spi->dev));
700 	device_unregister(&spi->dev);
701 }
702 EXPORT_SYMBOL_GPL(spi_unregister_device);
703 
704 static void spi_match_controller_to_boardinfo(struct spi_controller *ctlr,
705 					      struct spi_board_info *bi)
706 {
707 	struct spi_device *dev;
708 
709 	if (ctlr->bus_num != bi->bus_num)
710 		return;
711 
712 	dev = spi_new_device(ctlr, bi);
713 	if (!dev)
714 		dev_err(ctlr->dev.parent, "can't create new device for %s\n",
715 			bi->modalias);
716 }
717 
718 /**
719  * spi_register_board_info - register SPI devices for a given board
720  * @info: array of chip descriptors
721  * @n: how many descriptors are provided
722  * Context: can sleep
723  *
724  * Board-specific early init code calls this (probably during arch_initcall)
725  * with segments of the SPI device table.  Any device nodes are created later,
726  * after the relevant parent SPI controller (bus_num) is defined.  We keep
727  * this table of devices forever, so that reloading a controller driver will
728  * not make Linux forget about these hard-wired devices.
729  *
730  * Other code can also call this, e.g. a particular add-on board might provide
731  * SPI devices through its expansion connector, so code initializing that board
732  * would naturally declare its SPI devices.
733  *
734  * The board info passed can safely be __initdata ... but be careful of
735  * any embedded pointers (platform_data, etc), they're copied as-is.
736  * Device properties are deep-copied though.
737  *
738  * Return: zero on success, else a negative error code.
739  */
740 int spi_register_board_info(struct spi_board_info const *info, unsigned n)
741 {
742 	struct boardinfo *bi;
743 	int i;
744 
745 	if (!n)
746 		return 0;
747 
748 	bi = kcalloc(n, sizeof(*bi), GFP_KERNEL);
749 	if (!bi)
750 		return -ENOMEM;
751 
752 	for (i = 0; i < n; i++, bi++, info++) {
753 		struct spi_controller *ctlr;
754 
755 		memcpy(&bi->board_info, info, sizeof(*info));
756 		if (info->properties) {
757 			bi->board_info.properties =
758 					property_entries_dup(info->properties);
759 			if (IS_ERR(bi->board_info.properties))
760 				return PTR_ERR(bi->board_info.properties);
761 		}
762 
763 		mutex_lock(&board_lock);
764 		list_add_tail(&bi->list, &board_list);
765 		list_for_each_entry(ctlr, &spi_controller_list, list)
766 			spi_match_controller_to_boardinfo(ctlr,
767 							  &bi->board_info);
768 		mutex_unlock(&board_lock);
769 	}
770 
771 	return 0;
772 }
773 
774 /*-------------------------------------------------------------------------*/
775 
776 static void spi_set_cs(struct spi_device *spi, bool enable)
777 {
778 	bool enable1 = enable;
779 
780 	if (!spi->controller->set_cs_timing) {
781 		if (enable1)
782 			spi_delay_exec(&spi->controller->cs_setup, NULL);
783 		else
784 			spi_delay_exec(&spi->controller->cs_hold, NULL);
785 	}
786 
787 	if (spi->mode & SPI_CS_HIGH)
788 		enable = !enable;
789 
790 	if (spi->cs_gpiod || gpio_is_valid(spi->cs_gpio)) {
791 		/*
792 		 * Honour the SPI_NO_CS flag and invert the enable line, as
793 		 * active low is default for SPI. Execution paths that handle
794 		 * polarity inversion in gpiolib (such as device tree) will
795 		 * enforce active high using the SPI_CS_HIGH resulting in a
796 		 * double inversion through the code above.
797 		 */
798 		if (!(spi->mode & SPI_NO_CS)) {
799 			if (spi->cs_gpiod)
800 				gpiod_set_value_cansleep(spi->cs_gpiod,
801 							 !enable);
802 			else
803 				gpio_set_value_cansleep(spi->cs_gpio, !enable);
804 		}
805 		/* Some SPI masters need both GPIO CS & slave_select */
806 		if ((spi->controller->flags & SPI_MASTER_GPIO_SS) &&
807 		    spi->controller->set_cs)
808 			spi->controller->set_cs(spi, !enable);
809 	} else if (spi->controller->set_cs) {
810 		spi->controller->set_cs(spi, !enable);
811 	}
812 
813 	if (!spi->controller->set_cs_timing) {
814 		if (!enable1)
815 			spi_delay_exec(&spi->controller->cs_inactive, NULL);
816 	}
817 }
818 
819 #ifdef CONFIG_HAS_DMA
820 int spi_map_buf(struct spi_controller *ctlr, struct device *dev,
821 		struct sg_table *sgt, void *buf, size_t len,
822 		enum dma_data_direction dir)
823 {
824 	const bool vmalloced_buf = is_vmalloc_addr(buf);
825 	unsigned int max_seg_size = dma_get_max_seg_size(dev);
826 #ifdef CONFIG_HIGHMEM
827 	const bool kmap_buf = ((unsigned long)buf >= PKMAP_BASE &&
828 				(unsigned long)buf < (PKMAP_BASE +
829 					(LAST_PKMAP * PAGE_SIZE)));
830 #else
831 	const bool kmap_buf = false;
832 #endif
833 	int desc_len;
834 	int sgs;
835 	struct page *vm_page;
836 	struct scatterlist *sg;
837 	void *sg_buf;
838 	size_t min;
839 	int i, ret;
840 
841 	if (vmalloced_buf || kmap_buf) {
842 		desc_len = min_t(int, max_seg_size, PAGE_SIZE);
843 		sgs = DIV_ROUND_UP(len + offset_in_page(buf), desc_len);
844 	} else if (virt_addr_valid(buf)) {
845 		desc_len = min_t(int, max_seg_size, ctlr->max_dma_len);
846 		sgs = DIV_ROUND_UP(len, desc_len);
847 	} else {
848 		return -EINVAL;
849 	}
850 
851 	ret = sg_alloc_table(sgt, sgs, GFP_KERNEL);
852 	if (ret != 0)
853 		return ret;
854 
855 	sg = &sgt->sgl[0];
856 	for (i = 0; i < sgs; i++) {
857 
858 		if (vmalloced_buf || kmap_buf) {
859 			/*
860 			 * Next scatterlist entry size is the minimum between
861 			 * the desc_len and the remaining buffer length that
862 			 * fits in a page.
863 			 */
864 			min = min_t(size_t, desc_len,
865 				    min_t(size_t, len,
866 					  PAGE_SIZE - offset_in_page(buf)));
867 			if (vmalloced_buf)
868 				vm_page = vmalloc_to_page(buf);
869 			else
870 				vm_page = kmap_to_page(buf);
871 			if (!vm_page) {
872 				sg_free_table(sgt);
873 				return -ENOMEM;
874 			}
875 			sg_set_page(sg, vm_page,
876 				    min, offset_in_page(buf));
877 		} else {
878 			min = min_t(size_t, len, desc_len);
879 			sg_buf = buf;
880 			sg_set_buf(sg, sg_buf, min);
881 		}
882 
883 		buf += min;
884 		len -= min;
885 		sg = sg_next(sg);
886 	}
887 
888 	ret = dma_map_sg(dev, sgt->sgl, sgt->nents, dir);
889 	if (!ret)
890 		ret = -ENOMEM;
891 	if (ret < 0) {
892 		sg_free_table(sgt);
893 		return ret;
894 	}
895 
896 	sgt->nents = ret;
897 
898 	return 0;
899 }
900 
901 void spi_unmap_buf(struct spi_controller *ctlr, struct device *dev,
902 		   struct sg_table *sgt, enum dma_data_direction dir)
903 {
904 	if (sgt->orig_nents) {
905 		dma_unmap_sg(dev, sgt->sgl, sgt->orig_nents, dir);
906 		sg_free_table(sgt);
907 	}
908 }
909 
910 static int __spi_map_msg(struct spi_controller *ctlr, struct spi_message *msg)
911 {
912 	struct device *tx_dev, *rx_dev;
913 	struct spi_transfer *xfer;
914 	int ret;
915 
916 	if (!ctlr->can_dma)
917 		return 0;
918 
919 	if (ctlr->dma_tx)
920 		tx_dev = ctlr->dma_tx->device->dev;
921 	else
922 		tx_dev = ctlr->dev.parent;
923 
924 	if (ctlr->dma_rx)
925 		rx_dev = ctlr->dma_rx->device->dev;
926 	else
927 		rx_dev = ctlr->dev.parent;
928 
929 	list_for_each_entry(xfer, &msg->transfers, transfer_list) {
930 		if (!ctlr->can_dma(ctlr, msg->spi, xfer))
931 			continue;
932 
933 		if (xfer->tx_buf != NULL) {
934 			ret = spi_map_buf(ctlr, tx_dev, &xfer->tx_sg,
935 					  (void *)xfer->tx_buf, xfer->len,
936 					  DMA_TO_DEVICE);
937 			if (ret != 0)
938 				return ret;
939 		}
940 
941 		if (xfer->rx_buf != NULL) {
942 			ret = spi_map_buf(ctlr, rx_dev, &xfer->rx_sg,
943 					  xfer->rx_buf, xfer->len,
944 					  DMA_FROM_DEVICE);
945 			if (ret != 0) {
946 				spi_unmap_buf(ctlr, tx_dev, &xfer->tx_sg,
947 					      DMA_TO_DEVICE);
948 				return ret;
949 			}
950 		}
951 	}
952 
953 	ctlr->cur_msg_mapped = true;
954 
955 	return 0;
956 }
957 
958 static int __spi_unmap_msg(struct spi_controller *ctlr, struct spi_message *msg)
959 {
960 	struct spi_transfer *xfer;
961 	struct device *tx_dev, *rx_dev;
962 
963 	if (!ctlr->cur_msg_mapped || !ctlr->can_dma)
964 		return 0;
965 
966 	if (ctlr->dma_tx)
967 		tx_dev = ctlr->dma_tx->device->dev;
968 	else
969 		tx_dev = ctlr->dev.parent;
970 
971 	if (ctlr->dma_rx)
972 		rx_dev = ctlr->dma_rx->device->dev;
973 	else
974 		rx_dev = ctlr->dev.parent;
975 
976 	list_for_each_entry(xfer, &msg->transfers, transfer_list) {
977 		if (!ctlr->can_dma(ctlr, msg->spi, xfer))
978 			continue;
979 
980 		spi_unmap_buf(ctlr, rx_dev, &xfer->rx_sg, DMA_FROM_DEVICE);
981 		spi_unmap_buf(ctlr, tx_dev, &xfer->tx_sg, DMA_TO_DEVICE);
982 	}
983 
984 	return 0;
985 }
986 #else /* !CONFIG_HAS_DMA */
987 static inline int __spi_map_msg(struct spi_controller *ctlr,
988 				struct spi_message *msg)
989 {
990 	return 0;
991 }
992 
993 static inline int __spi_unmap_msg(struct spi_controller *ctlr,
994 				  struct spi_message *msg)
995 {
996 	return 0;
997 }
998 #endif /* !CONFIG_HAS_DMA */
999 
1000 static inline int spi_unmap_msg(struct spi_controller *ctlr,
1001 				struct spi_message *msg)
1002 {
1003 	struct spi_transfer *xfer;
1004 
1005 	list_for_each_entry(xfer, &msg->transfers, transfer_list) {
1006 		/*
1007 		 * Restore the original value of tx_buf or rx_buf if they are
1008 		 * NULL.
1009 		 */
1010 		if (xfer->tx_buf == ctlr->dummy_tx)
1011 			xfer->tx_buf = NULL;
1012 		if (xfer->rx_buf == ctlr->dummy_rx)
1013 			xfer->rx_buf = NULL;
1014 	}
1015 
1016 	return __spi_unmap_msg(ctlr, msg);
1017 }
1018 
1019 static int spi_map_msg(struct spi_controller *ctlr, struct spi_message *msg)
1020 {
1021 	struct spi_transfer *xfer;
1022 	void *tmp;
1023 	unsigned int max_tx, max_rx;
1024 
1025 	if (ctlr->flags & (SPI_CONTROLLER_MUST_RX | SPI_CONTROLLER_MUST_TX)) {
1026 		max_tx = 0;
1027 		max_rx = 0;
1028 
1029 		list_for_each_entry(xfer, &msg->transfers, transfer_list) {
1030 			if ((ctlr->flags & SPI_CONTROLLER_MUST_TX) &&
1031 			    !xfer->tx_buf)
1032 				max_tx = max(xfer->len, max_tx);
1033 			if ((ctlr->flags & SPI_CONTROLLER_MUST_RX) &&
1034 			    !xfer->rx_buf)
1035 				max_rx = max(xfer->len, max_rx);
1036 		}
1037 
1038 		if (max_tx) {
1039 			tmp = krealloc(ctlr->dummy_tx, max_tx,
1040 				       GFP_KERNEL | GFP_DMA);
1041 			if (!tmp)
1042 				return -ENOMEM;
1043 			ctlr->dummy_tx = tmp;
1044 			memset(tmp, 0, max_tx);
1045 		}
1046 
1047 		if (max_rx) {
1048 			tmp = krealloc(ctlr->dummy_rx, max_rx,
1049 				       GFP_KERNEL | GFP_DMA);
1050 			if (!tmp)
1051 				return -ENOMEM;
1052 			ctlr->dummy_rx = tmp;
1053 		}
1054 
1055 		if (max_tx || max_rx) {
1056 			list_for_each_entry(xfer, &msg->transfers,
1057 					    transfer_list) {
1058 				if (!xfer->len)
1059 					continue;
1060 				if (!xfer->tx_buf)
1061 					xfer->tx_buf = ctlr->dummy_tx;
1062 				if (!xfer->rx_buf)
1063 					xfer->rx_buf = ctlr->dummy_rx;
1064 			}
1065 		}
1066 	}
1067 
1068 	return __spi_map_msg(ctlr, msg);
1069 }
1070 
1071 static int spi_transfer_wait(struct spi_controller *ctlr,
1072 			     struct spi_message *msg,
1073 			     struct spi_transfer *xfer)
1074 {
1075 	struct spi_statistics *statm = &ctlr->statistics;
1076 	struct spi_statistics *stats = &msg->spi->statistics;
1077 	unsigned long long ms = 1;
1078 
1079 	if (spi_controller_is_slave(ctlr)) {
1080 		if (wait_for_completion_interruptible(&ctlr->xfer_completion)) {
1081 			dev_dbg(&msg->spi->dev, "SPI transfer interrupted\n");
1082 			return -EINTR;
1083 		}
1084 	} else {
1085 		ms = 8LL * 1000LL * xfer->len;
1086 		do_div(ms, xfer->speed_hz);
1087 		ms += ms + 200; /* some tolerance */
1088 
1089 		if (ms > UINT_MAX)
1090 			ms = UINT_MAX;
1091 
1092 		ms = wait_for_completion_timeout(&ctlr->xfer_completion,
1093 						 msecs_to_jiffies(ms));
1094 
1095 		if (ms == 0) {
1096 			SPI_STATISTICS_INCREMENT_FIELD(statm, timedout);
1097 			SPI_STATISTICS_INCREMENT_FIELD(stats, timedout);
1098 			dev_err(&msg->spi->dev,
1099 				"SPI transfer timed out\n");
1100 			return -ETIMEDOUT;
1101 		}
1102 	}
1103 
1104 	return 0;
1105 }
1106 
1107 static void _spi_transfer_delay_ns(u32 ns)
1108 {
1109 	if (!ns)
1110 		return;
1111 	if (ns <= 1000) {
1112 		ndelay(ns);
1113 	} else {
1114 		u32 us = DIV_ROUND_UP(ns, 1000);
1115 
1116 		if (us <= 10)
1117 			udelay(us);
1118 		else
1119 			usleep_range(us, us + DIV_ROUND_UP(us, 10));
1120 	}
1121 }
1122 
1123 int spi_delay_to_ns(struct spi_delay *_delay, struct spi_transfer *xfer)
1124 {
1125 	u32 delay = _delay->value;
1126 	u32 unit = _delay->unit;
1127 	u32 hz;
1128 
1129 	if (!delay)
1130 		return 0;
1131 
1132 	switch (unit) {
1133 	case SPI_DELAY_UNIT_USECS:
1134 		delay *= 1000;
1135 		break;
1136 	case SPI_DELAY_UNIT_NSECS: /* nothing to do here */
1137 		break;
1138 	case SPI_DELAY_UNIT_SCK:
1139 		/* clock cycles need to be obtained from spi_transfer */
1140 		if (!xfer)
1141 			return -EINVAL;
1142 		/* if there is no effective speed know, then approximate
1143 		 * by underestimating with half the requested hz
1144 		 */
1145 		hz = xfer->effective_speed_hz ?: xfer->speed_hz / 2;
1146 		if (!hz)
1147 			return -EINVAL;
1148 		delay *= DIV_ROUND_UP(1000000000, hz);
1149 		break;
1150 	default:
1151 		return -EINVAL;
1152 	}
1153 
1154 	return delay;
1155 }
1156 EXPORT_SYMBOL_GPL(spi_delay_to_ns);
1157 
1158 int spi_delay_exec(struct spi_delay *_delay, struct spi_transfer *xfer)
1159 {
1160 	int delay;
1161 
1162 	if (!_delay)
1163 		return -EINVAL;
1164 
1165 	delay = spi_delay_to_ns(_delay, xfer);
1166 	if (delay < 0)
1167 		return delay;
1168 
1169 	_spi_transfer_delay_ns(delay);
1170 
1171 	return 0;
1172 }
1173 EXPORT_SYMBOL_GPL(spi_delay_exec);
1174 
1175 static void _spi_transfer_cs_change_delay(struct spi_message *msg,
1176 					  struct spi_transfer *xfer)
1177 {
1178 	u32 delay = xfer->cs_change_delay.value;
1179 	u32 unit = xfer->cs_change_delay.unit;
1180 	int ret;
1181 
1182 	/* return early on "fast" mode - for everything but USECS */
1183 	if (!delay) {
1184 		if (unit == SPI_DELAY_UNIT_USECS)
1185 			_spi_transfer_delay_ns(10000);
1186 		return;
1187 	}
1188 
1189 	ret = spi_delay_exec(&xfer->cs_change_delay, xfer);
1190 	if (ret) {
1191 		dev_err_once(&msg->spi->dev,
1192 			     "Use of unsupported delay unit %i, using default of 10us\n",
1193 			     unit);
1194 		_spi_transfer_delay_ns(10000);
1195 	}
1196 }
1197 
1198 /*
1199  * spi_transfer_one_message - Default implementation of transfer_one_message()
1200  *
1201  * This is a standard implementation of transfer_one_message() for
1202  * drivers which implement a transfer_one() operation.  It provides
1203  * standard handling of delays and chip select management.
1204  */
1205 static int spi_transfer_one_message(struct spi_controller *ctlr,
1206 				    struct spi_message *msg)
1207 {
1208 	struct spi_transfer *xfer;
1209 	bool keep_cs = false;
1210 	int ret = 0;
1211 	struct spi_statistics *statm = &ctlr->statistics;
1212 	struct spi_statistics *stats = &msg->spi->statistics;
1213 
1214 	spi_set_cs(msg->spi, true);
1215 
1216 	SPI_STATISTICS_INCREMENT_FIELD(statm, messages);
1217 	SPI_STATISTICS_INCREMENT_FIELD(stats, messages);
1218 
1219 	list_for_each_entry(xfer, &msg->transfers, transfer_list) {
1220 		trace_spi_transfer_start(msg, xfer);
1221 
1222 		spi_statistics_add_transfer_stats(statm, xfer, ctlr);
1223 		spi_statistics_add_transfer_stats(stats, xfer, ctlr);
1224 
1225 		if (!ctlr->ptp_sts_supported) {
1226 			xfer->ptp_sts_word_pre = 0;
1227 			ptp_read_system_prets(xfer->ptp_sts);
1228 		}
1229 
1230 		if (xfer->tx_buf || xfer->rx_buf) {
1231 			reinit_completion(&ctlr->xfer_completion);
1232 
1233 			ret = ctlr->transfer_one(ctlr, msg->spi, xfer);
1234 			if (ret < 0) {
1235 				SPI_STATISTICS_INCREMENT_FIELD(statm,
1236 							       errors);
1237 				SPI_STATISTICS_INCREMENT_FIELD(stats,
1238 							       errors);
1239 				dev_err(&msg->spi->dev,
1240 					"SPI transfer failed: %d\n", ret);
1241 				goto out;
1242 			}
1243 
1244 			if (ret > 0) {
1245 				ret = spi_transfer_wait(ctlr, msg, xfer);
1246 				if (ret < 0)
1247 					msg->status = ret;
1248 			}
1249 		} else {
1250 			if (xfer->len)
1251 				dev_err(&msg->spi->dev,
1252 					"Bufferless transfer has length %u\n",
1253 					xfer->len);
1254 		}
1255 
1256 		if (!ctlr->ptp_sts_supported) {
1257 			ptp_read_system_postts(xfer->ptp_sts);
1258 			xfer->ptp_sts_word_post = xfer->len;
1259 		}
1260 
1261 		trace_spi_transfer_stop(msg, xfer);
1262 
1263 		if (msg->status != -EINPROGRESS)
1264 			goto out;
1265 
1266 		spi_transfer_delay_exec(xfer);
1267 
1268 		if (xfer->cs_change) {
1269 			if (list_is_last(&xfer->transfer_list,
1270 					 &msg->transfers)) {
1271 				keep_cs = true;
1272 			} else {
1273 				spi_set_cs(msg->spi, false);
1274 				_spi_transfer_cs_change_delay(msg, xfer);
1275 				spi_set_cs(msg->spi, true);
1276 			}
1277 		}
1278 
1279 		msg->actual_length += xfer->len;
1280 	}
1281 
1282 out:
1283 	if (ret != 0 || !keep_cs)
1284 		spi_set_cs(msg->spi, false);
1285 
1286 	if (msg->status == -EINPROGRESS)
1287 		msg->status = ret;
1288 
1289 	if (msg->status && ctlr->handle_err)
1290 		ctlr->handle_err(ctlr, msg);
1291 
1292 	spi_res_release(ctlr, msg);
1293 
1294 	spi_finalize_current_message(ctlr);
1295 
1296 	return ret;
1297 }
1298 
1299 /**
1300  * spi_finalize_current_transfer - report completion of a transfer
1301  * @ctlr: the controller reporting completion
1302  *
1303  * Called by SPI drivers using the core transfer_one_message()
1304  * implementation to notify it that the current interrupt driven
1305  * transfer has finished and the next one may be scheduled.
1306  */
1307 void spi_finalize_current_transfer(struct spi_controller *ctlr)
1308 {
1309 	complete(&ctlr->xfer_completion);
1310 }
1311 EXPORT_SYMBOL_GPL(spi_finalize_current_transfer);
1312 
1313 /**
1314  * __spi_pump_messages - function which processes spi message queue
1315  * @ctlr: controller to process queue for
1316  * @in_kthread: true if we are in the context of the message pump thread
1317  *
1318  * This function checks if there is any spi message in the queue that
1319  * needs processing and if so call out to the driver to initialize hardware
1320  * and transfer each message.
1321  *
1322  * Note that it is called both from the kthread itself and also from
1323  * inside spi_sync(); the queue extraction handling at the top of the
1324  * function should deal with this safely.
1325  */
1326 static void __spi_pump_messages(struct spi_controller *ctlr, bool in_kthread)
1327 {
1328 	struct spi_transfer *xfer;
1329 	struct spi_message *msg;
1330 	bool was_busy = false;
1331 	unsigned long flags;
1332 	int ret;
1333 
1334 	/* Lock queue */
1335 	spin_lock_irqsave(&ctlr->queue_lock, flags);
1336 
1337 	/* Make sure we are not already running a message */
1338 	if (ctlr->cur_msg) {
1339 		spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1340 		return;
1341 	}
1342 
1343 	/* If another context is idling the device then defer */
1344 	if (ctlr->idling) {
1345 		kthread_queue_work(&ctlr->kworker, &ctlr->pump_messages);
1346 		spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1347 		return;
1348 	}
1349 
1350 	/* Check if the queue is idle */
1351 	if (list_empty(&ctlr->queue) || !ctlr->running) {
1352 		if (!ctlr->busy) {
1353 			spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1354 			return;
1355 		}
1356 
1357 		/* Only do teardown in the thread */
1358 		if (!in_kthread) {
1359 			kthread_queue_work(&ctlr->kworker,
1360 					   &ctlr->pump_messages);
1361 			spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1362 			return;
1363 		}
1364 
1365 		ctlr->busy = false;
1366 		ctlr->idling = true;
1367 		spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1368 
1369 		kfree(ctlr->dummy_rx);
1370 		ctlr->dummy_rx = NULL;
1371 		kfree(ctlr->dummy_tx);
1372 		ctlr->dummy_tx = NULL;
1373 		if (ctlr->unprepare_transfer_hardware &&
1374 		    ctlr->unprepare_transfer_hardware(ctlr))
1375 			dev_err(&ctlr->dev,
1376 				"failed to unprepare transfer hardware\n");
1377 		if (ctlr->auto_runtime_pm) {
1378 			pm_runtime_mark_last_busy(ctlr->dev.parent);
1379 			pm_runtime_put_autosuspend(ctlr->dev.parent);
1380 		}
1381 		trace_spi_controller_idle(ctlr);
1382 
1383 		spin_lock_irqsave(&ctlr->queue_lock, flags);
1384 		ctlr->idling = false;
1385 		spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1386 		return;
1387 	}
1388 
1389 	/* Extract head of queue */
1390 	msg = list_first_entry(&ctlr->queue, struct spi_message, queue);
1391 	ctlr->cur_msg = msg;
1392 
1393 	list_del_init(&msg->queue);
1394 	if (ctlr->busy)
1395 		was_busy = true;
1396 	else
1397 		ctlr->busy = true;
1398 	spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1399 
1400 	mutex_lock(&ctlr->io_mutex);
1401 
1402 	if (!was_busy && ctlr->auto_runtime_pm) {
1403 		ret = pm_runtime_get_sync(ctlr->dev.parent);
1404 		if (ret < 0) {
1405 			pm_runtime_put_noidle(ctlr->dev.parent);
1406 			dev_err(&ctlr->dev, "Failed to power device: %d\n",
1407 				ret);
1408 			mutex_unlock(&ctlr->io_mutex);
1409 			return;
1410 		}
1411 	}
1412 
1413 	if (!was_busy)
1414 		trace_spi_controller_busy(ctlr);
1415 
1416 	if (!was_busy && ctlr->prepare_transfer_hardware) {
1417 		ret = ctlr->prepare_transfer_hardware(ctlr);
1418 		if (ret) {
1419 			dev_err(&ctlr->dev,
1420 				"failed to prepare transfer hardware: %d\n",
1421 				ret);
1422 
1423 			if (ctlr->auto_runtime_pm)
1424 				pm_runtime_put(ctlr->dev.parent);
1425 
1426 			msg->status = ret;
1427 			spi_finalize_current_message(ctlr);
1428 
1429 			mutex_unlock(&ctlr->io_mutex);
1430 			return;
1431 		}
1432 	}
1433 
1434 	trace_spi_message_start(msg);
1435 
1436 	if (ctlr->prepare_message) {
1437 		ret = ctlr->prepare_message(ctlr, msg);
1438 		if (ret) {
1439 			dev_err(&ctlr->dev, "failed to prepare message: %d\n",
1440 				ret);
1441 			msg->status = ret;
1442 			spi_finalize_current_message(ctlr);
1443 			goto out;
1444 		}
1445 		ctlr->cur_msg_prepared = true;
1446 	}
1447 
1448 	ret = spi_map_msg(ctlr, msg);
1449 	if (ret) {
1450 		msg->status = ret;
1451 		spi_finalize_current_message(ctlr);
1452 		goto out;
1453 	}
1454 
1455 	if (!ctlr->ptp_sts_supported && !ctlr->transfer_one) {
1456 		list_for_each_entry(xfer, &msg->transfers, transfer_list) {
1457 			xfer->ptp_sts_word_pre = 0;
1458 			ptp_read_system_prets(xfer->ptp_sts);
1459 		}
1460 	}
1461 
1462 	ret = ctlr->transfer_one_message(ctlr, msg);
1463 	if (ret) {
1464 		dev_err(&ctlr->dev,
1465 			"failed to transfer one message from queue\n");
1466 		goto out;
1467 	}
1468 
1469 out:
1470 	mutex_unlock(&ctlr->io_mutex);
1471 
1472 	/* Prod the scheduler in case transfer_one() was busy waiting */
1473 	if (!ret)
1474 		cond_resched();
1475 }
1476 
1477 /**
1478  * spi_pump_messages - kthread work function which processes spi message queue
1479  * @work: pointer to kthread work struct contained in the controller struct
1480  */
1481 static void spi_pump_messages(struct kthread_work *work)
1482 {
1483 	struct spi_controller *ctlr =
1484 		container_of(work, struct spi_controller, pump_messages);
1485 
1486 	__spi_pump_messages(ctlr, true);
1487 }
1488 
1489 /**
1490  * spi_take_timestamp_pre - helper for drivers to collect the beginning of the
1491  *			    TX timestamp for the requested byte from the SPI
1492  *			    transfer. The frequency with which this function
1493  *			    must be called (once per word, once for the whole
1494  *			    transfer, once per batch of words etc) is arbitrary
1495  *			    as long as the @tx buffer offset is greater than or
1496  *			    equal to the requested byte at the time of the
1497  *			    call. The timestamp is only taken once, at the
1498  *			    first such call. It is assumed that the driver
1499  *			    advances its @tx buffer pointer monotonically.
1500  * @ctlr: Pointer to the spi_controller structure of the driver
1501  * @xfer: Pointer to the transfer being timestamped
1502  * @progress: How many words (not bytes) have been transferred so far
1503  * @irqs_off: If true, will disable IRQs and preemption for the duration of the
1504  *	      transfer, for less jitter in time measurement. Only compatible
1505  *	      with PIO drivers. If true, must follow up with
1506  *	      spi_take_timestamp_post or otherwise system will crash.
1507  *	      WARNING: for fully predictable results, the CPU frequency must
1508  *	      also be under control (governor).
1509  */
1510 void spi_take_timestamp_pre(struct spi_controller *ctlr,
1511 			    struct spi_transfer *xfer,
1512 			    size_t progress, bool irqs_off)
1513 {
1514 	if (!xfer->ptp_sts)
1515 		return;
1516 
1517 	if (xfer->timestamped_pre)
1518 		return;
1519 
1520 	if (progress < xfer->ptp_sts_word_pre)
1521 		return;
1522 
1523 	/* Capture the resolution of the timestamp */
1524 	xfer->ptp_sts_word_pre = progress;
1525 
1526 	xfer->timestamped_pre = true;
1527 
1528 	if (irqs_off) {
1529 		local_irq_save(ctlr->irq_flags);
1530 		preempt_disable();
1531 	}
1532 
1533 	ptp_read_system_prets(xfer->ptp_sts);
1534 }
1535 EXPORT_SYMBOL_GPL(spi_take_timestamp_pre);
1536 
1537 /**
1538  * spi_take_timestamp_post - helper for drivers to collect the end of the
1539  *			     TX timestamp for the requested byte from the SPI
1540  *			     transfer. Can be called with an arbitrary
1541  *			     frequency: only the first call where @tx exceeds
1542  *			     or is equal to the requested word will be
1543  *			     timestamped.
1544  * @ctlr: Pointer to the spi_controller structure of the driver
1545  * @xfer: Pointer to the transfer being timestamped
1546  * @progress: How many words (not bytes) have been transferred so far
1547  * @irqs_off: If true, will re-enable IRQs and preemption for the local CPU.
1548  */
1549 void spi_take_timestamp_post(struct spi_controller *ctlr,
1550 			     struct spi_transfer *xfer,
1551 			     size_t progress, bool irqs_off)
1552 {
1553 	if (!xfer->ptp_sts)
1554 		return;
1555 
1556 	if (xfer->timestamped_post)
1557 		return;
1558 
1559 	if (progress < xfer->ptp_sts_word_post)
1560 		return;
1561 
1562 	ptp_read_system_postts(xfer->ptp_sts);
1563 
1564 	if (irqs_off) {
1565 		local_irq_restore(ctlr->irq_flags);
1566 		preempt_enable();
1567 	}
1568 
1569 	/* Capture the resolution of the timestamp */
1570 	xfer->ptp_sts_word_post = progress;
1571 
1572 	xfer->timestamped_post = true;
1573 }
1574 EXPORT_SYMBOL_GPL(spi_take_timestamp_post);
1575 
1576 /**
1577  * spi_set_thread_rt - set the controller to pump at realtime priority
1578  * @ctlr: controller to boost priority of
1579  *
1580  * This can be called because the controller requested realtime priority
1581  * (by setting the ->rt value before calling spi_register_controller()) or
1582  * because a device on the bus said that its transfers needed realtime
1583  * priority.
1584  *
1585  * NOTE: at the moment if any device on a bus says it needs realtime then
1586  * the thread will be at realtime priority for all transfers on that
1587  * controller.  If this eventually becomes a problem we may see if we can
1588  * find a way to boost the priority only temporarily during relevant
1589  * transfers.
1590  */
1591 static void spi_set_thread_rt(struct spi_controller *ctlr)
1592 {
1593 	struct sched_param param = { .sched_priority = MAX_RT_PRIO / 2 };
1594 
1595 	dev_info(&ctlr->dev,
1596 		"will run message pump with realtime priority\n");
1597 	sched_setscheduler(ctlr->kworker_task, SCHED_FIFO, &param);
1598 }
1599 
1600 static int spi_init_queue(struct spi_controller *ctlr)
1601 {
1602 	ctlr->running = false;
1603 	ctlr->busy = false;
1604 
1605 	kthread_init_worker(&ctlr->kworker);
1606 	ctlr->kworker_task = kthread_run(kthread_worker_fn, &ctlr->kworker,
1607 					 "%s", dev_name(&ctlr->dev));
1608 	if (IS_ERR(ctlr->kworker_task)) {
1609 		dev_err(&ctlr->dev, "failed to create message pump task\n");
1610 		return PTR_ERR(ctlr->kworker_task);
1611 	}
1612 	kthread_init_work(&ctlr->pump_messages, spi_pump_messages);
1613 
1614 	/*
1615 	 * Controller config will indicate if this controller should run the
1616 	 * message pump with high (realtime) priority to reduce the transfer
1617 	 * latency on the bus by minimising the delay between a transfer
1618 	 * request and the scheduling of the message pump thread. Without this
1619 	 * setting the message pump thread will remain at default priority.
1620 	 */
1621 	if (ctlr->rt)
1622 		spi_set_thread_rt(ctlr);
1623 
1624 	return 0;
1625 }
1626 
1627 /**
1628  * spi_get_next_queued_message() - called by driver to check for queued
1629  * messages
1630  * @ctlr: the controller to check for queued messages
1631  *
1632  * If there are more messages in the queue, the next message is returned from
1633  * this call.
1634  *
1635  * Return: the next message in the queue, else NULL if the queue is empty.
1636  */
1637 struct spi_message *spi_get_next_queued_message(struct spi_controller *ctlr)
1638 {
1639 	struct spi_message *next;
1640 	unsigned long flags;
1641 
1642 	/* get a pointer to the next message, if any */
1643 	spin_lock_irqsave(&ctlr->queue_lock, flags);
1644 	next = list_first_entry_or_null(&ctlr->queue, struct spi_message,
1645 					queue);
1646 	spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1647 
1648 	return next;
1649 }
1650 EXPORT_SYMBOL_GPL(spi_get_next_queued_message);
1651 
1652 /**
1653  * spi_finalize_current_message() - the current message is complete
1654  * @ctlr: the controller to return the message to
1655  *
1656  * Called by the driver to notify the core that the message in the front of the
1657  * queue is complete and can be removed from the queue.
1658  */
1659 void spi_finalize_current_message(struct spi_controller *ctlr)
1660 {
1661 	struct spi_transfer *xfer;
1662 	struct spi_message *mesg;
1663 	unsigned long flags;
1664 	int ret;
1665 
1666 	spin_lock_irqsave(&ctlr->queue_lock, flags);
1667 	mesg = ctlr->cur_msg;
1668 	spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1669 
1670 	if (!ctlr->ptp_sts_supported && !ctlr->transfer_one) {
1671 		list_for_each_entry(xfer, &mesg->transfers, transfer_list) {
1672 			ptp_read_system_postts(xfer->ptp_sts);
1673 			xfer->ptp_sts_word_post = xfer->len;
1674 		}
1675 	}
1676 
1677 	if (unlikely(ctlr->ptp_sts_supported)) {
1678 		list_for_each_entry(xfer, &mesg->transfers, transfer_list) {
1679 			WARN_ON_ONCE(xfer->ptp_sts && !xfer->timestamped_pre);
1680 			WARN_ON_ONCE(xfer->ptp_sts && !xfer->timestamped_post);
1681 		}
1682 	}
1683 
1684 	spi_unmap_msg(ctlr, mesg);
1685 
1686 	if (ctlr->cur_msg_prepared && ctlr->unprepare_message) {
1687 		ret = ctlr->unprepare_message(ctlr, mesg);
1688 		if (ret) {
1689 			dev_err(&ctlr->dev, "failed to unprepare message: %d\n",
1690 				ret);
1691 		}
1692 	}
1693 
1694 	spin_lock_irqsave(&ctlr->queue_lock, flags);
1695 	ctlr->cur_msg = NULL;
1696 	ctlr->cur_msg_prepared = false;
1697 	kthread_queue_work(&ctlr->kworker, &ctlr->pump_messages);
1698 	spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1699 
1700 	trace_spi_message_done(mesg);
1701 
1702 	mesg->state = NULL;
1703 	if (mesg->complete)
1704 		mesg->complete(mesg->context);
1705 }
1706 EXPORT_SYMBOL_GPL(spi_finalize_current_message);
1707 
1708 static int spi_start_queue(struct spi_controller *ctlr)
1709 {
1710 	unsigned long flags;
1711 
1712 	spin_lock_irqsave(&ctlr->queue_lock, flags);
1713 
1714 	if (ctlr->running || ctlr->busy) {
1715 		spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1716 		return -EBUSY;
1717 	}
1718 
1719 	ctlr->running = true;
1720 	ctlr->cur_msg = NULL;
1721 	spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1722 
1723 	kthread_queue_work(&ctlr->kworker, &ctlr->pump_messages);
1724 
1725 	return 0;
1726 }
1727 
1728 static int spi_stop_queue(struct spi_controller *ctlr)
1729 {
1730 	unsigned long flags;
1731 	unsigned limit = 500;
1732 	int ret = 0;
1733 
1734 	spin_lock_irqsave(&ctlr->queue_lock, flags);
1735 
1736 	/*
1737 	 * This is a bit lame, but is optimized for the common execution path.
1738 	 * A wait_queue on the ctlr->busy could be used, but then the common
1739 	 * execution path (pump_messages) would be required to call wake_up or
1740 	 * friends on every SPI message. Do this instead.
1741 	 */
1742 	while ((!list_empty(&ctlr->queue) || ctlr->busy) && limit--) {
1743 		spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1744 		usleep_range(10000, 11000);
1745 		spin_lock_irqsave(&ctlr->queue_lock, flags);
1746 	}
1747 
1748 	if (!list_empty(&ctlr->queue) || ctlr->busy)
1749 		ret = -EBUSY;
1750 	else
1751 		ctlr->running = false;
1752 
1753 	spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1754 
1755 	if (ret) {
1756 		dev_warn(&ctlr->dev, "could not stop message queue\n");
1757 		return ret;
1758 	}
1759 	return ret;
1760 }
1761 
1762 static int spi_destroy_queue(struct spi_controller *ctlr)
1763 {
1764 	int ret;
1765 
1766 	ret = spi_stop_queue(ctlr);
1767 
1768 	/*
1769 	 * kthread_flush_worker will block until all work is done.
1770 	 * If the reason that stop_queue timed out is that the work will never
1771 	 * finish, then it does no good to call flush/stop thread, so
1772 	 * return anyway.
1773 	 */
1774 	if (ret) {
1775 		dev_err(&ctlr->dev, "problem destroying queue\n");
1776 		return ret;
1777 	}
1778 
1779 	kthread_flush_worker(&ctlr->kworker);
1780 	kthread_stop(ctlr->kworker_task);
1781 
1782 	return 0;
1783 }
1784 
1785 static int __spi_queued_transfer(struct spi_device *spi,
1786 				 struct spi_message *msg,
1787 				 bool need_pump)
1788 {
1789 	struct spi_controller *ctlr = spi->controller;
1790 	unsigned long flags;
1791 
1792 	spin_lock_irqsave(&ctlr->queue_lock, flags);
1793 
1794 	if (!ctlr->running) {
1795 		spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1796 		return -ESHUTDOWN;
1797 	}
1798 	msg->actual_length = 0;
1799 	msg->status = -EINPROGRESS;
1800 
1801 	list_add_tail(&msg->queue, &ctlr->queue);
1802 	if (!ctlr->busy && need_pump)
1803 		kthread_queue_work(&ctlr->kworker, &ctlr->pump_messages);
1804 
1805 	spin_unlock_irqrestore(&ctlr->queue_lock, flags);
1806 	return 0;
1807 }
1808 
1809 /**
1810  * spi_queued_transfer - transfer function for queued transfers
1811  * @spi: spi device which is requesting transfer
1812  * @msg: spi message which is to handled is queued to driver queue
1813  *
1814  * Return: zero on success, else a negative error code.
1815  */
1816 static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
1817 {
1818 	return __spi_queued_transfer(spi, msg, true);
1819 }
1820 
1821 static int spi_controller_initialize_queue(struct spi_controller *ctlr)
1822 {
1823 	int ret;
1824 
1825 	ctlr->transfer = spi_queued_transfer;
1826 	if (!ctlr->transfer_one_message)
1827 		ctlr->transfer_one_message = spi_transfer_one_message;
1828 
1829 	/* Initialize and start queue */
1830 	ret = spi_init_queue(ctlr);
1831 	if (ret) {
1832 		dev_err(&ctlr->dev, "problem initializing queue\n");
1833 		goto err_init_queue;
1834 	}
1835 	ctlr->queued = true;
1836 	ret = spi_start_queue(ctlr);
1837 	if (ret) {
1838 		dev_err(&ctlr->dev, "problem starting queue\n");
1839 		goto err_start_queue;
1840 	}
1841 
1842 	return 0;
1843 
1844 err_start_queue:
1845 	spi_destroy_queue(ctlr);
1846 err_init_queue:
1847 	return ret;
1848 }
1849 
1850 /**
1851  * spi_flush_queue - Send all pending messages in the queue from the callers'
1852  *		     context
1853  * @ctlr: controller to process queue for
1854  *
1855  * This should be used when one wants to ensure all pending messages have been
1856  * sent before doing something. Is used by the spi-mem code to make sure SPI
1857  * memory operations do not preempt regular SPI transfers that have been queued
1858  * before the spi-mem operation.
1859  */
1860 void spi_flush_queue(struct spi_controller *ctlr)
1861 {
1862 	if (ctlr->transfer == spi_queued_transfer)
1863 		__spi_pump_messages(ctlr, false);
1864 }
1865 
1866 /*-------------------------------------------------------------------------*/
1867 
1868 #if defined(CONFIG_OF)
1869 static int of_spi_parse_dt(struct spi_controller *ctlr, struct spi_device *spi,
1870 			   struct device_node *nc)
1871 {
1872 	u32 value;
1873 	int rc;
1874 
1875 	/* Mode (clock phase/polarity/etc.) */
1876 	if (of_property_read_bool(nc, "spi-cpha"))
1877 		spi->mode |= SPI_CPHA;
1878 	if (of_property_read_bool(nc, "spi-cpol"))
1879 		spi->mode |= SPI_CPOL;
1880 	if (of_property_read_bool(nc, "spi-3wire"))
1881 		spi->mode |= SPI_3WIRE;
1882 	if (of_property_read_bool(nc, "spi-lsb-first"))
1883 		spi->mode |= SPI_LSB_FIRST;
1884 	if (of_property_read_bool(nc, "spi-cs-high"))
1885 		spi->mode |= SPI_CS_HIGH;
1886 
1887 	/* Device DUAL/QUAD mode */
1888 	if (!of_property_read_u32(nc, "spi-tx-bus-width", &value)) {
1889 		switch (value) {
1890 		case 1:
1891 			break;
1892 		case 2:
1893 			spi->mode |= SPI_TX_DUAL;
1894 			break;
1895 		case 4:
1896 			spi->mode |= SPI_TX_QUAD;
1897 			break;
1898 		case 8:
1899 			spi->mode |= SPI_TX_OCTAL;
1900 			break;
1901 		default:
1902 			dev_warn(&ctlr->dev,
1903 				"spi-tx-bus-width %d not supported\n",
1904 				value);
1905 			break;
1906 		}
1907 	}
1908 
1909 	if (!of_property_read_u32(nc, "spi-rx-bus-width", &value)) {
1910 		switch (value) {
1911 		case 1:
1912 			break;
1913 		case 2:
1914 			spi->mode |= SPI_RX_DUAL;
1915 			break;
1916 		case 4:
1917 			spi->mode |= SPI_RX_QUAD;
1918 			break;
1919 		case 8:
1920 			spi->mode |= SPI_RX_OCTAL;
1921 			break;
1922 		default:
1923 			dev_warn(&ctlr->dev,
1924 				"spi-rx-bus-width %d not supported\n",
1925 				value);
1926 			break;
1927 		}
1928 	}
1929 
1930 	if (spi_controller_is_slave(ctlr)) {
1931 		if (!of_node_name_eq(nc, "slave")) {
1932 			dev_err(&ctlr->dev, "%pOF is not called 'slave'\n",
1933 				nc);
1934 			return -EINVAL;
1935 		}
1936 		return 0;
1937 	}
1938 
1939 	/* Device address */
1940 	rc = of_property_read_u32(nc, "reg", &value);
1941 	if (rc) {
1942 		dev_err(&ctlr->dev, "%pOF has no valid 'reg' property (%d)\n",
1943 			nc, rc);
1944 		return rc;
1945 	}
1946 	spi->chip_select = value;
1947 
1948 	/*
1949 	 * For descriptors associated with the device, polarity inversion is
1950 	 * handled in the gpiolib, so all gpio chip selects are "active high"
1951 	 * in the logical sense, the gpiolib will invert the line if need be.
1952 	 */
1953 	if ((ctlr->use_gpio_descriptors) && ctlr->cs_gpiods &&
1954 	    ctlr->cs_gpiods[spi->chip_select])
1955 		spi->mode |= SPI_CS_HIGH;
1956 
1957 	/* Device speed */
1958 	rc = of_property_read_u32(nc, "spi-max-frequency", &value);
1959 	if (rc) {
1960 		dev_err(&ctlr->dev,
1961 			"%pOF has no valid 'spi-max-frequency' property (%d)\n", nc, rc);
1962 		return rc;
1963 	}
1964 	spi->max_speed_hz = value;
1965 
1966 	return 0;
1967 }
1968 
1969 static struct spi_device *
1970 of_register_spi_device(struct spi_controller *ctlr, struct device_node *nc)
1971 {
1972 	struct spi_device *spi;
1973 	int rc;
1974 
1975 	/* Alloc an spi_device */
1976 	spi = spi_alloc_device(ctlr);
1977 	if (!spi) {
1978 		dev_err(&ctlr->dev, "spi_device alloc error for %pOF\n", nc);
1979 		rc = -ENOMEM;
1980 		goto err_out;
1981 	}
1982 
1983 	/* Select device driver */
1984 	rc = of_modalias_node(nc, spi->modalias,
1985 				sizeof(spi->modalias));
1986 	if (rc < 0) {
1987 		dev_err(&ctlr->dev, "cannot find modalias for %pOF\n", nc);
1988 		goto err_out;
1989 	}
1990 
1991 	rc = of_spi_parse_dt(ctlr, spi, nc);
1992 	if (rc)
1993 		goto err_out;
1994 
1995 	/* Store a pointer to the node in the device structure */
1996 	of_node_get(nc);
1997 	spi->dev.of_node = nc;
1998 
1999 	/* Register the new device */
2000 	rc = spi_add_device(spi);
2001 	if (rc) {
2002 		dev_err(&ctlr->dev, "spi_device register error %pOF\n", nc);
2003 		goto err_of_node_put;
2004 	}
2005 
2006 	return spi;
2007 
2008 err_of_node_put:
2009 	of_node_put(nc);
2010 err_out:
2011 	spi_dev_put(spi);
2012 	return ERR_PTR(rc);
2013 }
2014 
2015 /**
2016  * of_register_spi_devices() - Register child devices onto the SPI bus
2017  * @ctlr:	Pointer to spi_controller device
2018  *
2019  * Registers an spi_device for each child node of controller node which
2020  * represents a valid SPI slave.
2021  */
2022 static void of_register_spi_devices(struct spi_controller *ctlr)
2023 {
2024 	struct spi_device *spi;
2025 	struct device_node *nc;
2026 
2027 	if (!ctlr->dev.of_node)
2028 		return;
2029 
2030 	for_each_available_child_of_node(ctlr->dev.of_node, nc) {
2031 		if (of_node_test_and_set_flag(nc, OF_POPULATED))
2032 			continue;
2033 		spi = of_register_spi_device(ctlr, nc);
2034 		if (IS_ERR(spi)) {
2035 			dev_warn(&ctlr->dev,
2036 				 "Failed to create SPI device for %pOF\n", nc);
2037 			of_node_clear_flag(nc, OF_POPULATED);
2038 		}
2039 	}
2040 }
2041 #else
2042 static void of_register_spi_devices(struct spi_controller *ctlr) { }
2043 #endif
2044 
2045 #ifdef CONFIG_ACPI
2046 struct acpi_spi_lookup {
2047 	struct spi_controller 	*ctlr;
2048 	u32			max_speed_hz;
2049 	u32			mode;
2050 	int			irq;
2051 	u8			bits_per_word;
2052 	u8			chip_select;
2053 };
2054 
2055 static void acpi_spi_parse_apple_properties(struct acpi_device *dev,
2056 					    struct acpi_spi_lookup *lookup)
2057 {
2058 	const union acpi_object *obj;
2059 
2060 	if (!x86_apple_machine)
2061 		return;
2062 
2063 	if (!acpi_dev_get_property(dev, "spiSclkPeriod", ACPI_TYPE_BUFFER, &obj)
2064 	    && obj->buffer.length >= 4)
2065 		lookup->max_speed_hz  = NSEC_PER_SEC / *(u32 *)obj->buffer.pointer;
2066 
2067 	if (!acpi_dev_get_property(dev, "spiWordSize", ACPI_TYPE_BUFFER, &obj)
2068 	    && obj->buffer.length == 8)
2069 		lookup->bits_per_word = *(u64 *)obj->buffer.pointer;
2070 
2071 	if (!acpi_dev_get_property(dev, "spiBitOrder", ACPI_TYPE_BUFFER, &obj)
2072 	    && obj->buffer.length == 8 && !*(u64 *)obj->buffer.pointer)
2073 		lookup->mode |= SPI_LSB_FIRST;
2074 
2075 	if (!acpi_dev_get_property(dev, "spiSPO", ACPI_TYPE_BUFFER, &obj)
2076 	    && obj->buffer.length == 8 &&  *(u64 *)obj->buffer.pointer)
2077 		lookup->mode |= SPI_CPOL;
2078 
2079 	if (!acpi_dev_get_property(dev, "spiSPH", ACPI_TYPE_BUFFER, &obj)
2080 	    && obj->buffer.length == 8 &&  *(u64 *)obj->buffer.pointer)
2081 		lookup->mode |= SPI_CPHA;
2082 }
2083 
2084 static int acpi_spi_add_resource(struct acpi_resource *ares, void *data)
2085 {
2086 	struct acpi_spi_lookup *lookup = data;
2087 	struct spi_controller *ctlr = lookup->ctlr;
2088 
2089 	if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
2090 		struct acpi_resource_spi_serialbus *sb;
2091 		acpi_handle parent_handle;
2092 		acpi_status status;
2093 
2094 		sb = &ares->data.spi_serial_bus;
2095 		if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_SPI) {
2096 
2097 			status = acpi_get_handle(NULL,
2098 						 sb->resource_source.string_ptr,
2099 						 &parent_handle);
2100 
2101 			if (ACPI_FAILURE(status) ||
2102 			    ACPI_HANDLE(ctlr->dev.parent) != parent_handle)
2103 				return -ENODEV;
2104 
2105 			/*
2106 			 * ACPI DeviceSelection numbering is handled by the
2107 			 * host controller driver in Windows and can vary
2108 			 * from driver to driver. In Linux we always expect
2109 			 * 0 .. max - 1 so we need to ask the driver to
2110 			 * translate between the two schemes.
2111 			 */
2112 			if (ctlr->fw_translate_cs) {
2113 				int cs = ctlr->fw_translate_cs(ctlr,
2114 						sb->device_selection);
2115 				if (cs < 0)
2116 					return cs;
2117 				lookup->chip_select = cs;
2118 			} else {
2119 				lookup->chip_select = sb->device_selection;
2120 			}
2121 
2122 			lookup->max_speed_hz = sb->connection_speed;
2123 
2124 			if (sb->clock_phase == ACPI_SPI_SECOND_PHASE)
2125 				lookup->mode |= SPI_CPHA;
2126 			if (sb->clock_polarity == ACPI_SPI_START_HIGH)
2127 				lookup->mode |= SPI_CPOL;
2128 			if (sb->device_polarity == ACPI_SPI_ACTIVE_HIGH)
2129 				lookup->mode |= SPI_CS_HIGH;
2130 		}
2131 	} else if (lookup->irq < 0) {
2132 		struct resource r;
2133 
2134 		if (acpi_dev_resource_interrupt(ares, 0, &r))
2135 			lookup->irq = r.start;
2136 	}
2137 
2138 	/* Always tell the ACPI core to skip this resource */
2139 	return 1;
2140 }
2141 
2142 static acpi_status acpi_register_spi_device(struct spi_controller *ctlr,
2143 					    struct acpi_device *adev)
2144 {
2145 	acpi_handle parent_handle = NULL;
2146 	struct list_head resource_list;
2147 	struct acpi_spi_lookup lookup = {};
2148 	struct spi_device *spi;
2149 	int ret;
2150 
2151 	if (acpi_bus_get_status(adev) || !adev->status.present ||
2152 	    acpi_device_enumerated(adev))
2153 		return AE_OK;
2154 
2155 	lookup.ctlr		= ctlr;
2156 	lookup.irq		= -1;
2157 
2158 	INIT_LIST_HEAD(&resource_list);
2159 	ret = acpi_dev_get_resources(adev, &resource_list,
2160 				     acpi_spi_add_resource, &lookup);
2161 	acpi_dev_free_resource_list(&resource_list);
2162 
2163 	if (ret < 0)
2164 		/* found SPI in _CRS but it points to another controller */
2165 		return AE_OK;
2166 
2167 	if (!lookup.max_speed_hz &&
2168 	    !ACPI_FAILURE(acpi_get_parent(adev->handle, &parent_handle)) &&
2169 	    ACPI_HANDLE(ctlr->dev.parent) == parent_handle) {
2170 		/* Apple does not use _CRS but nested devices for SPI slaves */
2171 		acpi_spi_parse_apple_properties(adev, &lookup);
2172 	}
2173 
2174 	if (!lookup.max_speed_hz)
2175 		return AE_OK;
2176 
2177 	spi = spi_alloc_device(ctlr);
2178 	if (!spi) {
2179 		dev_err(&ctlr->dev, "failed to allocate SPI device for %s\n",
2180 			dev_name(&adev->dev));
2181 		return AE_NO_MEMORY;
2182 	}
2183 
2184 	ACPI_COMPANION_SET(&spi->dev, adev);
2185 	spi->max_speed_hz	= lookup.max_speed_hz;
2186 	spi->mode		= lookup.mode;
2187 	spi->irq		= lookup.irq;
2188 	spi->bits_per_word	= lookup.bits_per_word;
2189 	spi->chip_select	= lookup.chip_select;
2190 
2191 	acpi_set_modalias(adev, acpi_device_hid(adev), spi->modalias,
2192 			  sizeof(spi->modalias));
2193 
2194 	if (spi->irq < 0)
2195 		spi->irq = acpi_dev_gpio_irq_get(adev, 0);
2196 
2197 	acpi_device_set_enumerated(adev);
2198 
2199 	adev->power.flags.ignore_parent = true;
2200 	if (spi_add_device(spi)) {
2201 		adev->power.flags.ignore_parent = false;
2202 		dev_err(&ctlr->dev, "failed to add SPI device %s from ACPI\n",
2203 			dev_name(&adev->dev));
2204 		spi_dev_put(spi);
2205 	}
2206 
2207 	return AE_OK;
2208 }
2209 
2210 static acpi_status acpi_spi_add_device(acpi_handle handle, u32 level,
2211 				       void *data, void **return_value)
2212 {
2213 	struct spi_controller *ctlr = data;
2214 	struct acpi_device *adev;
2215 
2216 	if (acpi_bus_get_device(handle, &adev))
2217 		return AE_OK;
2218 
2219 	return acpi_register_spi_device(ctlr, adev);
2220 }
2221 
2222 #define SPI_ACPI_ENUMERATE_MAX_DEPTH		32
2223 
2224 static void acpi_register_spi_devices(struct spi_controller *ctlr)
2225 {
2226 	acpi_status status;
2227 	acpi_handle handle;
2228 
2229 	handle = ACPI_HANDLE(ctlr->dev.parent);
2230 	if (!handle)
2231 		return;
2232 
2233 	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
2234 				     SPI_ACPI_ENUMERATE_MAX_DEPTH,
2235 				     acpi_spi_add_device, NULL, ctlr, NULL);
2236 	if (ACPI_FAILURE(status))
2237 		dev_warn(&ctlr->dev, "failed to enumerate SPI slaves\n");
2238 }
2239 #else
2240 static inline void acpi_register_spi_devices(struct spi_controller *ctlr) {}
2241 #endif /* CONFIG_ACPI */
2242 
2243 static void spi_controller_release(struct device *dev)
2244 {
2245 	struct spi_controller *ctlr;
2246 
2247 	ctlr = container_of(dev, struct spi_controller, dev);
2248 	kfree(ctlr);
2249 }
2250 
2251 static struct class spi_master_class = {
2252 	.name		= "spi_master",
2253 	.owner		= THIS_MODULE,
2254 	.dev_release	= spi_controller_release,
2255 	.dev_groups	= spi_master_groups,
2256 };
2257 
2258 #ifdef CONFIG_SPI_SLAVE
2259 /**
2260  * spi_slave_abort - abort the ongoing transfer request on an SPI slave
2261  *		     controller
2262  * @spi: device used for the current transfer
2263  */
2264 int spi_slave_abort(struct spi_device *spi)
2265 {
2266 	struct spi_controller *ctlr = spi->controller;
2267 
2268 	if (spi_controller_is_slave(ctlr) && ctlr->slave_abort)
2269 		return ctlr->slave_abort(ctlr);
2270 
2271 	return -ENOTSUPP;
2272 }
2273 EXPORT_SYMBOL_GPL(spi_slave_abort);
2274 
2275 static int match_true(struct device *dev, void *data)
2276 {
2277 	return 1;
2278 }
2279 
2280 static ssize_t slave_show(struct device *dev, struct device_attribute *attr,
2281 			  char *buf)
2282 {
2283 	struct spi_controller *ctlr = container_of(dev, struct spi_controller,
2284 						   dev);
2285 	struct device *child;
2286 
2287 	child = device_find_child(&ctlr->dev, NULL, match_true);
2288 	return sprintf(buf, "%s\n",
2289 		       child ? to_spi_device(child)->modalias : NULL);
2290 }
2291 
2292 static ssize_t slave_store(struct device *dev, struct device_attribute *attr,
2293 			   const char *buf, size_t count)
2294 {
2295 	struct spi_controller *ctlr = container_of(dev, struct spi_controller,
2296 						   dev);
2297 	struct spi_device *spi;
2298 	struct device *child;
2299 	char name[32];
2300 	int rc;
2301 
2302 	rc = sscanf(buf, "%31s", name);
2303 	if (rc != 1 || !name[0])
2304 		return -EINVAL;
2305 
2306 	child = device_find_child(&ctlr->dev, NULL, match_true);
2307 	if (child) {
2308 		/* Remove registered slave */
2309 		device_unregister(child);
2310 		put_device(child);
2311 	}
2312 
2313 	if (strcmp(name, "(null)")) {
2314 		/* Register new slave */
2315 		spi = spi_alloc_device(ctlr);
2316 		if (!spi)
2317 			return -ENOMEM;
2318 
2319 		strlcpy(spi->modalias, name, sizeof(spi->modalias));
2320 
2321 		rc = spi_add_device(spi);
2322 		if (rc) {
2323 			spi_dev_put(spi);
2324 			return rc;
2325 		}
2326 	}
2327 
2328 	return count;
2329 }
2330 
2331 static DEVICE_ATTR_RW(slave);
2332 
2333 static struct attribute *spi_slave_attrs[] = {
2334 	&dev_attr_slave.attr,
2335 	NULL,
2336 };
2337 
2338 static const struct attribute_group spi_slave_group = {
2339 	.attrs = spi_slave_attrs,
2340 };
2341 
2342 static const struct attribute_group *spi_slave_groups[] = {
2343 	&spi_controller_statistics_group,
2344 	&spi_slave_group,
2345 	NULL,
2346 };
2347 
2348 static struct class spi_slave_class = {
2349 	.name		= "spi_slave",
2350 	.owner		= THIS_MODULE,
2351 	.dev_release	= spi_controller_release,
2352 	.dev_groups	= spi_slave_groups,
2353 };
2354 #else
2355 extern struct class spi_slave_class;	/* dummy */
2356 #endif
2357 
2358 /**
2359  * __spi_alloc_controller - allocate an SPI master or slave controller
2360  * @dev: the controller, possibly using the platform_bus
2361  * @size: how much zeroed driver-private data to allocate; the pointer to this
2362  *	memory is in the driver_data field of the returned device, accessible
2363  *	with spi_controller_get_devdata(); the memory is cacheline aligned;
2364  *	drivers granting DMA access to portions of their private data need to
2365  *	round up @size using ALIGN(size, dma_get_cache_alignment()).
2366  * @slave: flag indicating whether to allocate an SPI master (false) or SPI
2367  *	slave (true) controller
2368  * Context: can sleep
2369  *
2370  * This call is used only by SPI controller drivers, which are the
2371  * only ones directly touching chip registers.  It's how they allocate
2372  * an spi_controller structure, prior to calling spi_register_controller().
2373  *
2374  * This must be called from context that can sleep.
2375  *
2376  * The caller is responsible for assigning the bus number and initializing the
2377  * controller's methods before calling spi_register_controller(); and (after
2378  * errors adding the device) calling spi_controller_put() to prevent a memory
2379  * leak.
2380  *
2381  * Return: the SPI controller structure on success, else NULL.
2382  */
2383 struct spi_controller *__spi_alloc_controller(struct device *dev,
2384 					      unsigned int size, bool slave)
2385 {
2386 	struct spi_controller	*ctlr;
2387 	size_t ctlr_size = ALIGN(sizeof(*ctlr), dma_get_cache_alignment());
2388 
2389 	if (!dev)
2390 		return NULL;
2391 
2392 	ctlr = kzalloc(size + ctlr_size, GFP_KERNEL);
2393 	if (!ctlr)
2394 		return NULL;
2395 
2396 	device_initialize(&ctlr->dev);
2397 	ctlr->bus_num = -1;
2398 	ctlr->num_chipselect = 1;
2399 	ctlr->slave = slave;
2400 	if (IS_ENABLED(CONFIG_SPI_SLAVE) && slave)
2401 		ctlr->dev.class = &spi_slave_class;
2402 	else
2403 		ctlr->dev.class = &spi_master_class;
2404 	ctlr->dev.parent = dev;
2405 	pm_suspend_ignore_children(&ctlr->dev, true);
2406 	spi_controller_set_devdata(ctlr, (void *)ctlr + ctlr_size);
2407 
2408 	return ctlr;
2409 }
2410 EXPORT_SYMBOL_GPL(__spi_alloc_controller);
2411 
2412 #ifdef CONFIG_OF
2413 static int of_spi_get_gpio_numbers(struct spi_controller *ctlr)
2414 {
2415 	int nb, i, *cs;
2416 	struct device_node *np = ctlr->dev.of_node;
2417 
2418 	if (!np)
2419 		return 0;
2420 
2421 	nb = of_gpio_named_count(np, "cs-gpios");
2422 	ctlr->num_chipselect = max_t(int, nb, ctlr->num_chipselect);
2423 
2424 	/* Return error only for an incorrectly formed cs-gpios property */
2425 	if (nb == 0 || nb == -ENOENT)
2426 		return 0;
2427 	else if (nb < 0)
2428 		return nb;
2429 
2430 	cs = devm_kcalloc(&ctlr->dev, ctlr->num_chipselect, sizeof(int),
2431 			  GFP_KERNEL);
2432 	ctlr->cs_gpios = cs;
2433 
2434 	if (!ctlr->cs_gpios)
2435 		return -ENOMEM;
2436 
2437 	for (i = 0; i < ctlr->num_chipselect; i++)
2438 		cs[i] = -ENOENT;
2439 
2440 	for (i = 0; i < nb; i++)
2441 		cs[i] = of_get_named_gpio(np, "cs-gpios", i);
2442 
2443 	return 0;
2444 }
2445 #else
2446 static int of_spi_get_gpio_numbers(struct spi_controller *ctlr)
2447 {
2448 	return 0;
2449 }
2450 #endif
2451 
2452 /**
2453  * spi_get_gpio_descs() - grab chip select GPIOs for the master
2454  * @ctlr: The SPI master to grab GPIO descriptors for
2455  */
2456 static int spi_get_gpio_descs(struct spi_controller *ctlr)
2457 {
2458 	int nb, i;
2459 	struct gpio_desc **cs;
2460 	struct device *dev = &ctlr->dev;
2461 	unsigned long native_cs_mask = 0;
2462 	unsigned int num_cs_gpios = 0;
2463 
2464 	nb = gpiod_count(dev, "cs");
2465 	ctlr->num_chipselect = max_t(int, nb, ctlr->num_chipselect);
2466 
2467 	/* No GPIOs at all is fine, else return the error */
2468 	if (nb == 0 || nb == -ENOENT)
2469 		return 0;
2470 	else if (nb < 0)
2471 		return nb;
2472 
2473 	cs = devm_kcalloc(dev, ctlr->num_chipselect, sizeof(*cs),
2474 			  GFP_KERNEL);
2475 	if (!cs)
2476 		return -ENOMEM;
2477 	ctlr->cs_gpiods = cs;
2478 
2479 	for (i = 0; i < nb; i++) {
2480 		/*
2481 		 * Most chipselects are active low, the inverted
2482 		 * semantics are handled by special quirks in gpiolib,
2483 		 * so initializing them GPIOD_OUT_LOW here means
2484 		 * "unasserted", in most cases this will drive the physical
2485 		 * line high.
2486 		 */
2487 		cs[i] = devm_gpiod_get_index_optional(dev, "cs", i,
2488 						      GPIOD_OUT_LOW);
2489 		if (IS_ERR(cs[i]))
2490 			return PTR_ERR(cs[i]);
2491 
2492 		if (cs[i]) {
2493 			/*
2494 			 * If we find a CS GPIO, name it after the device and
2495 			 * chip select line.
2496 			 */
2497 			char *gpioname;
2498 
2499 			gpioname = devm_kasprintf(dev, GFP_KERNEL, "%s CS%d",
2500 						  dev_name(dev), i);
2501 			if (!gpioname)
2502 				return -ENOMEM;
2503 			gpiod_set_consumer_name(cs[i], gpioname);
2504 			num_cs_gpios++;
2505 			continue;
2506 		}
2507 
2508 		if (ctlr->max_native_cs && i >= ctlr->max_native_cs) {
2509 			dev_err(dev, "Invalid native chip select %d\n", i);
2510 			return -EINVAL;
2511 		}
2512 		native_cs_mask |= BIT(i);
2513 	}
2514 
2515 	ctlr->unused_native_cs = ffz(native_cs_mask);
2516 	if (num_cs_gpios && ctlr->max_native_cs &&
2517 	    ctlr->unused_native_cs >= ctlr->max_native_cs) {
2518 		dev_err(dev, "No unused native chip select available\n");
2519 		return -EINVAL;
2520 	}
2521 
2522 	return 0;
2523 }
2524 
2525 static int spi_controller_check_ops(struct spi_controller *ctlr)
2526 {
2527 	/*
2528 	 * The controller may implement only the high-level SPI-memory like
2529 	 * operations if it does not support regular SPI transfers, and this is
2530 	 * valid use case.
2531 	 * If ->mem_ops is NULL, we request that at least one of the
2532 	 * ->transfer_xxx() method be implemented.
2533 	 */
2534 	if (ctlr->mem_ops) {
2535 		if (!ctlr->mem_ops->exec_op)
2536 			return -EINVAL;
2537 	} else if (!ctlr->transfer && !ctlr->transfer_one &&
2538 		   !ctlr->transfer_one_message) {
2539 		return -EINVAL;
2540 	}
2541 
2542 	return 0;
2543 }
2544 
2545 /**
2546  * spi_register_controller - register SPI master or slave controller
2547  * @ctlr: initialized master, originally from spi_alloc_master() or
2548  *	spi_alloc_slave()
2549  * Context: can sleep
2550  *
2551  * SPI controllers connect to their drivers using some non-SPI bus,
2552  * such as the platform bus.  The final stage of probe() in that code
2553  * includes calling spi_register_controller() to hook up to this SPI bus glue.
2554  *
2555  * SPI controllers use board specific (often SOC specific) bus numbers,
2556  * and board-specific addressing for SPI devices combines those numbers
2557  * with chip select numbers.  Since SPI does not directly support dynamic
2558  * device identification, boards need configuration tables telling which
2559  * chip is at which address.
2560  *
2561  * This must be called from context that can sleep.  It returns zero on
2562  * success, else a negative error code (dropping the controller's refcount).
2563  * After a successful return, the caller is responsible for calling
2564  * spi_unregister_controller().
2565  *
2566  * Return: zero on success, else a negative error code.
2567  */
2568 int spi_register_controller(struct spi_controller *ctlr)
2569 {
2570 	struct device		*dev = ctlr->dev.parent;
2571 	struct boardinfo	*bi;
2572 	int			status;
2573 	int			id, first_dynamic;
2574 
2575 	if (!dev)
2576 		return -ENODEV;
2577 
2578 	/*
2579 	 * Make sure all necessary hooks are implemented before registering
2580 	 * the SPI controller.
2581 	 */
2582 	status = spi_controller_check_ops(ctlr);
2583 	if (status)
2584 		return status;
2585 
2586 	if (ctlr->bus_num >= 0) {
2587 		/* devices with a fixed bus num must check-in with the num */
2588 		mutex_lock(&board_lock);
2589 		id = idr_alloc(&spi_master_idr, ctlr, ctlr->bus_num,
2590 			ctlr->bus_num + 1, GFP_KERNEL);
2591 		mutex_unlock(&board_lock);
2592 		if (WARN(id < 0, "couldn't get idr"))
2593 			return id == -ENOSPC ? -EBUSY : id;
2594 		ctlr->bus_num = id;
2595 	} else if (ctlr->dev.of_node) {
2596 		/* allocate dynamic bus number using Linux idr */
2597 		id = of_alias_get_id(ctlr->dev.of_node, "spi");
2598 		if (id >= 0) {
2599 			ctlr->bus_num = id;
2600 			mutex_lock(&board_lock);
2601 			id = idr_alloc(&spi_master_idr, ctlr, ctlr->bus_num,
2602 				       ctlr->bus_num + 1, GFP_KERNEL);
2603 			mutex_unlock(&board_lock);
2604 			if (WARN(id < 0, "couldn't get idr"))
2605 				return id == -ENOSPC ? -EBUSY : id;
2606 		}
2607 	}
2608 	if (ctlr->bus_num < 0) {
2609 		first_dynamic = of_alias_get_highest_id("spi");
2610 		if (first_dynamic < 0)
2611 			first_dynamic = 0;
2612 		else
2613 			first_dynamic++;
2614 
2615 		mutex_lock(&board_lock);
2616 		id = idr_alloc(&spi_master_idr, ctlr, first_dynamic,
2617 			       0, GFP_KERNEL);
2618 		mutex_unlock(&board_lock);
2619 		if (WARN(id < 0, "couldn't get idr"))
2620 			return id;
2621 		ctlr->bus_num = id;
2622 	}
2623 	INIT_LIST_HEAD(&ctlr->queue);
2624 	spin_lock_init(&ctlr->queue_lock);
2625 	spin_lock_init(&ctlr->bus_lock_spinlock);
2626 	mutex_init(&ctlr->bus_lock_mutex);
2627 	mutex_init(&ctlr->io_mutex);
2628 	ctlr->bus_lock_flag = 0;
2629 	init_completion(&ctlr->xfer_completion);
2630 	if (!ctlr->max_dma_len)
2631 		ctlr->max_dma_len = INT_MAX;
2632 
2633 	/* register the device, then userspace will see it.
2634 	 * registration fails if the bus ID is in use.
2635 	 */
2636 	dev_set_name(&ctlr->dev, "spi%u", ctlr->bus_num);
2637 
2638 	if (!spi_controller_is_slave(ctlr)) {
2639 		if (ctlr->use_gpio_descriptors) {
2640 			status = spi_get_gpio_descs(ctlr);
2641 			if (status)
2642 				goto free_bus_id;
2643 			/*
2644 			 * A controller using GPIO descriptors always
2645 			 * supports SPI_CS_HIGH if need be.
2646 			 */
2647 			ctlr->mode_bits |= SPI_CS_HIGH;
2648 		} else {
2649 			/* Legacy code path for GPIOs from DT */
2650 			status = of_spi_get_gpio_numbers(ctlr);
2651 			if (status)
2652 				goto free_bus_id;
2653 		}
2654 	}
2655 
2656 	/*
2657 	 * Even if it's just one always-selected device, there must
2658 	 * be at least one chipselect.
2659 	 */
2660 	if (!ctlr->num_chipselect) {
2661 		status = -EINVAL;
2662 		goto free_bus_id;
2663 	}
2664 
2665 	status = device_add(&ctlr->dev);
2666 	if (status < 0)
2667 		goto free_bus_id;
2668 	dev_dbg(dev, "registered %s %s\n",
2669 			spi_controller_is_slave(ctlr) ? "slave" : "master",
2670 			dev_name(&ctlr->dev));
2671 
2672 	/*
2673 	 * If we're using a queued driver, start the queue. Note that we don't
2674 	 * need the queueing logic if the driver is only supporting high-level
2675 	 * memory operations.
2676 	 */
2677 	if (ctlr->transfer) {
2678 		dev_info(dev, "controller is unqueued, this is deprecated\n");
2679 	} else if (ctlr->transfer_one || ctlr->transfer_one_message) {
2680 		status = spi_controller_initialize_queue(ctlr);
2681 		if (status) {
2682 			device_del(&ctlr->dev);
2683 			goto free_bus_id;
2684 		}
2685 	}
2686 	/* add statistics */
2687 	spin_lock_init(&ctlr->statistics.lock);
2688 
2689 	mutex_lock(&board_lock);
2690 	list_add_tail(&ctlr->list, &spi_controller_list);
2691 	list_for_each_entry(bi, &board_list, list)
2692 		spi_match_controller_to_boardinfo(ctlr, &bi->board_info);
2693 	mutex_unlock(&board_lock);
2694 
2695 	/* Register devices from the device tree and ACPI */
2696 	of_register_spi_devices(ctlr);
2697 	acpi_register_spi_devices(ctlr);
2698 	return status;
2699 
2700 free_bus_id:
2701 	mutex_lock(&board_lock);
2702 	idr_remove(&spi_master_idr, ctlr->bus_num);
2703 	mutex_unlock(&board_lock);
2704 	return status;
2705 }
2706 EXPORT_SYMBOL_GPL(spi_register_controller);
2707 
2708 static void devm_spi_unregister(struct device *dev, void *res)
2709 {
2710 	spi_unregister_controller(*(struct spi_controller **)res);
2711 }
2712 
2713 /**
2714  * devm_spi_register_controller - register managed SPI master or slave
2715  *	controller
2716  * @dev:    device managing SPI controller
2717  * @ctlr: initialized controller, originally from spi_alloc_master() or
2718  *	spi_alloc_slave()
2719  * Context: can sleep
2720  *
2721  * Register a SPI device as with spi_register_controller() which will
2722  * automatically be unregistered and freed.
2723  *
2724  * Return: zero on success, else a negative error code.
2725  */
2726 int devm_spi_register_controller(struct device *dev,
2727 				 struct spi_controller *ctlr)
2728 {
2729 	struct spi_controller **ptr;
2730 	int ret;
2731 
2732 	ptr = devres_alloc(devm_spi_unregister, sizeof(*ptr), GFP_KERNEL);
2733 	if (!ptr)
2734 		return -ENOMEM;
2735 
2736 	ret = spi_register_controller(ctlr);
2737 	if (!ret) {
2738 		*ptr = ctlr;
2739 		devres_add(dev, ptr);
2740 	} else {
2741 		devres_free(ptr);
2742 	}
2743 
2744 	return ret;
2745 }
2746 EXPORT_SYMBOL_GPL(devm_spi_register_controller);
2747 
2748 static int __unregister(struct device *dev, void *null)
2749 {
2750 	spi_unregister_device(to_spi_device(dev));
2751 	return 0;
2752 }
2753 
2754 /**
2755  * spi_unregister_controller - unregister SPI master or slave controller
2756  * @ctlr: the controller being unregistered
2757  * Context: can sleep
2758  *
2759  * This call is used only by SPI controller drivers, which are the
2760  * only ones directly touching chip registers.
2761  *
2762  * This must be called from context that can sleep.
2763  *
2764  * Note that this function also drops a reference to the controller.
2765  */
2766 void spi_unregister_controller(struct spi_controller *ctlr)
2767 {
2768 	struct spi_controller *found;
2769 	int id = ctlr->bus_num;
2770 
2771 	/* First make sure that this controller was ever added */
2772 	mutex_lock(&board_lock);
2773 	found = idr_find(&spi_master_idr, id);
2774 	mutex_unlock(&board_lock);
2775 	if (ctlr->queued) {
2776 		if (spi_destroy_queue(ctlr))
2777 			dev_err(&ctlr->dev, "queue remove failed\n");
2778 	}
2779 	mutex_lock(&board_lock);
2780 	list_del(&ctlr->list);
2781 	mutex_unlock(&board_lock);
2782 
2783 	device_for_each_child(&ctlr->dev, NULL, __unregister);
2784 	device_unregister(&ctlr->dev);
2785 	/* free bus id */
2786 	mutex_lock(&board_lock);
2787 	if (found == ctlr)
2788 		idr_remove(&spi_master_idr, id);
2789 	mutex_unlock(&board_lock);
2790 }
2791 EXPORT_SYMBOL_GPL(spi_unregister_controller);
2792 
2793 int spi_controller_suspend(struct spi_controller *ctlr)
2794 {
2795 	int ret;
2796 
2797 	/* Basically no-ops for non-queued controllers */
2798 	if (!ctlr->queued)
2799 		return 0;
2800 
2801 	ret = spi_stop_queue(ctlr);
2802 	if (ret)
2803 		dev_err(&ctlr->dev, "queue stop failed\n");
2804 
2805 	return ret;
2806 }
2807 EXPORT_SYMBOL_GPL(spi_controller_suspend);
2808 
2809 int spi_controller_resume(struct spi_controller *ctlr)
2810 {
2811 	int ret;
2812 
2813 	if (!ctlr->queued)
2814 		return 0;
2815 
2816 	ret = spi_start_queue(ctlr);
2817 	if (ret)
2818 		dev_err(&ctlr->dev, "queue restart failed\n");
2819 
2820 	return ret;
2821 }
2822 EXPORT_SYMBOL_GPL(spi_controller_resume);
2823 
2824 static int __spi_controller_match(struct device *dev, const void *data)
2825 {
2826 	struct spi_controller *ctlr;
2827 	const u16 *bus_num = data;
2828 
2829 	ctlr = container_of(dev, struct spi_controller, dev);
2830 	return ctlr->bus_num == *bus_num;
2831 }
2832 
2833 /**
2834  * spi_busnum_to_master - look up master associated with bus_num
2835  * @bus_num: the master's bus number
2836  * Context: can sleep
2837  *
2838  * This call may be used with devices that are registered after
2839  * arch init time.  It returns a refcounted pointer to the relevant
2840  * spi_controller (which the caller must release), or NULL if there is
2841  * no such master registered.
2842  *
2843  * Return: the SPI master structure on success, else NULL.
2844  */
2845 struct spi_controller *spi_busnum_to_master(u16 bus_num)
2846 {
2847 	struct device		*dev;
2848 	struct spi_controller	*ctlr = NULL;
2849 
2850 	dev = class_find_device(&spi_master_class, NULL, &bus_num,
2851 				__spi_controller_match);
2852 	if (dev)
2853 		ctlr = container_of(dev, struct spi_controller, dev);
2854 	/* reference got in class_find_device */
2855 	return ctlr;
2856 }
2857 EXPORT_SYMBOL_GPL(spi_busnum_to_master);
2858 
2859 /*-------------------------------------------------------------------------*/
2860 
2861 /* Core methods for SPI resource management */
2862 
2863 /**
2864  * spi_res_alloc - allocate a spi resource that is life-cycle managed
2865  *                 during the processing of a spi_message while using
2866  *                 spi_transfer_one
2867  * @spi:     the spi device for which we allocate memory
2868  * @release: the release code to execute for this resource
2869  * @size:    size to alloc and return
2870  * @gfp:     GFP allocation flags
2871  *
2872  * Return: the pointer to the allocated data
2873  *
2874  * This may get enhanced in the future to allocate from a memory pool
2875  * of the @spi_device or @spi_controller to avoid repeated allocations.
2876  */
2877 void *spi_res_alloc(struct spi_device *spi,
2878 		    spi_res_release_t release,
2879 		    size_t size, gfp_t gfp)
2880 {
2881 	struct spi_res *sres;
2882 
2883 	sres = kzalloc(sizeof(*sres) + size, gfp);
2884 	if (!sres)
2885 		return NULL;
2886 
2887 	INIT_LIST_HEAD(&sres->entry);
2888 	sres->release = release;
2889 
2890 	return sres->data;
2891 }
2892 EXPORT_SYMBOL_GPL(spi_res_alloc);
2893 
2894 /**
2895  * spi_res_free - free an spi resource
2896  * @res: pointer to the custom data of a resource
2897  *
2898  */
2899 void spi_res_free(void *res)
2900 {
2901 	struct spi_res *sres = container_of(res, struct spi_res, data);
2902 
2903 	if (!res)
2904 		return;
2905 
2906 	WARN_ON(!list_empty(&sres->entry));
2907 	kfree(sres);
2908 }
2909 EXPORT_SYMBOL_GPL(spi_res_free);
2910 
2911 /**
2912  * spi_res_add - add a spi_res to the spi_message
2913  * @message: the spi message
2914  * @res:     the spi_resource
2915  */
2916 void spi_res_add(struct spi_message *message, void *res)
2917 {
2918 	struct spi_res *sres = container_of(res, struct spi_res, data);
2919 
2920 	WARN_ON(!list_empty(&sres->entry));
2921 	list_add_tail(&sres->entry, &message->resources);
2922 }
2923 EXPORT_SYMBOL_GPL(spi_res_add);
2924 
2925 /**
2926  * spi_res_release - release all spi resources for this message
2927  * @ctlr:  the @spi_controller
2928  * @message: the @spi_message
2929  */
2930 void spi_res_release(struct spi_controller *ctlr, struct spi_message *message)
2931 {
2932 	struct spi_res *res, *tmp;
2933 
2934 	list_for_each_entry_safe_reverse(res, tmp, &message->resources, entry) {
2935 		if (res->release)
2936 			res->release(ctlr, message, res->data);
2937 
2938 		list_del(&res->entry);
2939 
2940 		kfree(res);
2941 	}
2942 }
2943 EXPORT_SYMBOL_GPL(spi_res_release);
2944 
2945 /*-------------------------------------------------------------------------*/
2946 
2947 /* Core methods for spi_message alterations */
2948 
2949 static void __spi_replace_transfers_release(struct spi_controller *ctlr,
2950 					    struct spi_message *msg,
2951 					    void *res)
2952 {
2953 	struct spi_replaced_transfers *rxfer = res;
2954 	size_t i;
2955 
2956 	/* call extra callback if requested */
2957 	if (rxfer->release)
2958 		rxfer->release(ctlr, msg, res);
2959 
2960 	/* insert replaced transfers back into the message */
2961 	list_splice(&rxfer->replaced_transfers, rxfer->replaced_after);
2962 
2963 	/* remove the formerly inserted entries */
2964 	for (i = 0; i < rxfer->inserted; i++)
2965 		list_del(&rxfer->inserted_transfers[i].transfer_list);
2966 }
2967 
2968 /**
2969  * spi_replace_transfers - replace transfers with several transfers
2970  *                         and register change with spi_message.resources
2971  * @msg:           the spi_message we work upon
2972  * @xfer_first:    the first spi_transfer we want to replace
2973  * @remove:        number of transfers to remove
2974  * @insert:        the number of transfers we want to insert instead
2975  * @release:       extra release code necessary in some circumstances
2976  * @extradatasize: extra data to allocate (with alignment guarantees
2977  *                 of struct @spi_transfer)
2978  * @gfp:           gfp flags
2979  *
2980  * Returns: pointer to @spi_replaced_transfers,
2981  *          PTR_ERR(...) in case of errors.
2982  */
2983 struct spi_replaced_transfers *spi_replace_transfers(
2984 	struct spi_message *msg,
2985 	struct spi_transfer *xfer_first,
2986 	size_t remove,
2987 	size_t insert,
2988 	spi_replaced_release_t release,
2989 	size_t extradatasize,
2990 	gfp_t gfp)
2991 {
2992 	struct spi_replaced_transfers *rxfer;
2993 	struct spi_transfer *xfer;
2994 	size_t i;
2995 
2996 	/* allocate the structure using spi_res */
2997 	rxfer = spi_res_alloc(msg->spi, __spi_replace_transfers_release,
2998 			      struct_size(rxfer, inserted_transfers, insert)
2999 			      + extradatasize,
3000 			      gfp);
3001 	if (!rxfer)
3002 		return ERR_PTR(-ENOMEM);
3003 
3004 	/* the release code to invoke before running the generic release */
3005 	rxfer->release = release;
3006 
3007 	/* assign extradata */
3008 	if (extradatasize)
3009 		rxfer->extradata =
3010 			&rxfer->inserted_transfers[insert];
3011 
3012 	/* init the replaced_transfers list */
3013 	INIT_LIST_HEAD(&rxfer->replaced_transfers);
3014 
3015 	/* assign the list_entry after which we should reinsert
3016 	 * the @replaced_transfers - it may be spi_message.messages!
3017 	 */
3018 	rxfer->replaced_after = xfer_first->transfer_list.prev;
3019 
3020 	/* remove the requested number of transfers */
3021 	for (i = 0; i < remove; i++) {
3022 		/* if the entry after replaced_after it is msg->transfers
3023 		 * then we have been requested to remove more transfers
3024 		 * than are in the list
3025 		 */
3026 		if (rxfer->replaced_after->next == &msg->transfers) {
3027 			dev_err(&msg->spi->dev,
3028 				"requested to remove more spi_transfers than are available\n");
3029 			/* insert replaced transfers back into the message */
3030 			list_splice(&rxfer->replaced_transfers,
3031 				    rxfer->replaced_after);
3032 
3033 			/* free the spi_replace_transfer structure */
3034 			spi_res_free(rxfer);
3035 
3036 			/* and return with an error */
3037 			return ERR_PTR(-EINVAL);
3038 		}
3039 
3040 		/* remove the entry after replaced_after from list of
3041 		 * transfers and add it to list of replaced_transfers
3042 		 */
3043 		list_move_tail(rxfer->replaced_after->next,
3044 			       &rxfer->replaced_transfers);
3045 	}
3046 
3047 	/* create copy of the given xfer with identical settings
3048 	 * based on the first transfer to get removed
3049 	 */
3050 	for (i = 0; i < insert; i++) {
3051 		/* we need to run in reverse order */
3052 		xfer = &rxfer->inserted_transfers[insert - 1 - i];
3053 
3054 		/* copy all spi_transfer data */
3055 		memcpy(xfer, xfer_first, sizeof(*xfer));
3056 
3057 		/* add to list */
3058 		list_add(&xfer->transfer_list, rxfer->replaced_after);
3059 
3060 		/* clear cs_change and delay for all but the last */
3061 		if (i) {
3062 			xfer->cs_change = false;
3063 			xfer->delay_usecs = 0;
3064 			xfer->delay.value = 0;
3065 		}
3066 	}
3067 
3068 	/* set up inserted */
3069 	rxfer->inserted = insert;
3070 
3071 	/* and register it with spi_res/spi_message */
3072 	spi_res_add(msg, rxfer);
3073 
3074 	return rxfer;
3075 }
3076 EXPORT_SYMBOL_GPL(spi_replace_transfers);
3077 
3078 static int __spi_split_transfer_maxsize(struct spi_controller *ctlr,
3079 					struct spi_message *msg,
3080 					struct spi_transfer **xferp,
3081 					size_t maxsize,
3082 					gfp_t gfp)
3083 {
3084 	struct spi_transfer *xfer = *xferp, *xfers;
3085 	struct spi_replaced_transfers *srt;
3086 	size_t offset;
3087 	size_t count, i;
3088 
3089 	/* calculate how many we have to replace */
3090 	count = DIV_ROUND_UP(xfer->len, maxsize);
3091 
3092 	/* create replacement */
3093 	srt = spi_replace_transfers(msg, xfer, 1, count, NULL, 0, gfp);
3094 	if (IS_ERR(srt))
3095 		return PTR_ERR(srt);
3096 	xfers = srt->inserted_transfers;
3097 
3098 	/* now handle each of those newly inserted spi_transfers
3099 	 * note that the replacements spi_transfers all are preset
3100 	 * to the same values as *xferp, so tx_buf, rx_buf and len
3101 	 * are all identical (as well as most others)
3102 	 * so we just have to fix up len and the pointers.
3103 	 *
3104 	 * this also includes support for the depreciated
3105 	 * spi_message.is_dma_mapped interface
3106 	 */
3107 
3108 	/* the first transfer just needs the length modified, so we
3109 	 * run it outside the loop
3110 	 */
3111 	xfers[0].len = min_t(size_t, maxsize, xfer[0].len);
3112 
3113 	/* all the others need rx_buf/tx_buf also set */
3114 	for (i = 1, offset = maxsize; i < count; offset += maxsize, i++) {
3115 		/* update rx_buf, tx_buf and dma */
3116 		if (xfers[i].rx_buf)
3117 			xfers[i].rx_buf += offset;
3118 		if (xfers[i].rx_dma)
3119 			xfers[i].rx_dma += offset;
3120 		if (xfers[i].tx_buf)
3121 			xfers[i].tx_buf += offset;
3122 		if (xfers[i].tx_dma)
3123 			xfers[i].tx_dma += offset;
3124 
3125 		/* update length */
3126 		xfers[i].len = min(maxsize, xfers[i].len - offset);
3127 	}
3128 
3129 	/* we set up xferp to the last entry we have inserted,
3130 	 * so that we skip those already split transfers
3131 	 */
3132 	*xferp = &xfers[count - 1];
3133 
3134 	/* increment statistics counters */
3135 	SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics,
3136 				       transfers_split_maxsize);
3137 	SPI_STATISTICS_INCREMENT_FIELD(&msg->spi->statistics,
3138 				       transfers_split_maxsize);
3139 
3140 	return 0;
3141 }
3142 
3143 /**
3144  * spi_split_tranfers_maxsize - split spi transfers into multiple transfers
3145  *                              when an individual transfer exceeds a
3146  *                              certain size
3147  * @ctlr:    the @spi_controller for this transfer
3148  * @msg:   the @spi_message to transform
3149  * @maxsize:  the maximum when to apply this
3150  * @gfp: GFP allocation flags
3151  *
3152  * Return: status of transformation
3153  */
3154 int spi_split_transfers_maxsize(struct spi_controller *ctlr,
3155 				struct spi_message *msg,
3156 				size_t maxsize,
3157 				gfp_t gfp)
3158 {
3159 	struct spi_transfer *xfer;
3160 	int ret;
3161 
3162 	/* iterate over the transfer_list,
3163 	 * but note that xfer is advanced to the last transfer inserted
3164 	 * to avoid checking sizes again unnecessarily (also xfer does
3165 	 * potentiall belong to a different list by the time the
3166 	 * replacement has happened
3167 	 */
3168 	list_for_each_entry(xfer, &msg->transfers, transfer_list) {
3169 		if (xfer->len > maxsize) {
3170 			ret = __spi_split_transfer_maxsize(ctlr, msg, &xfer,
3171 							   maxsize, gfp);
3172 			if (ret)
3173 				return ret;
3174 		}
3175 	}
3176 
3177 	return 0;
3178 }
3179 EXPORT_SYMBOL_GPL(spi_split_transfers_maxsize);
3180 
3181 /*-------------------------------------------------------------------------*/
3182 
3183 /* Core methods for SPI controller protocol drivers.  Some of the
3184  * other core methods are currently defined as inline functions.
3185  */
3186 
3187 static int __spi_validate_bits_per_word(struct spi_controller *ctlr,
3188 					u8 bits_per_word)
3189 {
3190 	if (ctlr->bits_per_word_mask) {
3191 		/* Only 32 bits fit in the mask */
3192 		if (bits_per_word > 32)
3193 			return -EINVAL;
3194 		if (!(ctlr->bits_per_word_mask & SPI_BPW_MASK(bits_per_word)))
3195 			return -EINVAL;
3196 	}
3197 
3198 	return 0;
3199 }
3200 
3201 /**
3202  * spi_setup - setup SPI mode and clock rate
3203  * @spi: the device whose settings are being modified
3204  * Context: can sleep, and no requests are queued to the device
3205  *
3206  * SPI protocol drivers may need to update the transfer mode if the
3207  * device doesn't work with its default.  They may likewise need
3208  * to update clock rates or word sizes from initial values.  This function
3209  * changes those settings, and must be called from a context that can sleep.
3210  * Except for SPI_CS_HIGH, which takes effect immediately, the changes take
3211  * effect the next time the device is selected and data is transferred to
3212  * or from it.  When this function returns, the spi device is deselected.
3213  *
3214  * Note that this call will fail if the protocol driver specifies an option
3215  * that the underlying controller or its driver does not support.  For
3216  * example, not all hardware supports wire transfers using nine bit words,
3217  * LSB-first wire encoding, or active-high chipselects.
3218  *
3219  * Return: zero on success, else a negative error code.
3220  */
3221 int spi_setup(struct spi_device *spi)
3222 {
3223 	unsigned	bad_bits, ugly_bits;
3224 	int		status;
3225 
3226 	/* check mode to prevent that DUAL and QUAD set at the same time
3227 	 */
3228 	if (((spi->mode & SPI_TX_DUAL) && (spi->mode & SPI_TX_QUAD)) ||
3229 		((spi->mode & SPI_RX_DUAL) && (spi->mode & SPI_RX_QUAD))) {
3230 		dev_err(&spi->dev,
3231 		"setup: can not select dual and quad at the same time\n");
3232 		return -EINVAL;
3233 	}
3234 	/* if it is SPI_3WIRE mode, DUAL and QUAD should be forbidden
3235 	 */
3236 	if ((spi->mode & SPI_3WIRE) && (spi->mode &
3237 		(SPI_TX_DUAL | SPI_TX_QUAD | SPI_TX_OCTAL |
3238 		 SPI_RX_DUAL | SPI_RX_QUAD | SPI_RX_OCTAL)))
3239 		return -EINVAL;
3240 	/* help drivers fail *cleanly* when they need options
3241 	 * that aren't supported with their current controller
3242 	 * SPI_CS_WORD has a fallback software implementation,
3243 	 * so it is ignored here.
3244 	 */
3245 	bad_bits = spi->mode & ~(spi->controller->mode_bits | SPI_CS_WORD);
3246 	/* nothing prevents from working with active-high CS in case if it
3247 	 * is driven by GPIO.
3248 	 */
3249 	if (gpio_is_valid(spi->cs_gpio))
3250 		bad_bits &= ~SPI_CS_HIGH;
3251 	ugly_bits = bad_bits &
3252 		    (SPI_TX_DUAL | SPI_TX_QUAD | SPI_TX_OCTAL |
3253 		     SPI_RX_DUAL | SPI_RX_QUAD | SPI_RX_OCTAL);
3254 	if (ugly_bits) {
3255 		dev_warn(&spi->dev,
3256 			 "setup: ignoring unsupported mode bits %x\n",
3257 			 ugly_bits);
3258 		spi->mode &= ~ugly_bits;
3259 		bad_bits &= ~ugly_bits;
3260 	}
3261 	if (bad_bits) {
3262 		dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
3263 			bad_bits);
3264 		return -EINVAL;
3265 	}
3266 
3267 	if (!spi->bits_per_word)
3268 		spi->bits_per_word = 8;
3269 
3270 	status = __spi_validate_bits_per_word(spi->controller,
3271 					      spi->bits_per_word);
3272 	if (status)
3273 		return status;
3274 
3275 	if (!spi->max_speed_hz)
3276 		spi->max_speed_hz = spi->controller->max_speed_hz;
3277 
3278 	if (spi->controller->setup)
3279 		status = spi->controller->setup(spi);
3280 
3281 	if (spi->controller->auto_runtime_pm && spi->controller->set_cs) {
3282 		status = pm_runtime_get_sync(spi->controller->dev.parent);
3283 		if (status < 0) {
3284 			pm_runtime_put_noidle(spi->controller->dev.parent);
3285 			dev_err(&spi->controller->dev, "Failed to power device: %d\n",
3286 				status);
3287 			return status;
3288 		}
3289 
3290 		/*
3291 		 * We do not want to return positive value from pm_runtime_get,
3292 		 * there are many instances of devices calling spi_setup() and
3293 		 * checking for a non-zero return value instead of a negative
3294 		 * return value.
3295 		 */
3296 		status = 0;
3297 
3298 		spi_set_cs(spi, false);
3299 		pm_runtime_mark_last_busy(spi->controller->dev.parent);
3300 		pm_runtime_put_autosuspend(spi->controller->dev.parent);
3301 	} else {
3302 		spi_set_cs(spi, false);
3303 	}
3304 
3305 	if (spi->rt && !spi->controller->rt) {
3306 		spi->controller->rt = true;
3307 		spi_set_thread_rt(spi->controller);
3308 	}
3309 
3310 	dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s%u bits/w, %u Hz max --> %d\n",
3311 			(int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
3312 			(spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
3313 			(spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
3314 			(spi->mode & SPI_3WIRE) ? "3wire, " : "",
3315 			(spi->mode & SPI_LOOP) ? "loopback, " : "",
3316 			spi->bits_per_word, spi->max_speed_hz,
3317 			status);
3318 
3319 	return status;
3320 }
3321 EXPORT_SYMBOL_GPL(spi_setup);
3322 
3323 /**
3324  * spi_set_cs_timing - configure CS setup, hold, and inactive delays
3325  * @spi: the device that requires specific CS timing configuration
3326  * @setup: CS setup time specified via @spi_delay
3327  * @hold: CS hold time specified via @spi_delay
3328  * @inactive: CS inactive delay between transfers specified via @spi_delay
3329  *
3330  * Return: zero on success, else a negative error code.
3331  */
3332 int spi_set_cs_timing(struct spi_device *spi, struct spi_delay *setup,
3333 		      struct spi_delay *hold, struct spi_delay *inactive)
3334 {
3335 	size_t len;
3336 
3337 	if (spi->controller->set_cs_timing)
3338 		return spi->controller->set_cs_timing(spi, setup, hold,
3339 						      inactive);
3340 
3341 	if ((setup && setup->unit == SPI_DELAY_UNIT_SCK) ||
3342 	    (hold && hold->unit == SPI_DELAY_UNIT_SCK) ||
3343 	    (inactive && inactive->unit == SPI_DELAY_UNIT_SCK)) {
3344 		dev_err(&spi->dev,
3345 			"Clock-cycle delays for CS not supported in SW mode\n");
3346 		return -ENOTSUPP;
3347 	}
3348 
3349 	len = sizeof(struct spi_delay);
3350 
3351 	/* copy delays to controller */
3352 	if (setup)
3353 		memcpy(&spi->controller->cs_setup, setup, len);
3354 	else
3355 		memset(&spi->controller->cs_setup, 0, len);
3356 
3357 	if (hold)
3358 		memcpy(&spi->controller->cs_hold, hold, len);
3359 	else
3360 		memset(&spi->controller->cs_hold, 0, len);
3361 
3362 	if (inactive)
3363 		memcpy(&spi->controller->cs_inactive, inactive, len);
3364 	else
3365 		memset(&spi->controller->cs_inactive, 0, len);
3366 
3367 	return 0;
3368 }
3369 EXPORT_SYMBOL_GPL(spi_set_cs_timing);
3370 
3371 static int _spi_xfer_word_delay_update(struct spi_transfer *xfer,
3372 				       struct spi_device *spi)
3373 {
3374 	int delay1, delay2;
3375 
3376 	delay1 = spi_delay_to_ns(&xfer->word_delay, xfer);
3377 	if (delay1 < 0)
3378 		return delay1;
3379 
3380 	delay2 = spi_delay_to_ns(&spi->word_delay, xfer);
3381 	if (delay2 < 0)
3382 		return delay2;
3383 
3384 	if (delay1 < delay2)
3385 		memcpy(&xfer->word_delay, &spi->word_delay,
3386 		       sizeof(xfer->word_delay));
3387 
3388 	return 0;
3389 }
3390 
3391 static int __spi_validate(struct spi_device *spi, struct spi_message *message)
3392 {
3393 	struct spi_controller *ctlr = spi->controller;
3394 	struct spi_transfer *xfer;
3395 	int w_size;
3396 
3397 	if (list_empty(&message->transfers))
3398 		return -EINVAL;
3399 
3400 	/* If an SPI controller does not support toggling the CS line on each
3401 	 * transfer (indicated by the SPI_CS_WORD flag) or we are using a GPIO
3402 	 * for the CS line, we can emulate the CS-per-word hardware function by
3403 	 * splitting transfers into one-word transfers and ensuring that
3404 	 * cs_change is set for each transfer.
3405 	 */
3406 	if ((spi->mode & SPI_CS_WORD) && (!(ctlr->mode_bits & SPI_CS_WORD) ||
3407 					  spi->cs_gpiod ||
3408 					  gpio_is_valid(spi->cs_gpio))) {
3409 		size_t maxsize;
3410 		int ret;
3411 
3412 		maxsize = (spi->bits_per_word + 7) / 8;
3413 
3414 		/* spi_split_transfers_maxsize() requires message->spi */
3415 		message->spi = spi;
3416 
3417 		ret = spi_split_transfers_maxsize(ctlr, message, maxsize,
3418 						  GFP_KERNEL);
3419 		if (ret)
3420 			return ret;
3421 
3422 		list_for_each_entry(xfer, &message->transfers, transfer_list) {
3423 			/* don't change cs_change on the last entry in the list */
3424 			if (list_is_last(&xfer->transfer_list, &message->transfers))
3425 				break;
3426 			xfer->cs_change = 1;
3427 		}
3428 	}
3429 
3430 	/* Half-duplex links include original MicroWire, and ones with
3431 	 * only one data pin like SPI_3WIRE (switches direction) or where
3432 	 * either MOSI or MISO is missing.  They can also be caused by
3433 	 * software limitations.
3434 	 */
3435 	if ((ctlr->flags & SPI_CONTROLLER_HALF_DUPLEX) ||
3436 	    (spi->mode & SPI_3WIRE)) {
3437 		unsigned flags = ctlr->flags;
3438 
3439 		list_for_each_entry(xfer, &message->transfers, transfer_list) {
3440 			if (xfer->rx_buf && xfer->tx_buf)
3441 				return -EINVAL;
3442 			if ((flags & SPI_CONTROLLER_NO_TX) && xfer->tx_buf)
3443 				return -EINVAL;
3444 			if ((flags & SPI_CONTROLLER_NO_RX) && xfer->rx_buf)
3445 				return -EINVAL;
3446 		}
3447 	}
3448 
3449 	/**
3450 	 * Set transfer bits_per_word and max speed as spi device default if
3451 	 * it is not set for this transfer.
3452 	 * Set transfer tx_nbits and rx_nbits as single transfer default
3453 	 * (SPI_NBITS_SINGLE) if it is not set for this transfer.
3454 	 * Ensure transfer word_delay is at least as long as that required by
3455 	 * device itself.
3456 	 */
3457 	message->frame_length = 0;
3458 	list_for_each_entry(xfer, &message->transfers, transfer_list) {
3459 		xfer->effective_speed_hz = 0;
3460 		message->frame_length += xfer->len;
3461 		if (!xfer->bits_per_word)
3462 			xfer->bits_per_word = spi->bits_per_word;
3463 
3464 		if (!xfer->speed_hz)
3465 			xfer->speed_hz = spi->max_speed_hz;
3466 
3467 		if (ctlr->max_speed_hz && xfer->speed_hz > ctlr->max_speed_hz)
3468 			xfer->speed_hz = ctlr->max_speed_hz;
3469 
3470 		if (__spi_validate_bits_per_word(ctlr, xfer->bits_per_word))
3471 			return -EINVAL;
3472 
3473 		/*
3474 		 * SPI transfer length should be multiple of SPI word size
3475 		 * where SPI word size should be power-of-two multiple
3476 		 */
3477 		if (xfer->bits_per_word <= 8)
3478 			w_size = 1;
3479 		else if (xfer->bits_per_word <= 16)
3480 			w_size = 2;
3481 		else
3482 			w_size = 4;
3483 
3484 		/* No partial transfers accepted */
3485 		if (xfer->len % w_size)
3486 			return -EINVAL;
3487 
3488 		if (xfer->speed_hz && ctlr->min_speed_hz &&
3489 		    xfer->speed_hz < ctlr->min_speed_hz)
3490 			return -EINVAL;
3491 
3492 		if (xfer->tx_buf && !xfer->tx_nbits)
3493 			xfer->tx_nbits = SPI_NBITS_SINGLE;
3494 		if (xfer->rx_buf && !xfer->rx_nbits)
3495 			xfer->rx_nbits = SPI_NBITS_SINGLE;
3496 		/* check transfer tx/rx_nbits:
3497 		 * 1. check the value matches one of single, dual and quad
3498 		 * 2. check tx/rx_nbits match the mode in spi_device
3499 		 */
3500 		if (xfer->tx_buf) {
3501 			if (xfer->tx_nbits != SPI_NBITS_SINGLE &&
3502 				xfer->tx_nbits != SPI_NBITS_DUAL &&
3503 				xfer->tx_nbits != SPI_NBITS_QUAD)
3504 				return -EINVAL;
3505 			if ((xfer->tx_nbits == SPI_NBITS_DUAL) &&
3506 				!(spi->mode & (SPI_TX_DUAL | SPI_TX_QUAD)))
3507 				return -EINVAL;
3508 			if ((xfer->tx_nbits == SPI_NBITS_QUAD) &&
3509 				!(spi->mode & SPI_TX_QUAD))
3510 				return -EINVAL;
3511 		}
3512 		/* check transfer rx_nbits */
3513 		if (xfer->rx_buf) {
3514 			if (xfer->rx_nbits != SPI_NBITS_SINGLE &&
3515 				xfer->rx_nbits != SPI_NBITS_DUAL &&
3516 				xfer->rx_nbits != SPI_NBITS_QUAD)
3517 				return -EINVAL;
3518 			if ((xfer->rx_nbits == SPI_NBITS_DUAL) &&
3519 				!(spi->mode & (SPI_RX_DUAL | SPI_RX_QUAD)))
3520 				return -EINVAL;
3521 			if ((xfer->rx_nbits == SPI_NBITS_QUAD) &&
3522 				!(spi->mode & SPI_RX_QUAD))
3523 				return -EINVAL;
3524 		}
3525 
3526 		if (_spi_xfer_word_delay_update(xfer, spi))
3527 			return -EINVAL;
3528 	}
3529 
3530 	message->status = -EINPROGRESS;
3531 
3532 	return 0;
3533 }
3534 
3535 static int __spi_async(struct spi_device *spi, struct spi_message *message)
3536 {
3537 	struct spi_controller *ctlr = spi->controller;
3538 	struct spi_transfer *xfer;
3539 
3540 	/*
3541 	 * Some controllers do not support doing regular SPI transfers. Return
3542 	 * ENOTSUPP when this is the case.
3543 	 */
3544 	if (!ctlr->transfer)
3545 		return -ENOTSUPP;
3546 
3547 	message->spi = spi;
3548 
3549 	SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics, spi_async);
3550 	SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_async);
3551 
3552 	trace_spi_message_submit(message);
3553 
3554 	if (!ctlr->ptp_sts_supported) {
3555 		list_for_each_entry(xfer, &message->transfers, transfer_list) {
3556 			xfer->ptp_sts_word_pre = 0;
3557 			ptp_read_system_prets(xfer->ptp_sts);
3558 		}
3559 	}
3560 
3561 	return ctlr->transfer(spi, message);
3562 }
3563 
3564 /**
3565  * spi_async - asynchronous SPI transfer
3566  * @spi: device with which data will be exchanged
3567  * @message: describes the data transfers, including completion callback
3568  * Context: any (irqs may be blocked, etc)
3569  *
3570  * This call may be used in_irq and other contexts which can't sleep,
3571  * as well as from task contexts which can sleep.
3572  *
3573  * The completion callback is invoked in a context which can't sleep.
3574  * Before that invocation, the value of message->status is undefined.
3575  * When the callback is issued, message->status holds either zero (to
3576  * indicate complete success) or a negative error code.  After that
3577  * callback returns, the driver which issued the transfer request may
3578  * deallocate the associated memory; it's no longer in use by any SPI
3579  * core or controller driver code.
3580  *
3581  * Note that although all messages to a spi_device are handled in
3582  * FIFO order, messages may go to different devices in other orders.
3583  * Some device might be higher priority, or have various "hard" access
3584  * time requirements, for example.
3585  *
3586  * On detection of any fault during the transfer, processing of
3587  * the entire message is aborted, and the device is deselected.
3588  * Until returning from the associated message completion callback,
3589  * no other spi_message queued to that device will be processed.
3590  * (This rule applies equally to all the synchronous transfer calls,
3591  * which are wrappers around this core asynchronous primitive.)
3592  *
3593  * Return: zero on success, else a negative error code.
3594  */
3595 int spi_async(struct spi_device *spi, struct spi_message *message)
3596 {
3597 	struct spi_controller *ctlr = spi->controller;
3598 	int ret;
3599 	unsigned long flags;
3600 
3601 	ret = __spi_validate(spi, message);
3602 	if (ret != 0)
3603 		return ret;
3604 
3605 	spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags);
3606 
3607 	if (ctlr->bus_lock_flag)
3608 		ret = -EBUSY;
3609 	else
3610 		ret = __spi_async(spi, message);
3611 
3612 	spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags);
3613 
3614 	return ret;
3615 }
3616 EXPORT_SYMBOL_GPL(spi_async);
3617 
3618 /**
3619  * spi_async_locked - version of spi_async with exclusive bus usage
3620  * @spi: device with which data will be exchanged
3621  * @message: describes the data transfers, including completion callback
3622  * Context: any (irqs may be blocked, etc)
3623  *
3624  * This call may be used in_irq and other contexts which can't sleep,
3625  * as well as from task contexts which can sleep.
3626  *
3627  * The completion callback is invoked in a context which can't sleep.
3628  * Before that invocation, the value of message->status is undefined.
3629  * When the callback is issued, message->status holds either zero (to
3630  * indicate complete success) or a negative error code.  After that
3631  * callback returns, the driver which issued the transfer request may
3632  * deallocate the associated memory; it's no longer in use by any SPI
3633  * core or controller driver code.
3634  *
3635  * Note that although all messages to a spi_device are handled in
3636  * FIFO order, messages may go to different devices in other orders.
3637  * Some device might be higher priority, or have various "hard" access
3638  * time requirements, for example.
3639  *
3640  * On detection of any fault during the transfer, processing of
3641  * the entire message is aborted, and the device is deselected.
3642  * Until returning from the associated message completion callback,
3643  * no other spi_message queued to that device will be processed.
3644  * (This rule applies equally to all the synchronous transfer calls,
3645  * which are wrappers around this core asynchronous primitive.)
3646  *
3647  * Return: zero on success, else a negative error code.
3648  */
3649 int spi_async_locked(struct spi_device *spi, struct spi_message *message)
3650 {
3651 	struct spi_controller *ctlr = spi->controller;
3652 	int ret;
3653 	unsigned long flags;
3654 
3655 	ret = __spi_validate(spi, message);
3656 	if (ret != 0)
3657 		return ret;
3658 
3659 	spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags);
3660 
3661 	ret = __spi_async(spi, message);
3662 
3663 	spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags);
3664 
3665 	return ret;
3666 
3667 }
3668 EXPORT_SYMBOL_GPL(spi_async_locked);
3669 
3670 /*-------------------------------------------------------------------------*/
3671 
3672 /* Utility methods for SPI protocol drivers, layered on
3673  * top of the core.  Some other utility methods are defined as
3674  * inline functions.
3675  */
3676 
3677 static void spi_complete(void *arg)
3678 {
3679 	complete(arg);
3680 }
3681 
3682 static int __spi_sync(struct spi_device *spi, struct spi_message *message)
3683 {
3684 	DECLARE_COMPLETION_ONSTACK(done);
3685 	int status;
3686 	struct spi_controller *ctlr = spi->controller;
3687 	unsigned long flags;
3688 
3689 	status = __spi_validate(spi, message);
3690 	if (status != 0)
3691 		return status;
3692 
3693 	message->complete = spi_complete;
3694 	message->context = &done;
3695 	message->spi = spi;
3696 
3697 	SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics, spi_sync);
3698 	SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_sync);
3699 
3700 	/* If we're not using the legacy transfer method then we will
3701 	 * try to transfer in the calling context so special case.
3702 	 * This code would be less tricky if we could remove the
3703 	 * support for driver implemented message queues.
3704 	 */
3705 	if (ctlr->transfer == spi_queued_transfer) {
3706 		spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags);
3707 
3708 		trace_spi_message_submit(message);
3709 
3710 		status = __spi_queued_transfer(spi, message, false);
3711 
3712 		spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags);
3713 	} else {
3714 		status = spi_async_locked(spi, message);
3715 	}
3716 
3717 	if (status == 0) {
3718 		/* Push out the messages in the calling context if we
3719 		 * can.
3720 		 */
3721 		if (ctlr->transfer == spi_queued_transfer) {
3722 			SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics,
3723 						       spi_sync_immediate);
3724 			SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics,
3725 						       spi_sync_immediate);
3726 			__spi_pump_messages(ctlr, false);
3727 		}
3728 
3729 		wait_for_completion(&done);
3730 		status = message->status;
3731 	}
3732 	message->context = NULL;
3733 	return status;
3734 }
3735 
3736 /**
3737  * spi_sync - blocking/synchronous SPI data transfers
3738  * @spi: device with which data will be exchanged
3739  * @message: describes the data transfers
3740  * Context: can sleep
3741  *
3742  * This call may only be used from a context that may sleep.  The sleep
3743  * is non-interruptible, and has no timeout.  Low-overhead controller
3744  * drivers may DMA directly into and out of the message buffers.
3745  *
3746  * Note that the SPI device's chip select is active during the message,
3747  * and then is normally disabled between messages.  Drivers for some
3748  * frequently-used devices may want to minimize costs of selecting a chip,
3749  * by leaving it selected in anticipation that the next message will go
3750  * to the same chip.  (That may increase power usage.)
3751  *
3752  * Also, the caller is guaranteeing that the memory associated with the
3753  * message will not be freed before this call returns.
3754  *
3755  * Return: zero on success, else a negative error code.
3756  */
3757 int spi_sync(struct spi_device *spi, struct spi_message *message)
3758 {
3759 	int ret;
3760 
3761 	mutex_lock(&spi->controller->bus_lock_mutex);
3762 	ret = __spi_sync(spi, message);
3763 	mutex_unlock(&spi->controller->bus_lock_mutex);
3764 
3765 	return ret;
3766 }
3767 EXPORT_SYMBOL_GPL(spi_sync);
3768 
3769 /**
3770  * spi_sync_locked - version of spi_sync with exclusive bus usage
3771  * @spi: device with which data will be exchanged
3772  * @message: describes the data transfers
3773  * Context: can sleep
3774  *
3775  * This call may only be used from a context that may sleep.  The sleep
3776  * is non-interruptible, and has no timeout.  Low-overhead controller
3777  * drivers may DMA directly into and out of the message buffers.
3778  *
3779  * This call should be used by drivers that require exclusive access to the
3780  * SPI bus. It has to be preceded by a spi_bus_lock call. The SPI bus must
3781  * be released by a spi_bus_unlock call when the exclusive access is over.
3782  *
3783  * Return: zero on success, else a negative error code.
3784  */
3785 int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
3786 {
3787 	return __spi_sync(spi, message);
3788 }
3789 EXPORT_SYMBOL_GPL(spi_sync_locked);
3790 
3791 /**
3792  * spi_bus_lock - obtain a lock for exclusive SPI bus usage
3793  * @ctlr: SPI bus master that should be locked for exclusive bus access
3794  * Context: can sleep
3795  *
3796  * This call may only be used from a context that may sleep.  The sleep
3797  * is non-interruptible, and has no timeout.
3798  *
3799  * This call should be used by drivers that require exclusive access to the
3800  * SPI bus. The SPI bus must be released by a spi_bus_unlock call when the
3801  * exclusive access is over. Data transfer must be done by spi_sync_locked
3802  * and spi_async_locked calls when the SPI bus lock is held.
3803  *
3804  * Return: always zero.
3805  */
3806 int spi_bus_lock(struct spi_controller *ctlr)
3807 {
3808 	unsigned long flags;
3809 
3810 	mutex_lock(&ctlr->bus_lock_mutex);
3811 
3812 	spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags);
3813 	ctlr->bus_lock_flag = 1;
3814 	spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags);
3815 
3816 	/* mutex remains locked until spi_bus_unlock is called */
3817 
3818 	return 0;
3819 }
3820 EXPORT_SYMBOL_GPL(spi_bus_lock);
3821 
3822 /**
3823  * spi_bus_unlock - release the lock for exclusive SPI bus usage
3824  * @ctlr: SPI bus master that was locked for exclusive bus access
3825  * Context: can sleep
3826  *
3827  * This call may only be used from a context that may sleep.  The sleep
3828  * is non-interruptible, and has no timeout.
3829  *
3830  * This call releases an SPI bus lock previously obtained by an spi_bus_lock
3831  * call.
3832  *
3833  * Return: always zero.
3834  */
3835 int spi_bus_unlock(struct spi_controller *ctlr)
3836 {
3837 	ctlr->bus_lock_flag = 0;
3838 
3839 	mutex_unlock(&ctlr->bus_lock_mutex);
3840 
3841 	return 0;
3842 }
3843 EXPORT_SYMBOL_GPL(spi_bus_unlock);
3844 
3845 /* portable code must never pass more than 32 bytes */
3846 #define	SPI_BUFSIZ	max(32, SMP_CACHE_BYTES)
3847 
3848 static u8	*buf;
3849 
3850 /**
3851  * spi_write_then_read - SPI synchronous write followed by read
3852  * @spi: device with which data will be exchanged
3853  * @txbuf: data to be written (need not be dma-safe)
3854  * @n_tx: size of txbuf, in bytes
3855  * @rxbuf: buffer into which data will be read (need not be dma-safe)
3856  * @n_rx: size of rxbuf, in bytes
3857  * Context: can sleep
3858  *
3859  * This performs a half duplex MicroWire style transaction with the
3860  * device, sending txbuf and then reading rxbuf.  The return value
3861  * is zero for success, else a negative errno status code.
3862  * This call may only be used from a context that may sleep.
3863  *
3864  * Parameters to this routine are always copied using a small buffer;
3865  * portable code should never use this for more than 32 bytes.
3866  * Performance-sensitive or bulk transfer code should instead use
3867  * spi_{async,sync}() calls with dma-safe buffers.
3868  *
3869  * Return: zero on success, else a negative error code.
3870  */
3871 int spi_write_then_read(struct spi_device *spi,
3872 		const void *txbuf, unsigned n_tx,
3873 		void *rxbuf, unsigned n_rx)
3874 {
3875 	static DEFINE_MUTEX(lock);
3876 
3877 	int			status;
3878 	struct spi_message	message;
3879 	struct spi_transfer	x[2];
3880 	u8			*local_buf;
3881 
3882 	/* Use preallocated DMA-safe buffer if we can.  We can't avoid
3883 	 * copying here, (as a pure convenience thing), but we can
3884 	 * keep heap costs out of the hot path unless someone else is
3885 	 * using the pre-allocated buffer or the transfer is too large.
3886 	 */
3887 	if ((n_tx + n_rx) > SPI_BUFSIZ || !mutex_trylock(&lock)) {
3888 		local_buf = kmalloc(max((unsigned)SPI_BUFSIZ, n_tx + n_rx),
3889 				    GFP_KERNEL | GFP_DMA);
3890 		if (!local_buf)
3891 			return -ENOMEM;
3892 	} else {
3893 		local_buf = buf;
3894 	}
3895 
3896 	spi_message_init(&message);
3897 	memset(x, 0, sizeof(x));
3898 	if (n_tx) {
3899 		x[0].len = n_tx;
3900 		spi_message_add_tail(&x[0], &message);
3901 	}
3902 	if (n_rx) {
3903 		x[1].len = n_rx;
3904 		spi_message_add_tail(&x[1], &message);
3905 	}
3906 
3907 	memcpy(local_buf, txbuf, n_tx);
3908 	x[0].tx_buf = local_buf;
3909 	x[1].rx_buf = local_buf + n_tx;
3910 
3911 	/* do the i/o */
3912 	status = spi_sync(spi, &message);
3913 	if (status == 0)
3914 		memcpy(rxbuf, x[1].rx_buf, n_rx);
3915 
3916 	if (x[0].tx_buf == buf)
3917 		mutex_unlock(&lock);
3918 	else
3919 		kfree(local_buf);
3920 
3921 	return status;
3922 }
3923 EXPORT_SYMBOL_GPL(spi_write_then_read);
3924 
3925 /*-------------------------------------------------------------------------*/
3926 
3927 #if IS_ENABLED(CONFIG_OF)
3928 /* must call put_device() when done with returned spi_device device */
3929 struct spi_device *of_find_spi_device_by_node(struct device_node *node)
3930 {
3931 	struct device *dev = bus_find_device_by_of_node(&spi_bus_type, node);
3932 
3933 	return dev ? to_spi_device(dev) : NULL;
3934 }
3935 EXPORT_SYMBOL_GPL(of_find_spi_device_by_node);
3936 #endif /* IS_ENABLED(CONFIG_OF) */
3937 
3938 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
3939 /* the spi controllers are not using spi_bus, so we find it with another way */
3940 static struct spi_controller *of_find_spi_controller_by_node(struct device_node *node)
3941 {
3942 	struct device *dev;
3943 
3944 	dev = class_find_device_by_of_node(&spi_master_class, node);
3945 	if (!dev && IS_ENABLED(CONFIG_SPI_SLAVE))
3946 		dev = class_find_device_by_of_node(&spi_slave_class, node);
3947 	if (!dev)
3948 		return NULL;
3949 
3950 	/* reference got in class_find_device */
3951 	return container_of(dev, struct spi_controller, dev);
3952 }
3953 
3954 static int of_spi_notify(struct notifier_block *nb, unsigned long action,
3955 			 void *arg)
3956 {
3957 	struct of_reconfig_data *rd = arg;
3958 	struct spi_controller *ctlr;
3959 	struct spi_device *spi;
3960 
3961 	switch (of_reconfig_get_state_change(action, arg)) {
3962 	case OF_RECONFIG_CHANGE_ADD:
3963 		ctlr = of_find_spi_controller_by_node(rd->dn->parent);
3964 		if (ctlr == NULL)
3965 			return NOTIFY_OK;	/* not for us */
3966 
3967 		if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
3968 			put_device(&ctlr->dev);
3969 			return NOTIFY_OK;
3970 		}
3971 
3972 		spi = of_register_spi_device(ctlr, rd->dn);
3973 		put_device(&ctlr->dev);
3974 
3975 		if (IS_ERR(spi)) {
3976 			pr_err("%s: failed to create for '%pOF'\n",
3977 					__func__, rd->dn);
3978 			of_node_clear_flag(rd->dn, OF_POPULATED);
3979 			return notifier_from_errno(PTR_ERR(spi));
3980 		}
3981 		break;
3982 
3983 	case OF_RECONFIG_CHANGE_REMOVE:
3984 		/* already depopulated? */
3985 		if (!of_node_check_flag(rd->dn, OF_POPULATED))
3986 			return NOTIFY_OK;
3987 
3988 		/* find our device by node */
3989 		spi = of_find_spi_device_by_node(rd->dn);
3990 		if (spi == NULL)
3991 			return NOTIFY_OK;	/* no? not meant for us */
3992 
3993 		/* unregister takes one ref away */
3994 		spi_unregister_device(spi);
3995 
3996 		/* and put the reference of the find */
3997 		put_device(&spi->dev);
3998 		break;
3999 	}
4000 
4001 	return NOTIFY_OK;
4002 }
4003 
4004 static struct notifier_block spi_of_notifier = {
4005 	.notifier_call = of_spi_notify,
4006 };
4007 #else /* IS_ENABLED(CONFIG_OF_DYNAMIC) */
4008 extern struct notifier_block spi_of_notifier;
4009 #endif /* IS_ENABLED(CONFIG_OF_DYNAMIC) */
4010 
4011 #if IS_ENABLED(CONFIG_ACPI)
4012 static int spi_acpi_controller_match(struct device *dev, const void *data)
4013 {
4014 	return ACPI_COMPANION(dev->parent) == data;
4015 }
4016 
4017 static struct spi_controller *acpi_spi_find_controller_by_adev(struct acpi_device *adev)
4018 {
4019 	struct device *dev;
4020 
4021 	dev = class_find_device(&spi_master_class, NULL, adev,
4022 				spi_acpi_controller_match);
4023 	if (!dev && IS_ENABLED(CONFIG_SPI_SLAVE))
4024 		dev = class_find_device(&spi_slave_class, NULL, adev,
4025 					spi_acpi_controller_match);
4026 	if (!dev)
4027 		return NULL;
4028 
4029 	return container_of(dev, struct spi_controller, dev);
4030 }
4031 
4032 static struct spi_device *acpi_spi_find_device_by_adev(struct acpi_device *adev)
4033 {
4034 	struct device *dev;
4035 
4036 	dev = bus_find_device_by_acpi_dev(&spi_bus_type, adev);
4037 	return dev ? to_spi_device(dev) : NULL;
4038 }
4039 
4040 static int acpi_spi_notify(struct notifier_block *nb, unsigned long value,
4041 			   void *arg)
4042 {
4043 	struct acpi_device *adev = arg;
4044 	struct spi_controller *ctlr;
4045 	struct spi_device *spi;
4046 
4047 	switch (value) {
4048 	case ACPI_RECONFIG_DEVICE_ADD:
4049 		ctlr = acpi_spi_find_controller_by_adev(adev->parent);
4050 		if (!ctlr)
4051 			break;
4052 
4053 		acpi_register_spi_device(ctlr, adev);
4054 		put_device(&ctlr->dev);
4055 		break;
4056 	case ACPI_RECONFIG_DEVICE_REMOVE:
4057 		if (!acpi_device_enumerated(adev))
4058 			break;
4059 
4060 		spi = acpi_spi_find_device_by_adev(adev);
4061 		if (!spi)
4062 			break;
4063 
4064 		spi_unregister_device(spi);
4065 		put_device(&spi->dev);
4066 		break;
4067 	}
4068 
4069 	return NOTIFY_OK;
4070 }
4071 
4072 static struct notifier_block spi_acpi_notifier = {
4073 	.notifier_call = acpi_spi_notify,
4074 };
4075 #else
4076 extern struct notifier_block spi_acpi_notifier;
4077 #endif
4078 
4079 static int __init spi_init(void)
4080 {
4081 	int	status;
4082 
4083 	buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
4084 	if (!buf) {
4085 		status = -ENOMEM;
4086 		goto err0;
4087 	}
4088 
4089 	status = bus_register(&spi_bus_type);
4090 	if (status < 0)
4091 		goto err1;
4092 
4093 	status = class_register(&spi_master_class);
4094 	if (status < 0)
4095 		goto err2;
4096 
4097 	if (IS_ENABLED(CONFIG_SPI_SLAVE)) {
4098 		status = class_register(&spi_slave_class);
4099 		if (status < 0)
4100 			goto err3;
4101 	}
4102 
4103 	if (IS_ENABLED(CONFIG_OF_DYNAMIC))
4104 		WARN_ON(of_reconfig_notifier_register(&spi_of_notifier));
4105 	if (IS_ENABLED(CONFIG_ACPI))
4106 		WARN_ON(acpi_reconfig_notifier_register(&spi_acpi_notifier));
4107 
4108 	return 0;
4109 
4110 err3:
4111 	class_unregister(&spi_master_class);
4112 err2:
4113 	bus_unregister(&spi_bus_type);
4114 err1:
4115 	kfree(buf);
4116 	buf = NULL;
4117 err0:
4118 	return status;
4119 }
4120 
4121 /* board_info is normally registered in arch_initcall(),
4122  * but even essential drivers wait till later
4123  *
4124  * REVISIT only boardinfo really needs static linking. the rest (device and
4125  * driver registration) _could_ be dynamically linked (modular) ... costs
4126  * include needing to have boardinfo data structures be much more public.
4127  */
4128 postcore_initcall(spi_init);
4129