Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael...
[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 /**
473  * platform_driver_register
474  * @drv: platform driver structure
475  */
476 int platform_driver_register(struct platform_driver *drv)
477 {
478         drv->driver.bus = &platform_bus_type;
479         if (drv->probe)
480                 drv->driver.probe = platform_drv_probe;
481         if (drv->remove)
482                 drv->driver.remove = platform_drv_remove;
483         if (drv->shutdown)
484                 drv->driver.shutdown = platform_drv_shutdown;
485         if (drv->suspend || drv->resume)
486                 pr_warning("Platform driver '%s' needs updating - please use "
487                         "dev_pm_ops\n", drv->driver.name);
488
489         return driver_register(&drv->driver);
490 }
491 EXPORT_SYMBOL_GPL(platform_driver_register);
492
493 /**
494  * platform_driver_unregister
495  * @drv: platform driver structure
496  */
497 void platform_driver_unregister(struct platform_driver *drv)
498 {
499         driver_unregister(&drv->driver);
500 }
501 EXPORT_SYMBOL_GPL(platform_driver_unregister);
502
503 /**
504  * platform_driver_probe - register driver for non-hotpluggable device
505  * @drv: platform driver structure
506  * @probe: the driver probe routine, probably from an __init section
507  *
508  * Use this instead of platform_driver_register() when you know the device
509  * is not hotpluggable and has already been registered, and you want to
510  * remove its run-once probe() infrastructure from memory after the driver
511  * has bound to the device.
512  *
513  * One typical use for this would be with drivers for controllers integrated
514  * into system-on-chip processors, where the controller devices have been
515  * configured as part of board setup.
516  *
517  * Returns zero if the driver registered and bound to a device, else returns
518  * a negative error code and with the driver not registered.
519  */
520 int __init_or_module platform_driver_probe(struct platform_driver *drv,
521                 int (*probe)(struct platform_device *))
522 {
523         int retval, code;
524
525         /* temporary section violation during probe() */
526         drv->probe = probe;
527         retval = code = platform_driver_register(drv);
528
529         /* Fixup that section violation, being paranoid about code scanning
530          * the list of drivers in order to probe new devices.  Check to see
531          * if the probe was successful, and make sure any forced probes of
532          * new devices fail.
533          */
534         spin_lock(&platform_bus_type.p->klist_drivers.k_lock);
535         drv->probe = NULL;
536         if (code == 0 && list_empty(&drv->driver.p->klist_devices.k_list))
537                 retval = -ENODEV;
538         drv->driver.probe = platform_drv_probe_fail;
539         spin_unlock(&platform_bus_type.p->klist_drivers.k_lock);
540
541         if (code != retval)
542                 platform_driver_unregister(drv);
543         return retval;
544 }
545 EXPORT_SYMBOL_GPL(platform_driver_probe);
546
547 /* modalias support enables more hands-off userspace setup:
548  * (a) environment variable lets new-style hotplug events work once system is
549  *     fully running:  "modprobe $MODALIAS"
550  * (b) sysfs attribute lets new-style coldplug recover from hotplug events
551  *     mishandled before system is fully running:  "modprobe $(cat modalias)"
552  */
553 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
554                              char *buf)
555 {
556         struct platform_device  *pdev = to_platform_device(dev);
557         int len = snprintf(buf, PAGE_SIZE, "platform:%s\n", pdev->name);
558
559         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
560 }
561
562 static struct device_attribute platform_dev_attrs[] = {
563         __ATTR_RO(modalias),
564         __ATTR_NULL,
565 };
566
567 static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
568 {
569         struct platform_device  *pdev = to_platform_device(dev);
570
571         add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX,
572                 (pdev->id_entry) ? pdev->id_entry->name : pdev->name);
573         return 0;
574 }
575
576 static const struct platform_device_id *platform_match_id(
577                         struct platform_device_id *id,
578                         struct platform_device *pdev)
579 {
580         while (id->name[0]) {
581                 if (strcmp(pdev->name, id->name) == 0) {
582                         pdev->id_entry = id;
583                         return id;
584                 }
585                 id++;
586         }
587         return NULL;
588 }
589
590 /**
591  * platform_match - bind platform device to platform driver.
592  * @dev: device.
593  * @drv: driver.
594  *
595  * Platform device IDs are assumed to be encoded like this:
596  * "<name><instance>", where <name> is a short description of the type of
597  * device, like "pci" or "floppy", and <instance> is the enumerated
598  * instance of the device, like '0' or '42'.  Driver IDs are simply
599  * "<name>".  So, extract the <name> from the platform_device structure,
600  * and compare it against the name of the driver. Return whether they match
601  * or not.
602  */
603 static int platform_match(struct device *dev, struct device_driver *drv)
604 {
605         struct platform_device *pdev = to_platform_device(dev);
606         struct platform_driver *pdrv = to_platform_driver(drv);
607
608         /* match against the id table first */
609         if (pdrv->id_table)
610                 return platform_match_id(pdrv->id_table, pdev) != NULL;
611
612         /* fall-back to driver name match */
613         return (strcmp(pdev->name, drv->name) == 0);
614 }
615
616 #ifdef CONFIG_PM_SLEEP
617
618 static int platform_legacy_suspend(struct device *dev, pm_message_t mesg)
619 {
620         struct platform_driver *pdrv = to_platform_driver(dev->driver);
621         struct platform_device *pdev = to_platform_device(dev);
622         int ret = 0;
623
624         if (dev->driver && pdrv->suspend)
625                 ret = pdrv->suspend(pdev, mesg);
626
627         return ret;
628 }
629
630 static int platform_legacy_suspend_late(struct device *dev, pm_message_t mesg)
631 {
632         struct platform_driver *pdrv = to_platform_driver(dev->driver);
633         struct platform_device *pdev = to_platform_device(dev);
634         int ret = 0;
635
636         if (dev->driver && pdrv->suspend_late)
637                 ret = pdrv->suspend_late(pdev, mesg);
638
639         return ret;
640 }
641
642 static int platform_legacy_resume_early(struct device *dev)
643 {
644         struct platform_driver *pdrv = to_platform_driver(dev->driver);
645         struct platform_device *pdev = to_platform_device(dev);
646         int ret = 0;
647
648         if (dev->driver && pdrv->resume_early)
649                 ret = pdrv->resume_early(pdev);
650
651         return ret;
652 }
653
654 static int platform_legacy_resume(struct device *dev)
655 {
656         struct platform_driver *pdrv = to_platform_driver(dev->driver);
657         struct platform_device *pdev = to_platform_device(dev);
658         int ret = 0;
659
660         if (dev->driver && pdrv->resume)
661                 ret = pdrv->resume(pdev);
662
663         return ret;
664 }
665
666 static int platform_pm_prepare(struct device *dev)
667 {
668         struct device_driver *drv = dev->driver;
669         int ret = 0;
670
671         if (drv && drv->pm && drv->pm->prepare)
672                 ret = drv->pm->prepare(dev);
673
674         return ret;
675 }
676
677 static void platform_pm_complete(struct device *dev)
678 {
679         struct device_driver *drv = dev->driver;
680
681         if (drv && drv->pm && drv->pm->complete)
682                 drv->pm->complete(dev);
683 }
684
685 #ifdef CONFIG_SUSPEND
686
687 static int platform_pm_suspend(struct device *dev)
688 {
689         struct device_driver *drv = dev->driver;
690         int ret = 0;
691
692         if (!drv)
693                 return 0;
694
695         if (drv->pm) {
696                 if (drv->pm->suspend)
697                         ret = drv->pm->suspend(dev);
698         } else {
699                 ret = platform_legacy_suspend(dev, PMSG_SUSPEND);
700         }
701
702         return ret;
703 }
704
705 static int platform_pm_suspend_noirq(struct device *dev)
706 {
707         struct device_driver *drv = dev->driver;
708         int ret = 0;
709
710         if (!drv)
711                 return 0;
712
713         if (drv->pm) {
714                 if (drv->pm->suspend_noirq)
715                         ret = drv->pm->suspend_noirq(dev);
716         } else {
717                 ret = platform_legacy_suspend_late(dev, PMSG_SUSPEND);
718         }
719
720         return ret;
721 }
722
723 static int platform_pm_resume(struct device *dev)
724 {
725         struct device_driver *drv = dev->driver;
726         int ret = 0;
727
728         if (!drv)
729                 return 0;
730
731         if (drv->pm) {
732                 if (drv->pm->resume)
733                         ret = drv->pm->resume(dev);
734         } else {
735                 ret = platform_legacy_resume(dev);
736         }
737
738         return ret;
739 }
740
741 static int platform_pm_resume_noirq(struct device *dev)
742 {
743         struct device_driver *drv = dev->driver;
744         int ret = 0;
745
746         if (!drv)
747                 return 0;
748
749         if (drv->pm) {
750                 if (drv->pm->resume_noirq)
751                         ret = drv->pm->resume_noirq(dev);
752         } else {
753                 ret = platform_legacy_resume_early(dev);
754         }
755
756         return ret;
757 }
758
759 #else /* !CONFIG_SUSPEND */
760
761 #define platform_pm_suspend             NULL
762 #define platform_pm_resume              NULL
763 #define platform_pm_suspend_noirq       NULL
764 #define platform_pm_resume_noirq        NULL
765
766 #endif /* !CONFIG_SUSPEND */
767
768 #ifdef CONFIG_HIBERNATION
769
770 static int platform_pm_freeze(struct device *dev)
771 {
772         struct device_driver *drv = dev->driver;
773         int ret = 0;
774
775         if (!drv)
776                 return 0;
777
778         if (drv->pm) {
779                 if (drv->pm->freeze)
780                         ret = drv->pm->freeze(dev);
781         } else {
782                 ret = platform_legacy_suspend(dev, PMSG_FREEZE);
783         }
784
785         return ret;
786 }
787
788 static int platform_pm_freeze_noirq(struct device *dev)
789 {
790         struct device_driver *drv = dev->driver;
791         int ret = 0;
792
793         if (!drv)
794                 return 0;
795
796         if (drv->pm) {
797                 if (drv->pm->freeze_noirq)
798                         ret = drv->pm->freeze_noirq(dev);
799         } else {
800                 ret = platform_legacy_suspend_late(dev, PMSG_FREEZE);
801         }
802
803         return ret;
804 }
805
806 static int platform_pm_thaw(struct device *dev)
807 {
808         struct device_driver *drv = dev->driver;
809         int ret = 0;
810
811         if (!drv)
812                 return 0;
813
814         if (drv->pm) {
815                 if (drv->pm->thaw)
816                         ret = drv->pm->thaw(dev);
817         } else {
818                 ret = platform_legacy_resume(dev);
819         }
820
821         return ret;
822 }
823
824 static int platform_pm_thaw_noirq(struct device *dev)
825 {
826         struct device_driver *drv = dev->driver;
827         int ret = 0;
828
829         if (!drv)
830                 return 0;
831
832         if (drv->pm) {
833                 if (drv->pm->thaw_noirq)
834                         ret = drv->pm->thaw_noirq(dev);
835         } else {
836                 ret = platform_legacy_resume_early(dev);
837         }
838
839         return ret;
840 }
841
842 static int platform_pm_poweroff(struct device *dev)
843 {
844         struct device_driver *drv = dev->driver;
845         int ret = 0;
846
847         if (!drv)
848                 return 0;
849
850         if (drv->pm) {
851                 if (drv->pm->poweroff)
852                         ret = drv->pm->poweroff(dev);
853         } else {
854                 ret = platform_legacy_suspend(dev, PMSG_HIBERNATE);
855         }
856
857         return ret;
858 }
859
860 static int platform_pm_poweroff_noirq(struct device *dev)
861 {
862         struct device_driver *drv = dev->driver;
863         int ret = 0;
864
865         if (!drv)
866                 return 0;
867
868         if (drv->pm) {
869                 if (drv->pm->poweroff_noirq)
870                         ret = drv->pm->poweroff_noirq(dev);
871         } else {
872                 ret = platform_legacy_suspend_late(dev, PMSG_HIBERNATE);
873         }
874
875         return ret;
876 }
877
878 static int platform_pm_restore(struct device *dev)
879 {
880         struct device_driver *drv = dev->driver;
881         int ret = 0;
882
883         if (!drv)
884                 return 0;
885
886         if (drv->pm) {
887                 if (drv->pm->restore)
888                         ret = drv->pm->restore(dev);
889         } else {
890                 ret = platform_legacy_resume(dev);
891         }
892
893         return ret;
894 }
895
896 static int platform_pm_restore_noirq(struct device *dev)
897 {
898         struct device_driver *drv = dev->driver;
899         int ret = 0;
900
901         if (!drv)
902                 return 0;
903
904         if (drv->pm) {
905                 if (drv->pm->restore_noirq)
906                         ret = drv->pm->restore_noirq(dev);
907         } else {
908                 ret = platform_legacy_resume_early(dev);
909         }
910
911         return ret;
912 }
913
914 #else /* !CONFIG_HIBERNATION */
915
916 #define platform_pm_freeze              NULL
917 #define platform_pm_thaw                NULL
918 #define platform_pm_poweroff            NULL
919 #define platform_pm_restore             NULL
920 #define platform_pm_freeze_noirq        NULL
921 #define platform_pm_thaw_noirq          NULL
922 #define platform_pm_poweroff_noirq      NULL
923 #define platform_pm_restore_noirq       NULL
924
925 #endif /* !CONFIG_HIBERNATION */
926
927 static struct dev_pm_ops platform_dev_pm_ops = {
928         .prepare = platform_pm_prepare,
929         .complete = platform_pm_complete,
930         .suspend = platform_pm_suspend,
931         .resume = platform_pm_resume,
932         .freeze = platform_pm_freeze,
933         .thaw = platform_pm_thaw,
934         .poweroff = platform_pm_poweroff,
935         .restore = platform_pm_restore,
936         .suspend_noirq = platform_pm_suspend_noirq,
937         .resume_noirq = platform_pm_resume_noirq,
938         .freeze_noirq = platform_pm_freeze_noirq,
939         .thaw_noirq = platform_pm_thaw_noirq,
940         .poweroff_noirq = platform_pm_poweroff_noirq,
941         .restore_noirq = platform_pm_restore_noirq,
942 };
943
944 #define PLATFORM_PM_OPS_PTR     (&platform_dev_pm_ops)
945
946 #else /* !CONFIG_PM_SLEEP */
947
948 #define PLATFORM_PM_OPS_PTR     NULL
949
950 #endif /* !CONFIG_PM_SLEEP */
951
952 struct bus_type platform_bus_type = {
953         .name           = "platform",
954         .dev_attrs      = platform_dev_attrs,
955         .match          = platform_match,
956         .uevent         = platform_uevent,
957         .pm             = PLATFORM_PM_OPS_PTR,
958 };
959 EXPORT_SYMBOL_GPL(platform_bus_type);
960
961 int __init platform_bus_init(void)
962 {
963         int error;
964
965         early_platform_cleanup();
966
967         error = device_register(&platform_bus);
968         if (error)
969                 return error;
970         error =  bus_register(&platform_bus_type);
971         if (error)
972                 device_unregister(&platform_bus);
973         return error;
974 }
975
976 #ifndef ARCH_HAS_DMA_GET_REQUIRED_MASK
977 u64 dma_get_required_mask(struct device *dev)
978 {
979         u32 low_totalram = ((max_pfn - 1) << PAGE_SHIFT);
980         u32 high_totalram = ((max_pfn - 1) >> (32 - PAGE_SHIFT));
981         u64 mask;
982
983         if (!high_totalram) {
984                 /* convert to mask just covering totalram */
985                 low_totalram = (1 << (fls(low_totalram) - 1));
986                 low_totalram += low_totalram - 1;
987                 mask = low_totalram;
988         } else {
989                 high_totalram = (1 << (fls(high_totalram) - 1));
990                 high_totalram += high_totalram - 1;
991                 mask = (((u64)high_totalram) << 32) + 0xffffffff;
992         }
993         return mask;
994 }
995 EXPORT_SYMBOL_GPL(dma_get_required_mask);
996 #endif
997
998 static __initdata LIST_HEAD(early_platform_driver_list);
999 static __initdata LIST_HEAD(early_platform_device_list);
1000
1001 /**
1002  * early_platform_driver_register
1003  * @epdrv: early_platform driver structure
1004  * @buf: string passed from early_param()
1005  */
1006 int __init early_platform_driver_register(struct early_platform_driver *epdrv,
1007                                           char *buf)
1008 {
1009         unsigned long index;
1010         int n;
1011
1012         /* Simply add the driver to the end of the global list.
1013          * Drivers will by default be put on the list in compiled-in order.
1014          */
1015         if (!epdrv->list.next) {
1016                 INIT_LIST_HEAD(&epdrv->list);
1017                 list_add_tail(&epdrv->list, &early_platform_driver_list);
1018         }
1019
1020         /* If the user has specified device then make sure the driver
1021          * gets prioritized. The driver of the last device specified on
1022          * command line will be put first on the list.
1023          */
1024         n = strlen(epdrv->pdrv->driver.name);
1025         if (buf && !strncmp(buf, epdrv->pdrv->driver.name, n)) {
1026                 list_move(&epdrv->list, &early_platform_driver_list);
1027
1028                 if (!strcmp(buf, epdrv->pdrv->driver.name))
1029                         epdrv->requested_id = -1;
1030                 else if (buf[n] == '.' && strict_strtoul(&buf[n + 1], 10,
1031                                                          &index) == 0)
1032                         epdrv->requested_id = index;
1033                 else
1034                         epdrv->requested_id = EARLY_PLATFORM_ID_ERROR;
1035         }
1036
1037         return 0;
1038 }
1039
1040 /**
1041  * early_platform_add_devices - add a numbers of early platform devices
1042  * @devs: array of early platform devices to add
1043  * @num: number of early platform devices in array
1044  */
1045 void __init early_platform_add_devices(struct platform_device **devs, int num)
1046 {
1047         struct device *dev;
1048         int i;
1049
1050         /* simply add the devices to list */
1051         for (i = 0; i < num; i++) {
1052                 dev = &devs[i]->dev;
1053
1054                 if (!dev->devres_head.next) {
1055                         INIT_LIST_HEAD(&dev->devres_head);
1056                         list_add_tail(&dev->devres_head,
1057                                       &early_platform_device_list);
1058                 }
1059         }
1060 }
1061
1062 /**
1063  * early_platform_driver_register_all
1064  * @class_str: string to identify early platform driver class
1065  */
1066 void __init early_platform_driver_register_all(char *class_str)
1067 {
1068         /* The "class_str" parameter may or may not be present on the kernel
1069          * command line. If it is present then there may be more than one
1070          * matching parameter.
1071          *
1072          * Since we register our early platform drivers using early_param()
1073          * we need to make sure that they also get registered in the case
1074          * when the parameter is missing from the kernel command line.
1075          *
1076          * We use parse_early_options() to make sure the early_param() gets
1077          * called at least once. The early_param() may be called more than
1078          * once since the name of the preferred device may be specified on
1079          * the kernel command line. early_platform_driver_register() handles
1080          * this case for us.
1081          */
1082         parse_early_options(class_str);
1083 }
1084
1085 /**
1086  * early_platform_match
1087  * @epdrv: early platform driver structure
1088  * @id: id to match against
1089  */
1090 static  __init struct platform_device *
1091 early_platform_match(struct early_platform_driver *epdrv, int id)
1092 {
1093         struct platform_device *pd;
1094
1095         list_for_each_entry(pd, &early_platform_device_list, dev.devres_head)
1096                 if (platform_match(&pd->dev, &epdrv->pdrv->driver))
1097                         if (pd->id == id)
1098                                 return pd;
1099
1100         return NULL;
1101 }
1102
1103 /**
1104  * early_platform_left
1105  * @epdrv: early platform driver structure
1106  * @id: return true if id or above exists
1107  */
1108 static  __init int early_platform_left(struct early_platform_driver *epdrv,
1109                                        int id)
1110 {
1111         struct platform_device *pd;
1112
1113         list_for_each_entry(pd, &early_platform_device_list, dev.devres_head)
1114                 if (platform_match(&pd->dev, &epdrv->pdrv->driver))
1115                         if (pd->id >= id)
1116                                 return 1;
1117
1118         return 0;
1119 }
1120
1121 /**
1122  * early_platform_driver_probe_id
1123  * @class_str: string to identify early platform driver class
1124  * @id: id to match against
1125  * @nr_probe: number of platform devices to successfully probe before exiting
1126  */
1127 static int __init early_platform_driver_probe_id(char *class_str,
1128                                                  int id,
1129                                                  int nr_probe)
1130 {
1131         struct early_platform_driver *epdrv;
1132         struct platform_device *match;
1133         int match_id;
1134         int n = 0;
1135         int left = 0;
1136
1137         list_for_each_entry(epdrv, &early_platform_driver_list, list) {
1138                 /* only use drivers matching our class_str */
1139                 if (strcmp(class_str, epdrv->class_str))
1140                         continue;
1141
1142                 if (id == -2) {
1143                         match_id = epdrv->requested_id;
1144                         left = 1;
1145
1146                 } else {
1147                         match_id = id;
1148                         left += early_platform_left(epdrv, id);
1149
1150                         /* skip requested id */
1151                         switch (epdrv->requested_id) {
1152                         case EARLY_PLATFORM_ID_ERROR:
1153                         case EARLY_PLATFORM_ID_UNSET:
1154                                 break;
1155                         default:
1156                                 if (epdrv->requested_id == id)
1157                                         match_id = EARLY_PLATFORM_ID_UNSET;
1158                         }
1159                 }
1160
1161                 switch (match_id) {
1162                 case EARLY_PLATFORM_ID_ERROR:
1163                         pr_warning("%s: unable to parse %s parameter\n",
1164                                    class_str, epdrv->pdrv->driver.name);
1165                         /* fall-through */
1166                 case EARLY_PLATFORM_ID_UNSET:
1167                         match = NULL;
1168                         break;
1169                 default:
1170                         match = early_platform_match(epdrv, match_id);
1171                 }
1172
1173                 if (match) {
1174                         if (epdrv->pdrv->probe(match))
1175                                 pr_warning("%s: unable to probe %s early.\n",
1176                                            class_str, match->name);
1177                         else
1178                                 n++;
1179                 }
1180
1181                 if (n >= nr_probe)
1182                         break;
1183         }
1184
1185         if (left)
1186                 return n;
1187         else
1188                 return -ENODEV;
1189 }
1190
1191 /**
1192  * early_platform_driver_probe
1193  * @class_str: string to identify early platform driver class
1194  * @nr_probe: number of platform devices to successfully probe before exiting
1195  * @user_only: only probe user specified early platform devices
1196  */
1197 int __init early_platform_driver_probe(char *class_str,
1198                                        int nr_probe,
1199                                        int user_only)
1200 {
1201         int k, n, i;
1202
1203         n = 0;
1204         for (i = -2; n < nr_probe; i++) {
1205                 k = early_platform_driver_probe_id(class_str, i, nr_probe - n);
1206
1207                 if (k < 0)
1208                         break;
1209
1210                 n += k;
1211
1212                 if (user_only)
1213                         break;
1214         }
1215
1216         return n;
1217 }
1218
1219 /**
1220  * early_platform_cleanup - clean up early platform code
1221  */
1222 void __init early_platform_cleanup(void)
1223 {
1224         struct platform_device *pd, *pd2;
1225
1226         /* clean up the devres list used to chain devices */
1227         list_for_each_entry_safe(pd, pd2, &early_platform_device_list,
1228                                  dev.devres_head) {
1229                 list_del(&pd->dev.devres_head);
1230                 memset(&pd->dev.devres_head, 0, sizeof(pd->dev.devres_head));
1231         }
1232 }
1233