vmxnet3: Disable napi in suspend, reenable in resume.
[linux-2.6.git] / drivers / of / platform.c
1 /*
2  *    Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp.
3  *                       <benh@kernel.crashing.org>
4  *    and                Arnd Bergmann, IBM Corp.
5  *    Merged from powerpc/kernel/of_platform.c and
6  *    sparc{,64}/kernel/of_device.c by Stephen Rothwell
7  *
8  *  This program is free software; you can redistribute it and/or
9  *  modify it under the terms of the GNU General Public License
10  *  as published by the Free Software Foundation; either version
11  *  2 of the License, or (at your option) any later version.
12  *
13  */
14 #include <linux/errno.h>
15 #include <linux/module.h>
16 #include <linux/device.h>
17 #include <linux/dma-mapping.h>
18 #include <linux/slab.h>
19 #include <linux/of_address.h>
20 #include <linux/of_device.h>
21 #include <linux/of_irq.h>
22 #include <linux/of_platform.h>
23 #include <linux/platform_device.h>
24
25 static int of_dev_node_match(struct device *dev, void *data)
26 {
27         return dev->of_node == data;
28 }
29
30 /**
31  * of_find_device_by_node - Find the platform_device associated with a node
32  * @np: Pointer to device tree node
33  *
34  * Returns platform_device pointer, or NULL if not found
35  */
36 struct platform_device *of_find_device_by_node(struct device_node *np)
37 {
38         struct device *dev;
39
40         dev = bus_find_device(&platform_bus_type, NULL, np, of_dev_node_match);
41         return dev ? to_platform_device(dev) : NULL;
42 }
43 EXPORT_SYMBOL(of_find_device_by_node);
44
45 static int platform_driver_probe_shim(struct platform_device *pdev)
46 {
47         struct platform_driver *pdrv;
48         struct of_platform_driver *ofpdrv;
49         const struct of_device_id *match;
50
51         pdrv = container_of(pdev->dev.driver, struct platform_driver, driver);
52         ofpdrv = container_of(pdrv, struct of_platform_driver, platform_driver);
53
54         /* There is an unlikely chance that an of_platform driver might match
55          * on a non-OF platform device.  If so, then of_match_device() will
56          * come up empty.  Return -EINVAL in this case so other drivers get
57          * the chance to bind. */
58         match = of_match_device(pdev->dev.driver->of_match_table, &pdev->dev);
59         return match ? ofpdrv->probe(pdev, match) : -EINVAL;
60 }
61
62 static void platform_driver_shutdown_shim(struct platform_device *pdev)
63 {
64         struct platform_driver *pdrv;
65         struct of_platform_driver *ofpdrv;
66
67         pdrv = container_of(pdev->dev.driver, struct platform_driver, driver);
68         ofpdrv = container_of(pdrv, struct of_platform_driver, platform_driver);
69         ofpdrv->shutdown(pdev);
70 }
71
72 /**
73  * of_register_platform_driver
74  */
75 int of_register_platform_driver(struct of_platform_driver *drv)
76 {
77         char *of_name;
78
79         /* setup of_platform_driver to platform_driver adaptors */
80         drv->platform_driver.driver = drv->driver;
81
82         /* Prefix the driver name with 'of:' to avoid namespace collisions
83          * and bogus matches.  There are some drivers in the tree that
84          * register both an of_platform_driver and a platform_driver with
85          * the same name.  This is a temporary measure until they are all
86          * cleaned up --gcl July 29, 2010 */
87         of_name = kmalloc(strlen(drv->driver.name) + 5, GFP_KERNEL);
88         if (!of_name)
89                 return -ENOMEM;
90         sprintf(of_name, "of:%s", drv->driver.name);
91         drv->platform_driver.driver.name = of_name;
92
93         if (drv->probe)
94                 drv->platform_driver.probe = platform_driver_probe_shim;
95         drv->platform_driver.remove = drv->remove;
96         if (drv->shutdown)
97                 drv->platform_driver.shutdown = platform_driver_shutdown_shim;
98         drv->platform_driver.suspend = drv->suspend;
99         drv->platform_driver.resume = drv->resume;
100
101         return platform_driver_register(&drv->platform_driver);
102 }
103 EXPORT_SYMBOL(of_register_platform_driver);
104
105 void of_unregister_platform_driver(struct of_platform_driver *drv)
106 {
107         platform_driver_unregister(&drv->platform_driver);
108         kfree(drv->platform_driver.driver.name);
109         drv->platform_driver.driver.name = NULL;
110 }
111 EXPORT_SYMBOL(of_unregister_platform_driver);
112
113 #if defined(CONFIG_PPC_DCR)
114 #include <asm/dcr.h>
115 #endif
116
117 extern struct device_attribute of_platform_device_attrs[];
118
119 static int of_platform_bus_match(struct device *dev, struct device_driver *drv)
120 {
121         const struct of_device_id *matches = drv->of_match_table;
122
123         if (!matches)
124                 return 0;
125
126         return of_match_device(matches, dev) != NULL;
127 }
128
129 static int of_platform_device_probe(struct device *dev)
130 {
131         int error = -ENODEV;
132         struct of_platform_driver *drv;
133         struct platform_device *of_dev;
134         const struct of_device_id *match;
135
136         drv = to_of_platform_driver(dev->driver);
137         of_dev = to_platform_device(dev);
138
139         if (!drv->probe)
140                 return error;
141
142         of_dev_get(of_dev);
143
144         match = of_match_device(drv->driver.of_match_table, dev);
145         if (match)
146                 error = drv->probe(of_dev, match);
147         if (error)
148                 of_dev_put(of_dev);
149
150         return error;
151 }
152
153 static int of_platform_device_remove(struct device *dev)
154 {
155         struct platform_device *of_dev = to_platform_device(dev);
156         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
157
158         if (dev->driver && drv->remove)
159                 drv->remove(of_dev);
160         return 0;
161 }
162
163 static void of_platform_device_shutdown(struct device *dev)
164 {
165         struct platform_device *of_dev = to_platform_device(dev);
166         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
167
168         if (dev->driver && drv->shutdown)
169                 drv->shutdown(of_dev);
170 }
171
172 #ifdef CONFIG_PM_SLEEP
173
174 static int of_platform_legacy_suspend(struct device *dev, pm_message_t mesg)
175 {
176         struct platform_device *of_dev = to_platform_device(dev);
177         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
178         int ret = 0;
179
180         if (dev->driver && drv->suspend)
181                 ret = drv->suspend(of_dev, mesg);
182         return ret;
183 }
184
185 static int of_platform_legacy_resume(struct device *dev)
186 {
187         struct platform_device *of_dev = to_platform_device(dev);
188         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
189         int ret = 0;
190
191         if (dev->driver && drv->resume)
192                 ret = drv->resume(of_dev);
193         return ret;
194 }
195
196 static int of_platform_pm_prepare(struct device *dev)
197 {
198         struct device_driver *drv = dev->driver;
199         int ret = 0;
200
201         if (drv && drv->pm && drv->pm->prepare)
202                 ret = drv->pm->prepare(dev);
203
204         return ret;
205 }
206
207 static void of_platform_pm_complete(struct device *dev)
208 {
209         struct device_driver *drv = dev->driver;
210
211         if (drv && drv->pm && drv->pm->complete)
212                 drv->pm->complete(dev);
213 }
214
215 #ifdef CONFIG_SUSPEND
216
217 static int of_platform_pm_suspend(struct device *dev)
218 {
219         struct device_driver *drv = dev->driver;
220         int ret = 0;
221
222         if (!drv)
223                 return 0;
224
225         if (drv->pm) {
226                 if (drv->pm->suspend)
227                         ret = drv->pm->suspend(dev);
228         } else {
229                 ret = of_platform_legacy_suspend(dev, PMSG_SUSPEND);
230         }
231
232         return ret;
233 }
234
235 static int of_platform_pm_suspend_noirq(struct device *dev)
236 {
237         struct device_driver *drv = dev->driver;
238         int ret = 0;
239
240         if (!drv)
241                 return 0;
242
243         if (drv->pm) {
244                 if (drv->pm->suspend_noirq)
245                         ret = drv->pm->suspend_noirq(dev);
246         }
247
248         return ret;
249 }
250
251 static int of_platform_pm_resume(struct device *dev)
252 {
253         struct device_driver *drv = dev->driver;
254         int ret = 0;
255
256         if (!drv)
257                 return 0;
258
259         if (drv->pm) {
260                 if (drv->pm->resume)
261                         ret = drv->pm->resume(dev);
262         } else {
263                 ret = of_platform_legacy_resume(dev);
264         }
265
266         return ret;
267 }
268
269 static int of_platform_pm_resume_noirq(struct device *dev)
270 {
271         struct device_driver *drv = dev->driver;
272         int ret = 0;
273
274         if (!drv)
275                 return 0;
276
277         if (drv->pm) {
278                 if (drv->pm->resume_noirq)
279                         ret = drv->pm->resume_noirq(dev);
280         }
281
282         return ret;
283 }
284
285 #else /* !CONFIG_SUSPEND */
286
287 #define of_platform_pm_suspend          NULL
288 #define of_platform_pm_resume           NULL
289 #define of_platform_pm_suspend_noirq    NULL
290 #define of_platform_pm_resume_noirq     NULL
291
292 #endif /* !CONFIG_SUSPEND */
293
294 #ifdef CONFIG_HIBERNATION
295
296 static int of_platform_pm_freeze(struct device *dev)
297 {
298         struct device_driver *drv = dev->driver;
299         int ret = 0;
300
301         if (!drv)
302                 return 0;
303
304         if (drv->pm) {
305                 if (drv->pm->freeze)
306                         ret = drv->pm->freeze(dev);
307         } else {
308                 ret = of_platform_legacy_suspend(dev, PMSG_FREEZE);
309         }
310
311         return ret;
312 }
313
314 static int of_platform_pm_freeze_noirq(struct device *dev)
315 {
316         struct device_driver *drv = dev->driver;
317         int ret = 0;
318
319         if (!drv)
320                 return 0;
321
322         if (drv->pm) {
323                 if (drv->pm->freeze_noirq)
324                         ret = drv->pm->freeze_noirq(dev);
325         }
326
327         return ret;
328 }
329
330 static int of_platform_pm_thaw(struct device *dev)
331 {
332         struct device_driver *drv = dev->driver;
333         int ret = 0;
334
335         if (!drv)
336                 return 0;
337
338         if (drv->pm) {
339                 if (drv->pm->thaw)
340                         ret = drv->pm->thaw(dev);
341         } else {
342                 ret = of_platform_legacy_resume(dev);
343         }
344
345         return ret;
346 }
347
348 static int of_platform_pm_thaw_noirq(struct device *dev)
349 {
350         struct device_driver *drv = dev->driver;
351         int ret = 0;
352
353         if (!drv)
354                 return 0;
355
356         if (drv->pm) {
357                 if (drv->pm->thaw_noirq)
358                         ret = drv->pm->thaw_noirq(dev);
359         }
360
361         return ret;
362 }
363
364 static int of_platform_pm_poweroff(struct device *dev)
365 {
366         struct device_driver *drv = dev->driver;
367         int ret = 0;
368
369         if (!drv)
370                 return 0;
371
372         if (drv->pm) {
373                 if (drv->pm->poweroff)
374                         ret = drv->pm->poweroff(dev);
375         } else {
376                 ret = of_platform_legacy_suspend(dev, PMSG_HIBERNATE);
377         }
378
379         return ret;
380 }
381
382 static int of_platform_pm_poweroff_noirq(struct device *dev)
383 {
384         struct device_driver *drv = dev->driver;
385         int ret = 0;
386
387         if (!drv)
388                 return 0;
389
390         if (drv->pm) {
391                 if (drv->pm->poweroff_noirq)
392                         ret = drv->pm->poweroff_noirq(dev);
393         }
394
395         return ret;
396 }
397
398 static int of_platform_pm_restore(struct device *dev)
399 {
400         struct device_driver *drv = dev->driver;
401         int ret = 0;
402
403         if (!drv)
404                 return 0;
405
406         if (drv->pm) {
407                 if (drv->pm->restore)
408                         ret = drv->pm->restore(dev);
409         } else {
410                 ret = of_platform_legacy_resume(dev);
411         }
412
413         return ret;
414 }
415
416 static int of_platform_pm_restore_noirq(struct device *dev)
417 {
418         struct device_driver *drv = dev->driver;
419         int ret = 0;
420
421         if (!drv)
422                 return 0;
423
424         if (drv->pm) {
425                 if (drv->pm->restore_noirq)
426                         ret = drv->pm->restore_noirq(dev);
427         }
428
429         return ret;
430 }
431
432 #else /* !CONFIG_HIBERNATION */
433
434 #define of_platform_pm_freeze           NULL
435 #define of_platform_pm_thaw             NULL
436 #define of_platform_pm_poweroff         NULL
437 #define of_platform_pm_restore          NULL
438 #define of_platform_pm_freeze_noirq     NULL
439 #define of_platform_pm_thaw_noirq               NULL
440 #define of_platform_pm_poweroff_noirq   NULL
441 #define of_platform_pm_restore_noirq    NULL
442
443 #endif /* !CONFIG_HIBERNATION */
444
445 static struct dev_pm_ops of_platform_dev_pm_ops = {
446         .prepare = of_platform_pm_prepare,
447         .complete = of_platform_pm_complete,
448         .suspend = of_platform_pm_suspend,
449         .resume = of_platform_pm_resume,
450         .freeze = of_platform_pm_freeze,
451         .thaw = of_platform_pm_thaw,
452         .poweroff = of_platform_pm_poweroff,
453         .restore = of_platform_pm_restore,
454         .suspend_noirq = of_platform_pm_suspend_noirq,
455         .resume_noirq = of_platform_pm_resume_noirq,
456         .freeze_noirq = of_platform_pm_freeze_noirq,
457         .thaw_noirq = of_platform_pm_thaw_noirq,
458         .poweroff_noirq = of_platform_pm_poweroff_noirq,
459         .restore_noirq = of_platform_pm_restore_noirq,
460 };
461
462 #define OF_PLATFORM_PM_OPS_PTR  (&of_platform_dev_pm_ops)
463
464 #else /* !CONFIG_PM_SLEEP */
465
466 #define OF_PLATFORM_PM_OPS_PTR  NULL
467
468 #endif /* !CONFIG_PM_SLEEP */
469
470 int of_bus_type_init(struct bus_type *bus, const char *name)
471 {
472         bus->name = name;
473         bus->match = of_platform_bus_match;
474         bus->probe = of_platform_device_probe;
475         bus->remove = of_platform_device_remove;
476         bus->shutdown = of_platform_device_shutdown;
477         bus->dev_attrs = of_platform_device_attrs;
478         bus->pm = OF_PLATFORM_PM_OPS_PTR;
479         return bus_register(bus);
480 }
481
482 int of_register_driver(struct of_platform_driver *drv, struct bus_type *bus)
483 {
484         /*
485          * Temporary: of_platform_bus used to be distinct from the platform
486          * bus.  It isn't anymore, and so drivers on the platform bus need
487          * to be registered in a special way.
488          *
489          * After all of_platform_bus_type drivers are converted to
490          * platform_drivers, this exception can be removed.
491          */
492         if (bus == &platform_bus_type)
493                 return of_register_platform_driver(drv);
494
495         /* register with core */
496         drv->driver.bus = bus;
497         return driver_register(&drv->driver);
498 }
499 EXPORT_SYMBOL(of_register_driver);
500
501 void of_unregister_driver(struct of_platform_driver *drv)
502 {
503         if (drv->driver.bus == &platform_bus_type)
504                 of_unregister_platform_driver(drv);
505         else
506                 driver_unregister(&drv->driver);
507 }
508 EXPORT_SYMBOL(of_unregister_driver);
509
510 #if !defined(CONFIG_SPARC)
511 /*
512  * The following routines scan a subtree and registers a device for
513  * each applicable node.
514  *
515  * Note: sparc doesn't use these routines because it has a different
516  * mechanism for creating devices from device tree nodes.
517  */
518
519 /**
520  * of_device_make_bus_id - Use the device node data to assign a unique name
521  * @dev: pointer to device structure that is linked to a device tree node
522  *
523  * This routine will first try using either the dcr-reg or the reg property
524  * value to derive a unique name.  As a last resort it will use the node
525  * name followed by a unique number.
526  */
527 void of_device_make_bus_id(struct device *dev)
528 {
529         static atomic_t bus_no_reg_magic;
530         struct device_node *node = dev->of_node;
531         const u32 *reg;
532         u64 addr;
533         int magic;
534
535 #ifdef CONFIG_PPC_DCR
536         /*
537          * If it's a DCR based device, use 'd' for native DCRs
538          * and 'D' for MMIO DCRs.
539          */
540         reg = of_get_property(node, "dcr-reg", NULL);
541         if (reg) {
542 #ifdef CONFIG_PPC_DCR_NATIVE
543                 dev_set_name(dev, "d%x.%s", *reg, node->name);
544 #else /* CONFIG_PPC_DCR_NATIVE */
545                 u64 addr = of_translate_dcr_address(node, *reg, NULL);
546                 if (addr != OF_BAD_ADDR) {
547                         dev_set_name(dev, "D%llx.%s",
548                                      (unsigned long long)addr, node->name);
549                         return;
550                 }
551 #endif /* !CONFIG_PPC_DCR_NATIVE */
552         }
553 #endif /* CONFIG_PPC_DCR */
554
555         /*
556          * For MMIO, get the physical address
557          */
558         reg = of_get_property(node, "reg", NULL);
559         if (reg) {
560                 addr = of_translate_address(node, reg);
561                 if (addr != OF_BAD_ADDR) {
562                         dev_set_name(dev, "%llx.%s",
563                                      (unsigned long long)addr, node->name);
564                         return;
565                 }
566         }
567
568         /*
569          * No BusID, use the node name and add a globally incremented
570          * counter (and pray...)
571          */
572         magic = atomic_add_return(1, &bus_no_reg_magic);
573         dev_set_name(dev, "%s.%d", node->name, magic - 1);
574 }
575
576 /**
577  * of_device_alloc - Allocate and initialize an of_device
578  * @np: device node to assign to device
579  * @bus_id: Name to assign to the device.  May be null to use default name.
580  * @parent: Parent device.
581  */
582 struct platform_device *of_device_alloc(struct device_node *np,
583                                   const char *bus_id,
584                                   struct device *parent)
585 {
586         struct platform_device *dev;
587         int rc, i, num_reg = 0, num_irq;
588         struct resource *res, temp_res;
589
590         dev = platform_device_alloc("", -1);
591         if (!dev)
592                 return NULL;
593
594         /* count the io and irq resources */
595         while (of_address_to_resource(np, num_reg, &temp_res) == 0)
596                 num_reg++;
597         num_irq = of_irq_count(np);
598
599         /* Populate the resource table */
600         if (num_irq || num_reg) {
601                 res = kzalloc(sizeof(*res) * (num_irq + num_reg), GFP_KERNEL);
602                 if (!res) {
603                         platform_device_put(dev);
604                         return NULL;
605                 }
606
607                 dev->num_resources = num_reg + num_irq;
608                 dev->resource = res;
609                 for (i = 0; i < num_reg; i++, res++) {
610                         rc = of_address_to_resource(np, i, res);
611                         WARN_ON(rc);
612                 }
613                 WARN_ON(of_irq_to_resource_table(np, res, num_irq) != num_irq);
614         }
615
616         dev->dev.of_node = of_node_get(np);
617 #if defined(CONFIG_PPC) || defined(CONFIG_MICROBLAZE)
618         dev->dev.dma_mask = &dev->archdata.dma_mask;
619 #endif
620         dev->dev.parent = parent;
621
622         if (bus_id)
623                 dev_set_name(&dev->dev, "%s", bus_id);
624         else
625                 of_device_make_bus_id(&dev->dev);
626
627         return dev;
628 }
629 EXPORT_SYMBOL(of_device_alloc);
630
631 /**
632  * of_platform_device_create - Alloc, initialize and register an of_device
633  * @np: pointer to node to create device for
634  * @bus_id: name to assign device
635  * @parent: Linux device model parent device.
636  */
637 struct platform_device *of_platform_device_create(struct device_node *np,
638                                             const char *bus_id,
639                                             struct device *parent)
640 {
641         struct platform_device *dev;
642
643         dev = of_device_alloc(np, bus_id, parent);
644         if (!dev)
645                 return NULL;
646
647 #if defined(CONFIG_PPC) || defined(CONFIG_MICROBLAZE)
648         dev->archdata.dma_mask = 0xffffffffUL;
649 #endif
650         dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
651         dev->dev.bus = &platform_bus_type;
652
653         /* We do not fill the DMA ops for platform devices by default.
654          * This is currently the responsibility of the platform code
655          * to do such, possibly using a device notifier
656          */
657
658         if (of_device_add(dev) != 0) {
659                 platform_device_put(dev);
660                 return NULL;
661         }
662
663         return dev;
664 }
665 EXPORT_SYMBOL(of_platform_device_create);
666
667 /**
668  * of_platform_bus_create - Create an OF device for a bus node and all its
669  * children. Optionally recursively instantiate matching busses.
670  * @bus: device node of the bus to instantiate
671  * @matches: match table, NULL to use the default, OF_NO_DEEP_PROBE to
672  * disallow recursive creation of child busses
673  */
674 static int of_platform_bus_create(const struct device_node *bus,
675                                   const struct of_device_id *matches,
676                                   struct device *parent)
677 {
678         struct device_node *child;
679         struct platform_device *dev;
680         int rc = 0;
681
682         for_each_child_of_node(bus, child) {
683                 pr_debug("   create child: %s\n", child->full_name);
684                 dev = of_platform_device_create(child, NULL, parent);
685                 if (dev == NULL)
686                         rc = -ENOMEM;
687                 else if (!of_match_node(matches, child))
688                         continue;
689                 if (rc == 0) {
690                         pr_debug("   and sub busses\n");
691                         rc = of_platform_bus_create(child, matches, &dev->dev);
692                 }
693                 if (rc) {
694                         of_node_put(child);
695                         break;
696                 }
697         }
698         return rc;
699 }
700
701 /**
702  * of_platform_bus_probe - Probe the device-tree for platform busses
703  * @root: parent of the first level to probe or NULL for the root of the tree
704  * @matches: match table, NULL to use the default
705  * @parent: parent to hook devices from, NULL for toplevel
706  *
707  * Note that children of the provided root are not instantiated as devices
708  * unless the specified root itself matches the bus list and is not NULL.
709  */
710 int of_platform_bus_probe(struct device_node *root,
711                           const struct of_device_id *matches,
712                           struct device *parent)
713 {
714         struct device_node *child;
715         struct platform_device *dev;
716         int rc = 0;
717
718         if (WARN_ON(!matches || matches == OF_NO_DEEP_PROBE))
719                 return -EINVAL;
720         if (root == NULL)
721                 root = of_find_node_by_path("/");
722         else
723                 of_node_get(root);
724         if (root == NULL)
725                 return -EINVAL;
726
727         pr_debug("of_platform_bus_probe()\n");
728         pr_debug(" starting at: %s\n", root->full_name);
729
730         /* Do a self check of bus type, if there's a match, create
731          * children
732          */
733         if (of_match_node(matches, root)) {
734                 pr_debug(" root match, create all sub devices\n");
735                 dev = of_platform_device_create(root, NULL, parent);
736                 if (dev == NULL) {
737                         rc = -ENOMEM;
738                         goto bail;
739                 }
740                 pr_debug(" create all sub busses\n");
741                 rc = of_platform_bus_create(root, matches, &dev->dev);
742                 goto bail;
743         }
744         for_each_child_of_node(root, child) {
745                 if (!of_match_node(matches, child))
746                         continue;
747
748                 pr_debug("  match: %s\n", child->full_name);
749                 dev = of_platform_device_create(child, NULL, parent);
750                 if (dev == NULL)
751                         rc = -ENOMEM;
752                 else
753                         rc = of_platform_bus_create(child, matches, &dev->dev);
754                 if (rc) {
755                         of_node_put(child);
756                         break;
757                 }
758         }
759  bail:
760         of_node_put(root);
761         return rc;
762 }
763 EXPORT_SYMBOL(of_platform_bus_probe);
764 #endif /* !CONFIG_SPARC */