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