1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <linux/kernel.h>
23#include <linux/kmod.h>
24#include <linux/device.h>
25#include <linux/init.h>
26#include <linux/cache.h>
27#include <linux/mutex.h>
28#include <linux/of_device.h>
29#include <linux/of_irq.h>
30#include <linux/slab.h>
31#include <linux/mod_devicetable.h>
32#include <linux/spi/spi.h>
33#include <linux/of_gpio.h>
34#include <linux/pm_runtime.h>
35#include <linux/export.h>
36#include <linux/sched/rt.h>
37#include <linux/delay.h>
38#include <linux/kthread.h>
39#include <linux/ioport.h>
40#include <linux/acpi.h>
41
42static void spidev_release(struct device *dev)
43{
44 struct spi_device *spi = to_spi_device(dev);
45
46
47 if (spi->master->cleanup)
48 spi->master->cleanup(spi);
49
50 spi_master_put(spi->master);
51 kfree(spi);
52}
53
54static ssize_t
55modalias_show(struct device *dev, struct device_attribute *a, char *buf)
56{
57 const struct spi_device *spi = to_spi_device(dev);
58
59 return sprintf(buf, "%s%s\n", SPI_MODULE_PREFIX, spi->modalias);
60}
61
62static struct device_attribute spi_dev_attrs[] = {
63 __ATTR_RO(modalias),
64 __ATTR_NULL,
65};
66
67
68
69
70
71static const struct spi_device_id *spi_match_id(const struct spi_device_id *id,
72 const struct spi_device *sdev)
73{
74 while (id->name[0]) {
75 if (!strcmp(sdev->modalias, id->name))
76 return id;
77 id++;
78 }
79 return NULL;
80}
81
82const struct spi_device_id *spi_get_device_id(const struct spi_device *sdev)
83{
84 const struct spi_driver *sdrv = to_spi_driver(sdev->dev.driver);
85
86 return spi_match_id(sdrv->id_table, sdev);
87}
88EXPORT_SYMBOL_GPL(spi_get_device_id);
89
90static int spi_match_device(struct device *dev, struct device_driver *drv)
91{
92 const struct spi_device *spi = to_spi_device(dev);
93 const struct spi_driver *sdrv = to_spi_driver(drv);
94
95
96 if (of_driver_match_device(dev, drv))
97 return 1;
98
99
100 if (acpi_driver_match_device(dev, drv))
101 return 1;
102
103 if (sdrv->id_table)
104 return !!spi_match_id(sdrv->id_table, spi);
105
106 return strcmp(spi->modalias, drv->name) == 0;
107}
108
109static int spi_uevent(struct device *dev, struct kobj_uevent_env *env)
110{
111 const struct spi_device *spi = to_spi_device(dev);
112
113 add_uevent_var(env, "MODALIAS=%s%s", SPI_MODULE_PREFIX, spi->modalias);
114 return 0;
115}
116
117#ifdef CONFIG_PM_SLEEP
118static int spi_legacy_suspend(struct device *dev, pm_message_t message)
119{
120 int value = 0;
121 struct spi_driver *drv = to_spi_driver(dev->driver);
122
123
124 if (drv) {
125 if (drv->suspend)
126 value = drv->suspend(to_spi_device(dev), message);
127 else
128 dev_dbg(dev, "... can't suspend\n");
129 }
130 return value;
131}
132
133static int spi_legacy_resume(struct device *dev)
134{
135 int value = 0;
136 struct spi_driver *drv = to_spi_driver(dev->driver);
137
138
139 if (drv) {
140 if (drv->resume)
141 value = drv->resume(to_spi_device(dev));
142 else
143 dev_dbg(dev, "... can't resume\n");
144 }
145 return value;
146}
147
148static int spi_pm_suspend(struct device *dev)
149{
150 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
151
152 if (pm)
153 return pm_generic_suspend(dev);
154 else
155 return spi_legacy_suspend(dev, PMSG_SUSPEND);
156}
157
158static int spi_pm_resume(struct device *dev)
159{
160 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
161
162 if (pm)
163 return pm_generic_resume(dev);
164 else
165 return spi_legacy_resume(dev);
166}
167
168static int spi_pm_freeze(struct device *dev)
169{
170 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
171
172 if (pm)
173 return pm_generic_freeze(dev);
174 else
175 return spi_legacy_suspend(dev, PMSG_FREEZE);
176}
177
178static int spi_pm_thaw(struct device *dev)
179{
180 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
181
182 if (pm)
183 return pm_generic_thaw(dev);
184 else
185 return spi_legacy_resume(dev);
186}
187
188static int spi_pm_poweroff(struct device *dev)
189{
190 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
191
192 if (pm)
193 return pm_generic_poweroff(dev);
194 else
195 return spi_legacy_suspend(dev, PMSG_HIBERNATE);
196}
197
198static int spi_pm_restore(struct device *dev)
199{
200 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
201
202 if (pm)
203 return pm_generic_restore(dev);
204 else
205 return spi_legacy_resume(dev);
206}
207#else
208#define spi_pm_suspend NULL
209#define spi_pm_resume NULL
210#define spi_pm_freeze NULL
211#define spi_pm_thaw NULL
212#define spi_pm_poweroff NULL
213#define spi_pm_restore NULL
214#endif
215
216static const struct dev_pm_ops spi_pm = {
217 .suspend = spi_pm_suspend,
218 .resume = spi_pm_resume,
219 .freeze = spi_pm_freeze,
220 .thaw = spi_pm_thaw,
221 .poweroff = spi_pm_poweroff,
222 .restore = spi_pm_restore,
223 SET_RUNTIME_PM_OPS(
224 pm_generic_runtime_suspend,
225 pm_generic_runtime_resume,
226 NULL
227 )
228};
229
230struct bus_type spi_bus_type = {
231 .name = "spi",
232 .dev_attrs = spi_dev_attrs,
233 .match = spi_match_device,
234 .uevent = spi_uevent,
235 .pm = &spi_pm,
236};
237EXPORT_SYMBOL_GPL(spi_bus_type);
238
239
240static int spi_drv_probe(struct device *dev)
241{
242 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
243
244 return sdrv->probe(to_spi_device(dev));
245}
246
247static int spi_drv_remove(struct device *dev)
248{
249 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
250
251 return sdrv->remove(to_spi_device(dev));
252}
253
254static void spi_drv_shutdown(struct device *dev)
255{
256 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
257
258 sdrv->shutdown(to_spi_device(dev));
259}
260
261
262
263
264
265
266int spi_register_driver(struct spi_driver *sdrv)
267{
268 sdrv->driver.bus = &spi_bus_type;
269 if (sdrv->probe)
270 sdrv->driver.probe = spi_drv_probe;
271 if (sdrv->remove)
272 sdrv->driver.remove = spi_drv_remove;
273 if (sdrv->shutdown)
274 sdrv->driver.shutdown = spi_drv_shutdown;
275 return driver_register(&sdrv->driver);
276}
277EXPORT_SYMBOL_GPL(spi_register_driver);
278
279
280
281
282
283
284
285
286
287struct boardinfo {
288 struct list_head list;
289 struct spi_board_info board_info;
290};
291
292static LIST_HEAD(board_list);
293static LIST_HEAD(spi_master_list);
294
295
296
297
298
299static DEFINE_MUTEX(board_lock);
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318struct spi_device *spi_alloc_device(struct spi_master *master)
319{
320 struct spi_device *spi;
321 struct device *dev = master->dev.parent;
322
323 if (!spi_master_get(master))
324 return NULL;
325
326 spi = kzalloc(sizeof *spi, GFP_KERNEL);
327 if (!spi) {
328 dev_err(dev, "cannot alloc spi_device\n");
329 spi_master_put(master);
330 return NULL;
331 }
332
333 spi->master = master;
334 spi->dev.parent = &master->dev;
335 spi->dev.bus = &spi_bus_type;
336 spi->dev.release = spidev_release;
337 spi->cs_gpio = -ENOENT;
338 device_initialize(&spi->dev);
339 return spi;
340}
341EXPORT_SYMBOL_GPL(spi_alloc_device);
342
343
344
345
346
347
348
349
350
351
352int spi_add_device(struct spi_device *spi)
353{
354 static DEFINE_MUTEX(spi_add_lock);
355 struct spi_master *master = spi->master;
356 struct device *dev = master->dev.parent;
357 struct device *d;
358 int status;
359
360
361 if (spi->chip_select >= master->num_chipselect) {
362 dev_err(dev, "cs%d >= max %d\n",
363 spi->chip_select,
364 master->num_chipselect);
365 return -EINVAL;
366 }
367
368
369 dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),
370 spi->chip_select);
371
372
373
374
375
376
377 mutex_lock(&spi_add_lock);
378
379 d = bus_find_device_by_name(&spi_bus_type, NULL, dev_name(&spi->dev));
380 if (d != NULL) {
381 dev_err(dev, "chipselect %d already in use\n",
382 spi->chip_select);
383 put_device(d);
384 status = -EBUSY;
385 goto done;
386 }
387
388 if (master->cs_gpios)
389 spi->cs_gpio = master->cs_gpios[spi->chip_select];
390
391
392
393
394
395 status = spi_setup(spi);
396 if (status < 0) {
397 dev_err(dev, "can't setup %s, status %d\n",
398 dev_name(&spi->dev), status);
399 goto done;
400 }
401
402
403 status = device_add(&spi->dev);
404 if (status < 0)
405 dev_err(dev, "can't add %s, status %d\n",
406 dev_name(&spi->dev), status);
407 else
408 dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));
409
410done:
411 mutex_unlock(&spi_add_lock);
412 return status;
413}
414EXPORT_SYMBOL_GPL(spi_add_device);
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430struct spi_device *spi_new_device(struct spi_master *master,
431 struct spi_board_info *chip)
432{
433 struct spi_device *proxy;
434 int status;
435
436
437
438
439
440
441
442
443 proxy = spi_alloc_device(master);
444 if (!proxy)
445 return NULL;
446
447 WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
448
449 proxy->chip_select = chip->chip_select;
450 proxy->max_speed_hz = chip->max_speed_hz;
451 proxy->mode = chip->mode;
452 proxy->irq = chip->irq;
453 strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));
454 proxy->dev.platform_data = (void *) chip->platform_data;
455 proxy->controller_data = chip->controller_data;
456 proxy->controller_state = NULL;
457
458 status = spi_add_device(proxy);
459 if (status < 0) {
460 spi_dev_put(proxy);
461 return NULL;
462 }
463
464 return proxy;
465}
466EXPORT_SYMBOL_GPL(spi_new_device);
467
468static void spi_match_master_to_boardinfo(struct spi_master *master,
469 struct spi_board_info *bi)
470{
471 struct spi_device *dev;
472
473 if (master->bus_num != bi->bus_num)
474 return;
475
476 dev = spi_new_device(master, bi);
477 if (!dev)
478 dev_err(master->dev.parent, "can't create new device for %s\n",
479 bi->modalias);
480}
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501int spi_register_board_info(struct spi_board_info const *info, unsigned n)
502{
503 struct boardinfo *bi;
504 int i;
505
506 bi = kzalloc(n * sizeof(*bi), GFP_KERNEL);
507 if (!bi)
508 return -ENOMEM;
509
510 for (i = 0; i < n; i++, bi++, info++) {
511 struct spi_master *master;
512
513 memcpy(&bi->board_info, info, sizeof(*info));
514 mutex_lock(&board_lock);
515 list_add_tail(&bi->list, &board_list);
516 list_for_each_entry(master, &spi_master_list, list)
517 spi_match_master_to_boardinfo(master, &bi->board_info);
518 mutex_unlock(&board_lock);
519 }
520
521 return 0;
522}
523
524
525
526
527
528
529
530
531
532
533
534
535static void spi_pump_messages(struct kthread_work *work)
536{
537 struct spi_master *master =
538 container_of(work, struct spi_master, pump_messages);
539 unsigned long flags;
540 bool was_busy = false;
541 int ret;
542
543
544 spin_lock_irqsave(&master->queue_lock, flags);
545 if (list_empty(&master->queue) || !master->running) {
546 if (!master->busy) {
547 spin_unlock_irqrestore(&master->queue_lock, flags);
548 return;
549 }
550 master->busy = false;
551 spin_unlock_irqrestore(&master->queue_lock, flags);
552 if (master->unprepare_transfer_hardware &&
553 master->unprepare_transfer_hardware(master))
554 dev_err(&master->dev,
555 "failed to unprepare transfer hardware\n");
556 return;
557 }
558
559
560 if (master->cur_msg) {
561 spin_unlock_irqrestore(&master->queue_lock, flags);
562 return;
563 }
564
565 master->cur_msg =
566 list_entry(master->queue.next, struct spi_message, queue);
567
568 list_del_init(&master->cur_msg->queue);
569 if (master->busy)
570 was_busy = true;
571 else
572 master->busy = true;
573 spin_unlock_irqrestore(&master->queue_lock, flags);
574
575 if (!was_busy && master->prepare_transfer_hardware) {
576 ret = master->prepare_transfer_hardware(master);
577 if (ret) {
578 dev_err(&master->dev,
579 "failed to prepare transfer hardware\n");
580 return;
581 }
582 }
583
584 ret = master->transfer_one_message(master, master->cur_msg);
585 if (ret) {
586 dev_err(&master->dev,
587 "failed to transfer one message from queue\n");
588 return;
589 }
590}
591
592static int spi_init_queue(struct spi_master *master)
593{
594 struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
595
596 INIT_LIST_HEAD(&master->queue);
597 spin_lock_init(&master->queue_lock);
598
599 master->running = false;
600 master->busy = false;
601
602 init_kthread_worker(&master->kworker);
603 master->kworker_task = kthread_run(kthread_worker_fn,
604 &master->kworker,
605 dev_name(&master->dev));
606 if (IS_ERR(master->kworker_task)) {
607 dev_err(&master->dev, "failed to create message pump task\n");
608 return -ENOMEM;
609 }
610 init_kthread_work(&master->pump_messages, spi_pump_messages);
611
612
613
614
615
616
617
618
619 if (master->rt) {
620 dev_info(&master->dev,
621 "will run message pump with realtime priority\n");
622 sched_setscheduler(master->kworker_task, SCHED_FIFO, ¶m);
623 }
624
625 return 0;
626}
627
628
629
630
631
632
633
634
635
636struct spi_message *spi_get_next_queued_message(struct spi_master *master)
637{
638 struct spi_message *next;
639 unsigned long flags;
640
641
642 spin_lock_irqsave(&master->queue_lock, flags);
643 if (list_empty(&master->queue))
644 next = NULL;
645 else
646 next = list_entry(master->queue.next,
647 struct spi_message, queue);
648 spin_unlock_irqrestore(&master->queue_lock, flags);
649
650 return next;
651}
652EXPORT_SYMBOL_GPL(spi_get_next_queued_message);
653
654
655
656
657
658
659
660
661void spi_finalize_current_message(struct spi_master *master)
662{
663 struct spi_message *mesg;
664 unsigned long flags;
665
666 spin_lock_irqsave(&master->queue_lock, flags);
667 mesg = master->cur_msg;
668 master->cur_msg = NULL;
669
670 queue_kthread_work(&master->kworker, &master->pump_messages);
671 spin_unlock_irqrestore(&master->queue_lock, flags);
672
673 mesg->state = NULL;
674 if (mesg->complete)
675 mesg->complete(mesg->context);
676}
677EXPORT_SYMBOL_GPL(spi_finalize_current_message);
678
679static int spi_start_queue(struct spi_master *master)
680{
681 unsigned long flags;
682
683 spin_lock_irqsave(&master->queue_lock, flags);
684
685 if (master->running || master->busy) {
686 spin_unlock_irqrestore(&master->queue_lock, flags);
687 return -EBUSY;
688 }
689
690 master->running = true;
691 master->cur_msg = NULL;
692 spin_unlock_irqrestore(&master->queue_lock, flags);
693
694 queue_kthread_work(&master->kworker, &master->pump_messages);
695
696 return 0;
697}
698
699static int spi_stop_queue(struct spi_master *master)
700{
701 unsigned long flags;
702 unsigned limit = 500;
703 int ret = 0;
704
705 spin_lock_irqsave(&master->queue_lock, flags);
706
707
708
709
710
711
712
713 while ((!list_empty(&master->queue) || master->busy) && limit--) {
714 spin_unlock_irqrestore(&master->queue_lock, flags);
715 msleep(10);
716 spin_lock_irqsave(&master->queue_lock, flags);
717 }
718
719 if (!list_empty(&master->queue) || master->busy)
720 ret = -EBUSY;
721 else
722 master->running = false;
723
724 spin_unlock_irqrestore(&master->queue_lock, flags);
725
726 if (ret) {
727 dev_warn(&master->dev,
728 "could not stop message queue\n");
729 return ret;
730 }
731 return ret;
732}
733
734static int spi_destroy_queue(struct spi_master *master)
735{
736 int ret;
737
738 ret = spi_stop_queue(master);
739
740
741
742
743
744
745
746 if (ret) {
747 dev_err(&master->dev, "problem destroying queue\n");
748 return ret;
749 }
750
751 flush_kthread_worker(&master->kworker);
752 kthread_stop(master->kworker_task);
753
754 return 0;
755}
756
757
758
759
760
761
762static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
763{
764 struct spi_master *master = spi->master;
765 unsigned long flags;
766
767 spin_lock_irqsave(&master->queue_lock, flags);
768
769 if (!master->running) {
770 spin_unlock_irqrestore(&master->queue_lock, flags);
771 return -ESHUTDOWN;
772 }
773 msg->actual_length = 0;
774 msg->status = -EINPROGRESS;
775
776 list_add_tail(&msg->queue, &master->queue);
777 if (master->running && !master->busy)
778 queue_kthread_work(&master->kworker, &master->pump_messages);
779
780 spin_unlock_irqrestore(&master->queue_lock, flags);
781 return 0;
782}
783
784static int spi_master_initialize_queue(struct spi_master *master)
785{
786 int ret;
787
788 master->queued = true;
789 master->transfer = spi_queued_transfer;
790
791
792 ret = spi_init_queue(master);
793 if (ret) {
794 dev_err(&master->dev, "problem initializing queue\n");
795 goto err_init_queue;
796 }
797 ret = spi_start_queue(master);
798 if (ret) {
799 dev_err(&master->dev, "problem starting queue\n");
800 goto err_start_queue;
801 }
802
803 return 0;
804
805err_start_queue:
806err_init_queue:
807 spi_destroy_queue(master);
808 return ret;
809}
810
811
812
813#if defined(CONFIG_OF)
814
815
816
817
818
819
820
821static void of_register_spi_devices(struct spi_master *master)
822{
823 struct spi_device *spi;
824 struct device_node *nc;
825 const __be32 *prop;
826 char modalias[SPI_NAME_SIZE + 4];
827 int rc;
828 int len;
829
830 if (!master->dev.of_node)
831 return;
832
833 for_each_available_child_of_node(master->dev.of_node, nc) {
834
835 spi = spi_alloc_device(master);
836 if (!spi) {
837 dev_err(&master->dev, "spi_device alloc error for %s\n",
838 nc->full_name);
839 spi_dev_put(spi);
840 continue;
841 }
842
843
844 if (of_modalias_node(nc, spi->modalias,
845 sizeof(spi->modalias)) < 0) {
846 dev_err(&master->dev, "cannot find modalias for %s\n",
847 nc->full_name);
848 spi_dev_put(spi);
849 continue;
850 }
851
852
853 prop = of_get_property(nc, "reg", &len);
854 if (!prop || len < sizeof(*prop)) {
855 dev_err(&master->dev, "%s has no 'reg' property\n",
856 nc->full_name);
857 spi_dev_put(spi);
858 continue;
859 }
860 spi->chip_select = be32_to_cpup(prop);
861
862
863 if (of_find_property(nc, "spi-cpha", NULL))
864 spi->mode |= SPI_CPHA;
865 if (of_find_property(nc, "spi-cpol", NULL))
866 spi->mode |= SPI_CPOL;
867 if (of_find_property(nc, "spi-cs-high", NULL))
868 spi->mode |= SPI_CS_HIGH;
869 if (of_find_property(nc, "spi-3wire", NULL))
870 spi->mode |= SPI_3WIRE;
871
872
873 prop = of_get_property(nc, "spi-max-frequency", &len);
874 if (!prop || len < sizeof(*prop)) {
875 dev_err(&master->dev, "%s has no 'spi-max-frequency' property\n",
876 nc->full_name);
877 spi_dev_put(spi);
878 continue;
879 }
880 spi->max_speed_hz = be32_to_cpup(prop);
881
882
883 spi->irq = irq_of_parse_and_map(nc, 0);
884
885
886 of_node_get(nc);
887 spi->dev.of_node = nc;
888
889
890 snprintf(modalias, sizeof(modalias), "%s%s", SPI_MODULE_PREFIX,
891 spi->modalias);
892 request_module(modalias);
893 rc = spi_add_device(spi);
894 if (rc) {
895 dev_err(&master->dev, "spi_device register error %s\n",
896 nc->full_name);
897 spi_dev_put(spi);
898 }
899
900 }
901}
902#else
903static void of_register_spi_devices(struct spi_master *master) { }
904#endif
905
906#ifdef CONFIG_ACPI
907static int acpi_spi_add_resource(struct acpi_resource *ares, void *data)
908{
909 struct spi_device *spi = data;
910
911 if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
912 struct acpi_resource_spi_serialbus *sb;
913
914 sb = &ares->data.spi_serial_bus;
915 if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_SPI) {
916 spi->chip_select = sb->device_selection;
917 spi->max_speed_hz = sb->connection_speed;
918
919 if (sb->clock_phase == ACPI_SPI_SECOND_PHASE)
920 spi->mode |= SPI_CPHA;
921 if (sb->clock_polarity == ACPI_SPI_START_HIGH)
922 spi->mode |= SPI_CPOL;
923 if (sb->device_polarity == ACPI_SPI_ACTIVE_HIGH)
924 spi->mode |= SPI_CS_HIGH;
925 }
926 } else if (spi->irq < 0) {
927 struct resource r;
928
929 if (acpi_dev_resource_interrupt(ares, 0, &r))
930 spi->irq = r.start;
931 }
932
933
934 return 1;
935}
936
937static acpi_status acpi_spi_add_device(acpi_handle handle, u32 level,
938 void *data, void **return_value)
939{
940 struct spi_master *master = data;
941 struct list_head resource_list;
942 struct acpi_device *adev;
943 struct spi_device *spi;
944 int ret;
945
946 if (acpi_bus_get_device(handle, &adev))
947 return AE_OK;
948 if (acpi_bus_get_status(adev) || !adev->status.present)
949 return AE_OK;
950
951 spi = spi_alloc_device(master);
952 if (!spi) {
953 dev_err(&master->dev, "failed to allocate SPI device for %s\n",
954 dev_name(&adev->dev));
955 return AE_NO_MEMORY;
956 }
957
958 ACPI_COMPANION_SET(&spi->dev, adev);
959 spi->irq = -1;
960
961 INIT_LIST_HEAD(&resource_list);
962 ret = acpi_dev_get_resources(adev, &resource_list,
963 acpi_spi_add_resource, spi);
964 acpi_dev_free_resource_list(&resource_list);
965
966 if (ret < 0 || !spi->max_speed_hz) {
967 spi_dev_put(spi);
968 return AE_OK;
969 }
970
971 strlcpy(spi->modalias, dev_name(&adev->dev), sizeof(spi->modalias));
972 if (spi_add_device(spi)) {
973 dev_err(&master->dev, "failed to add SPI device %s from ACPI\n",
974 dev_name(&adev->dev));
975 spi_dev_put(spi);
976 }
977
978 return AE_OK;
979}
980
981static void acpi_register_spi_devices(struct spi_master *master)
982{
983 acpi_status status;
984 acpi_handle handle;
985
986 handle = ACPI_HANDLE(master->dev.parent);
987 if (!handle)
988 return;
989
990 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
991 acpi_spi_add_device, NULL,
992 master, NULL);
993 if (ACPI_FAILURE(status))
994 dev_warn(&master->dev, "failed to enumerate SPI slaves\n");
995}
996#else
997static inline void acpi_register_spi_devices(struct spi_master *master) {}
998#endif
999
1000static void spi_master_release(struct device *dev)
1001{
1002 struct spi_master *master;
1003
1004 master = container_of(dev, struct spi_master, dev);
1005 kfree(master);
1006}
1007
1008static struct class spi_master_class = {
1009 .name = "spi_master",
1010 .owner = THIS_MODULE,
1011 .dev_release = spi_master_release,
1012};
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
1037{
1038 struct spi_master *master;
1039
1040 if (!dev)
1041 return NULL;
1042
1043 master = kzalloc(size + sizeof *master, GFP_KERNEL);
1044 if (!master)
1045 return NULL;
1046
1047 device_initialize(&master->dev);
1048 master->bus_num = -1;
1049 master->num_chipselect = 1;
1050 master->dev.class = &spi_master_class;
1051 master->dev.parent = get_device(dev);
1052 spi_master_set_devdata(master, &master[1]);
1053
1054 return master;
1055}
1056EXPORT_SYMBOL_GPL(spi_alloc_master);
1057
1058#ifdef CONFIG_OF
1059static int of_spi_register_master(struct spi_master *master)
1060{
1061 int nb, i, *cs;
1062 struct device_node *np = master->dev.of_node;
1063
1064 if (!np)
1065 return 0;
1066
1067 nb = of_gpio_named_count(np, "cs-gpios");
1068 master->num_chipselect = max(nb, (int)master->num_chipselect);
1069
1070
1071 if (nb == 0 || nb == -ENOENT)
1072 return 0;
1073 else if (nb < 0)
1074 return nb;
1075
1076 cs = devm_kzalloc(&master->dev,
1077 sizeof(int) * master->num_chipselect,
1078 GFP_KERNEL);
1079 master->cs_gpios = cs;
1080
1081 if (!master->cs_gpios)
1082 return -ENOMEM;
1083
1084 for (i = 0; i < master->num_chipselect; i++)
1085 cs[i] = -ENOENT;
1086
1087 for (i = 0; i < nb; i++)
1088 cs[i] = of_get_named_gpio(np, "cs-gpios", i);
1089
1090 return 0;
1091}
1092#else
1093static int of_spi_register_master(struct spi_master *master)
1094{
1095 return 0;
1096}
1097#endif
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119int spi_register_master(struct spi_master *master)
1120{
1121 static atomic_t dyn_bus_id = ATOMIC_INIT((1<<15) - 1);
1122 struct device *dev = master->dev.parent;
1123 struct boardinfo *bi;
1124 int status = -ENODEV;
1125 int dynamic = 0;
1126
1127 if (!dev)
1128 return -ENODEV;
1129
1130 status = of_spi_register_master(master);
1131 if (status)
1132 return status;
1133
1134
1135
1136
1137 if (master->num_chipselect == 0)
1138 return -EINVAL;
1139
1140 if ((master->bus_num < 0) && master->dev.of_node)
1141 master->bus_num = of_alias_get_id(master->dev.of_node, "spi");
1142
1143
1144 if (master->bus_num < 0) {
1145
1146
1147
1148 master->bus_num = atomic_dec_return(&dyn_bus_id);
1149 dynamic = 1;
1150 }
1151
1152 spin_lock_init(&master->bus_lock_spinlock);
1153 mutex_init(&master->bus_lock_mutex);
1154 master->bus_lock_flag = 0;
1155
1156
1157
1158
1159 dev_set_name(&master->dev, "spi%u", master->bus_num);
1160 status = device_add(&master->dev);
1161 if (status < 0)
1162 goto done;
1163 dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev),
1164 dynamic ? " (dynamic)" : "");
1165
1166
1167 if (master->transfer)
1168 dev_info(dev, "master is unqueued, this is deprecated\n");
1169 else {
1170 status = spi_master_initialize_queue(master);
1171 if (status) {
1172 device_unregister(&master->dev);
1173 goto done;
1174 }
1175 }
1176
1177 mutex_lock(&board_lock);
1178 list_add_tail(&master->list, &spi_master_list);
1179 list_for_each_entry(bi, &board_list, list)
1180 spi_match_master_to_boardinfo(master, &bi->board_info);
1181 mutex_unlock(&board_lock);
1182
1183
1184 of_register_spi_devices(master);
1185 acpi_register_spi_devices(master);
1186done:
1187 return status;
1188}
1189EXPORT_SYMBOL_GPL(spi_register_master);
1190
1191static int __unregister(struct device *dev, void *null)
1192{
1193 spi_unregister_device(to_spi_device(dev));
1194 return 0;
1195}
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207void spi_unregister_master(struct spi_master *master)
1208{
1209 int dummy;
1210
1211 if (master->queued) {
1212 if (spi_destroy_queue(master))
1213 dev_err(&master->dev, "queue remove failed\n");
1214 }
1215
1216 mutex_lock(&board_lock);
1217 list_del(&master->list);
1218 mutex_unlock(&board_lock);
1219
1220 dummy = device_for_each_child(&master->dev, NULL, __unregister);
1221 device_unregister(&master->dev);
1222}
1223EXPORT_SYMBOL_GPL(spi_unregister_master);
1224
1225int spi_master_suspend(struct spi_master *master)
1226{
1227 int ret;
1228
1229
1230 if (!master->queued)
1231 return 0;
1232
1233 ret = spi_stop_queue(master);
1234 if (ret)
1235 dev_err(&master->dev, "queue stop failed\n");
1236
1237 return ret;
1238}
1239EXPORT_SYMBOL_GPL(spi_master_suspend);
1240
1241int spi_master_resume(struct spi_master *master)
1242{
1243 int ret;
1244
1245 if (!master->queued)
1246 return 0;
1247
1248 ret = spi_start_queue(master);
1249 if (ret)
1250 dev_err(&master->dev, "queue restart failed\n");
1251
1252 return ret;
1253}
1254EXPORT_SYMBOL_GPL(spi_master_resume);
1255
1256static int __spi_master_match(struct device *dev, const void *data)
1257{
1258 struct spi_master *m;
1259 const u16 *bus_num = data;
1260
1261 m = container_of(dev, struct spi_master, dev);
1262 return m->bus_num == *bus_num;
1263}
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275struct spi_master *spi_busnum_to_master(u16 bus_num)
1276{
1277 struct device *dev;
1278 struct spi_master *master = NULL;
1279
1280 dev = class_find_device(&spi_master_class, NULL, &bus_num,
1281 __spi_master_match);
1282 if (dev)
1283 master = container_of(dev, struct spi_master, dev);
1284
1285 return master;
1286}
1287EXPORT_SYMBOL_GPL(spi_busnum_to_master);
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314int spi_setup(struct spi_device *spi)
1315{
1316 unsigned bad_bits;
1317 int status = 0;
1318
1319
1320
1321
1322 bad_bits = spi->mode & ~spi->master->mode_bits;
1323 if (bad_bits) {
1324 dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
1325 bad_bits);
1326 return -EINVAL;
1327 }
1328
1329 if (!spi->bits_per_word)
1330 spi->bits_per_word = 8;
1331
1332 if (spi->master->setup)
1333 status = spi->master->setup(spi);
1334
1335 dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s"
1336 "%u bits/w, %u Hz max --> %d\n",
1337 (int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
1338 (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
1339 (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
1340 (spi->mode & SPI_3WIRE) ? "3wire, " : "",
1341 (spi->mode & SPI_LOOP) ? "loopback, " : "",
1342 spi->bits_per_word, spi->max_speed_hz,
1343 status);
1344
1345 return status;
1346}
1347EXPORT_SYMBOL_GPL(spi_setup);
1348
1349static int __spi_async(struct spi_device *spi, struct spi_message *message)
1350{
1351 struct spi_master *master = spi->master;
1352 struct spi_transfer *xfer;
1353
1354
1355
1356
1357
1358
1359 if ((master->flags & SPI_MASTER_HALF_DUPLEX)
1360 || (spi->mode & SPI_3WIRE)) {
1361 unsigned flags = master->flags;
1362
1363 list_for_each_entry(xfer, &message->transfers, transfer_list) {
1364 if (xfer->rx_buf && xfer->tx_buf)
1365 return -EINVAL;
1366 if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
1367 return -EINVAL;
1368 if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
1369 return -EINVAL;
1370 }
1371 }
1372
1373
1374
1375
1376
1377 list_for_each_entry(xfer, &message->transfers, transfer_list) {
1378 if (!xfer->bits_per_word)
1379 xfer->bits_per_word = spi->bits_per_word;
1380 if (!xfer->speed_hz)
1381 xfer->speed_hz = spi->max_speed_hz;
1382 if (master->bits_per_word_mask) {
1383
1384 if (xfer->bits_per_word > 32)
1385 return -EINVAL;
1386 if (!(master->bits_per_word_mask &
1387 BIT(xfer->bits_per_word - 1)))
1388 return -EINVAL;
1389 }
1390 }
1391
1392 message->spi = spi;
1393 message->status = -EINPROGRESS;
1394 return master->transfer(spi, message);
1395}
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426int spi_async(struct spi_device *spi, struct spi_message *message)
1427{
1428 struct spi_master *master = spi->master;
1429 int ret;
1430 unsigned long flags;
1431
1432 spin_lock_irqsave(&master->bus_lock_spinlock, flags);
1433
1434 if (master->bus_lock_flag)
1435 ret = -EBUSY;
1436 else
1437 ret = __spi_async(spi, message);
1438
1439 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
1440
1441 return ret;
1442}
1443EXPORT_SYMBOL_GPL(spi_async);
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474int spi_async_locked(struct spi_device *spi, struct spi_message *message)
1475{
1476 struct spi_master *master = spi->master;
1477 int ret;
1478 unsigned long flags;
1479
1480 spin_lock_irqsave(&master->bus_lock_spinlock, flags);
1481
1482 ret = __spi_async(spi, message);
1483
1484 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
1485
1486 return ret;
1487
1488}
1489EXPORT_SYMBOL_GPL(spi_async_locked);
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499static void spi_complete(void *arg)
1500{
1501 complete(arg);
1502}
1503
1504static int __spi_sync(struct spi_device *spi, struct spi_message *message,
1505 int bus_locked)
1506{
1507 DECLARE_COMPLETION_ONSTACK(done);
1508 int status;
1509 struct spi_master *master = spi->master;
1510
1511 message->complete = spi_complete;
1512 message->context = &done;
1513
1514 if (!bus_locked)
1515 mutex_lock(&master->bus_lock_mutex);
1516
1517 status = spi_async_locked(spi, message);
1518
1519 if (!bus_locked)
1520 mutex_unlock(&master->bus_lock_mutex);
1521
1522 if (status == 0) {
1523 wait_for_completion(&done);
1524 status = message->status;
1525 }
1526 message->context = NULL;
1527 return status;
1528}
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551int spi_sync(struct spi_device *spi, struct spi_message *message)
1552{
1553 return __spi_sync(spi, message, 0);
1554}
1555EXPORT_SYMBOL_GPL(spi_sync);
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
1574{
1575 return __spi_sync(spi, message, 1);
1576}
1577EXPORT_SYMBOL_GPL(spi_sync_locked);
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594int spi_bus_lock(struct spi_master *master)
1595{
1596 unsigned long flags;
1597
1598 mutex_lock(&master->bus_lock_mutex);
1599
1600 spin_lock_irqsave(&master->bus_lock_spinlock, flags);
1601 master->bus_lock_flag = 1;
1602 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
1603
1604
1605
1606 return 0;
1607}
1608EXPORT_SYMBOL_GPL(spi_bus_lock);
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623int spi_bus_unlock(struct spi_master *master)
1624{
1625 master->bus_lock_flag = 0;
1626
1627 mutex_unlock(&master->bus_lock_mutex);
1628
1629 return 0;
1630}
1631EXPORT_SYMBOL_GPL(spi_bus_unlock);
1632
1633
1634#define SPI_BUFSIZ max(32,SMP_CACHE_BYTES)
1635
1636static u8 *buf;
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657int spi_write_then_read(struct spi_device *spi,
1658 const void *txbuf, unsigned n_tx,
1659 void *rxbuf, unsigned n_rx)
1660{
1661 static DEFINE_MUTEX(lock);
1662
1663 int status;
1664 struct spi_message message;
1665 struct spi_transfer x[2];
1666 u8 *local_buf;
1667
1668
1669
1670
1671
1672
1673 if ((n_tx + n_rx) > SPI_BUFSIZ || !mutex_trylock(&lock)) {
1674 local_buf = kmalloc(max((unsigned)SPI_BUFSIZ, n_tx + n_rx),
1675 GFP_KERNEL | GFP_DMA);
1676 if (!local_buf)
1677 return -ENOMEM;
1678 } else {
1679 local_buf = buf;
1680 }
1681
1682 spi_message_init(&message);
1683 memset(x, 0, sizeof x);
1684 if (n_tx) {
1685 x[0].len = n_tx;
1686 spi_message_add_tail(&x[0], &message);
1687 }
1688 if (n_rx) {
1689 x[1].len = n_rx;
1690 spi_message_add_tail(&x[1], &message);
1691 }
1692
1693 memcpy(local_buf, txbuf, n_tx);
1694 x[0].tx_buf = local_buf;
1695 x[1].rx_buf = local_buf + n_tx;
1696
1697
1698 status = spi_sync(spi, &message);
1699 if (status == 0)
1700 memcpy(rxbuf, x[1].rx_buf, n_rx);
1701
1702 if (x[0].tx_buf == buf)
1703 mutex_unlock(&lock);
1704 else
1705 kfree(local_buf);
1706
1707 return status;
1708}
1709EXPORT_SYMBOL_GPL(spi_write_then_read);
1710
1711
1712
1713static int __init spi_init(void)
1714{
1715 int status;
1716
1717 buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
1718 if (!buf) {
1719 status = -ENOMEM;
1720 goto err0;
1721 }
1722
1723 status = bus_register(&spi_bus_type);
1724 if (status < 0)
1725 goto err1;
1726
1727 status = class_register(&spi_master_class);
1728 if (status < 0)
1729 goto err2;
1730 return 0;
1731
1732err2:
1733 bus_unregister(&spi_bus_type);
1734err1:
1735 kfree(buf);
1736 buf = NULL;
1737err0:
1738 return status;
1739}
1740
1741
1742
1743
1744
1745
1746
1747
1748postcore_initcall(spi_init);
1749
1750