1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39#include <linux/init.h>
40#include <linux/export.h>
41#include <linux/console.h>
42#include <linux/kobject.h>
43#include <linux/dma-mapping.h>
44#include <linux/interrupt.h>
45#include <linux/of.h>
46#include <linux/slab.h>
47#include <linux/stat.h>
48#include <linux/of_platform.h>
49#include <asm/ibmebus.h>
50
51static struct device ibmebus_bus_device = {
52 .init_name = "ibmebus",
53};
54
55struct bus_type ibmebus_bus_type;
56
57
58static struct of_device_id __initdata ibmebus_matches[] = {
59 { .compatible = "IBM,lhca" },
60 { .compatible = "IBM,lhea" },
61 {},
62};
63
64static void *ibmebus_alloc_coherent(struct device *dev,
65 size_t size,
66 dma_addr_t *dma_handle,
67 gfp_t flag,
68 struct dma_attrs *attrs)
69{
70 void *mem;
71
72 mem = kmalloc(size, flag);
73 *dma_handle = (dma_addr_t)mem;
74
75 return mem;
76}
77
78static void ibmebus_free_coherent(struct device *dev,
79 size_t size, void *vaddr,
80 dma_addr_t dma_handle,
81 struct dma_attrs *attrs)
82{
83 kfree(vaddr);
84}
85
86static dma_addr_t ibmebus_map_page(struct device *dev,
87 struct page *page,
88 unsigned long offset,
89 size_t size,
90 enum dma_data_direction direction,
91 struct dma_attrs *attrs)
92{
93 return (dma_addr_t)(page_address(page) + offset);
94}
95
96static void ibmebus_unmap_page(struct device *dev,
97 dma_addr_t dma_addr,
98 size_t size,
99 enum dma_data_direction direction,
100 struct dma_attrs *attrs)
101{
102 return;
103}
104
105static int ibmebus_map_sg(struct device *dev,
106 struct scatterlist *sgl,
107 int nents, enum dma_data_direction direction,
108 struct dma_attrs *attrs)
109{
110 struct scatterlist *sg;
111 int i;
112
113 for_each_sg(sgl, sg, nents, i) {
114 sg->dma_address = (dma_addr_t) sg_virt(sg);
115 sg->dma_length = sg->length;
116 }
117
118 return nents;
119}
120
121static void ibmebus_unmap_sg(struct device *dev,
122 struct scatterlist *sg,
123 int nents, enum dma_data_direction direction,
124 struct dma_attrs *attrs)
125{
126 return;
127}
128
129static int ibmebus_dma_supported(struct device *dev, u64 mask)
130{
131 return mask == DMA_BIT_MASK(64);
132}
133
134static u64 ibmebus_dma_get_required_mask(struct device *dev)
135{
136 return DMA_BIT_MASK(64);
137}
138
139static struct dma_map_ops ibmebus_dma_ops = {
140 .alloc = ibmebus_alloc_coherent,
141 .free = ibmebus_free_coherent,
142 .map_sg = ibmebus_map_sg,
143 .unmap_sg = ibmebus_unmap_sg,
144 .dma_supported = ibmebus_dma_supported,
145 .get_required_mask = ibmebus_dma_get_required_mask,
146 .map_page = ibmebus_map_page,
147 .unmap_page = ibmebus_unmap_page,
148};
149
150static int ibmebus_match_path(struct device *dev, void *data)
151{
152 struct device_node *dn = to_platform_device(dev)->dev.of_node;
153 return (dn->full_name &&
154 (strcasecmp((char *)data, dn->full_name) == 0));
155}
156
157static int ibmebus_match_node(struct device *dev, void *data)
158{
159 return to_platform_device(dev)->dev.of_node == data;
160}
161
162static int ibmebus_create_device(struct device_node *dn)
163{
164 struct platform_device *dev;
165 int ret;
166
167 dev = of_device_alloc(dn, NULL, &ibmebus_bus_device);
168 if (!dev)
169 return -ENOMEM;
170
171 dev->dev.bus = &ibmebus_bus_type;
172 dev->dev.archdata.dma_ops = &ibmebus_dma_ops;
173
174 ret = of_device_add(dev);
175 if (ret)
176 platform_device_put(dev);
177 return ret;
178}
179
180static int ibmebus_create_devices(const struct of_device_id *matches)
181{
182 struct device_node *root, *child;
183 int ret = 0;
184
185 root = of_find_node_by_path("/");
186
187 for_each_child_of_node(root, child) {
188 if (!of_match_node(matches, child))
189 continue;
190
191 if (bus_find_device(&ibmebus_bus_type, NULL, child,
192 ibmebus_match_node))
193 continue;
194
195 ret = ibmebus_create_device(child);
196 if (ret) {
197 printk(KERN_ERR "%s: failed to create device (%i)",
198 __func__, ret);
199 of_node_put(child);
200 break;
201 }
202 }
203
204 of_node_put(root);
205 return ret;
206}
207
208int ibmebus_register_driver(struct of_platform_driver *drv)
209{
210
211 ibmebus_create_devices(drv->driver.of_match_table);
212
213 drv->driver.bus = &ibmebus_bus_type;
214 return driver_register(&drv->driver);
215}
216EXPORT_SYMBOL(ibmebus_register_driver);
217
218void ibmebus_unregister_driver(struct of_platform_driver *drv)
219{
220 driver_unregister(&drv->driver);
221}
222EXPORT_SYMBOL(ibmebus_unregister_driver);
223
224int ibmebus_request_irq(u32 ist, irq_handler_t handler,
225 unsigned long irq_flags, const char *devname,
226 void *dev_id)
227{
228 unsigned int irq = irq_create_mapping(NULL, ist);
229
230 if (irq == NO_IRQ)
231 return -EINVAL;
232
233 return request_irq(irq, handler, irq_flags, devname, dev_id);
234}
235EXPORT_SYMBOL(ibmebus_request_irq);
236
237void ibmebus_free_irq(u32 ist, void *dev_id)
238{
239 unsigned int irq = irq_find_mapping(NULL, ist);
240
241 free_irq(irq, dev_id);
242 irq_dispose_mapping(irq);
243}
244EXPORT_SYMBOL(ibmebus_free_irq);
245
246static char *ibmebus_chomp(const char *in, size_t count)
247{
248 char *out = kmalloc(count + 1, GFP_KERNEL);
249
250 if (!out)
251 return NULL;
252
253 memcpy(out, in, count);
254 out[count] = '\0';
255 if (out[count - 1] == '\n')
256 out[count - 1] = '\0';
257
258 return out;
259}
260
261static ssize_t ibmebus_store_probe(struct bus_type *bus,
262 const char *buf, size_t count)
263{
264 struct device_node *dn = NULL;
265 char *path;
266 ssize_t rc = 0;
267
268 path = ibmebus_chomp(buf, count);
269 if (!path)
270 return -ENOMEM;
271
272 if (bus_find_device(&ibmebus_bus_type, NULL, path,
273 ibmebus_match_path)) {
274 printk(KERN_WARNING "%s: %s has already been probed\n",
275 __func__, path);
276 rc = -EEXIST;
277 goto out;
278 }
279
280 if ((dn = of_find_node_by_path(path))) {
281 rc = ibmebus_create_device(dn);
282 of_node_put(dn);
283 } else {
284 printk(KERN_WARNING "%s: no such device node: %s\n",
285 __func__, path);
286 rc = -ENODEV;
287 }
288
289out:
290 kfree(path);
291 if (rc)
292 return rc;
293 return count;
294}
295
296static ssize_t ibmebus_store_remove(struct bus_type *bus,
297 const char *buf, size_t count)
298{
299 struct device *dev;
300 char *path;
301
302 path = ibmebus_chomp(buf, count);
303 if (!path)
304 return -ENOMEM;
305
306 if ((dev = bus_find_device(&ibmebus_bus_type, NULL, path,
307 ibmebus_match_path))) {
308 of_device_unregister(to_platform_device(dev));
309
310 kfree(path);
311 return count;
312 } else {
313 printk(KERN_WARNING "%s: %s not on the bus\n",
314 __func__, path);
315
316 kfree(path);
317 return -ENODEV;
318 }
319}
320
321
322static struct bus_attribute ibmebus_bus_attrs[] = {
323 __ATTR(probe, S_IWUSR, NULL, ibmebus_store_probe),
324 __ATTR(remove, S_IWUSR, NULL, ibmebus_store_remove),
325 __ATTR_NULL
326};
327
328static int ibmebus_bus_bus_match(struct device *dev, struct device_driver *drv)
329{
330 const struct of_device_id *matches = drv->of_match_table;
331
332 if (!matches)
333 return 0;
334
335 return of_match_device(matches, dev) != NULL;
336}
337
338static int ibmebus_bus_device_probe(struct device *dev)
339{
340 int error = -ENODEV;
341 struct of_platform_driver *drv;
342 struct platform_device *of_dev;
343 const struct of_device_id *match;
344
345 drv = to_of_platform_driver(dev->driver);
346 of_dev = to_platform_device(dev);
347
348 if (!drv->probe)
349 return error;
350
351 of_dev_get(of_dev);
352
353 match = of_match_device(drv->driver.of_match_table, dev);
354 if (match)
355 error = drv->probe(of_dev, match);
356 if (error)
357 of_dev_put(of_dev);
358
359 return error;
360}
361
362static int ibmebus_bus_device_remove(struct device *dev)
363{
364 struct platform_device *of_dev = to_platform_device(dev);
365 struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
366
367 if (dev->driver && drv->remove)
368 drv->remove(of_dev);
369 return 0;
370}
371
372static void ibmebus_bus_device_shutdown(struct device *dev)
373{
374 struct platform_device *of_dev = to_platform_device(dev);
375 struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
376
377 if (dev->driver && drv->shutdown)
378 drv->shutdown(of_dev);
379}
380
381
382
383
384static ssize_t devspec_show(struct device *dev,
385 struct device_attribute *attr, char *buf)
386{
387 struct platform_device *ofdev;
388
389 ofdev = to_platform_device(dev);
390 return sprintf(buf, "%s\n", ofdev->dev.of_node->full_name);
391}
392
393static ssize_t name_show(struct device *dev,
394 struct device_attribute *attr, char *buf)
395{
396 struct platform_device *ofdev;
397
398 ofdev = to_platform_device(dev);
399 return sprintf(buf, "%s\n", ofdev->dev.of_node->name);
400}
401
402static ssize_t modalias_show(struct device *dev,
403 struct device_attribute *attr, char *buf)
404{
405 ssize_t len = of_device_get_modalias(dev, buf, PAGE_SIZE - 2);
406 buf[len] = '\n';
407 buf[len+1] = 0;
408 return len+1;
409}
410
411struct device_attribute ibmebus_bus_device_attrs[] = {
412 __ATTR_RO(devspec),
413 __ATTR_RO(name),
414 __ATTR_RO(modalias),
415 __ATTR_NULL
416};
417
418#ifdef CONFIG_PM_SLEEP
419static int ibmebus_bus_legacy_suspend(struct device *dev, pm_message_t mesg)
420{
421 struct platform_device *of_dev = to_platform_device(dev);
422 struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
423 int ret = 0;
424
425 if (dev->driver && drv->suspend)
426 ret = drv->suspend(of_dev, mesg);
427 return ret;
428}
429
430static int ibmebus_bus_legacy_resume(struct device *dev)
431{
432 struct platform_device *of_dev = to_platform_device(dev);
433 struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
434 int ret = 0;
435
436 if (dev->driver && drv->resume)
437 ret = drv->resume(of_dev);
438 return ret;
439}
440
441static int ibmebus_bus_pm_prepare(struct device *dev)
442{
443 struct device_driver *drv = dev->driver;
444 int ret = 0;
445
446 if (drv && drv->pm && drv->pm->prepare)
447 ret = drv->pm->prepare(dev);
448
449 return ret;
450}
451
452static void ibmebus_bus_pm_complete(struct device *dev)
453{
454 struct device_driver *drv = dev->driver;
455
456 if (drv && drv->pm && drv->pm->complete)
457 drv->pm->complete(dev);
458}
459
460#ifdef CONFIG_SUSPEND
461
462static int ibmebus_bus_pm_suspend(struct device *dev)
463{
464 struct device_driver *drv = dev->driver;
465 int ret = 0;
466
467 if (!drv)
468 return 0;
469
470 if (drv->pm) {
471 if (drv->pm->suspend)
472 ret = drv->pm->suspend(dev);
473 } else {
474 ret = ibmebus_bus_legacy_suspend(dev, PMSG_SUSPEND);
475 }
476
477 return ret;
478}
479
480static int ibmebus_bus_pm_suspend_noirq(struct device *dev)
481{
482 struct device_driver *drv = dev->driver;
483 int ret = 0;
484
485 if (!drv)
486 return 0;
487
488 if (drv->pm) {
489 if (drv->pm->suspend_noirq)
490 ret = drv->pm->suspend_noirq(dev);
491 }
492
493 return ret;
494}
495
496static int ibmebus_bus_pm_resume(struct device *dev)
497{
498 struct device_driver *drv = dev->driver;
499 int ret = 0;
500
501 if (!drv)
502 return 0;
503
504 if (drv->pm) {
505 if (drv->pm->resume)
506 ret = drv->pm->resume(dev);
507 } else {
508 ret = ibmebus_bus_legacy_resume(dev);
509 }
510
511 return ret;
512}
513
514static int ibmebus_bus_pm_resume_noirq(struct device *dev)
515{
516 struct device_driver *drv = dev->driver;
517 int ret = 0;
518
519 if (!drv)
520 return 0;
521
522 if (drv->pm) {
523 if (drv->pm->resume_noirq)
524 ret = drv->pm->resume_noirq(dev);
525 }
526
527 return ret;
528}
529
530#else
531
532#define ibmebus_bus_pm_suspend NULL
533#define ibmebus_bus_pm_resume NULL
534#define ibmebus_bus_pm_suspend_noirq NULL
535#define ibmebus_bus_pm_resume_noirq NULL
536
537#endif
538
539#ifdef CONFIG_HIBERNATE_CALLBACKS
540
541static int ibmebus_bus_pm_freeze(struct device *dev)
542{
543 struct device_driver *drv = dev->driver;
544 int ret = 0;
545
546 if (!drv)
547 return 0;
548
549 if (drv->pm) {
550 if (drv->pm->freeze)
551 ret = drv->pm->freeze(dev);
552 } else {
553 ret = ibmebus_bus_legacy_suspend(dev, PMSG_FREEZE);
554 }
555
556 return ret;
557}
558
559static int ibmebus_bus_pm_freeze_noirq(struct device *dev)
560{
561 struct device_driver *drv = dev->driver;
562 int ret = 0;
563
564 if (!drv)
565 return 0;
566
567 if (drv->pm) {
568 if (drv->pm->freeze_noirq)
569 ret = drv->pm->freeze_noirq(dev);
570 }
571
572 return ret;
573}
574
575static int ibmebus_bus_pm_thaw(struct device *dev)
576{
577 struct device_driver *drv = dev->driver;
578 int ret = 0;
579
580 if (!drv)
581 return 0;
582
583 if (drv->pm) {
584 if (drv->pm->thaw)
585 ret = drv->pm->thaw(dev);
586 } else {
587 ret = ibmebus_bus_legacy_resume(dev);
588 }
589
590 return ret;
591}
592
593static int ibmebus_bus_pm_thaw_noirq(struct device *dev)
594{
595 struct device_driver *drv = dev->driver;
596 int ret = 0;
597
598 if (!drv)
599 return 0;
600
601 if (drv->pm) {
602 if (drv->pm->thaw_noirq)
603 ret = drv->pm->thaw_noirq(dev);
604 }
605
606 return ret;
607}
608
609static int ibmebus_bus_pm_poweroff(struct device *dev)
610{
611 struct device_driver *drv = dev->driver;
612 int ret = 0;
613
614 if (!drv)
615 return 0;
616
617 if (drv->pm) {
618 if (drv->pm->poweroff)
619 ret = drv->pm->poweroff(dev);
620 } else {
621 ret = ibmebus_bus_legacy_suspend(dev, PMSG_HIBERNATE);
622 }
623
624 return ret;
625}
626
627static int ibmebus_bus_pm_poweroff_noirq(struct device *dev)
628{
629 struct device_driver *drv = dev->driver;
630 int ret = 0;
631
632 if (!drv)
633 return 0;
634
635 if (drv->pm) {
636 if (drv->pm->poweroff_noirq)
637 ret = drv->pm->poweroff_noirq(dev);
638 }
639
640 return ret;
641}
642
643static int ibmebus_bus_pm_restore(struct device *dev)
644{
645 struct device_driver *drv = dev->driver;
646 int ret = 0;
647
648 if (!drv)
649 return 0;
650
651 if (drv->pm) {
652 if (drv->pm->restore)
653 ret = drv->pm->restore(dev);
654 } else {
655 ret = ibmebus_bus_legacy_resume(dev);
656 }
657
658 return ret;
659}
660
661static int ibmebus_bus_pm_restore_noirq(struct device *dev)
662{
663 struct device_driver *drv = dev->driver;
664 int ret = 0;
665
666 if (!drv)
667 return 0;
668
669 if (drv->pm) {
670 if (drv->pm->restore_noirq)
671 ret = drv->pm->restore_noirq(dev);
672 }
673
674 return ret;
675}
676
677#else
678
679#define ibmebus_bus_pm_freeze NULL
680#define ibmebus_bus_pm_thaw NULL
681#define ibmebus_bus_pm_poweroff NULL
682#define ibmebus_bus_pm_restore NULL
683#define ibmebus_bus_pm_freeze_noirq NULL
684#define ibmebus_bus_pm_thaw_noirq NULL
685#define ibmebus_bus_pm_poweroff_noirq NULL
686#define ibmebus_bus_pm_restore_noirq NULL
687
688#endif
689
690static struct dev_pm_ops ibmebus_bus_dev_pm_ops = {
691 .prepare = ibmebus_bus_pm_prepare,
692 .complete = ibmebus_bus_pm_complete,
693 .suspend = ibmebus_bus_pm_suspend,
694 .resume = ibmebus_bus_pm_resume,
695 .freeze = ibmebus_bus_pm_freeze,
696 .thaw = ibmebus_bus_pm_thaw,
697 .poweroff = ibmebus_bus_pm_poweroff,
698 .restore = ibmebus_bus_pm_restore,
699 .suspend_noirq = ibmebus_bus_pm_suspend_noirq,
700 .resume_noirq = ibmebus_bus_pm_resume_noirq,
701 .freeze_noirq = ibmebus_bus_pm_freeze_noirq,
702 .thaw_noirq = ibmebus_bus_pm_thaw_noirq,
703 .poweroff_noirq = ibmebus_bus_pm_poweroff_noirq,
704 .restore_noirq = ibmebus_bus_pm_restore_noirq,
705};
706
707#define IBMEBUS_BUS_PM_OPS_PTR (&ibmebus_bus_dev_pm_ops)
708
709#else
710
711#define IBMEBUS_BUS_PM_OPS_PTR NULL
712
713#endif
714
715struct bus_type ibmebus_bus_type = {
716 .name = "ibmebus",
717 .uevent = of_device_uevent_modalias,
718 .bus_attrs = ibmebus_bus_attrs,
719 .match = ibmebus_bus_bus_match,
720 .probe = ibmebus_bus_device_probe,
721 .remove = ibmebus_bus_device_remove,
722 .shutdown = ibmebus_bus_device_shutdown,
723 .dev_attrs = ibmebus_bus_device_attrs,
724 .pm = IBMEBUS_BUS_PM_OPS_PTR,
725};
726EXPORT_SYMBOL(ibmebus_bus_type);
727
728static int __init ibmebus_bus_init(void)
729{
730 int err;
731
732 printk(KERN_INFO "IBM eBus Device Driver\n");
733
734 err = bus_register(&ibmebus_bus_type);
735 if (err) {
736 printk(KERN_ERR "%s: failed to register IBM eBus.\n",
737 __func__);
738 return err;
739 }
740
741 err = device_register(&ibmebus_bus_device);
742 if (err) {
743 printk(KERN_WARNING "%s: device_register returned %i\n",
744 __func__, err);
745 bus_unregister(&ibmebus_bus_type);
746
747 return err;
748 }
749
750 err = ibmebus_create_devices(ibmebus_matches);
751 if (err) {
752 device_unregister(&ibmebus_bus_device);
753 bus_unregister(&ibmebus_bus_type);
754 return err;
755 }
756
757 return 0;
758}
759postcore_initcall(ibmebus_bus_init);
760
