Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/trivial
[linux-2.6] / drivers / base / platform.c
1 /*
2  * platform.c - platform 'pseudo' bus for legacy devices
3  *
4  * Copyright (c) 2002-3 Patrick Mochel
5  * Copyright (c) 2002-3 Open Source Development Labs
6  *
7  * This file is released under the GPLv2
8  *
9  * Please see Documentation/driver-model/platform.txt for more
10  * information.
11  */
12
13 #include <linux/platform_device.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/dma-mapping.h>
17 #include <linux/bootmem.h>
18 #include <linux/err.h>
19 #include <linux/slab.h>
20
21 #include "base.h"
22
23 #define to_platform_driver(drv) (container_of((drv), struct platform_driver, \
24                                  driver))
25
26 struct device platform_bus = {
27         .init_name      = "platform",
28 };
29 EXPORT_SYMBOL_GPL(platform_bus);
30
31 /**
32  * platform_get_resource - get a resource for a device
33  * @dev: platform device
34  * @type: resource type
35  * @num: resource index
36  */
37 struct resource *platform_get_resource(struct platform_device *dev,
38                                        unsigned int type, unsigned int num)
39 {
40         int i;
41
42         for (i = 0; i < dev->num_resources; i++) {
43                 struct resource *r = &dev->resource[i];
44
45                 if (type == resource_type(r) && num-- == 0)
46                         return r;
47         }
48         return NULL;
49 }
50 EXPORT_SYMBOL_GPL(platform_get_resource);
51
52 /**
53  * platform_get_irq - get an IRQ for a device
54  * @dev: platform device
55  * @num: IRQ number index
56  */
57 int platform_get_irq(struct platform_device *dev, unsigned int num)
58 {
59         struct resource *r = platform_get_resource(dev, IORESOURCE_IRQ, num);
60
61         return r ? r->start : -ENXIO;
62 }
63 EXPORT_SYMBOL_GPL(platform_get_irq);
64
65 /**
66  * platform_get_resource_byname - get a resource for a device by name
67  * @dev: platform device
68  * @type: resource type
69  * @name: resource name
70  */
71 struct resource *platform_get_resource_byname(struct platform_device *dev,
72                                               unsigned int type, char *name)
73 {
74         int i;
75
76         for (i = 0; i < dev->num_resources; i++) {
77                 struct resource *r = &dev->resource[i];
78
79                 if (type == resource_type(r) && !strcmp(r->name, name))
80                         return r;
81         }
82         return NULL;
83 }
84 EXPORT_SYMBOL_GPL(platform_get_resource_byname);
85
86 /**
87  * platform_get_irq - get an IRQ for a device
88  * @dev: platform device
89  * @name: IRQ name
90  */
91 int platform_get_irq_byname(struct platform_device *dev, char *name)
92 {
93         struct resource *r = platform_get_resource_byname(dev, IORESOURCE_IRQ,
94                                                           name);
95
96         return r ? r->start : -ENXIO;
97 }
98 EXPORT_SYMBOL_GPL(platform_get_irq_byname);
99
100 /**
101  * platform_add_devices - add a numbers of platform devices
102  * @devs: array of platform devices to add
103  * @num: number of platform devices in array
104  */
105 int platform_add_devices(struct platform_device **devs, int num)
106 {
107         int i, ret = 0;
108
109         for (i = 0; i < num; i++) {
110                 ret = platform_device_register(devs[i]);
111                 if (ret) {
112                         while (--i >= 0)
113                                 platform_device_unregister(devs[i]);
114                         break;
115                 }
116         }
117
118         return ret;
119 }
120 EXPORT_SYMBOL_GPL(platform_add_devices);
121
122 struct platform_object {
123         struct platform_device pdev;
124         char name[1];
125 };
126
127 /**
128  * platform_device_put
129  * @pdev: platform device to free
130  *
131  * Free all memory associated with a platform device.  This function must
132  * _only_ be externally called in error cases.  All other usage is a bug.
133  */
134 void platform_device_put(struct platform_device *pdev)
135 {
136         if (pdev)
137                 put_device(&pdev->dev);
138 }
139 EXPORT_SYMBOL_GPL(platform_device_put);
140
141 static void platform_device_release(struct device *dev)
142 {
143         struct platform_object *pa = container_of(dev, struct platform_object,
144                                                   pdev.dev);
145
146         kfree(pa->pdev.dev.platform_data);
147         kfree(pa->pdev.resource);
148         kfree(pa);
149 }
150
151 /**
152  * platform_device_alloc
153  * @name: base name of the device we're adding
154  * @id: instance id
155  *
156  * Create a platform device object which can have other objects attached
157  * to it, and which will have attached objects freed when it is released.
158  */
159 struct platform_device *platform_device_alloc(const char *name, int id)
160 {
161         struct platform_object *pa;
162
163         pa = kzalloc(sizeof(struct platform_object) + strlen(name), GFP_KERNEL);
164         if (pa) {
165                 strcpy(pa->name, name);
166                 pa->pdev.name = pa->name;
167                 pa->pdev.id = id;
168                 device_initialize(&pa->pdev.dev);
169                 pa->pdev.dev.release = platform_device_release;
170         }
171
172         return pa ? &pa->pdev : NULL;
173 }
174 EXPORT_SYMBOL_GPL(platform_device_alloc);
175
176 /**
177  * platform_device_add_resources
178  * @pdev: platform device allocated by platform_device_alloc to add resources to
179  * @res: set of resources that needs to be allocated for the device
180  * @num: number of resources
181  *
182  * Add a copy of the resources to the platform device.  The memory
183  * associated with the resources will be freed when the platform device is
184  * released.
185  */
186 int platform_device_add_resources(struct platform_device *pdev,
187                                   struct resource *res, unsigned int num)
188 {
189         struct resource *r;
190
191         r = kmalloc(sizeof(struct resource) * num, GFP_KERNEL);
192         if (r) {
193                 memcpy(r, res, sizeof(struct resource) * num);
194                 pdev->resource = r;
195                 pdev->num_resources = num;
196         }
197         return r ? 0 : -ENOMEM;
198 }
199 EXPORT_SYMBOL_GPL(platform_device_add_resources);
200
201 /**
202  * platform_device_add_data
203  * @pdev: platform device allocated by platform_device_alloc to add resources to
204  * @data: platform specific data for this platform device
205  * @size: size of platform specific data
206  *
207  * Add a copy of platform specific data to the platform device's
208  * platform_data pointer.  The memory associated with the platform data
209  * will be freed when the platform device is released.
210  */
211 int platform_device_add_data(struct platform_device *pdev, const void *data,
212                              size_t size)
213 {
214         void *d;
215
216         d = kmalloc(size, GFP_KERNEL);
217         if (d) {
218                 memcpy(d, data, size);
219                 pdev->dev.platform_data = d;
220         }
221         return d ? 0 : -ENOMEM;
222 }
223 EXPORT_SYMBOL_GPL(platform_device_add_data);
224
225 /**
226  * platform_device_add - add a platform device to device hierarchy
227  * @pdev: platform device we're adding
228  *
229  * This is part 2 of platform_device_register(), though may be called
230  * separately _iff_ pdev was allocated by platform_device_alloc().
231  */
232 int platform_device_add(struct platform_device *pdev)
233 {
234         int i, ret = 0;
235
236         if (!pdev)
237                 return -EINVAL;
238
239         if (!pdev->dev.parent)
240                 pdev->dev.parent = &platform_bus;
241
242         pdev->dev.bus = &platform_bus_type;
243
244         if (pdev->id != -1)
245                 dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);
246         else
247                 dev_set_name(&pdev->dev, pdev->name);
248
249         for (i = 0; i < pdev->num_resources; i++) {
250                 struct resource *p, *r = &pdev->resource[i];
251
252                 if (r->name == NULL)
253                         r->name = dev_name(&pdev->dev);
254
255                 p = r->parent;
256                 if (!p) {
257                         if (resource_type(r) == IORESOURCE_MEM)
258                                 p = &iomem_resource;
259                         else if (resource_type(r) == IORESOURCE_IO)
260                                 p = &ioport_resource;
261                 }
262
263                 if (p && insert_resource(p, r)) {
264                         printk(KERN_ERR
265                                "%s: failed to claim resource %d\n",
266                                dev_name(&pdev->dev), i);
267                         ret = -EBUSY;
268                         goto failed;
269                 }
270         }
271
272         pr_debug("Registering platform device '%s'. Parent at %s\n",
273                  dev_name(&pdev->dev), dev_name(pdev->dev.parent));
274
275         ret = device_add(&pdev->dev);
276         if (ret == 0)
277                 return ret;
278
279  failed:
280         while (--i >= 0) {
281                 struct resource *r = &pdev->resource[i];
282                 unsigned long type = resource_type(r);
283
284                 if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
285                         release_resource(r);
286         }
287
288         return ret;
289 }
290 EXPORT_SYMBOL_GPL(platform_device_add);
291
292 /**
293  * platform_device_del - remove a platform-level device
294  * @pdev: platform device we're removing
295  *
296  * Note that this function will also release all memory- and port-based
297  * resources owned by the device (@dev->resource).  This function must
298  * _only_ be externally called in error cases.  All other usage is a bug.
299  */
300 void platform_device_del(struct platform_device *pdev)
301 {
302         int i;
303
304         if (pdev) {
305                 device_del(&pdev->dev);
306
307                 for (i = 0; i < pdev->num_resources; i++) {
308                         struct resource *r = &pdev->resource[i];
309                         unsigned long type = resource_type(r);
310
311                         if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
312                                 release_resource(r);
313                 }
314         }
315 }
316 EXPORT_SYMBOL_GPL(platform_device_del);
317
318 /**
319  * platform_device_register - add a platform-level device
320  * @pdev: platform device we're adding
321  */
322 int platform_device_register(struct platform_device *pdev)
323 {
324         device_initialize(&pdev->dev);
325         return platform_device_add(pdev);
326 }
327 EXPORT_SYMBOL_GPL(platform_device_register);
328
329 /**
330  * platform_device_unregister - unregister a platform-level device
331  * @pdev: platform device we're unregistering
332  *
333  * Unregistration is done in 2 steps. First we release all resources
334  * and remove it from the subsystem, then we drop reference count by
335  * calling platform_device_put().
336  */
337 void platform_device_unregister(struct platform_device *pdev)
338 {
339         platform_device_del(pdev);
340         platform_device_put(pdev);
341 }
342 EXPORT_SYMBOL_GPL(platform_device_unregister);
343
344 /**
345  * platform_device_register_simple
346  * @name: base name of the device we're adding
347  * @id: instance id
348  * @res: set of resources that needs to be allocated for the device
349  * @num: number of resources
350  *
351  * This function creates a simple platform device that requires minimal
352  * resource and memory management. Canned release function freeing memory
353  * allocated for the device allows drivers using such devices to be
354  * unloaded without waiting for the last reference to the device to be
355  * dropped.
356  *
357  * This interface is primarily intended for use with legacy drivers which
358  * probe hardware directly.  Because such drivers create sysfs device nodes
359  * themselves, rather than letting system infrastructure handle such device
360  * enumeration tasks, they don't fully conform to the Linux driver model.
361  * In particular, when such drivers are built as modules, they can't be
362  * "hotplugged".
363  */
364 struct platform_device *platform_device_register_simple(const char *name,
365                                                         int id,
366                                                         struct resource *res,
367                                                         unsigned int num)
368 {
369         struct platform_device *pdev;
370         int retval;
371
372         pdev = platform_device_alloc(name, id);
373         if (!pdev) {
374                 retval = -ENOMEM;
375                 goto error;
376         }
377
378         if (num) {
379                 retval = platform_device_add_resources(pdev, res, num);
380                 if (retval)
381                         goto error;
382         }
383
384         retval = platform_device_add(pdev);
385         if (retval)
386                 goto error;
387
388         return pdev;
389
390 error:
391         platform_device_put(pdev);
392         return ERR_PTR(retval);
393 }
394 EXPORT_SYMBOL_GPL(platform_device_register_simple);
395
396 /**
397  * platform_device_register_data
398  * @parent: parent device for the device we're adding
399  * @name: base name of the device we're adding
400  * @id: instance id
401  * @data: platform specific data for this platform device
402  * @size: size of platform specific data
403  *
404  * This function creates a simple platform device that requires minimal
405  * resource and memory management. Canned release function freeing memory
406  * allocated for the device allows drivers using such devices to be
407  * unloaded without waiting for the last reference to the device to be
408  * dropped.
409  */
410 struct platform_device *platform_device_register_data(
411                 struct device *parent,
412                 const char *name, int id,
413                 const void *data, size_t size)
414 {
415         struct platform_device *pdev;
416         int retval;
417
418         pdev = platform_device_alloc(name, id);
419         if (!pdev) {
420                 retval = -ENOMEM;
421                 goto error;
422         }
423
424         pdev->dev.parent = parent;
425
426         if (size) {
427                 retval = platform_device_add_data(pdev, data, size);
428                 if (retval)
429                         goto error;
430         }
431
432         retval = platform_device_add(pdev);
433         if (retval)
434                 goto error;
435
436         return pdev;
437
438 error:
439         platform_device_put(pdev);
440         return ERR_PTR(retval);
441 }
442
443 static int platform_drv_probe(struct device *_dev)
444 {
445         struct platform_driver *drv = to_platform_driver(_dev->driver);
446         struct platform_device *dev = to_platform_device(_dev);
447
448         return drv->probe(dev);
449 }
450
451 static int platform_drv_probe_fail(struct device *_dev)
452 {
453         return -ENXIO;
454 }
455
456 static int platform_drv_remove(struct device *_dev)
457 {
458         struct platform_driver *drv = to_platform_driver(_dev->driver);
459         struct platform_device *dev = to_platform_device(_dev);
460
461         return drv->remove(dev);
462 }
463
464 static void platform_drv_shutdown(struct device *_dev)
465 {
466         struct platform_driver *drv = to_platform_driver(_dev->driver);
467         struct platform_device *dev = to_platform_device(_dev);
468
469         drv->shutdown(dev);
470 }
471
472 static int platform_drv_suspend(struct device *_dev, pm_message_t state)
473 {
474         struct platform_driver *drv = to_platform_driver(_dev->driver);
475         struct platform_device *dev = to_platform_device(_dev);
476
477         return drv->suspend(dev, state);
478 }
479
480 static int platform_drv_resume(struct device *_dev)
481 {
482         struct platform_driver *drv = to_platform_driver(_dev->driver);
483         struct platform_device *dev = to_platform_device(_dev);
484
485         return drv->resume(dev);
486 }
487
488 /**
489  * platform_driver_register
490  * @drv: platform driver structure
491  */
492 int platform_driver_register(struct platform_driver *drv)
493 {
494         drv->driver.bus = &platform_bus_type;
495         if (drv->probe)
496                 drv->driver.probe = platform_drv_probe;
497         if (drv->remove)
498                 drv->driver.remove = platform_drv_remove;
499         if (drv->shutdown)
500                 drv->driver.shutdown = platform_drv_shutdown;
501         if (drv->suspend)
502                 drv->driver.suspend = platform_drv_suspend;
503         if (drv->resume)
504                 drv->driver.resume = platform_drv_resume;
505         return driver_register(&drv->driver);
506 }
507 EXPORT_SYMBOL_GPL(platform_driver_register);
508
509 /**
510  * platform_driver_unregister
511  * @drv: platform driver structure
512  */
513 void platform_driver_unregister(struct platform_driver *drv)
514 {
515         driver_unregister(&drv->driver);
516 }
517 EXPORT_SYMBOL_GPL(platform_driver_unregister);
518
519 /**
520  * platform_driver_probe - register driver for non-hotpluggable device
521  * @drv: platform driver structure
522  * @probe: the driver probe routine, probably from an __init section
523  *
524  * Use this instead of platform_driver_register() when you know the device
525  * is not hotpluggable and has already been registered, and you want to
526  * remove its run-once probe() infrastructure from memory after the driver
527  * has bound to the device.
528  *
529  * One typical use for this would be with drivers for controllers integrated
530  * into system-on-chip processors, where the controller devices have been
531  * configured as part of board setup.
532  *
533  * Returns zero if the driver registered and bound to a device, else returns
534  * a negative error code and with the driver not registered.
535  */
536 int __init_or_module platform_driver_probe(struct platform_driver *drv,
537                 int (*probe)(struct platform_device *))
538 {
539         int retval, code;
540
541         /* temporary section violation during probe() */
542         drv->probe = probe;
543         retval = code = platform_driver_register(drv);
544
545         /* Fixup that section violation, being paranoid about code scanning
546          * the list of drivers in order to probe new devices.  Check to see
547          * if the probe was successful, and make sure any forced probes of
548          * new devices fail.
549          */
550         spin_lock(&platform_bus_type.p->klist_drivers.k_lock);
551         drv->probe = NULL;
552         if (code == 0 && list_empty(&drv->driver.p->klist_devices.k_list))
553                 retval = -ENODEV;
554         drv->driver.probe = platform_drv_probe_fail;
555         spin_unlock(&platform_bus_type.p->klist_drivers.k_lock);
556
557         if (code != retval)
558                 platform_driver_unregister(drv);
559         return retval;
560 }
561 EXPORT_SYMBOL_GPL(platform_driver_probe);
562
563 /* modalias support enables more hands-off userspace setup:
564  * (a) environment variable lets new-style hotplug events work once system is
565  *     fully running:  "modprobe $MODALIAS"
566  * (b) sysfs attribute lets new-style coldplug recover from hotplug events
567  *     mishandled before system is fully running:  "modprobe $(cat modalias)"
568  */
569 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
570                              char *buf)
571 {
572         struct platform_device  *pdev = to_platform_device(dev);
573         int len = snprintf(buf, PAGE_SIZE, "platform:%s\n", pdev->name);
574
575         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
576 }
577
578 static struct device_attribute platform_dev_attrs[] = {
579         __ATTR_RO(modalias),
580         __ATTR_NULL,
581 };
582
583 static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
584 {
585         struct platform_device  *pdev = to_platform_device(dev);
586
587         add_uevent_var(env, "MODALIAS=platform:%s", pdev->name);
588         return 0;
589 }
590
591 /**
592  * platform_match - bind platform device to platform driver.
593  * @dev: device.
594  * @drv: driver.
595  *
596  * Platform device IDs are assumed to be encoded like this:
597  * "<name><instance>", where <name> is a short description of the type of
598  * device, like "pci" or "floppy", and <instance> is the enumerated
599  * instance of the device, like '0' or '42'.  Driver IDs are simply
600  * "<name>".  So, extract the <name> from the platform_device structure,
601  * and compare it against the name of the driver. Return whether they match
602  * or not.
603  */
604 static int platform_match(struct device *dev, struct device_driver *drv)
605 {
606         struct platform_device *pdev;
607
608         pdev = container_of(dev, struct platform_device, dev);
609         return (strcmp(pdev->name, drv->name) == 0);
610 }
611
612 #ifdef CONFIG_PM_SLEEP
613
614 static int platform_legacy_suspend(struct device *dev, pm_message_t mesg)
615 {
616         int ret = 0;
617
618         if (dev->driver && dev->driver->suspend)
619                 ret = dev->driver->suspend(dev, mesg);
620
621         return ret;
622 }
623
624 static int platform_legacy_suspend_late(struct device *dev, pm_message_t mesg)
625 {
626         struct platform_driver *drv = to_platform_driver(dev->driver);
627         struct platform_device *pdev;
628         int ret = 0;
629
630         pdev = container_of(dev, struct platform_device, dev);
631         if (dev->driver && drv->suspend_late)
632                 ret = drv->suspend_late(pdev, mesg);
633
634         return ret;
635 }
636
637 static int platform_legacy_resume_early(struct device *dev)
638 {
639         struct platform_driver *drv = to_platform_driver(dev->driver);
640         struct platform_device *pdev;
641         int ret = 0;
642
643         pdev = container_of(dev, struct platform_device, dev);
644         if (dev->driver && drv->resume_early)
645                 ret = drv->resume_early(pdev);
646
647         return ret;
648 }
649
650 static int platform_legacy_resume(struct device *dev)
651 {
652         int ret = 0;
653
654         if (dev->driver && dev->driver->resume)
655                 ret = dev->driver->resume(dev);
656
657         return ret;
658 }
659
660 static int platform_pm_prepare(struct device *dev)
661 {
662         struct device_driver *drv = dev->driver;
663         int ret = 0;
664
665         if (drv && drv->pm && drv->pm->prepare)
666                 ret = drv->pm->prepare(dev);
667
668         return ret;
669 }
670
671 static void platform_pm_complete(struct device *dev)
672 {
673         struct device_driver *drv = dev->driver;
674
675         if (drv && drv->pm && drv->pm->complete)
676                 drv->pm->complete(dev);
677 }
678
679 #ifdef CONFIG_SUSPEND
680
681 static int platform_pm_suspend(struct device *dev)
682 {
683         struct device_driver *drv = dev->driver;
684         int ret = 0;
685
686         if (!drv)
687                 return 0;
688
689         if (drv->pm) {
690                 if (drv->pm->suspend)
691                         ret = drv->pm->suspend(dev);
692         } else {
693                 ret = platform_legacy_suspend(dev, PMSG_SUSPEND);
694         }
695
696         return ret;
697 }
698
699 static int platform_pm_suspend_noirq(struct device *dev)
700 {
701         struct device_driver *drv = dev->driver;
702         int ret = 0;
703
704         if (!drv)
705                 return 0;
706
707         if (drv->pm) {
708                 if (drv->pm->suspend_noirq)
709                         ret = drv->pm->suspend_noirq(dev);
710         } else {
711                 ret = platform_legacy_suspend_late(dev, PMSG_SUSPEND);
712         }
713
714         return ret;
715 }
716
717 static int platform_pm_resume(struct device *dev)
718 {
719         struct device_driver *drv = dev->driver;
720         int ret = 0;
721
722         if (!drv)
723                 return 0;
724
725         if (drv->pm) {
726                 if (drv->pm->resume)
727                         ret = drv->pm->resume(dev);
728         } else {
729                 ret = platform_legacy_resume(dev);
730         }
731
732         return ret;
733 }
734
735 static int platform_pm_resume_noirq(struct device *dev)
736 {
737         struct device_driver *drv = dev->driver;
738         int ret = 0;
739
740         if (!drv)
741                 return 0;
742
743         if (drv->pm) {
744                 if (drv->pm->resume_noirq)
745                         ret = drv->pm->resume_noirq(dev);
746         } else {
747                 ret = platform_legacy_resume_early(dev);
748         }
749
750         return ret;
751 }
752
753 #else /* !CONFIG_SUSPEND */
754
755 #define platform_pm_suspend             NULL
756 #define platform_pm_resume              NULL
757 #define platform_pm_suspend_noirq       NULL
758 #define platform_pm_resume_noirq        NULL
759
760 #endif /* !CONFIG_SUSPEND */
761
762 #ifdef CONFIG_HIBERNATION
763
764 static int platform_pm_freeze(struct device *dev)
765 {
766         struct device_driver *drv = dev->driver;
767         int ret = 0;
768
769         if (!drv)
770                 return 0;
771
772         if (drv->pm) {
773                 if (drv->pm->freeze)
774                         ret = drv->pm->freeze(dev);
775         } else {
776                 ret = platform_legacy_suspend(dev, PMSG_FREEZE);
777         }
778
779         return ret;
780 }
781
782 static int platform_pm_freeze_noirq(struct device *dev)
783 {
784         struct device_driver *drv = dev->driver;
785         int ret = 0;
786
787         if (!drv)
788                 return 0;
789
790         if (drv->pm) {
791                 if (drv->pm->freeze_noirq)
792                         ret = drv->pm->freeze_noirq(dev);
793         } else {
794                 ret = platform_legacy_suspend_late(dev, PMSG_FREEZE);
795         }
796
797         return ret;
798 }
799
800 static int platform_pm_thaw(struct device *dev)
801 {
802         struct device_driver *drv = dev->driver;
803         int ret = 0;
804
805         if (!drv)
806                 return 0;
807
808         if (drv->pm) {
809                 if (drv->pm->thaw)
810                         ret = drv->pm->thaw(dev);
811         } else {
812                 ret = platform_legacy_resume(dev);
813         }
814
815         return ret;
816 }
817
818 static int platform_pm_thaw_noirq(struct device *dev)
819 {
820         struct device_driver *drv = dev->driver;
821         int ret = 0;
822
823         if (!drv)
824                 return 0;
825
826         if (drv->pm) {
827                 if (drv->pm->thaw_noirq)
828                         ret = drv->pm->thaw_noirq(dev);
829         } else {
830                 ret = platform_legacy_resume_early(dev);
831         }
832
833         return ret;
834 }
835
836 static int platform_pm_poweroff(struct device *dev)
837 {
838         struct device_driver *drv = dev->driver;
839         int ret = 0;
840
841         if (!drv)
842                 return 0;
843
844         if (drv->pm) {
845                 if (drv->pm->poweroff)
846                         ret = drv->pm->poweroff(dev);
847         } else {
848                 ret = platform_legacy_suspend(dev, PMSG_HIBERNATE);
849         }
850
851         return ret;
852 }
853
854 static int platform_pm_poweroff_noirq(struct device *dev)
855 {
856         struct device_driver *drv = dev->driver;
857         int ret = 0;
858
859         if (!drv)
860                 return 0;
861
862         if (drv->pm) {
863                 if (drv->pm->poweroff_noirq)
864                         ret = drv->pm->poweroff_noirq(dev);
865         } else {
866                 ret = platform_legacy_suspend_late(dev, PMSG_HIBERNATE);
867         }
868
869         return ret;
870 }
871
872 static int platform_pm_restore(struct device *dev)
873 {
874         struct device_driver *drv = dev->driver;
875         int ret = 0;
876
877         if (!drv)
878                 return 0;
879
880         if (drv->pm) {
881                 if (drv->pm->restore)
882                         ret = drv->pm->restore(dev);
883         } else {
884                 ret = platform_legacy_resume(dev);
885         }
886
887         return ret;
888 }
889
890 static int platform_pm_restore_noirq(struct device *dev)
891 {
892         struct device_driver *drv = dev->driver;
893         int ret = 0;
894
895         if (!drv)
896                 return 0;
897
898         if (drv->pm) {
899                 if (drv->pm->restore_noirq)
900                         ret = drv->pm->restore_noirq(dev);
901         } else {
902                 ret = platform_legacy_resume_early(dev);
903         }
904
905         return ret;
906 }
907
908 #else /* !CONFIG_HIBERNATION */
909
910 #define platform_pm_freeze              NULL
911 #define platform_pm_thaw                NULL
912 #define platform_pm_poweroff            NULL
913 #define platform_pm_restore             NULL
914 #define platform_pm_freeze_noirq        NULL
915 #define platform_pm_thaw_noirq          NULL
916 #define platform_pm_poweroff_noirq      NULL
917 #define platform_pm_restore_noirq       NULL
918
919 #endif /* !CONFIG_HIBERNATION */
920
921 static struct dev_pm_ops platform_dev_pm_ops = {
922         .prepare = platform_pm_prepare,
923         .complete = platform_pm_complete,
924         .suspend = platform_pm_suspend,
925         .resume = platform_pm_resume,
926         .freeze = platform_pm_freeze,
927         .thaw = platform_pm_thaw,
928         .poweroff = platform_pm_poweroff,
929         .restore = platform_pm_restore,
930         .suspend_noirq = platform_pm_suspend_noirq,
931         .resume_noirq = platform_pm_resume_noirq,
932         .freeze_noirq = platform_pm_freeze_noirq,
933         .thaw_noirq = platform_pm_thaw_noirq,
934         .poweroff_noirq = platform_pm_poweroff_noirq,
935         .restore_noirq = platform_pm_restore_noirq,
936 };
937
938 #define PLATFORM_PM_OPS_PTR     (&platform_dev_pm_ops)
939
940 #else /* !CONFIG_PM_SLEEP */
941
942 #define PLATFORM_PM_OPS_PTR     NULL
943
944 #endif /* !CONFIG_PM_SLEEP */
945
946 struct bus_type platform_bus_type = {
947         .name           = "platform",
948         .dev_attrs      = platform_dev_attrs,
949         .match          = platform_match,
950         .uevent         = platform_uevent,
951         .pm             = PLATFORM_PM_OPS_PTR,
952 };
953 EXPORT_SYMBOL_GPL(platform_bus_type);
954
955 int __init platform_bus_init(void)
956 {
957         int error;
958
959         error = device_register(&platform_bus);
960         if (error)
961                 return error;
962         error =  bus_register(&platform_bus_type);
963         if (error)
964                 device_unregister(&platform_bus);
965         return error;
966 }
967
968 #ifndef ARCH_HAS_DMA_GET_REQUIRED_MASK
969 u64 dma_get_required_mask(struct device *dev)
970 {
971         u32 low_totalram = ((max_pfn - 1) << PAGE_SHIFT);
972         u32 high_totalram = ((max_pfn - 1) >> (32 - PAGE_SHIFT));
973         u64 mask;
974
975         if (!high_totalram) {
976                 /* convert to mask just covering totalram */
977                 low_totalram = (1 << (fls(low_totalram) - 1));
978                 low_totalram += low_totalram - 1;
979                 mask = low_totalram;
980         } else {
981                 high_totalram = (1 << (fls(high_totalram) - 1));
982                 high_totalram += high_totalram - 1;
983                 mask = (((u64)high_totalram) << 32) + 0xffffffff;
984         }
985         return mask;
986 }
987 EXPORT_SYMBOL_GPL(dma_get_required_mask);
988 #endif