1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <linux/kernel.h>
22#include <linux/device.h>
23#include <linux/init.h>
24#include <linux/cache.h>
25#include <linux/mutex.h>
26#include <linux/spi/spi.h>
27
28
29
30
31
32
33static void spidev_release(struct device *dev)
34{
35 struct spi_device *spi = to_spi_device(dev);
36
37
38 if (spi->master->cleanup)
39 spi->master->cleanup(spi);
40
41 spi_master_put(spi->master);
42 kfree(dev);
43}
44
45static ssize_t
46modalias_show(struct device *dev, struct device_attribute *a, char *buf)
47{
48 const struct spi_device *spi = to_spi_device(dev);
49
50 return snprintf(buf, BUS_ID_SIZE + 1, "%s\n", spi->modalias);
51}
52
53static struct device_attribute spi_dev_attrs[] = {
54 __ATTR_RO(modalias),
55 __ATTR_NULL,
56};
57
58
59
60
61
62static int spi_match_device(struct device *dev, struct device_driver *drv)
63{
64 const struct spi_device *spi = to_spi_device(dev);
65
66 return strncmp(spi->modalias, drv->name, BUS_ID_SIZE) == 0;
67}
68
69static int spi_uevent(struct device *dev, struct kobj_uevent_env *env)
70{
71 const struct spi_device *spi = to_spi_device(dev);
72
73 add_uevent_var(env, "MODALIAS=%s", spi->modalias);
74 return 0;
75}
76
77#ifdef CONFIG_PM
78
79static int spi_suspend(struct device *dev, pm_message_t message)
80{
81 int value = 0;
82 struct spi_driver *drv = to_spi_driver(dev->driver);
83
84
85 if (drv) {
86 if (drv->suspend)
87 value = drv->suspend(to_spi_device(dev), message);
88 else
89 dev_dbg(dev, "... can't suspend\n");
90 }
91 return value;
92}
93
94static int spi_resume(struct device *dev)
95{
96 int value = 0;
97 struct spi_driver *drv = to_spi_driver(dev->driver);
98
99
100 if (drv) {
101 if (drv->resume)
102 value = drv->resume(to_spi_device(dev));
103 else
104 dev_dbg(dev, "... can't resume\n");
105 }
106 return value;
107}
108
109#else
110#define spi_suspend NULL
111#define spi_resume NULL
112#endif
113
114struct bus_type spi_bus_type = {
115 .name = "spi",
116 .dev_attrs = spi_dev_attrs,
117 .match = spi_match_device,
118 .uevent = spi_uevent,
119 .suspend = spi_suspend,
120 .resume = spi_resume,
121};
122EXPORT_SYMBOL_GPL(spi_bus_type);
123
124
125static int spi_drv_probe(struct device *dev)
126{
127 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
128
129 return sdrv->probe(to_spi_device(dev));
130}
131
132static int spi_drv_remove(struct device *dev)
133{
134 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
135
136 return sdrv->remove(to_spi_device(dev));
137}
138
139static void spi_drv_shutdown(struct device *dev)
140{
141 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
142
143 sdrv->shutdown(to_spi_device(dev));
144}
145
146
147
148
149
150
151int spi_register_driver(struct spi_driver *sdrv)
152{
153 sdrv->driver.bus = &spi_bus_type;
154 if (sdrv->probe)
155 sdrv->driver.probe = spi_drv_probe;
156 if (sdrv->remove)
157 sdrv->driver.remove = spi_drv_remove;
158 if (sdrv->shutdown)
159 sdrv->driver.shutdown = spi_drv_shutdown;
160 return driver_register(&sdrv->driver);
161}
162EXPORT_SYMBOL_GPL(spi_register_driver);
163
164
165
166
167
168
169
170
171
172struct boardinfo {
173 struct list_head list;
174 unsigned n_board_info;
175 struct spi_board_info board_info[0];
176};
177
178static LIST_HEAD(board_list);
179static DEFINE_MUTEX(board_lock);
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198struct spi_device *spi_alloc_device(struct spi_master *master)
199{
200 struct spi_device *spi;
201 struct device *dev = master->dev.parent;
202
203 if (!spi_master_get(master))
204 return NULL;
205
206 spi = kzalloc(sizeof *spi, GFP_KERNEL);
207 if (!spi) {
208 dev_err(dev, "cannot alloc spi_device\n");
209 spi_master_put(master);
210 return NULL;
211 }
212
213 spi->master = master;
214 spi->dev.parent = dev;
215 spi->dev.bus = &spi_bus_type;
216 spi->dev.release = spidev_release;
217 device_initialize(&spi->dev);
218 return spi;
219}
220EXPORT_SYMBOL_GPL(spi_alloc_device);
221
222
223
224
225
226
227
228
229
230
231int spi_add_device(struct spi_device *spi)
232{
233 static DEFINE_MUTEX(spi_add_lock);
234 struct device *dev = spi->master->dev.parent;
235 int status;
236
237
238 if (spi->chip_select >= spi->master->num_chipselect) {
239 dev_err(dev, "cs%d >= max %d\n",
240 spi->chip_select,
241 spi->master->num_chipselect);
242 return -EINVAL;
243 }
244
245
246 snprintf(spi->dev.bus_id, sizeof spi->dev.bus_id,
247 "%s.%u", spi->master->dev.bus_id,
248 spi->chip_select);
249
250
251
252
253
254
255 mutex_lock(&spi_add_lock);
256
257 if (bus_find_device_by_name(&spi_bus_type, NULL, spi->dev.bus_id)
258 != NULL) {
259 dev_err(dev, "chipselect %d already in use\n",
260 spi->chip_select);
261 status = -EBUSY;
262 goto done;
263 }
264
265
266
267
268
269 status = spi->master->setup(spi);
270 if (status < 0) {
271 dev_err(dev, "can't %s %s, status %d\n",
272 "setup", spi->dev.bus_id, status);
273 goto done;
274 }
275
276
277 status = device_add(&spi->dev);
278 if (status < 0)
279 dev_err(dev, "can't %s %s, status %d\n",
280 "add", spi->dev.bus_id, status);
281 else
282 dev_dbg(dev, "registered child %s\n", spi->dev.bus_id);
283
284done:
285 mutex_unlock(&spi_add_lock);
286 return status;
287}
288EXPORT_SYMBOL_GPL(spi_add_device);
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304struct spi_device *spi_new_device(struct spi_master *master,
305 struct spi_board_info *chip)
306{
307 struct spi_device *proxy;
308 int status;
309
310
311
312
313
314
315
316
317 proxy = spi_alloc_device(master);
318 if (!proxy)
319 return NULL;
320
321 WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
322
323 proxy->chip_select = chip->chip_select;
324 proxy->max_speed_hz = chip->max_speed_hz;
325 proxy->mode = chip->mode;
326 proxy->irq = chip->irq;
327 strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));
328 proxy->dev.platform_data = (void *) chip->platform_data;
329 proxy->controller_data = chip->controller_data;
330 proxy->controller_state = NULL;
331
332 status = spi_add_device(proxy);
333 if (status < 0) {
334 spi_dev_put(proxy);
335 return NULL;
336 }
337
338 return proxy;
339}
340EXPORT_SYMBOL_GPL(spi_new_device);
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361int __init
362spi_register_board_info(struct spi_board_info const *info, unsigned n)
363{
364 struct boardinfo *bi;
365
366 bi = kmalloc(sizeof(*bi) + n * sizeof *info, GFP_KERNEL);
367 if (!bi)
368 return -ENOMEM;
369 bi->n_board_info = n;
370 memcpy(bi->board_info, info, n * sizeof *info);
371
372 mutex_lock(&board_lock);
373 list_add_tail(&bi->list, &board_list);
374 mutex_unlock(&board_lock);
375 return 0;
376}
377
378
379
380
381
382static void scan_boardinfo(struct spi_master *master)
383{
384 struct boardinfo *bi;
385
386 mutex_lock(&board_lock);
387 list_for_each_entry(bi, &board_list, list) {
388 struct spi_board_info *chip = bi->board_info;
389 unsigned n;
390
391 for (n = bi->n_board_info; n > 0; n--, chip++) {
392 if (chip->bus_num != master->bus_num)
393 continue;
394
395
396
397 (void) spi_new_device(master, chip);
398 }
399 }
400 mutex_unlock(&board_lock);
401}
402
403
404
405static void spi_master_release(struct device *dev)
406{
407 struct spi_master *master;
408
409 master = container_of(dev, struct spi_master, dev);
410 kfree(master);
411}
412
413static struct class spi_master_class = {
414 .name = "spi_master",
415 .owner = THIS_MODULE,
416 .dev_release = spi_master_release,
417};
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
440{
441 struct spi_master *master;
442
443 if (!dev)
444 return NULL;
445
446 master = kzalloc(size + sizeof *master, GFP_KERNEL);
447 if (!master)
448 return NULL;
449
450 device_initialize(&master->dev);
451 master->dev.class = &spi_master_class;
452 master->dev.parent = get_device(dev);
453 spi_master_set_devdata(master, &master[1]);
454
455 return master;
456}
457EXPORT_SYMBOL_GPL(spi_alloc_master);
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479int spi_register_master(struct spi_master *master)
480{
481 static atomic_t dyn_bus_id = ATOMIC_INIT((1<<15) - 1);
482 struct device *dev = master->dev.parent;
483 int status = -ENODEV;
484 int dynamic = 0;
485
486 if (!dev)
487 return -ENODEV;
488
489
490
491
492 if (master->num_chipselect == 0)
493 return -EINVAL;
494
495
496 if (master->bus_num < 0) {
497
498
499
500 master->bus_num = atomic_dec_return(&dyn_bus_id);
501 dynamic = 1;
502 }
503
504
505
506
507 snprintf(master->dev.bus_id, sizeof master->dev.bus_id,
508 "spi%u", master->bus_num);
509 status = device_add(&master->dev);
510 if (status < 0)
511 goto done;
512 dev_dbg(dev, "registered master %s%s\n", master->dev.bus_id,
513 dynamic ? " (dynamic)" : "");
514
515
516 scan_boardinfo(master);
517 status = 0;
518done:
519 return status;
520}
521EXPORT_SYMBOL_GPL(spi_register_master);
522
523
524static int __unregister(struct device *dev, void *master_dev)
525{
526
527 if (dev != master_dev)
528 spi_unregister_device(to_spi_device(dev));
529 return 0;
530}
531
532
533
534
535
536
537
538
539
540
541
542void spi_unregister_master(struct spi_master *master)
543{
544 int dummy;
545
546 dummy = device_for_each_child(master->dev.parent, &master->dev,
547 __unregister);
548 device_unregister(&master->dev);
549}
550EXPORT_SYMBOL_GPL(spi_unregister_master);
551
552static int __spi_master_match(struct device *dev, void *data)
553{
554 struct spi_master *m;
555 u16 *bus_num = data;
556
557 m = container_of(dev, struct spi_master, dev);
558 return m->bus_num == *bus_num;
559}
560
561
562
563
564
565
566
567
568
569
570
571struct spi_master *spi_busnum_to_master(u16 bus_num)
572{
573 struct device *dev;
574 struct spi_master *master = NULL;
575
576 dev = class_find_device(&spi_master_class, NULL, &bus_num,
577 __spi_master_match);
578 if (dev)
579 master = container_of(dev, struct spi_master, dev);
580
581 return master;
582}
583EXPORT_SYMBOL_GPL(spi_busnum_to_master);
584
585
586
587
588static void spi_complete(void *arg)
589{
590 complete(arg);
591}
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614int spi_sync(struct spi_device *spi, struct spi_message *message)
615{
616 DECLARE_COMPLETION_ONSTACK(done);
617 int status;
618
619 message->complete = spi_complete;
620 message->context = &done;
621 status = spi_async(spi, message);
622 if (status == 0) {
623 wait_for_completion(&done);
624 status = message->status;
625 }
626 message->context = NULL;
627 return status;
628}
629EXPORT_SYMBOL_GPL(spi_sync);
630
631
632#define SPI_BUFSIZ max(32,SMP_CACHE_BYTES)
633
634static u8 *buf;
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655int spi_write_then_read(struct spi_device *spi,
656 const u8 *txbuf, unsigned n_tx,
657 u8 *rxbuf, unsigned n_rx)
658{
659 static DEFINE_MUTEX(lock);
660
661 int status;
662 struct spi_message message;
663 struct spi_transfer x;
664 u8 *local_buf;
665
666
667
668
669
670 if ((n_tx + n_rx) > SPI_BUFSIZ)
671 return -EINVAL;
672
673 spi_message_init(&message);
674 memset(&x, 0, sizeof x);
675 x.len = n_tx + n_rx;
676 spi_message_add_tail(&x, &message);
677
678
679 if (!mutex_trylock(&lock)) {
680 local_buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
681 if (!local_buf)
682 return -ENOMEM;
683 } else
684 local_buf = buf;
685
686 memcpy(local_buf, txbuf, n_tx);
687 x.tx_buf = local_buf;
688 x.rx_buf = local_buf;
689
690
691 status = spi_sync(spi, &message);
692 if (status == 0)
693 memcpy(rxbuf, x.rx_buf + n_tx, n_rx);
694
695 if (x.tx_buf == buf)
696 mutex_unlock(&lock);
697 else
698 kfree(local_buf);
699
700 return status;
701}
702EXPORT_SYMBOL_GPL(spi_write_then_read);
703
704
705
706static int __init spi_init(void)
707{
708 int status;
709
710 buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
711 if (!buf) {
712 status = -ENOMEM;
713 goto err0;
714 }
715
716 status = bus_register(&spi_bus_type);
717 if (status < 0)
718 goto err1;
719
720 status = class_register(&spi_master_class);
721 if (status < 0)
722 goto err2;
723 return 0;
724
725err2:
726 bus_unregister(&spi_bus_type);
727err1:
728 kfree(buf);
729 buf = NULL;
730err0:
731 return status;
732}
733
734
735
736
737
738
739
740
741postcore_initcall(spi_init);
742