1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/kernel.h>
19#include <linux/device.h>
20#include <linux/init.h>
21#include <linux/cache.h>
22#include <linux/dma-mapping.h>
23#include <linux/dmaengine.h>
24#include <linux/mutex.h>
25#include <linux/of_device.h>
26#include <linux/of_irq.h>
27#include <linux/clk/clk-conf.h>
28#include <linux/slab.h>
29#include <linux/mod_devicetable.h>
30#include <linux/spi/spi.h>
31#include <linux/of_gpio.h>
32#include <linux/pm_runtime.h>
33#include <linux/pm_domain.h>
34#include <linux/export.h>
35#include <linux/sched/rt.h>
36#include <linux/delay.h>
37#include <linux/kthread.h>
38#include <linux/ioport.h>
39#include <linux/acpi.h>
40
41#define CREATE_TRACE_POINTS
42#include <trace/events/spi.h>
43
44static void spidev_release(struct device *dev)
45{
46 struct spi_device *spi = to_spi_device(dev);
47
48
49 if (spi->master->cleanup)
50 spi->master->cleanup(spi);
51
52 spi_master_put(spi->master);
53 kfree(spi);
54}
55
56static ssize_t
57modalias_show(struct device *dev, struct device_attribute *a, char *buf)
58{
59 const struct spi_device *spi = to_spi_device(dev);
60 int len;
61
62 len = acpi_device_modalias(dev, buf, PAGE_SIZE - 1);
63 if (len != -ENODEV)
64 return len;
65
66 return sprintf(buf, "%s%s\n", SPI_MODULE_PREFIX, spi->modalias);
67}
68static DEVICE_ATTR_RO(modalias);
69
70#define SPI_STATISTICS_ATTRS(field, file) \
71static ssize_t spi_master_##field##_show(struct device *dev, \
72 struct device_attribute *attr, \
73 char *buf) \
74{ \
75 struct spi_master *master = container_of(dev, \
76 struct spi_master, dev); \
77 return spi_statistics_##field##_show(&master->statistics, buf); \
78} \
79static struct device_attribute dev_attr_spi_master_##field = { \
80 .attr = { .name = file, .mode = S_IRUGO }, \
81 .show = spi_master_##field##_show, \
82}; \
83static ssize_t spi_device_##field##_show(struct device *dev, \
84 struct device_attribute *attr, \
85 char *buf) \
86{ \
87 struct spi_device *spi = to_spi_device(dev); \
88 return spi_statistics_##field##_show(&spi->statistics, buf); \
89} \
90static struct device_attribute dev_attr_spi_device_##field = { \
91 .attr = { .name = file, .mode = S_IRUGO }, \
92 .show = spi_device_##field##_show, \
93}
94
95#define SPI_STATISTICS_SHOW_NAME(name, file, field, format_string) \
96static ssize_t spi_statistics_##name##_show(struct spi_statistics *stat, \
97 char *buf) \
98{ \
99 unsigned long flags; \
100 ssize_t len; \
101 spin_lock_irqsave(&stat->lock, flags); \
102 len = sprintf(buf, format_string, stat->field); \
103 spin_unlock_irqrestore(&stat->lock, flags); \
104 return len; \
105} \
106SPI_STATISTICS_ATTRS(name, file)
107
108#define SPI_STATISTICS_SHOW(field, format_string) \
109 SPI_STATISTICS_SHOW_NAME(field, __stringify(field), \
110 field, format_string)
111
112SPI_STATISTICS_SHOW(messages, "%lu");
113SPI_STATISTICS_SHOW(transfers, "%lu");
114SPI_STATISTICS_SHOW(errors, "%lu");
115SPI_STATISTICS_SHOW(timedout, "%lu");
116
117SPI_STATISTICS_SHOW(spi_sync, "%lu");
118SPI_STATISTICS_SHOW(spi_sync_immediate, "%lu");
119SPI_STATISTICS_SHOW(spi_async, "%lu");
120
121SPI_STATISTICS_SHOW(bytes, "%llu");
122SPI_STATISTICS_SHOW(bytes_rx, "%llu");
123SPI_STATISTICS_SHOW(bytes_tx, "%llu");
124
125#define SPI_STATISTICS_TRANSFER_BYTES_HISTO(index, number) \
126 SPI_STATISTICS_SHOW_NAME(transfer_bytes_histo##index, \
127 "transfer_bytes_histo_" number, \
128 transfer_bytes_histo[index], "%lu")
129SPI_STATISTICS_TRANSFER_BYTES_HISTO(0, "0-1");
130SPI_STATISTICS_TRANSFER_BYTES_HISTO(1, "2-3");
131SPI_STATISTICS_TRANSFER_BYTES_HISTO(2, "4-7");
132SPI_STATISTICS_TRANSFER_BYTES_HISTO(3, "8-15");
133SPI_STATISTICS_TRANSFER_BYTES_HISTO(4, "16-31");
134SPI_STATISTICS_TRANSFER_BYTES_HISTO(5, "32-63");
135SPI_STATISTICS_TRANSFER_BYTES_HISTO(6, "64-127");
136SPI_STATISTICS_TRANSFER_BYTES_HISTO(7, "128-255");
137SPI_STATISTICS_TRANSFER_BYTES_HISTO(8, "256-511");
138SPI_STATISTICS_TRANSFER_BYTES_HISTO(9, "512-1023");
139SPI_STATISTICS_TRANSFER_BYTES_HISTO(10, "1024-2047");
140SPI_STATISTICS_TRANSFER_BYTES_HISTO(11, "2048-4095");
141SPI_STATISTICS_TRANSFER_BYTES_HISTO(12, "4096-8191");
142SPI_STATISTICS_TRANSFER_BYTES_HISTO(13, "8192-16383");
143SPI_STATISTICS_TRANSFER_BYTES_HISTO(14, "16384-32767");
144SPI_STATISTICS_TRANSFER_BYTES_HISTO(15, "32768-65535");
145SPI_STATISTICS_TRANSFER_BYTES_HISTO(16, "65536+");
146
147SPI_STATISTICS_SHOW(transfers_split_maxsize, "%lu");
148
149static struct attribute *spi_dev_attrs[] = {
150 &dev_attr_modalias.attr,
151 NULL,
152};
153
154static const struct attribute_group spi_dev_group = {
155 .attrs = spi_dev_attrs,
156};
157
158static struct attribute *spi_device_statistics_attrs[] = {
159 &dev_attr_spi_device_messages.attr,
160 &dev_attr_spi_device_transfers.attr,
161 &dev_attr_spi_device_errors.attr,
162 &dev_attr_spi_device_timedout.attr,
163 &dev_attr_spi_device_spi_sync.attr,
164 &dev_attr_spi_device_spi_sync_immediate.attr,
165 &dev_attr_spi_device_spi_async.attr,
166 &dev_attr_spi_device_bytes.attr,
167 &dev_attr_spi_device_bytes_rx.attr,
168 &dev_attr_spi_device_bytes_tx.attr,
169 &dev_attr_spi_device_transfer_bytes_histo0.attr,
170 &dev_attr_spi_device_transfer_bytes_histo1.attr,
171 &dev_attr_spi_device_transfer_bytes_histo2.attr,
172 &dev_attr_spi_device_transfer_bytes_histo3.attr,
173 &dev_attr_spi_device_transfer_bytes_histo4.attr,
174 &dev_attr_spi_device_transfer_bytes_histo5.attr,
175 &dev_attr_spi_device_transfer_bytes_histo6.attr,
176 &dev_attr_spi_device_transfer_bytes_histo7.attr,
177 &dev_attr_spi_device_transfer_bytes_histo8.attr,
178 &dev_attr_spi_device_transfer_bytes_histo9.attr,
179 &dev_attr_spi_device_transfer_bytes_histo10.attr,
180 &dev_attr_spi_device_transfer_bytes_histo11.attr,
181 &dev_attr_spi_device_transfer_bytes_histo12.attr,
182 &dev_attr_spi_device_transfer_bytes_histo13.attr,
183 &dev_attr_spi_device_transfer_bytes_histo14.attr,
184 &dev_attr_spi_device_transfer_bytes_histo15.attr,
185 &dev_attr_spi_device_transfer_bytes_histo16.attr,
186 &dev_attr_spi_device_transfers_split_maxsize.attr,
187 NULL,
188};
189
190static const struct attribute_group spi_device_statistics_group = {
191 .name = "statistics",
192 .attrs = spi_device_statistics_attrs,
193};
194
195static const struct attribute_group *spi_dev_groups[] = {
196 &spi_dev_group,
197 &spi_device_statistics_group,
198 NULL,
199};
200
201static struct attribute *spi_master_statistics_attrs[] = {
202 &dev_attr_spi_master_messages.attr,
203 &dev_attr_spi_master_transfers.attr,
204 &dev_attr_spi_master_errors.attr,
205 &dev_attr_spi_master_timedout.attr,
206 &dev_attr_spi_master_spi_sync.attr,
207 &dev_attr_spi_master_spi_sync_immediate.attr,
208 &dev_attr_spi_master_spi_async.attr,
209 &dev_attr_spi_master_bytes.attr,
210 &dev_attr_spi_master_bytes_rx.attr,
211 &dev_attr_spi_master_bytes_tx.attr,
212 &dev_attr_spi_master_transfer_bytes_histo0.attr,
213 &dev_attr_spi_master_transfer_bytes_histo1.attr,
214 &dev_attr_spi_master_transfer_bytes_histo2.attr,
215 &dev_attr_spi_master_transfer_bytes_histo3.attr,
216 &dev_attr_spi_master_transfer_bytes_histo4.attr,
217 &dev_attr_spi_master_transfer_bytes_histo5.attr,
218 &dev_attr_spi_master_transfer_bytes_histo6.attr,
219 &dev_attr_spi_master_transfer_bytes_histo7.attr,
220 &dev_attr_spi_master_transfer_bytes_histo8.attr,
221 &dev_attr_spi_master_transfer_bytes_histo9.attr,
222 &dev_attr_spi_master_transfer_bytes_histo10.attr,
223 &dev_attr_spi_master_transfer_bytes_histo11.attr,
224 &dev_attr_spi_master_transfer_bytes_histo12.attr,
225 &dev_attr_spi_master_transfer_bytes_histo13.attr,
226 &dev_attr_spi_master_transfer_bytes_histo14.attr,
227 &dev_attr_spi_master_transfer_bytes_histo15.attr,
228 &dev_attr_spi_master_transfer_bytes_histo16.attr,
229 &dev_attr_spi_master_transfers_split_maxsize.attr,
230 NULL,
231};
232
233static const struct attribute_group spi_master_statistics_group = {
234 .name = "statistics",
235 .attrs = spi_master_statistics_attrs,
236};
237
238static const struct attribute_group *spi_master_groups[] = {
239 &spi_master_statistics_group,
240 NULL,
241};
242
243void spi_statistics_add_transfer_stats(struct spi_statistics *stats,
244 struct spi_transfer *xfer,
245 struct spi_master *master)
246{
247 unsigned long flags;
248 int l2len = min(fls(xfer->len), SPI_STATISTICS_HISTO_SIZE) - 1;
249
250 if (l2len < 0)
251 l2len = 0;
252
253 spin_lock_irqsave(&stats->lock, flags);
254
255 stats->transfers++;
256 stats->transfer_bytes_histo[l2len]++;
257
258 stats->bytes += xfer->len;
259 if ((xfer->tx_buf) &&
260 (xfer->tx_buf != master->dummy_tx))
261 stats->bytes_tx += xfer->len;
262 if ((xfer->rx_buf) &&
263 (xfer->rx_buf != master->dummy_rx))
264 stats->bytes_rx += xfer->len;
265
266 spin_unlock_irqrestore(&stats->lock, flags);
267}
268EXPORT_SYMBOL_GPL(spi_statistics_add_transfer_stats);
269
270
271
272
273
274static const struct spi_device_id *spi_match_id(const struct spi_device_id *id,
275 const struct spi_device *sdev)
276{
277 while (id->name[0]) {
278 if (!strcmp(sdev->modalias, id->name))
279 return id;
280 id++;
281 }
282 return NULL;
283}
284
285const struct spi_device_id *spi_get_device_id(const struct spi_device *sdev)
286{
287 const struct spi_driver *sdrv = to_spi_driver(sdev->dev.driver);
288
289 return spi_match_id(sdrv->id_table, sdev);
290}
291EXPORT_SYMBOL_GPL(spi_get_device_id);
292
293static int spi_match_device(struct device *dev, struct device_driver *drv)
294{
295 const struct spi_device *spi = to_spi_device(dev);
296 const struct spi_driver *sdrv = to_spi_driver(drv);
297
298
299 if (of_driver_match_device(dev, drv))
300 return 1;
301
302
303 if (acpi_driver_match_device(dev, drv))
304 return 1;
305
306 if (sdrv->id_table)
307 return !!spi_match_id(sdrv->id_table, spi);
308
309 return strcmp(spi->modalias, drv->name) == 0;
310}
311
312static int spi_uevent(struct device *dev, struct kobj_uevent_env *env)
313{
314 const struct spi_device *spi = to_spi_device(dev);
315 int rc;
316
317 rc = acpi_device_uevent_modalias(dev, env);
318 if (rc != -ENODEV)
319 return rc;
320
321 add_uevent_var(env, "MODALIAS=%s%s", SPI_MODULE_PREFIX, spi->modalias);
322 return 0;
323}
324
325struct bus_type spi_bus_type = {
326 .name = "spi",
327 .dev_groups = spi_dev_groups,
328 .match = spi_match_device,
329 .uevent = spi_uevent,
330};
331EXPORT_SYMBOL_GPL(spi_bus_type);
332
333
334static int spi_drv_probe(struct device *dev)
335{
336 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
337 struct spi_device *spi = to_spi_device(dev);
338 int ret;
339
340 ret = of_clk_set_defaults(dev->of_node, false);
341 if (ret)
342 return ret;
343
344 if (dev->of_node) {
345 spi->irq = of_irq_get(dev->of_node, 0);
346 if (spi->irq == -EPROBE_DEFER)
347 return -EPROBE_DEFER;
348 if (spi->irq < 0)
349 spi->irq = 0;
350 }
351
352 ret = dev_pm_domain_attach(dev, true);
353 if (ret != -EPROBE_DEFER) {
354 ret = sdrv->probe(spi);
355 if (ret)
356 dev_pm_domain_detach(dev, true);
357 }
358
359 return ret;
360}
361
362static int spi_drv_remove(struct device *dev)
363{
364 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
365 int ret;
366
367 ret = sdrv->remove(to_spi_device(dev));
368 dev_pm_domain_detach(dev, true);
369
370 return ret;
371}
372
373static void spi_drv_shutdown(struct device *dev)
374{
375 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
376
377 sdrv->shutdown(to_spi_device(dev));
378}
379
380
381
382
383
384
385
386
387
388int __spi_register_driver(struct module *owner, struct spi_driver *sdrv)
389{
390 sdrv->driver.owner = owner;
391 sdrv->driver.bus = &spi_bus_type;
392 if (sdrv->probe)
393 sdrv->driver.probe = spi_drv_probe;
394 if (sdrv->remove)
395 sdrv->driver.remove = spi_drv_remove;
396 if (sdrv->shutdown)
397 sdrv->driver.shutdown = spi_drv_shutdown;
398 return driver_register(&sdrv->driver);
399}
400EXPORT_SYMBOL_GPL(__spi_register_driver);
401
402
403
404
405
406
407
408
409
410struct boardinfo {
411 struct list_head list;
412 struct spi_board_info board_info;
413};
414
415static LIST_HEAD(board_list);
416static LIST_HEAD(spi_master_list);
417
418
419
420
421
422static DEFINE_MUTEX(board_lock);
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441struct spi_device *spi_alloc_device(struct spi_master *master)
442{
443 struct spi_device *spi;
444
445 if (!spi_master_get(master))
446 return NULL;
447
448 spi = kzalloc(sizeof(*spi), GFP_KERNEL);
449 if (!spi) {
450 spi_master_put(master);
451 return NULL;
452 }
453
454 spi->master = master;
455 spi->dev.parent = &master->dev;
456 spi->dev.bus = &spi_bus_type;
457 spi->dev.release = spidev_release;
458 spi->cs_gpio = -ENOENT;
459
460 spin_lock_init(&spi->statistics.lock);
461
462 device_initialize(&spi->dev);
463 return spi;
464}
465EXPORT_SYMBOL_GPL(spi_alloc_device);
466
467static void spi_dev_set_name(struct spi_device *spi)
468{
469 struct acpi_device *adev = ACPI_COMPANION(&spi->dev);
470
471 if (adev) {
472 dev_set_name(&spi->dev, "spi-%s", acpi_dev_name(adev));
473 return;
474 }
475
476 dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),
477 spi->chip_select);
478}
479
480static int spi_dev_check(struct device *dev, void *data)
481{
482 struct spi_device *spi = to_spi_device(dev);
483 struct spi_device *new_spi = data;
484
485 if (spi->master == new_spi->master &&
486 spi->chip_select == new_spi->chip_select)
487 return -EBUSY;
488 return 0;
489}
490
491
492
493
494
495
496
497
498
499
500int spi_add_device(struct spi_device *spi)
501{
502 static DEFINE_MUTEX(spi_add_lock);
503 struct spi_master *master = spi->master;
504 struct device *dev = master->dev.parent;
505 int status;
506
507
508 if (spi->chip_select >= master->num_chipselect) {
509 dev_err(dev, "cs%d >= max %d\n",
510 spi->chip_select,
511 master->num_chipselect);
512 return -EINVAL;
513 }
514
515
516 spi_dev_set_name(spi);
517
518
519
520
521
522 mutex_lock(&spi_add_lock);
523
524 status = bus_for_each_dev(&spi_bus_type, NULL, spi, spi_dev_check);
525 if (status) {
526 dev_err(dev, "chipselect %d already in use\n",
527 spi->chip_select);
528 goto done;
529 }
530
531 if (master->cs_gpios)
532 spi->cs_gpio = master->cs_gpios[spi->chip_select];
533
534
535
536
537
538 status = spi_setup(spi);
539 if (status < 0) {
540 dev_err(dev, "can't setup %s, status %d\n",
541 dev_name(&spi->dev), status);
542 goto done;
543 }
544
545
546 status = device_add(&spi->dev);
547 if (status < 0)
548 dev_err(dev, "can't add %s, status %d\n",
549 dev_name(&spi->dev), status);
550 else
551 dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));
552
553done:
554 mutex_unlock(&spi_add_lock);
555 return status;
556}
557EXPORT_SYMBOL_GPL(spi_add_device);
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573struct spi_device *spi_new_device(struct spi_master *master,
574 struct spi_board_info *chip)
575{
576 struct spi_device *proxy;
577 int status;
578
579
580
581
582
583
584
585
586 proxy = spi_alloc_device(master);
587 if (!proxy)
588 return NULL;
589
590 WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
591
592 proxy->chip_select = chip->chip_select;
593 proxy->max_speed_hz = chip->max_speed_hz;
594 proxy->mode = chip->mode;
595 proxy->irq = chip->irq;
596 strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));
597 proxy->dev.platform_data = (void *) chip->platform_data;
598 proxy->controller_data = chip->controller_data;
599 proxy->controller_state = NULL;
600
601 status = spi_add_device(proxy);
602 if (status < 0) {
603 spi_dev_put(proxy);
604 return NULL;
605 }
606
607 return proxy;
608}
609EXPORT_SYMBOL_GPL(spi_new_device);
610
611
612
613
614
615
616
617
618void spi_unregister_device(struct spi_device *spi)
619{
620 if (!spi)
621 return;
622
623 if (spi->dev.of_node)
624 of_node_clear_flag(spi->dev.of_node, OF_POPULATED);
625 device_unregister(&spi->dev);
626}
627EXPORT_SYMBOL_GPL(spi_unregister_device);
628
629static void spi_match_master_to_boardinfo(struct spi_master *master,
630 struct spi_board_info *bi)
631{
632 struct spi_device *dev;
633
634 if (master->bus_num != bi->bus_num)
635 return;
636
637 dev = spi_new_device(master, bi);
638 if (!dev)
639 dev_err(master->dev.parent, "can't create new device for %s\n",
640 bi->modalias);
641}
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664int spi_register_board_info(struct spi_board_info const *info, unsigned n)
665{
666 struct boardinfo *bi;
667 int i;
668
669 if (!n)
670 return -EINVAL;
671
672 bi = kzalloc(n * sizeof(*bi), GFP_KERNEL);
673 if (!bi)
674 return -ENOMEM;
675
676 for (i = 0; i < n; i++, bi++, info++) {
677 struct spi_master *master;
678
679 memcpy(&bi->board_info, info, sizeof(*info));
680 mutex_lock(&board_lock);
681 list_add_tail(&bi->list, &board_list);
682 list_for_each_entry(master, &spi_master_list, list)
683 spi_match_master_to_boardinfo(master, &bi->board_info);
684 mutex_unlock(&board_lock);
685 }
686
687 return 0;
688}
689
690
691
692static void spi_set_cs(struct spi_device *spi, bool enable)
693{
694 if (spi->mode & SPI_CS_HIGH)
695 enable = !enable;
696
697 if (gpio_is_valid(spi->cs_gpio))
698 gpio_set_value(spi->cs_gpio, !enable);
699 else if (spi->master->set_cs)
700 spi->master->set_cs(spi, !enable);
701}
702
703#ifdef CONFIG_HAS_DMA
704static int spi_map_buf(struct spi_master *master, struct device *dev,
705 struct sg_table *sgt, void *buf, size_t len,
706 enum dma_data_direction dir)
707{
708 const bool vmalloced_buf = is_vmalloc_addr(buf);
709 unsigned int max_seg_size = dma_get_max_seg_size(dev);
710 int desc_len;
711 int sgs;
712 struct page *vm_page;
713 void *sg_buf;
714 size_t min;
715 int i, ret;
716
717 if (vmalloced_buf) {
718 desc_len = min_t(int, max_seg_size, PAGE_SIZE);
719 sgs = DIV_ROUND_UP(len + offset_in_page(buf), desc_len);
720 } else {
721 desc_len = min_t(int, max_seg_size, master->max_dma_len);
722 sgs = DIV_ROUND_UP(len, desc_len);
723 }
724
725 ret = sg_alloc_table(sgt, sgs, GFP_KERNEL);
726 if (ret != 0)
727 return ret;
728
729 for (i = 0; i < sgs; i++) {
730
731 if (vmalloced_buf) {
732 min = min_t(size_t,
733 len, desc_len - offset_in_page(buf));
734 vm_page = vmalloc_to_page(buf);
735 if (!vm_page) {
736 sg_free_table(sgt);
737 return -ENOMEM;
738 }
739 sg_set_page(&sgt->sgl[i], vm_page,
740 min, offset_in_page(buf));
741 } else {
742 min = min_t(size_t, len, desc_len);
743 sg_buf = buf;
744 sg_set_buf(&sgt->sgl[i], sg_buf, min);
745 }
746
747 buf += min;
748 len -= min;
749 }
750
751 ret = dma_map_sg(dev, sgt->sgl, sgt->nents, dir);
752 if (!ret)
753 ret = -ENOMEM;
754 if (ret < 0) {
755 sg_free_table(sgt);
756 return ret;
757 }
758
759 sgt->nents = ret;
760
761 return 0;
762}
763
764static void spi_unmap_buf(struct spi_master *master, struct device *dev,
765 struct sg_table *sgt, enum dma_data_direction dir)
766{
767 if (sgt->orig_nents) {
768 dma_unmap_sg(dev, sgt->sgl, sgt->orig_nents, dir);
769 sg_free_table(sgt);
770 }
771}
772
773static int __spi_map_msg(struct spi_master *master, struct spi_message *msg)
774{
775 struct device *tx_dev, *rx_dev;
776 struct spi_transfer *xfer;
777 int ret;
778
779 if (!master->can_dma)
780 return 0;
781
782 if (master->dma_tx)
783 tx_dev = master->dma_tx->device->dev;
784 else
785 tx_dev = &master->dev;
786
787 if (master->dma_rx)
788 rx_dev = master->dma_rx->device->dev;
789 else
790 rx_dev = &master->dev;
791
792 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
793 if (!master->can_dma(master, msg->spi, xfer))
794 continue;
795
796 if (xfer->tx_buf != NULL) {
797 ret = spi_map_buf(master, tx_dev, &xfer->tx_sg,
798 (void *)xfer->tx_buf, xfer->len,
799 DMA_TO_DEVICE);
800 if (ret != 0)
801 return ret;
802 }
803
804 if (xfer->rx_buf != NULL) {
805 ret = spi_map_buf(master, rx_dev, &xfer->rx_sg,
806 xfer->rx_buf, xfer->len,
807 DMA_FROM_DEVICE);
808 if (ret != 0) {
809 spi_unmap_buf(master, tx_dev, &xfer->tx_sg,
810 DMA_TO_DEVICE);
811 return ret;
812 }
813 }
814 }
815
816 master->cur_msg_mapped = true;
817
818 return 0;
819}
820
821static int __spi_unmap_msg(struct spi_master *master, struct spi_message *msg)
822{
823 struct spi_transfer *xfer;
824 struct device *tx_dev, *rx_dev;
825
826 if (!master->cur_msg_mapped || !master->can_dma)
827 return 0;
828
829 if (master->dma_tx)
830 tx_dev = master->dma_tx->device->dev;
831 else
832 tx_dev = &master->dev;
833
834 if (master->dma_rx)
835 rx_dev = master->dma_rx->device->dev;
836 else
837 rx_dev = &master->dev;
838
839 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
840 if (!master->can_dma(master, msg->spi, xfer))
841 continue;
842
843 spi_unmap_buf(master, rx_dev, &xfer->rx_sg, DMA_FROM_DEVICE);
844 spi_unmap_buf(master, tx_dev, &xfer->tx_sg, DMA_TO_DEVICE);
845 }
846
847 return 0;
848}
849#else
850static inline int __spi_map_msg(struct spi_master *master,
851 struct spi_message *msg)
852{
853 return 0;
854}
855
856static inline int __spi_unmap_msg(struct spi_master *master,
857 struct spi_message *msg)
858{
859 return 0;
860}
861#endif
862
863static inline int spi_unmap_msg(struct spi_master *master,
864 struct spi_message *msg)
865{
866 struct spi_transfer *xfer;
867
868 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
869
870
871
872
873 if (xfer->tx_buf == master->dummy_tx)
874 xfer->tx_buf = NULL;
875 if (xfer->rx_buf == master->dummy_rx)
876 xfer->rx_buf = NULL;
877 }
878
879 return __spi_unmap_msg(master, msg);
880}
881
882static int spi_map_msg(struct spi_master *master, struct spi_message *msg)
883{
884 struct spi_transfer *xfer;
885 void *tmp;
886 unsigned int max_tx, max_rx;
887
888 if (master->flags & (SPI_MASTER_MUST_RX | SPI_MASTER_MUST_TX)) {
889 max_tx = 0;
890 max_rx = 0;
891
892 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
893 if ((master->flags & SPI_MASTER_MUST_TX) &&
894 !xfer->tx_buf)
895 max_tx = max(xfer->len, max_tx);
896 if ((master->flags & SPI_MASTER_MUST_RX) &&
897 !xfer->rx_buf)
898 max_rx = max(xfer->len, max_rx);
899 }
900
901 if (max_tx) {
902 tmp = krealloc(master->dummy_tx, max_tx,
903 GFP_KERNEL | GFP_DMA);
904 if (!tmp)
905 return -ENOMEM;
906 master->dummy_tx = tmp;
907 memset(tmp, 0, max_tx);
908 }
909
910 if (max_rx) {
911 tmp = krealloc(master->dummy_rx, max_rx,
912 GFP_KERNEL | GFP_DMA);
913 if (!tmp)
914 return -ENOMEM;
915 master->dummy_rx = tmp;
916 }
917
918 if (max_tx || max_rx) {
919 list_for_each_entry(xfer, &msg->transfers,
920 transfer_list) {
921 if (!xfer->tx_buf)
922 xfer->tx_buf = master->dummy_tx;
923 if (!xfer->rx_buf)
924 xfer->rx_buf = master->dummy_rx;
925 }
926 }
927 }
928
929 return __spi_map_msg(master, msg);
930}
931
932
933
934
935
936
937
938
939static int spi_transfer_one_message(struct spi_master *master,
940 struct spi_message *msg)
941{
942 struct spi_transfer *xfer;
943 bool keep_cs = false;
944 int ret = 0;
945 unsigned long ms = 1;
946 struct spi_statistics *statm = &master->statistics;
947 struct spi_statistics *stats = &msg->spi->statistics;
948
949 spi_set_cs(msg->spi, true);
950
951 SPI_STATISTICS_INCREMENT_FIELD(statm, messages);
952 SPI_STATISTICS_INCREMENT_FIELD(stats, messages);
953
954 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
955 trace_spi_transfer_start(msg, xfer);
956
957 spi_statistics_add_transfer_stats(statm, xfer, master);
958 spi_statistics_add_transfer_stats(stats, xfer, master);
959
960 if (xfer->tx_buf || xfer->rx_buf) {
961 reinit_completion(&master->xfer_completion);
962
963 ret = master->transfer_one(master, msg->spi, xfer);
964 if (ret < 0) {
965 SPI_STATISTICS_INCREMENT_FIELD(statm,
966 errors);
967 SPI_STATISTICS_INCREMENT_FIELD(stats,
968 errors);
969 dev_err(&msg->spi->dev,
970 "SPI transfer failed: %d\n", ret);
971 goto out;
972 }
973
974 if (ret > 0) {
975 ret = 0;
976 ms = xfer->len * 8 * 1000 / xfer->speed_hz;
977 ms += ms + 100;
978
979 ms = wait_for_completion_timeout(&master->xfer_completion,
980 msecs_to_jiffies(ms));
981 }
982
983 if (ms == 0) {
984 SPI_STATISTICS_INCREMENT_FIELD(statm,
985 timedout);
986 SPI_STATISTICS_INCREMENT_FIELD(stats,
987 timedout);
988 dev_err(&msg->spi->dev,
989 "SPI transfer timed out\n");
990 msg->status = -ETIMEDOUT;
991 }
992 } else {
993 if (xfer->len)
994 dev_err(&msg->spi->dev,
995 "Bufferless transfer has length %u\n",
996 xfer->len);
997 }
998
999 trace_spi_transfer_stop(msg, xfer);
1000
1001 if (msg->status != -EINPROGRESS)
1002 goto out;
1003
1004 if (xfer->delay_usecs)
1005 udelay(xfer->delay_usecs);
1006
1007 if (xfer->cs_change) {
1008 if (list_is_last(&xfer->transfer_list,
1009 &msg->transfers)) {
1010 keep_cs = true;
1011 } else {
1012 spi_set_cs(msg->spi, false);
1013 udelay(10);
1014 spi_set_cs(msg->spi, true);
1015 }
1016 }
1017
1018 msg->actual_length += xfer->len;
1019 }
1020
1021out:
1022 if (ret != 0 || !keep_cs)
1023 spi_set_cs(msg->spi, false);
1024
1025 if (msg->status == -EINPROGRESS)
1026 msg->status = ret;
1027
1028 if (msg->status && master->handle_err)
1029 master->handle_err(master, msg);
1030
1031 spi_res_release(master, msg);
1032
1033 spi_finalize_current_message(master);
1034
1035 return ret;
1036}
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046void spi_finalize_current_transfer(struct spi_master *master)
1047{
1048 complete(&master->xfer_completion);
1049}
1050EXPORT_SYMBOL_GPL(spi_finalize_current_transfer);
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066static void __spi_pump_messages(struct spi_master *master, bool in_kthread,
1067 bool bus_locked)
1068{
1069 unsigned long flags;
1070 bool was_busy = false;
1071 int ret;
1072
1073
1074 spin_lock_irqsave(&master->queue_lock, flags);
1075
1076
1077 if (master->cur_msg) {
1078 spin_unlock_irqrestore(&master->queue_lock, flags);
1079 return;
1080 }
1081
1082
1083 if (master->idling) {
1084 queue_kthread_work(&master->kworker, &master->pump_messages);
1085 spin_unlock_irqrestore(&master->queue_lock, flags);
1086 return;
1087 }
1088
1089
1090 if (list_empty(&master->queue) || !master->running) {
1091 if (!master->busy) {
1092 spin_unlock_irqrestore(&master->queue_lock, flags);
1093 return;
1094 }
1095
1096
1097 if (!in_kthread) {
1098 queue_kthread_work(&master->kworker,
1099 &master->pump_messages);
1100 spin_unlock_irqrestore(&master->queue_lock, flags);
1101 return;
1102 }
1103
1104 master->busy = false;
1105 master->idling = true;
1106 spin_unlock_irqrestore(&master->queue_lock, flags);
1107
1108 kfree(master->dummy_rx);
1109 master->dummy_rx = NULL;
1110 kfree(master->dummy_tx);
1111 master->dummy_tx = NULL;
1112 if (master->unprepare_transfer_hardware &&
1113 master->unprepare_transfer_hardware(master))
1114 dev_err(&master->dev,
1115 "failed to unprepare transfer hardware\n");
1116 if (master->auto_runtime_pm) {
1117 pm_runtime_mark_last_busy(master->dev.parent);
1118 pm_runtime_put_autosuspend(master->dev.parent);
1119 }
1120 trace_spi_master_idle(master);
1121
1122 spin_lock_irqsave(&master->queue_lock, flags);
1123 master->idling = false;
1124 spin_unlock_irqrestore(&master->queue_lock, flags);
1125 return;
1126 }
1127
1128
1129 master->cur_msg =
1130 list_first_entry(&master->queue, struct spi_message, queue);
1131
1132 list_del_init(&master->cur_msg->queue);
1133 if (master->busy)
1134 was_busy = true;
1135 else
1136 master->busy = true;
1137 spin_unlock_irqrestore(&master->queue_lock, flags);
1138
1139 if (!was_busy && master->auto_runtime_pm) {
1140 ret = pm_runtime_get_sync(master->dev.parent);
1141 if (ret < 0) {
1142 dev_err(&master->dev, "Failed to power device: %d\n",
1143 ret);
1144 return;
1145 }
1146 }
1147
1148 if (!was_busy)
1149 trace_spi_master_busy(master);
1150
1151 if (!was_busy && master->prepare_transfer_hardware) {
1152 ret = master->prepare_transfer_hardware(master);
1153 if (ret) {
1154 dev_err(&master->dev,
1155 "failed to prepare transfer hardware\n");
1156
1157 if (master->auto_runtime_pm)
1158 pm_runtime_put(master->dev.parent);
1159 return;
1160 }
1161 }
1162
1163 if (!bus_locked)
1164 mutex_lock(&master->bus_lock_mutex);
1165
1166 trace_spi_message_start(master->cur_msg);
1167
1168 if (master->prepare_message) {
1169 ret = master->prepare_message(master, master->cur_msg);
1170 if (ret) {
1171 dev_err(&master->dev,
1172 "failed to prepare message: %d\n", ret);
1173 master->cur_msg->status = ret;
1174 spi_finalize_current_message(master);
1175 goto out;
1176 }
1177 master->cur_msg_prepared = true;
1178 }
1179
1180 ret = spi_map_msg(master, master->cur_msg);
1181 if (ret) {
1182 master->cur_msg->status = ret;
1183 spi_finalize_current_message(master);
1184 goto out;
1185 }
1186
1187 ret = master->transfer_one_message(master, master->cur_msg);
1188 if (ret) {
1189 dev_err(&master->dev,
1190 "failed to transfer one message from queue\n");
1191 goto out;
1192 }
1193
1194out:
1195 if (!bus_locked)
1196 mutex_unlock(&master->bus_lock_mutex);
1197
1198
1199 if (!ret)
1200 cond_resched();
1201}
1202
1203
1204
1205
1206
1207static void spi_pump_messages(struct kthread_work *work)
1208{
1209 struct spi_master *master =
1210 container_of(work, struct spi_master, pump_messages);
1211
1212 __spi_pump_messages(master, true, master->bus_lock_flag);
1213}
1214
1215static int spi_init_queue(struct spi_master *master)
1216{
1217 struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
1218
1219 master->running = false;
1220 master->busy = false;
1221
1222 init_kthread_worker(&master->kworker);
1223 master->kworker_task = kthread_run(kthread_worker_fn,
1224 &master->kworker, "%s",
1225 dev_name(&master->dev));
1226 if (IS_ERR(master->kworker_task)) {
1227 dev_err(&master->dev, "failed to create message pump task\n");
1228 return PTR_ERR(master->kworker_task);
1229 }
1230 init_kthread_work(&master->pump_messages, spi_pump_messages);
1231
1232
1233
1234
1235
1236
1237
1238
1239 if (master->rt) {
1240 dev_info(&master->dev,
1241 "will run message pump with realtime priority\n");
1242 sched_setscheduler(master->kworker_task, SCHED_FIFO, ¶m);
1243 }
1244
1245 return 0;
1246}
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258struct spi_message *spi_get_next_queued_message(struct spi_master *master)
1259{
1260 struct spi_message *next;
1261 unsigned long flags;
1262
1263
1264 spin_lock_irqsave(&master->queue_lock, flags);
1265 next = list_first_entry_or_null(&master->queue, struct spi_message,
1266 queue);
1267 spin_unlock_irqrestore(&master->queue_lock, flags);
1268
1269 return next;
1270}
1271EXPORT_SYMBOL_GPL(spi_get_next_queued_message);
1272
1273
1274
1275
1276
1277
1278
1279
1280void spi_finalize_current_message(struct spi_master *master)
1281{
1282 struct spi_message *mesg;
1283 unsigned long flags;
1284 int ret;
1285
1286 spin_lock_irqsave(&master->queue_lock, flags);
1287 mesg = master->cur_msg;
1288 spin_unlock_irqrestore(&master->queue_lock, flags);
1289
1290 spi_unmap_msg(master, mesg);
1291
1292 if (master->cur_msg_prepared && master->unprepare_message) {
1293 ret = master->unprepare_message(master, mesg);
1294 if (ret) {
1295 dev_err(&master->dev,
1296 "failed to unprepare message: %d\n", ret);
1297 }
1298 }
1299
1300 spin_lock_irqsave(&master->queue_lock, flags);
1301 master->cur_msg = NULL;
1302 master->cur_msg_prepared = false;
1303 queue_kthread_work(&master->kworker, &master->pump_messages);
1304 spin_unlock_irqrestore(&master->queue_lock, flags);
1305
1306 trace_spi_message_done(mesg);
1307
1308 mesg->state = NULL;
1309 if (mesg->complete)
1310 mesg->complete(mesg->context);
1311}
1312EXPORT_SYMBOL_GPL(spi_finalize_current_message);
1313
1314static int spi_start_queue(struct spi_master *master)
1315{
1316 unsigned long flags;
1317
1318 spin_lock_irqsave(&master->queue_lock, flags);
1319
1320 if (master->running || master->busy) {
1321 spin_unlock_irqrestore(&master->queue_lock, flags);
1322 return -EBUSY;
1323 }
1324
1325 master->running = true;
1326 master->cur_msg = NULL;
1327 spin_unlock_irqrestore(&master->queue_lock, flags);
1328
1329 queue_kthread_work(&master->kworker, &master->pump_messages);
1330
1331 return 0;
1332}
1333
1334static int spi_stop_queue(struct spi_master *master)
1335{
1336 unsigned long flags;
1337 unsigned limit = 500;
1338 int ret = 0;
1339
1340 spin_lock_irqsave(&master->queue_lock, flags);
1341
1342
1343
1344
1345
1346
1347
1348 while ((!list_empty(&master->queue) || master->busy) && limit--) {
1349 spin_unlock_irqrestore(&master->queue_lock, flags);
1350 usleep_range(10000, 11000);
1351 spin_lock_irqsave(&master->queue_lock, flags);
1352 }
1353
1354 if (!list_empty(&master->queue) || master->busy)
1355 ret = -EBUSY;
1356 else
1357 master->running = false;
1358
1359 spin_unlock_irqrestore(&master->queue_lock, flags);
1360
1361 if (ret) {
1362 dev_warn(&master->dev,
1363 "could not stop message queue\n");
1364 return ret;
1365 }
1366 return ret;
1367}
1368
1369static int spi_destroy_queue(struct spi_master *master)
1370{
1371 int ret;
1372
1373 ret = spi_stop_queue(master);
1374
1375
1376
1377
1378
1379
1380
1381 if (ret) {
1382 dev_err(&master->dev, "problem destroying queue\n");
1383 return ret;
1384 }
1385
1386 flush_kthread_worker(&master->kworker);
1387 kthread_stop(master->kworker_task);
1388
1389 return 0;
1390}
1391
1392static int __spi_queued_transfer(struct spi_device *spi,
1393 struct spi_message *msg,
1394 bool need_pump)
1395{
1396 struct spi_master *master = spi->master;
1397 unsigned long flags;
1398
1399 spin_lock_irqsave(&master->queue_lock, flags);
1400
1401 if (!master->running) {
1402 spin_unlock_irqrestore(&master->queue_lock, flags);
1403 return -ESHUTDOWN;
1404 }
1405 msg->actual_length = 0;
1406 msg->status = -EINPROGRESS;
1407
1408 list_add_tail(&msg->queue, &master->queue);
1409 if (!master->busy && need_pump)
1410 queue_kthread_work(&master->kworker, &master->pump_messages);
1411
1412 spin_unlock_irqrestore(&master->queue_lock, flags);
1413 return 0;
1414}
1415
1416
1417
1418
1419
1420
1421
1422
1423static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
1424{
1425 return __spi_queued_transfer(spi, msg, true);
1426}
1427
1428static int spi_master_initialize_queue(struct spi_master *master)
1429{
1430 int ret;
1431
1432 master->transfer = spi_queued_transfer;
1433 if (!master->transfer_one_message)
1434 master->transfer_one_message = spi_transfer_one_message;
1435
1436
1437 ret = spi_init_queue(master);
1438 if (ret) {
1439 dev_err(&master->dev, "problem initializing queue\n");
1440 goto err_init_queue;
1441 }
1442 master->queued = true;
1443 ret = spi_start_queue(master);
1444 if (ret) {
1445 dev_err(&master->dev, "problem starting queue\n");
1446 goto err_start_queue;
1447 }
1448
1449 return 0;
1450
1451err_start_queue:
1452 spi_destroy_queue(master);
1453err_init_queue:
1454 return ret;
1455}
1456
1457
1458
1459#if defined(CONFIG_OF)
1460static struct spi_device *
1461of_register_spi_device(struct spi_master *master, struct device_node *nc)
1462{
1463 struct spi_device *spi;
1464 int rc;
1465 u32 value;
1466
1467
1468 spi = spi_alloc_device(master);
1469 if (!spi) {
1470 dev_err(&master->dev, "spi_device alloc error for %s\n",
1471 nc->full_name);
1472 rc = -ENOMEM;
1473 goto err_out;
1474 }
1475
1476
1477 rc = of_modalias_node(nc, spi->modalias,
1478 sizeof(spi->modalias));
1479 if (rc < 0) {
1480 dev_err(&master->dev, "cannot find modalias for %s\n",
1481 nc->full_name);
1482 goto err_out;
1483 }
1484
1485
1486 rc = of_property_read_u32(nc, "reg", &value);
1487 if (rc) {
1488 dev_err(&master->dev, "%s has no valid 'reg' property (%d)\n",
1489 nc->full_name, rc);
1490 goto err_out;
1491 }
1492 spi->chip_select = value;
1493
1494
1495 if (of_find_property(nc, "spi-cpha", NULL))
1496 spi->mode |= SPI_CPHA;
1497 if (of_find_property(nc, "spi-cpol", NULL))
1498 spi->mode |= SPI_CPOL;
1499 if (of_find_property(nc, "spi-cs-high", NULL))
1500 spi->mode |= SPI_CS_HIGH;
1501 if (of_find_property(nc, "spi-3wire", NULL))
1502 spi->mode |= SPI_3WIRE;
1503 if (of_find_property(nc, "spi-lsb-first", NULL))
1504 spi->mode |= SPI_LSB_FIRST;
1505
1506
1507 if (!of_property_read_u32(nc, "spi-tx-bus-width", &value)) {
1508 switch (value) {
1509 case 1:
1510 break;
1511 case 2:
1512 spi->mode |= SPI_TX_DUAL;
1513 break;
1514 case 4:
1515 spi->mode |= SPI_TX_QUAD;
1516 break;
1517 default:
1518 dev_warn(&master->dev,
1519 "spi-tx-bus-width %d not supported\n",
1520 value);
1521 break;
1522 }
1523 }
1524
1525 if (!of_property_read_u32(nc, "spi-rx-bus-width", &value)) {
1526 switch (value) {
1527 case 1:
1528 break;
1529 case 2:
1530 spi->mode |= SPI_RX_DUAL;
1531 break;
1532 case 4:
1533 spi->mode |= SPI_RX_QUAD;
1534 break;
1535 default:
1536 dev_warn(&master->dev,
1537 "spi-rx-bus-width %d not supported\n",
1538 value);
1539 break;
1540 }
1541 }
1542
1543
1544 rc = of_property_read_u32(nc, "spi-max-frequency", &value);
1545 if (rc) {
1546 dev_err(&master->dev, "%s has no valid 'spi-max-frequency' property (%d)\n",
1547 nc->full_name, rc);
1548 goto err_out;
1549 }
1550 spi->max_speed_hz = value;
1551
1552
1553 of_node_get(nc);
1554 spi->dev.of_node = nc;
1555
1556
1557 rc = spi_add_device(spi);
1558 if (rc) {
1559 dev_err(&master->dev, "spi_device register error %s\n",
1560 nc->full_name);
1561 goto err_out;
1562 }
1563
1564 return spi;
1565
1566err_out:
1567 spi_dev_put(spi);
1568 return ERR_PTR(rc);
1569}
1570
1571
1572
1573
1574
1575
1576
1577
1578static void of_register_spi_devices(struct spi_master *master)
1579{
1580 struct spi_device *spi;
1581 struct device_node *nc;
1582
1583 if (!master->dev.of_node)
1584 return;
1585
1586 for_each_available_child_of_node(master->dev.of_node, nc) {
1587 if (of_node_test_and_set_flag(nc, OF_POPULATED))
1588 continue;
1589 spi = of_register_spi_device(master, nc);
1590 if (IS_ERR(spi))
1591 dev_warn(&master->dev, "Failed to create SPI device for %s\n",
1592 nc->full_name);
1593 }
1594}
1595#else
1596static void of_register_spi_devices(struct spi_master *master) { }
1597#endif
1598
1599#ifdef CONFIG_ACPI
1600static int acpi_spi_add_resource(struct acpi_resource *ares, void *data)
1601{
1602 struct spi_device *spi = data;
1603 struct spi_master *master = spi->master;
1604
1605 if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
1606 struct acpi_resource_spi_serialbus *sb;
1607
1608 sb = &ares->data.spi_serial_bus;
1609 if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_SPI) {
1610
1611
1612
1613
1614
1615
1616
1617 if (master->fw_translate_cs) {
1618 int cs = master->fw_translate_cs(master,
1619 sb->device_selection);
1620 if (cs < 0)
1621 return cs;
1622 spi->chip_select = cs;
1623 } else {
1624 spi->chip_select = sb->device_selection;
1625 }
1626
1627 spi->max_speed_hz = sb->connection_speed;
1628
1629 if (sb->clock_phase == ACPI_SPI_SECOND_PHASE)
1630 spi->mode |= SPI_CPHA;
1631 if (sb->clock_polarity == ACPI_SPI_START_HIGH)
1632 spi->mode |= SPI_CPOL;
1633 if (sb->device_polarity == ACPI_SPI_ACTIVE_HIGH)
1634 spi->mode |= SPI_CS_HIGH;
1635 }
1636 } else if (spi->irq < 0) {
1637 struct resource r;
1638
1639 if (acpi_dev_resource_interrupt(ares, 0, &r))
1640 spi->irq = r.start;
1641 }
1642
1643
1644 return 1;
1645}
1646
1647static acpi_status acpi_spi_add_device(acpi_handle handle, u32 level,
1648 void *data, void **return_value)
1649{
1650 struct spi_master *master = data;
1651 struct list_head resource_list;
1652 struct acpi_device *adev;
1653 struct spi_device *spi;
1654 int ret;
1655
1656 if (acpi_bus_get_device(handle, &adev))
1657 return AE_OK;
1658 if (acpi_bus_get_status(adev) || !adev->status.present)
1659 return AE_OK;
1660
1661 spi = spi_alloc_device(master);
1662 if (!spi) {
1663 dev_err(&master->dev, "failed to allocate SPI device for %s\n",
1664 dev_name(&adev->dev));
1665 return AE_NO_MEMORY;
1666 }
1667
1668 ACPI_COMPANION_SET(&spi->dev, adev);
1669 spi->irq = -1;
1670
1671 INIT_LIST_HEAD(&resource_list);
1672 ret = acpi_dev_get_resources(adev, &resource_list,
1673 acpi_spi_add_resource, spi);
1674 acpi_dev_free_resource_list(&resource_list);
1675
1676 if (ret < 0 || !spi->max_speed_hz) {
1677 spi_dev_put(spi);
1678 return AE_OK;
1679 }
1680
1681 if (spi->irq < 0)
1682 spi->irq = acpi_dev_gpio_irq_get(adev, 0);
1683
1684 adev->power.flags.ignore_parent = true;
1685 strlcpy(spi->modalias, acpi_device_hid(adev), sizeof(spi->modalias));
1686 if (spi_add_device(spi)) {
1687 adev->power.flags.ignore_parent = false;
1688 dev_err(&master->dev, "failed to add SPI device %s from ACPI\n",
1689 dev_name(&adev->dev));
1690 spi_dev_put(spi);
1691 }
1692
1693 return AE_OK;
1694}
1695
1696static void acpi_register_spi_devices(struct spi_master *master)
1697{
1698 acpi_status status;
1699 acpi_handle handle;
1700
1701 handle = ACPI_HANDLE(master->dev.parent);
1702 if (!handle)
1703 return;
1704
1705 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
1706 acpi_spi_add_device, NULL,
1707 master, NULL);
1708 if (ACPI_FAILURE(status))
1709 dev_warn(&master->dev, "failed to enumerate SPI slaves\n");
1710}
1711#else
1712static inline void acpi_register_spi_devices(struct spi_master *master) {}
1713#endif
1714
1715static void spi_master_release(struct device *dev)
1716{
1717 struct spi_master *master;
1718
1719 master = container_of(dev, struct spi_master, dev);
1720 kfree(master);
1721}
1722
1723static struct class spi_master_class = {
1724 .name = "spi_master",
1725 .owner = THIS_MODULE,
1726 .dev_release = spi_master_release,
1727 .dev_groups = spi_master_groups,
1728};
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
1752{
1753 struct spi_master *master;
1754
1755 if (!dev)
1756 return NULL;
1757
1758 master = kzalloc(size + sizeof(*master), GFP_KERNEL);
1759 if (!master)
1760 return NULL;
1761
1762 device_initialize(&master->dev);
1763 master->bus_num = -1;
1764 master->num_chipselect = 1;
1765 master->dev.class = &spi_master_class;
1766 master->dev.parent = dev;
1767 spi_master_set_devdata(master, &master[1]);
1768
1769 return master;
1770}
1771EXPORT_SYMBOL_GPL(spi_alloc_master);
1772
1773#ifdef CONFIG_OF
1774static int of_spi_register_master(struct spi_master *master)
1775{
1776 int nb, i, *cs;
1777 struct device_node *np = master->dev.of_node;
1778
1779 if (!np)
1780 return 0;
1781
1782 nb = of_gpio_named_count(np, "cs-gpios");
1783 master->num_chipselect = max_t(int, nb, master->num_chipselect);
1784
1785
1786 if (nb == 0 || nb == -ENOENT)
1787 return 0;
1788 else if (nb < 0)
1789 return nb;
1790
1791 cs = devm_kzalloc(&master->dev,
1792 sizeof(int) * master->num_chipselect,
1793 GFP_KERNEL);
1794 master->cs_gpios = cs;
1795
1796 if (!master->cs_gpios)
1797 return -ENOMEM;
1798
1799 for (i = 0; i < master->num_chipselect; i++)
1800 cs[i] = -ENOENT;
1801
1802 for (i = 0; i < nb; i++)
1803 cs[i] = of_get_named_gpio(np, "cs-gpios", i);
1804
1805 return 0;
1806}
1807#else
1808static int of_spi_register_master(struct spi_master *master)
1809{
1810 return 0;
1811}
1812#endif
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836int spi_register_master(struct spi_master *master)
1837{
1838 static atomic_t dyn_bus_id = ATOMIC_INIT((1<<15) - 1);
1839 struct device *dev = master->dev.parent;
1840 struct boardinfo *bi;
1841 int status = -ENODEV;
1842 int dynamic = 0;
1843
1844 if (!dev)
1845 return -ENODEV;
1846
1847 status = of_spi_register_master(master);
1848 if (status)
1849 return status;
1850
1851
1852
1853
1854 if (master->num_chipselect == 0)
1855 return -EINVAL;
1856
1857 if ((master->bus_num < 0) && master->dev.of_node)
1858 master->bus_num = of_alias_get_id(master->dev.of_node, "spi");
1859
1860
1861 if (master->bus_num < 0) {
1862
1863
1864
1865 master->bus_num = atomic_dec_return(&dyn_bus_id);
1866 dynamic = 1;
1867 }
1868
1869 INIT_LIST_HEAD(&master->queue);
1870 spin_lock_init(&master->queue_lock);
1871 spin_lock_init(&master->bus_lock_spinlock);
1872 mutex_init(&master->bus_lock_mutex);
1873 master->bus_lock_flag = 0;
1874 init_completion(&master->xfer_completion);
1875 if (!master->max_dma_len)
1876 master->max_dma_len = INT_MAX;
1877
1878
1879
1880
1881 dev_set_name(&master->dev, "spi%u", master->bus_num);
1882 status = device_add(&master->dev);
1883 if (status < 0)
1884 goto done;
1885 dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev),
1886 dynamic ? " (dynamic)" : "");
1887
1888
1889 if (master->transfer)
1890 dev_info(dev, "master is unqueued, this is deprecated\n");
1891 else {
1892 status = spi_master_initialize_queue(master);
1893 if (status) {
1894 device_del(&master->dev);
1895 goto done;
1896 }
1897 }
1898
1899 spin_lock_init(&master->statistics.lock);
1900
1901 mutex_lock(&board_lock);
1902 list_add_tail(&master->list, &spi_master_list);
1903 list_for_each_entry(bi, &board_list, list)
1904 spi_match_master_to_boardinfo(master, &bi->board_info);
1905 mutex_unlock(&board_lock);
1906
1907
1908 of_register_spi_devices(master);
1909 acpi_register_spi_devices(master);
1910done:
1911 return status;
1912}
1913EXPORT_SYMBOL_GPL(spi_register_master);
1914
1915static void devm_spi_unregister(struct device *dev, void *res)
1916{
1917 spi_unregister_master(*(struct spi_master **)res);
1918}
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931int devm_spi_register_master(struct device *dev, struct spi_master *master)
1932{
1933 struct spi_master **ptr;
1934 int ret;
1935
1936 ptr = devres_alloc(devm_spi_unregister, sizeof(*ptr), GFP_KERNEL);
1937 if (!ptr)
1938 return -ENOMEM;
1939
1940 ret = spi_register_master(master);
1941 if (!ret) {
1942 *ptr = master;
1943 devres_add(dev, ptr);
1944 } else {
1945 devres_free(ptr);
1946 }
1947
1948 return ret;
1949}
1950EXPORT_SYMBOL_GPL(devm_spi_register_master);
1951
1952static int __unregister(struct device *dev, void *null)
1953{
1954 spi_unregister_device(to_spi_device(dev));
1955 return 0;
1956}
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968void spi_unregister_master(struct spi_master *master)
1969{
1970 int dummy;
1971
1972 if (master->queued) {
1973 if (spi_destroy_queue(master))
1974 dev_err(&master->dev, "queue remove failed\n");
1975 }
1976
1977 mutex_lock(&board_lock);
1978 list_del(&master->list);
1979 mutex_unlock(&board_lock);
1980
1981 dummy = device_for_each_child(&master->dev, NULL, __unregister);
1982 device_unregister(&master->dev);
1983}
1984EXPORT_SYMBOL_GPL(spi_unregister_master);
1985
1986int spi_master_suspend(struct spi_master *master)
1987{
1988 int ret;
1989
1990
1991 if (!master->queued)
1992 return 0;
1993
1994 ret = spi_stop_queue(master);
1995 if (ret)
1996 dev_err(&master->dev, "queue stop failed\n");
1997
1998 return ret;
1999}
2000EXPORT_SYMBOL_GPL(spi_master_suspend);
2001
2002int spi_master_resume(struct spi_master *master)
2003{
2004 int ret;
2005
2006 if (!master->queued)
2007 return 0;
2008
2009 ret = spi_start_queue(master);
2010 if (ret)
2011 dev_err(&master->dev, "queue restart failed\n");
2012
2013 return ret;
2014}
2015EXPORT_SYMBOL_GPL(spi_master_resume);
2016
2017static int __spi_master_match(struct device *dev, const void *data)
2018{
2019 struct spi_master *m;
2020 const u16 *bus_num = data;
2021
2022 m = container_of(dev, struct spi_master, dev);
2023 return m->bus_num == *bus_num;
2024}
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038struct spi_master *spi_busnum_to_master(u16 bus_num)
2039{
2040 struct device *dev;
2041 struct spi_master *master = NULL;
2042
2043 dev = class_find_device(&spi_master_class, NULL, &bus_num,
2044 __spi_master_match);
2045 if (dev)
2046 master = container_of(dev, struct spi_master, dev);
2047
2048 return master;
2049}
2050EXPORT_SYMBOL_GPL(spi_busnum_to_master);
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070void *spi_res_alloc(struct spi_device *spi,
2071 spi_res_release_t release,
2072 size_t size, gfp_t gfp)
2073{
2074 struct spi_res *sres;
2075
2076 sres = kzalloc(sizeof(*sres) + size, gfp);
2077 if (!sres)
2078 return NULL;
2079
2080 INIT_LIST_HEAD(&sres->entry);
2081 sres->release = release;
2082
2083 return sres->data;
2084}
2085EXPORT_SYMBOL_GPL(spi_res_alloc);
2086
2087
2088
2089
2090
2091
2092void spi_res_free(void *res)
2093{
2094 struct spi_res *sres = container_of(res, struct spi_res, data);
2095
2096 if (!res)
2097 return;
2098
2099 WARN_ON(!list_empty(&sres->entry));
2100 kfree(sres);
2101}
2102EXPORT_SYMBOL_GPL(spi_res_free);
2103
2104
2105
2106
2107
2108
2109void spi_res_add(struct spi_message *message, void *res)
2110{
2111 struct spi_res *sres = container_of(res, struct spi_res, data);
2112
2113 WARN_ON(!list_empty(&sres->entry));
2114 list_add_tail(&sres->entry, &message->resources);
2115}
2116EXPORT_SYMBOL_GPL(spi_res_add);
2117
2118
2119
2120
2121
2122
2123void spi_res_release(struct spi_master *master,
2124 struct spi_message *message)
2125{
2126 struct spi_res *res;
2127
2128 while (!list_empty(&message->resources)) {
2129 res = list_last_entry(&message->resources,
2130 struct spi_res, entry);
2131
2132 if (res->release)
2133 res->release(master, message, res->data);
2134
2135 list_del(&res->entry);
2136
2137 kfree(res);
2138 }
2139}
2140EXPORT_SYMBOL_GPL(spi_res_release);
2141
2142
2143
2144
2145
2146static void __spi_replace_transfers_release(struct spi_master *master,
2147 struct spi_message *msg,
2148 void *res)
2149{
2150 struct spi_replaced_transfers *rxfer = res;
2151 size_t i;
2152
2153
2154 if (rxfer->release)
2155 rxfer->release(master, msg, res);
2156
2157
2158 list_splice(&rxfer->replaced_transfers, rxfer->replaced_after);
2159
2160
2161 for (i = 0; i < rxfer->inserted; i++)
2162 list_del(&rxfer->inserted_transfers[i].transfer_list);
2163}
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180struct spi_replaced_transfers *spi_replace_transfers(
2181 struct spi_message *msg,
2182 struct spi_transfer *xfer_first,
2183 size_t remove,
2184 size_t insert,
2185 spi_replaced_release_t release,
2186 size_t extradatasize,
2187 gfp_t gfp)
2188{
2189 struct spi_replaced_transfers *rxfer;
2190 struct spi_transfer *xfer;
2191 size_t i;
2192
2193
2194 rxfer = spi_res_alloc(msg->spi, __spi_replace_transfers_release,
2195 insert * sizeof(struct spi_transfer)
2196 + sizeof(struct spi_replaced_transfers)
2197 + extradatasize,
2198 gfp);
2199 if (!rxfer)
2200 return ERR_PTR(-ENOMEM);
2201
2202
2203 rxfer->release = release;
2204
2205
2206 if (extradatasize)
2207 rxfer->extradata =
2208 &rxfer->inserted_transfers[insert];
2209
2210
2211 INIT_LIST_HEAD(&rxfer->replaced_transfers);
2212
2213
2214
2215
2216 rxfer->replaced_after = xfer_first->transfer_list.prev;
2217
2218
2219 for (i = 0; i < remove; i++) {
2220
2221
2222
2223
2224 if (rxfer->replaced_after->next == &msg->transfers) {
2225 dev_err(&msg->spi->dev,
2226 "requested to remove more spi_transfers than are available\n");
2227
2228 list_splice(&rxfer->replaced_transfers,
2229 rxfer->replaced_after);
2230
2231
2232 spi_res_free(rxfer);
2233
2234
2235 return ERR_PTR(-EINVAL);
2236 }
2237
2238
2239
2240
2241 list_move_tail(rxfer->replaced_after->next,
2242 &rxfer->replaced_transfers);
2243 }
2244
2245
2246
2247
2248 for (i = 0; i < insert; i++) {
2249
2250 xfer = &rxfer->inserted_transfers[insert - 1 - i];
2251
2252
2253 memcpy(xfer, xfer_first, sizeof(*xfer));
2254
2255
2256 list_add(&xfer->transfer_list, rxfer->replaced_after);
2257
2258
2259 if (i) {
2260 xfer->cs_change = false;
2261 xfer->delay_usecs = 0;
2262 }
2263 }
2264
2265
2266 rxfer->inserted = insert;
2267
2268
2269 spi_res_add(msg, rxfer);
2270
2271 return rxfer;
2272}
2273EXPORT_SYMBOL_GPL(spi_replace_transfers);
2274
2275static int __spi_split_transfer_maxsize(struct spi_master *master,
2276 struct spi_message *msg,
2277 struct spi_transfer **xferp,
2278 size_t maxsize,
2279 gfp_t gfp)
2280{
2281 struct spi_transfer *xfer = *xferp, *xfers;
2282 struct spi_replaced_transfers *srt;
2283 size_t offset;
2284 size_t count, i;
2285
2286
2287 dev_warn_once(&msg->spi->dev,
2288 "spi_transfer of length %i exceed max length of %zu - needed to split transfers\n",
2289 xfer->len, maxsize);
2290
2291
2292 count = DIV_ROUND_UP(xfer->len, maxsize);
2293
2294
2295 srt = spi_replace_transfers(msg, xfer, 1, count, NULL, 0, gfp);
2296 if (IS_ERR(srt))
2297 return PTR_ERR(srt);
2298 xfers = srt->inserted_transfers;
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313 xfers[0].len = min_t(size_t, maxsize, xfer[0].len);
2314
2315
2316 for (i = 1, offset = maxsize; i < count; offset += maxsize, i++) {
2317
2318 if (xfers[i].rx_buf)
2319 xfers[i].rx_buf += offset;
2320 if (xfers[i].rx_dma)
2321 xfers[i].rx_dma += offset;
2322 if (xfers[i].tx_buf)
2323 xfers[i].tx_buf += offset;
2324 if (xfers[i].tx_dma)
2325 xfers[i].tx_dma += offset;
2326
2327
2328 xfers[i].len = min(maxsize, xfers[i].len - offset);
2329 }
2330
2331
2332
2333
2334 *xferp = &xfers[count - 1];
2335
2336
2337 SPI_STATISTICS_INCREMENT_FIELD(&master->statistics,
2338 transfers_split_maxsize);
2339 SPI_STATISTICS_INCREMENT_FIELD(&msg->spi->statistics,
2340 transfers_split_maxsize);
2341
2342 return 0;
2343}
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356int spi_split_transfers_maxsize(struct spi_master *master,
2357 struct spi_message *msg,
2358 size_t maxsize,
2359 gfp_t gfp)
2360{
2361 struct spi_transfer *xfer;
2362 int ret;
2363
2364
2365
2366
2367
2368
2369
2370 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
2371 if (xfer->len > maxsize) {
2372 ret = __spi_split_transfer_maxsize(
2373 master, msg, &xfer, maxsize, gfp);
2374 if (ret)
2375 return ret;
2376 }
2377 }
2378
2379 return 0;
2380}
2381EXPORT_SYMBOL_GPL(spi_split_transfers_maxsize);
2382
2383
2384
2385
2386
2387
2388
2389static int __spi_validate_bits_per_word(struct spi_master *master, u8 bits_per_word)
2390{
2391 if (master->bits_per_word_mask) {
2392
2393 if (bits_per_word > 32)
2394 return -EINVAL;
2395 if (!(master->bits_per_word_mask &
2396 SPI_BPW_MASK(bits_per_word)))
2397 return -EINVAL;
2398 }
2399
2400 return 0;
2401}
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423int spi_setup(struct spi_device *spi)
2424{
2425 unsigned bad_bits, ugly_bits;
2426 int status;
2427
2428
2429
2430 if (((spi->mode & SPI_TX_DUAL) && (spi->mode & SPI_TX_QUAD)) ||
2431 ((spi->mode & SPI_RX_DUAL) && (spi->mode & SPI_RX_QUAD))) {
2432 dev_err(&spi->dev,
2433 "setup: can not select dual and quad at the same time\n");
2434 return -EINVAL;
2435 }
2436
2437
2438 if ((spi->mode & SPI_3WIRE) && (spi->mode &
2439 (SPI_TX_DUAL | SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD)))
2440 return -EINVAL;
2441
2442
2443
2444 bad_bits = spi->mode & ~spi->master->mode_bits;
2445 ugly_bits = bad_bits &
2446 (SPI_TX_DUAL | SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD);
2447 if (ugly_bits) {
2448 dev_warn(&spi->dev,
2449 "setup: ignoring unsupported mode bits %x\n",
2450 ugly_bits);
2451 spi->mode &= ~ugly_bits;
2452 bad_bits &= ~ugly_bits;
2453 }
2454 if (bad_bits) {
2455 dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
2456 bad_bits);
2457 return -EINVAL;
2458 }
2459
2460 if (!spi->bits_per_word)
2461 spi->bits_per_word = 8;
2462
2463 status = __spi_validate_bits_per_word(spi->master, spi->bits_per_word);
2464 if (status)
2465 return status;
2466
2467 if (!spi->max_speed_hz)
2468 spi->max_speed_hz = spi->master->max_speed_hz;
2469
2470 if (spi->master->setup)
2471 status = spi->master->setup(spi);
2472
2473 spi_set_cs(spi, false);
2474
2475 dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s%u bits/w, %u Hz max --> %d\n",
2476 (int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
2477 (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
2478 (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
2479 (spi->mode & SPI_3WIRE) ? "3wire, " : "",
2480 (spi->mode & SPI_LOOP) ? "loopback, " : "",
2481 spi->bits_per_word, spi->max_speed_hz,
2482 status);
2483
2484 return status;
2485}
2486EXPORT_SYMBOL_GPL(spi_setup);
2487
2488static int __spi_validate(struct spi_device *spi, struct spi_message *message)
2489{
2490 struct spi_master *master = spi->master;
2491 struct spi_transfer *xfer;
2492 int w_size;
2493
2494 if (list_empty(&message->transfers))
2495 return -EINVAL;
2496
2497
2498
2499
2500
2501
2502 if ((master->flags & SPI_MASTER_HALF_DUPLEX)
2503 || (spi->mode & SPI_3WIRE)) {
2504 unsigned flags = master->flags;
2505
2506 list_for_each_entry(xfer, &message->transfers, transfer_list) {
2507 if (xfer->rx_buf && xfer->tx_buf)
2508 return -EINVAL;
2509 if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
2510 return -EINVAL;
2511 if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
2512 return -EINVAL;
2513 }
2514 }
2515
2516
2517
2518
2519
2520
2521
2522 message->frame_length = 0;
2523 list_for_each_entry(xfer, &message->transfers, transfer_list) {
2524 message->frame_length += xfer->len;
2525 if (!xfer->bits_per_word)
2526 xfer->bits_per_word = spi->bits_per_word;
2527
2528 if (!xfer->speed_hz)
2529 xfer->speed_hz = spi->max_speed_hz;
2530 if (!xfer->speed_hz)
2531 xfer->speed_hz = master->max_speed_hz;
2532
2533 if (master->max_speed_hz &&
2534 xfer->speed_hz > master->max_speed_hz)
2535 xfer->speed_hz = master->max_speed_hz;
2536
2537 if (__spi_validate_bits_per_word(master, xfer->bits_per_word))
2538 return -EINVAL;
2539
2540
2541
2542
2543
2544 if (xfer->bits_per_word <= 8)
2545 w_size = 1;
2546 else if (xfer->bits_per_word <= 16)
2547 w_size = 2;
2548 else
2549 w_size = 4;
2550
2551
2552 if (xfer->len % w_size)
2553 return -EINVAL;
2554
2555 if (xfer->speed_hz && master->min_speed_hz &&
2556 xfer->speed_hz < master->min_speed_hz)
2557 return -EINVAL;
2558
2559 if (xfer->tx_buf && !xfer->tx_nbits)
2560 xfer->tx_nbits = SPI_NBITS_SINGLE;
2561 if (xfer->rx_buf && !xfer->rx_nbits)
2562 xfer->rx_nbits = SPI_NBITS_SINGLE;
2563
2564
2565
2566
2567 if (xfer->tx_buf) {
2568 if (xfer->tx_nbits != SPI_NBITS_SINGLE &&
2569 xfer->tx_nbits != SPI_NBITS_DUAL &&
2570 xfer->tx_nbits != SPI_NBITS_QUAD)
2571 return -EINVAL;
2572 if ((xfer->tx_nbits == SPI_NBITS_DUAL) &&
2573 !(spi->mode & (SPI_TX_DUAL | SPI_TX_QUAD)))
2574 return -EINVAL;
2575 if ((xfer->tx_nbits == SPI_NBITS_QUAD) &&
2576 !(spi->mode & SPI_TX_QUAD))
2577 return -EINVAL;
2578 }
2579
2580 if (xfer->rx_buf) {
2581 if (xfer->rx_nbits != SPI_NBITS_SINGLE &&
2582 xfer->rx_nbits != SPI_NBITS_DUAL &&
2583 xfer->rx_nbits != SPI_NBITS_QUAD)
2584 return -EINVAL;
2585 if ((xfer->rx_nbits == SPI_NBITS_DUAL) &&
2586 !(spi->mode & (SPI_RX_DUAL | SPI_RX_QUAD)))
2587 return -EINVAL;
2588 if ((xfer->rx_nbits == SPI_NBITS_QUAD) &&
2589 !(spi->mode & SPI_RX_QUAD))
2590 return -EINVAL;
2591 }
2592 }
2593
2594 message->status = -EINPROGRESS;
2595
2596 return 0;
2597}
2598
2599static int __spi_async(struct spi_device *spi, struct spi_message *message)
2600{
2601 struct spi_master *master = spi->master;
2602
2603 message->spi = spi;
2604
2605 SPI_STATISTICS_INCREMENT_FIELD(&master->statistics, spi_async);
2606 SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_async);
2607
2608 trace_spi_message_submit(message);
2609
2610 return master->transfer(spi, message);
2611}
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644int spi_async(struct spi_device *spi, struct spi_message *message)
2645{
2646 struct spi_master *master = spi->master;
2647 int ret;
2648 unsigned long flags;
2649
2650 ret = __spi_validate(spi, message);
2651 if (ret != 0)
2652 return ret;
2653
2654 spin_lock_irqsave(&master->bus_lock_spinlock, flags);
2655
2656 if (master->bus_lock_flag)
2657 ret = -EBUSY;
2658 else
2659 ret = __spi_async(spi, message);
2660
2661 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
2662
2663 return ret;
2664}
2665EXPORT_SYMBOL_GPL(spi_async);
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698int spi_async_locked(struct spi_device *spi, struct spi_message *message)
2699{
2700 struct spi_master *master = spi->master;
2701 int ret;
2702 unsigned long flags;
2703
2704 ret = __spi_validate(spi, message);
2705 if (ret != 0)
2706 return ret;
2707
2708 spin_lock_irqsave(&master->bus_lock_spinlock, flags);
2709
2710 ret = __spi_async(spi, message);
2711
2712 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
2713
2714 return ret;
2715
2716}
2717EXPORT_SYMBOL_GPL(spi_async_locked);
2718
2719
2720int spi_flash_read(struct spi_device *spi,
2721 struct spi_flash_read_message *msg)
2722
2723{
2724 struct spi_master *master = spi->master;
2725 int ret;
2726
2727 if ((msg->opcode_nbits == SPI_NBITS_DUAL ||
2728 msg->addr_nbits == SPI_NBITS_DUAL) &&
2729 !(spi->mode & (SPI_TX_DUAL | SPI_TX_QUAD)))
2730 return -EINVAL;
2731 if ((msg->opcode_nbits == SPI_NBITS_QUAD ||
2732 msg->addr_nbits == SPI_NBITS_QUAD) &&
2733 !(spi->mode & SPI_TX_QUAD))
2734 return -EINVAL;
2735 if (msg->data_nbits == SPI_NBITS_DUAL &&
2736 !(spi->mode & (SPI_RX_DUAL | SPI_RX_QUAD)))
2737 return -EINVAL;
2738 if (msg->data_nbits == SPI_NBITS_QUAD &&
2739 !(spi->mode & SPI_RX_QUAD))
2740 return -EINVAL;
2741
2742 if (master->auto_runtime_pm) {
2743 ret = pm_runtime_get_sync(master->dev.parent);
2744 if (ret < 0) {
2745 dev_err(&master->dev, "Failed to power device: %d\n",
2746 ret);
2747 return ret;
2748 }
2749 }
2750 mutex_lock(&master->bus_lock_mutex);
2751 ret = master->spi_flash_read(spi, msg);
2752 mutex_unlock(&master->bus_lock_mutex);
2753 if (master->auto_runtime_pm)
2754 pm_runtime_put(master->dev.parent);
2755
2756 return ret;
2757}
2758EXPORT_SYMBOL_GPL(spi_flash_read);
2759
2760
2761
2762
2763
2764
2765
2766
2767static void spi_complete(void *arg)
2768{
2769 complete(arg);
2770}
2771
2772static int __spi_sync(struct spi_device *spi, struct spi_message *message,
2773 int bus_locked)
2774{
2775 DECLARE_COMPLETION_ONSTACK(done);
2776 int status;
2777 struct spi_master *master = spi->master;
2778 unsigned long flags;
2779
2780 status = __spi_validate(spi, message);
2781 if (status != 0)
2782 return status;
2783
2784 message->complete = spi_complete;
2785 message->context = &done;
2786 message->spi = spi;
2787
2788 SPI_STATISTICS_INCREMENT_FIELD(&master->statistics, spi_sync);
2789 SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_sync);
2790
2791 if (!bus_locked)
2792 mutex_lock(&master->bus_lock_mutex);
2793
2794
2795
2796
2797
2798
2799 if (master->transfer == spi_queued_transfer) {
2800 spin_lock_irqsave(&master->bus_lock_spinlock, flags);
2801
2802 trace_spi_message_submit(message);
2803
2804 status = __spi_queued_transfer(spi, message, false);
2805
2806 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
2807 } else {
2808 status = spi_async_locked(spi, message);
2809 }
2810
2811 if (!bus_locked)
2812 mutex_unlock(&master->bus_lock_mutex);
2813
2814 if (status == 0) {
2815
2816
2817
2818 if (master->transfer == spi_queued_transfer) {
2819 SPI_STATISTICS_INCREMENT_FIELD(&master->statistics,
2820 spi_sync_immediate);
2821 SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics,
2822 spi_sync_immediate);
2823 __spi_pump_messages(master, false, bus_locked);
2824 }
2825
2826 wait_for_completion(&done);
2827 status = message->status;
2828 }
2829 message->context = NULL;
2830 return status;
2831}
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854int spi_sync(struct spi_device *spi, struct spi_message *message)
2855{
2856 return __spi_sync(spi, message, spi->master->bus_lock_flag);
2857}
2858EXPORT_SYMBOL_GPL(spi_sync);
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
2877{
2878 return __spi_sync(spi, message, 1);
2879}
2880EXPORT_SYMBOL_GPL(spi_sync_locked);
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897int spi_bus_lock(struct spi_master *master)
2898{
2899 unsigned long flags;
2900
2901 mutex_lock(&master->bus_lock_mutex);
2902
2903 spin_lock_irqsave(&master->bus_lock_spinlock, flags);
2904 master->bus_lock_flag = 1;
2905 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
2906
2907
2908
2909 return 0;
2910}
2911EXPORT_SYMBOL_GPL(spi_bus_lock);
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926int spi_bus_unlock(struct spi_master *master)
2927{
2928 master->bus_lock_flag = 0;
2929
2930 mutex_unlock(&master->bus_lock_mutex);
2931
2932 return 0;
2933}
2934EXPORT_SYMBOL_GPL(spi_bus_unlock);
2935
2936
2937#define SPI_BUFSIZ max(32, SMP_CACHE_BYTES)
2938
2939static u8 *buf;
2940
2941
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952
2953
2954
2955
2956
2957
2958
2959
2960
2961
2962int spi_write_then_read(struct spi_device *spi,
2963 const void *txbuf, unsigned n_tx,
2964 void *rxbuf, unsigned n_rx)
2965{
2966 static DEFINE_MUTEX(lock);
2967
2968 int status;
2969 struct spi_message message;
2970 struct spi_transfer x[2];
2971 u8 *local_buf;
2972
2973
2974
2975
2976
2977
2978 if ((n_tx + n_rx) > SPI_BUFSIZ || !mutex_trylock(&lock)) {
2979 local_buf = kmalloc(max((unsigned)SPI_BUFSIZ, n_tx + n_rx),
2980 GFP_KERNEL | GFP_DMA);
2981 if (!local_buf)
2982 return -ENOMEM;
2983 } else {
2984 local_buf = buf;
2985 }
2986
2987 spi_message_init(&message);
2988 memset(x, 0, sizeof(x));
2989 if (n_tx) {
2990 x[0].len = n_tx;
2991 spi_message_add_tail(&x[0], &message);
2992 }
2993 if (n_rx) {
2994 x[1].len = n_rx;
2995 spi_message_add_tail(&x[1], &message);
2996 }
2997
2998 memcpy(local_buf, txbuf, n_tx);
2999 x[0].tx_buf = local_buf;
3000 x[1].rx_buf = local_buf + n_tx;
3001
3002
3003 status = spi_sync(spi, &message);
3004 if (status == 0)
3005 memcpy(rxbuf, x[1].rx_buf, n_rx);
3006
3007 if (x[0].tx_buf == buf)
3008 mutex_unlock(&lock);
3009 else
3010 kfree(local_buf);
3011
3012 return status;
3013}
3014EXPORT_SYMBOL_GPL(spi_write_then_read);
3015
3016
3017
3018#if IS_ENABLED(CONFIG_OF_DYNAMIC)
3019static int __spi_of_device_match(struct device *dev, void *data)
3020{
3021 return dev->of_node == data;
3022}
3023
3024
3025static struct spi_device *of_find_spi_device_by_node(struct device_node *node)
3026{
3027 struct device *dev = bus_find_device(&spi_bus_type, NULL, node,
3028 __spi_of_device_match);
3029 return dev ? to_spi_device(dev) : NULL;
3030}
3031
3032static int __spi_of_master_match(struct device *dev, const void *data)
3033{
3034 return dev->of_node == data;
3035}
3036
3037
3038static struct spi_master *of_find_spi_master_by_node(struct device_node *node)
3039{
3040 struct device *dev;
3041
3042 dev = class_find_device(&spi_master_class, NULL, node,
3043 __spi_of_master_match);
3044 if (!dev)
3045 return NULL;
3046
3047
3048 return container_of(dev, struct spi_master, dev);
3049}
3050
3051static int of_spi_notify(struct notifier_block *nb, unsigned long action,
3052 void *arg)
3053{
3054 struct of_reconfig_data *rd = arg;
3055 struct spi_master *master;
3056 struct spi_device *spi;
3057
3058 switch (of_reconfig_get_state_change(action, arg)) {
3059 case OF_RECONFIG_CHANGE_ADD:
3060 master = of_find_spi_master_by_node(rd->dn->parent);
3061 if (master == NULL)
3062 return NOTIFY_OK;
3063
3064 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
3065 put_device(&master->dev);
3066 return NOTIFY_OK;
3067 }
3068
3069 spi = of_register_spi_device(master, rd->dn);
3070 put_device(&master->dev);
3071
3072 if (IS_ERR(spi)) {
3073 pr_err("%s: failed to create for '%s'\n",
3074 __func__, rd->dn->full_name);
3075 return notifier_from_errno(PTR_ERR(spi));
3076 }
3077 break;
3078
3079 case OF_RECONFIG_CHANGE_REMOVE:
3080
3081 if (!of_node_check_flag(rd->dn, OF_POPULATED))
3082 return NOTIFY_OK;
3083
3084
3085 spi = of_find_spi_device_by_node(rd->dn);
3086 if (spi == NULL)
3087 return NOTIFY_OK;
3088
3089
3090 spi_unregister_device(spi);
3091
3092
3093 put_device(&spi->dev);
3094 break;
3095 }
3096
3097 return NOTIFY_OK;
3098}
3099
3100static struct notifier_block spi_of_notifier = {
3101 .notifier_call = of_spi_notify,
3102};
3103#else
3104extern struct notifier_block spi_of_notifier;
3105#endif
3106
3107static int __init spi_init(void)
3108{
3109 int status;
3110
3111 buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
3112 if (!buf) {
3113 status = -ENOMEM;
3114 goto err0;
3115 }
3116
3117 status = bus_register(&spi_bus_type);
3118 if (status < 0)
3119 goto err1;
3120
3121 status = class_register(&spi_master_class);
3122 if (status < 0)
3123 goto err2;
3124
3125 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
3126 WARN_ON(of_reconfig_notifier_register(&spi_of_notifier));
3127
3128 return 0;
3129
3130err2:
3131 bus_unregister(&spi_bus_type);
3132err1:
3133 kfree(buf);
3134 buf = NULL;
3135err0:
3136 return status;
3137}
3138
3139
3140
3141
3142
3143
3144
3145
3146postcore_initcall(spi_init);
3147
3148