Merge branch 'fix/asoc' into for-linus
[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                 pdev->platform_data = d;
221         }
222         return d ? 0 : -ENOMEM;
223 }
224 EXPORT_SYMBOL_GPL(platform_device_add_data);
225
226 /**
227  * platform_device_add - add a platform device to device hierarchy
228  * @pdev: platform device we're adding
229  *
230  * This is part 2 of platform_device_register(), though may be called
231  * separately _iff_ pdev was allocated by platform_device_alloc().
232  */
233 int platform_device_add(struct platform_device *pdev)
234 {
235         int i, ret = 0;
236
237         if (!pdev)
238                 return -EINVAL;
239
240         if (!pdev->dev.parent)
241                 pdev->dev.parent = &platform_bus;
242
243         pdev->dev.bus = &platform_bus_type;
244
245         if (pdev->id != -1)
246                 dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);
247         else
248                 dev_set_name(&pdev->dev, pdev->name);
249
250         /* We will remove platform_data field from struct device
251         * if all platform devices pass its platform specific data
252         * from platform_device. The conversion is going to be a
253         * long time, so we allow the two cases coexist to make
254         * this kind of fix more easily*/
255         if (pdev->platform_data && pdev->dev.platform_data) {
256                 printk(KERN_ERR
257                                "%s: use which platform_data?\n",
258                                dev_name(&pdev->dev));
259         } else if (pdev->platform_data) {
260                 pdev->dev.platform_data = pdev->platform_data;
261         } else if (pdev->dev.platform_data) {
262                 pdev->platform_data = pdev->dev.platform_data;
263         }
264
265         for (i = 0; i < pdev->num_resources; i++) {
266                 struct resource *p, *r = &pdev->resource[i];
267
268                 if (r->name == NULL)
269                         r->name = dev_name(&pdev->dev);
270
271                 p = r->parent;
272                 if (!p) {
273                         if (resource_type(r) == IORESOURCE_MEM)
274                                 p = &iomem_resource;
275                         else if (resource_type(r) == IORESOURCE_IO)
276                                 p = &ioport_resource;
277                 }
278
279                 if (p && insert_resource(p, r)) {
280                         printk(KERN_ERR
281                                "%s: failed to claim resource %d\n",
282                                dev_name(&pdev->dev), i);
283                         ret = -EBUSY;
284                         goto failed;
285                 }
286         }
287
288         pr_debug("Registering platform device '%s'. Parent at %s\n",
289                  dev_name(&pdev->dev), dev_name(pdev->dev.parent));
290
291         ret = device_add(&pdev->dev);
292         if (ret == 0)
293                 return ret;
294
295  failed:
296         while (--i >= 0) {
297                 struct resource *r = &pdev->resource[i];
298                 unsigned long type = resource_type(r);
299
300                 if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
301                         release_resource(r);
302         }
303
304         return ret;
305 }
306 EXPORT_SYMBOL_GPL(platform_device_add);
307
308 /**
309  * platform_device_del - remove a platform-level device
310  * @pdev: platform device we're removing
311  *
312  * Note that this function will also release all memory- and port-based
313  * resources owned by the device (@dev->resource).  This function must
314  * _only_ be externally called in error cases.  All other usage is a bug.
315  */
316 void platform_device_del(struct platform_device *pdev)
317 {
318         int i;
319
320         if (pdev) {
321                 device_del(&pdev->dev);
322
323                 for (i = 0; i < pdev->num_resources; i++) {
324                         struct resource *r = &pdev->resource[i];
325                         unsigned long type = resource_type(r);
326
327                         if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
328                                 release_resource(r);
329                 }
330         }
331 }
332 EXPORT_SYMBOL_GPL(platform_device_del);
333
334 /**
335  * platform_device_register - add a platform-level device
336  * @pdev: platform device we're adding
337  */
338 int platform_device_register(struct platform_device *pdev)
339 {
340         device_initialize(&pdev->dev);
341         return platform_device_add(pdev);
342 }
343 EXPORT_SYMBOL_GPL(platform_device_register);
344
345 /**
346  * platform_device_unregister - unregister a platform-level device
347  * @pdev: platform device we're unregistering
348  *
349  * Unregistration is done in 2 steps. First we release all resources
350  * and remove it from the subsystem, then we drop reference count by
351  * calling platform_device_put().
352  */
353 void platform_device_unregister(struct platform_device *pdev)
354 {
355         platform_device_del(pdev);
356         platform_device_put(pdev);
357 }
358 EXPORT_SYMBOL_GPL(platform_device_unregister);
359
360 /**
361  * platform_device_register_simple
362  * @name: base name of the device we're adding
363  * @id: instance id
364  * @res: set of resources that needs to be allocated for the device
365  * @num: number of resources
366  *
367  * This function creates a simple platform device that requires minimal
368  * resource and memory management. Canned release function freeing memory
369  * allocated for the device allows drivers using such devices to be
370  * unloaded without waiting for the last reference to the device to be
371  * dropped.
372  *
373  * This interface is primarily intended for use with legacy drivers which
374  * probe hardware directly.  Because such drivers create sysfs device nodes
375  * themselves, rather than letting system infrastructure handle such device
376  * enumeration tasks, they don't fully conform to the Linux driver model.
377  * In particular, when such drivers are built as modules, they can't be
378  * "hotplugged".
379  */
380 struct platform_device *platform_device_register_simple(const char *name,
381                                                         int id,
382                                                         struct resource *res,
383                                                         unsigned int num)
384 {
385         struct platform_device *pdev;
386         int retval;
387
388         pdev = platform_device_alloc(name, id);
389         if (!pdev) {
390                 retval = -ENOMEM;
391                 goto error;
392         }
393
394         if (num) {
395                 retval = platform_device_add_resources(pdev, res, num);
396                 if (retval)
397                         goto error;
398         }
399
400         retval = platform_device_add(pdev);
401         if (retval)
402                 goto error;
403
404         return pdev;
405
406 error:
407         platform_device_put(pdev);
408         return ERR_PTR(retval);
409 }
410 EXPORT_SYMBOL_GPL(platform_device_register_simple);
411
412 /**
413  * platform_device_register_data
414  * @parent: parent device for the device we're adding
415  * @name: base name of the device we're adding
416  * @id: instance id
417  * @data: platform specific data for this platform device
418  * @size: size of platform specific data
419  *
420  * This function creates a simple platform device that requires minimal
421  * resource and memory management. Canned release function freeing memory
422  * allocated for the device allows drivers using such devices to be
423  * unloaded without waiting for the last reference to the device to be
424  * dropped.
425  */
426 struct platform_device *platform_device_register_data(
427                 struct device *parent,
428                 const char *name, int id,
429                 const void *data, size_t size)
430 {
431         struct platform_device *pdev;
432         int retval;
433
434         pdev = platform_device_alloc(name, id);
435         if (!pdev) {
436                 retval = -ENOMEM;
437                 goto error;
438         }
439
440         pdev->dev.parent = parent;
441
442         if (size) {
443                 retval = platform_device_add_data(pdev, data, size);
444                 if (retval)
445                         goto error;
446         }
447
448         retval = platform_device_add(pdev);
449         if (retval)
450                 goto error;
451
452         return pdev;
453
454 error:
455         platform_device_put(pdev);
456         return ERR_PTR(retval);
457 }
458
459 static int platform_drv_probe(struct device *_dev)
460 {
461         struct platform_driver *drv = to_platform_driver(_dev->driver);
462         struct platform_device *dev = to_platform_device(_dev);
463
464         return drv->probe(dev);
465 }
466
467 static int platform_drv_probe_fail(struct device *_dev)
468 {
469         return -ENXIO;
470 }
471
472 static int platform_drv_remove(struct device *_dev)
473 {
474         struct platform_driver *drv = to_platform_driver(_dev->driver);
475         struct platform_device *dev = to_platform_device(_dev);
476
477         return drv->remove(dev);
478 }
479
480 static void platform_drv_shutdown(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         drv->shutdown(dev);
486 }
487
488 static int platform_drv_suspend(struct device *_dev, pm_message_t state)
489 {
490         struct platform_driver *drv = to_platform_driver(_dev->driver);
491         struct platform_device *dev = to_platform_device(_dev);
492
493         return drv->suspend(dev, state);
494 }
495
496 static int platform_drv_resume(struct device *_dev)
497 {
498         struct platform_driver *drv = to_platform_driver(_dev->driver);
499         struct platform_device *dev = to_platform_device(_dev);
500
501         return drv->resume(dev);
502 }
503
504 /**
505  * platform_driver_register
506  * @drv: platform driver structure
507  */
508 int platform_driver_register(struct platform_driver *drv)
509 {
510         drv->driver.bus = &platform_bus_type;
511         if (drv->probe)
512                 drv->driver.probe = platform_drv_probe;
513         if (drv->remove)
514                 drv->driver.remove = platform_drv_remove;
515         if (drv->shutdown)
516                 drv->driver.shutdown = platform_drv_shutdown;
517         if (drv->suspend)
518                 drv->driver.suspend = platform_drv_suspend;
519         if (drv->resume)
520                 drv->driver.resume = platform_drv_resume;
521         return driver_register(&drv->driver);
522 }
523 EXPORT_SYMBOL_GPL(platform_driver_register);
524
525 /**
526  * platform_driver_unregister
527  * @drv: platform driver structure
528  */
529 void platform_driver_unregister(struct platform_driver *drv)
530 {
531         driver_unregister(&drv->driver);
532 }
533 EXPORT_SYMBOL_GPL(platform_driver_unregister);
534
535 /**
536  * platform_driver_probe - register driver for non-hotpluggable device
537  * @drv: platform driver structure
538  * @probe: the driver probe routine, probably from an __init section
539  *
540  * Use this instead of platform_driver_register() when you know the device
541  * is not hotpluggable and has already been registered, and you want to
542  * remove its run-once probe() infrastructure from memory after the driver
543  * has bound to the device.
544  *
545  * One typical use for this would be with drivers for controllers integrated
546  * into system-on-chip processors, where the controller devices have been
547  * configured as part of board setup.
548  *
549  * Returns zero if the driver registered and bound to a device, else returns
550  * a negative error code and with the driver not registered.
551  */
552 int __init_or_module platform_driver_probe(struct platform_driver *drv,
553                 int (*probe)(struct platform_device *))
554 {
555         int retval, code;
556
557         /* temporary section violation during probe() */
558         drv->probe = probe;
559         retval = code = platform_driver_register(drv);
560
561         /* Fixup that section violation, being paranoid about code scanning
562          * the list of drivers in order to probe new devices.  Check to see
563          * if the probe was successful, and make sure any forced probes of
564          * new devices fail.
565          */
566         spin_lock(&platform_bus_type.p->klist_drivers.k_lock);
567         drv->probe = NULL;
568         if (code == 0 && list_empty(&drv->driver.p->klist_devices.k_list))
569                 retval = -ENODEV;
570         drv->driver.probe = platform_drv_probe_fail;
571         spin_unlock(&platform_bus_type.p->klist_drivers.k_lock);
572
573         if (code != retval)
574                 platform_driver_unregister(drv);
575         return retval;
576 }
577 EXPORT_SYMBOL_GPL(platform_driver_probe);
578
579 /* modalias support enables more hands-off userspace setup:
580  * (a) environment variable lets new-style hotplug events work once system is
581  *     fully running:  "modprobe $MODALIAS"
582  * (b) sysfs attribute lets new-style coldplug recover from hotplug events
583  *     mishandled before system is fully running:  "modprobe $(cat modalias)"
584  */
585 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
586                              char *buf)
587 {
588         struct platform_device  *pdev = to_platform_device(dev);
589         int len = snprintf(buf, PAGE_SIZE, "platform:%s\n", pdev->name);
590
591         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
592 }
593
594 static struct device_attribute platform_dev_attrs[] = {
595         __ATTR_RO(modalias),
596         __ATTR_NULL,
597 };
598
599 static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
600 {
601         struct platform_device  *pdev = to_platform_device(dev);
602
603         add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX,
604                 (pdev->id_entry) ? pdev->id_entry->name : pdev->name);
605         return 0;
606 }
607
608 static const struct platform_device_id *platform_match_id(
609                         struct platform_device_id *id,
610                         struct platform_device *pdev)
611 {
612         while (id->name[0]) {
613                 if (strcmp(pdev->name, id->name) == 0) {
614                         pdev->id_entry = id;
615                         return id;
616                 }
617                 id++;
618         }
619         return NULL;
620 }
621
622 /**
623  * platform_match - bind platform device to platform driver.
624  * @dev: device.
625  * @drv: driver.
626  *
627  * Platform device IDs are assumed to be encoded like this:
628  * "<name><instance>", where <name> is a short description of the type of
629  * device, like "pci" or "floppy", and <instance> is the enumerated
630  * instance of the device, like '0' or '42'.  Driver IDs are simply
631  * "<name>".  So, extract the <name> from the platform_device structure,
632  * and compare it against the name of the driver. Return whether they match
633  * or not.
634  */
635 static int platform_match(struct device *dev, struct device_driver *drv)
636 {
637         struct platform_device *pdev = to_platform_device(dev);
638         struct platform_driver *pdrv = to_platform_driver(drv);
639
640         /* match against the id table first */
641         if (pdrv->id_table)
642                 return platform_match_id(pdrv->id_table, pdev) != NULL;
643
644         /* fall-back to driver name match */
645         return (strcmp(pdev->name, drv->name) == 0);
646 }
647
648 #ifdef CONFIG_PM_SLEEP
649
650 static int platform_legacy_suspend(struct device *dev, pm_message_t mesg)
651 {
652         int ret = 0;
653
654         if (dev->driver && dev->driver->suspend)
655                 ret = dev->driver->suspend(dev, mesg);
656
657         return ret;
658 }
659
660 static int platform_legacy_suspend_late(struct device *dev, pm_message_t mesg)
661 {
662         struct platform_driver *pdrv = to_platform_driver(dev->driver);
663         struct platform_device *pdev = to_platform_device(dev);
664         int ret = 0;
665
666         if (dev->driver && pdrv->suspend_late)
667                 ret = pdrv->suspend_late(pdev, mesg);
668
669         return ret;
670 }
671
672 static int platform_legacy_resume_early(struct device *dev)
673 {
674         struct platform_driver *pdrv = to_platform_driver(dev->driver);
675         struct platform_device *pdev = to_platform_device(dev);
676         int ret = 0;
677
678         if (dev->driver && pdrv->resume_early)
679                 ret = pdrv->resume_early(pdev);
680
681         return ret;
682 }
683
684 static int platform_legacy_resume(struct device *dev)
685 {
686         int ret = 0;
687
688         if (dev->driver && dev->driver->resume)
689                 ret = dev->driver->resume(dev);
690
691         return ret;
692 }
693
694 static int platform_pm_prepare(struct device *dev)
695 {
696         struct device_driver *drv = dev->driver;
697         int ret = 0;
698
699         if (drv && drv->pm && drv->pm->prepare)
700                 ret = drv->pm->prepare(dev);
701
702         return ret;
703 }
704
705 static void platform_pm_complete(struct device *dev)
706 {
707         struct device_driver *drv = dev->driver;
708
709         if (drv && drv->pm && drv->pm->complete)
710                 drv->pm->complete(dev);
711 }
712
713 #ifdef CONFIG_SUSPEND
714
715 static int platform_pm_suspend(struct device *dev)
716 {
717         struct device_driver *drv = dev->driver;
718         int ret = 0;
719
720         if (!drv)
721                 return 0;
722
723         if (drv->pm) {
724                 if (drv->pm->suspend)
725                         ret = drv->pm->suspend(dev);
726         } else {
727                 ret = platform_legacy_suspend(dev, PMSG_SUSPEND);
728         }
729
730         return ret;
731 }
732
733 static int platform_pm_suspend_noirq(struct device *dev)
734 {
735         struct device_driver *drv = dev->driver;
736         int ret = 0;
737
738         if (!drv)
739                 return 0;
740
741         if (drv->pm) {
742                 if (drv->pm->suspend_noirq)
743                         ret = drv->pm->suspend_noirq(dev);
744         } else {
745                 ret = platform_legacy_suspend_late(dev, PMSG_SUSPEND);
746         }
747
748         return ret;
749 }
750
751 static int platform_pm_resume(struct device *dev)
752 {
753         struct device_driver *drv = dev->driver;
754         int ret = 0;
755
756         if (!drv)
757                 return 0;
758
759         if (drv->pm) {
760                 if (drv->pm->resume)
761                         ret = drv->pm->resume(dev);
762         } else {
763                 ret = platform_legacy_resume(dev);
764         }
765
766         return ret;
767 }
768
769 static int platform_pm_resume_noirq(struct device *dev)
770 {
771         struct device_driver *drv = dev->driver;
772         int ret = 0;
773
774         if (!drv)
775                 return 0;
776
777         if (drv->pm) {
778                 if (drv->pm->resume_noirq)
779                         ret = drv->pm->resume_noirq(dev);
780         } else {
781                 ret = platform_legacy_resume_early(dev);
782         }
783
784         return ret;
785 }
786
787 #else /* !CONFIG_SUSPEND */
788
789 #define platform_pm_suspend             NULL
790 #define platform_pm_resume              NULL
791 #define platform_pm_suspend_noirq       NULL
792 #define platform_pm_resume_noirq        NULL
793
794 #endif /* !CONFIG_SUSPEND */
795
796 #ifdef CONFIG_HIBERNATION
797
798 static int platform_pm_freeze(struct device *dev)
799 {
800         struct device_driver *drv = dev->driver;
801         int ret = 0;
802
803         if (!drv)
804                 return 0;
805
806         if (drv->pm) {
807                 if (drv->pm->freeze)
808                         ret = drv->pm->freeze(dev);
809         } else {
810                 ret = platform_legacy_suspend(dev, PMSG_FREEZE);
811         }
812
813         return ret;
814 }
815
816 static int platform_pm_freeze_noirq(struct device *dev)
817 {
818         struct device_driver *drv = dev->driver;
819         int ret = 0;
820
821         if (!drv)
822                 return 0;
823
824         if (drv->pm) {
825                 if (drv->pm->freeze_noirq)
826                         ret = drv->pm->freeze_noirq(dev);
827         } else {
828                 ret = platform_legacy_suspend_late(dev, PMSG_FREEZE);
829         }
830
831         return ret;
832 }
833
834 static int platform_pm_thaw(struct device *dev)
835 {
836         struct device_driver *drv = dev->driver;
837         int ret = 0;
838
839         if (!drv)
840                 return 0;
841
842         if (drv->pm) {
843                 if (drv->pm->thaw)
844                         ret = drv->pm->thaw(dev);
845         } else {
846                 ret = platform_legacy_resume(dev);
847         }
848
849         return ret;
850 }
851
852 static int platform_pm_thaw_noirq(struct device *dev)
853 {
854         struct device_driver *drv = dev->driver;
855         int ret = 0;
856
857         if (!drv)
858                 return 0;
859
860         if (drv->pm) {
861                 if (drv->pm->thaw_noirq)
862                         ret = drv->pm->thaw_noirq(dev);
863         } else {
864                 ret = platform_legacy_resume_early(dev);
865         }
866
867         return ret;
868 }
869
870 static int platform_pm_poweroff(struct device *dev)
871 {
872         struct device_driver *drv = dev->driver;
873         int ret = 0;
874
875         if (!drv)
876                 return 0;
877
878         if (drv->pm) {
879                 if (drv->pm->poweroff)
880                         ret = drv->pm->poweroff(dev);
881         } else {
882                 ret = platform_legacy_suspend(dev, PMSG_HIBERNATE);
883         }
884
885         return ret;
886 }
887
888 static int platform_pm_poweroff_noirq(struct device *dev)
889 {
890         struct device_driver *drv = dev->driver;
891         int ret = 0;
892
893         if (!drv)
894                 return 0;
895
896         if (drv->pm) {
897                 if (drv->pm->poweroff_noirq)
898                         ret = drv->pm->poweroff_noirq(dev);
899         } else {
900                 ret = platform_legacy_suspend_late(dev, PMSG_HIBERNATE);
901         }
902
903         return ret;
904 }
905
906 static int platform_pm_restore(struct device *dev)
907 {
908         struct device_driver *drv = dev->driver;
909         int ret = 0;
910
911         if (!drv)
912                 return 0;
913
914         if (drv->pm) {
915                 if (drv->pm->restore)
916                         ret = drv->pm->restore(dev);
917         } else {
918                 ret = platform_legacy_resume(dev);
919         }
920
921         return ret;
922 }
923
924 static int platform_pm_restore_noirq(struct device *dev)
925 {
926         struct device_driver *drv = dev->driver;
927         int ret = 0;
928
929         if (!drv)
930                 return 0;
931
932         if (drv->pm) {
933                 if (drv->pm->restore_noirq)
934                         ret = drv->pm->restore_noirq(dev);
935         } else {
936                 ret = platform_legacy_resume_early(dev);
937         }
938
939         return ret;
940 }
941
942 #else /* !CONFIG_HIBERNATION */
943
944 #define platform_pm_freeze              NULL
945 #define platform_pm_thaw                NULL
946 #define platform_pm_poweroff            NULL
947 #define platform_pm_restore             NULL
948 #define platform_pm_freeze_noirq        NULL
949 #define platform_pm_thaw_noirq          NULL
950 #define platform_pm_poweroff_noirq      NULL
951 #define platform_pm_restore_noirq       NULL
952
953 #endif /* !CONFIG_HIBERNATION */
954
955 static struct dev_pm_ops platform_dev_pm_ops = {
956         .prepare = platform_pm_prepare,
957         .complete = platform_pm_complete,
958         .suspend = platform_pm_suspend,
959         .resume = platform_pm_resume,
960         .freeze = platform_pm_freeze,
961         .thaw = platform_pm_thaw,
962         .poweroff = platform_pm_poweroff,
963         .restore = platform_pm_restore,
964         .suspend_noirq = platform_pm_suspend_noirq,
965         .resume_noirq = platform_pm_resume_noirq,
966         .freeze_noirq = platform_pm_freeze_noirq,
967         .thaw_noirq = platform_pm_thaw_noirq,
968         .poweroff_noirq = platform_pm_poweroff_noirq,
969         .restore_noirq = platform_pm_restore_noirq,
970 };
971
972 #define PLATFORM_PM_OPS_PTR     (&platform_dev_pm_ops)
973
974 #else /* !CONFIG_PM_SLEEP */
975
976 #define PLATFORM_PM_OPS_PTR     NULL
977
978 #endif /* !CONFIG_PM_SLEEP */
979
980 struct bus_type platform_bus_type = {
981         .name           = "platform",
982         .dev_attrs      = platform_dev_attrs,
983         .match          = platform_match,
984         .uevent         = platform_uevent,
985         .pm             = PLATFORM_PM_OPS_PTR,
986 };
987 EXPORT_SYMBOL_GPL(platform_bus_type);
988
989 int __init platform_bus_init(void)
990 {
991         int error;
992
993         early_platform_cleanup();
994
995         error = device_register(&platform_bus);
996         if (error)
997                 return error;
998         error =  bus_register(&platform_bus_type);
999         if (error)
1000                 device_unregister(&platform_bus);
1001         return error;
1002 }
1003
1004 #ifndef ARCH_HAS_DMA_GET_REQUIRED_MASK
1005 u64 dma_get_required_mask(struct device *dev)
1006 {
1007         u32 low_totalram = ((max_pfn - 1) << PAGE_SHIFT);
1008         u32 high_totalram = ((max_pfn - 1) >> (32 - PAGE_SHIFT));
1009         u64 mask;
1010
1011         if (!high_totalram) {
1012                 /* convert to mask just covering totalram */
1013                 low_totalram = (1 << (fls(low_totalram) - 1));
1014                 low_totalram += low_totalram - 1;
1015                 mask = low_totalram;
1016         } else {
1017                 high_totalram = (1 << (fls(high_totalram) - 1));
1018                 high_totalram += high_totalram - 1;
1019                 mask = (((u64)high_totalram) << 32) + 0xffffffff;
1020         }
1021         return mask;
1022 }
1023 EXPORT_SYMBOL_GPL(dma_get_required_mask);
1024 #endif
1025
1026 static __initdata LIST_HEAD(early_platform_driver_list);
1027 static __initdata LIST_HEAD(early_platform_device_list);
1028
1029 /**
1030  * early_platform_driver_register
1031  * @edrv: early_platform driver structure
1032  * @buf: string passed from early_param()
1033  */
1034 int __init early_platform_driver_register(struct early_platform_driver *epdrv,
1035                                           char *buf)
1036 {
1037         unsigned long index;
1038         int n;
1039
1040         /* Simply add the driver to the end of the global list.
1041          * Drivers will by default be put on the list in compiled-in order.
1042          */
1043         if (!epdrv->list.next) {
1044                 INIT_LIST_HEAD(&epdrv->list);
1045                 list_add_tail(&epdrv->list, &early_platform_driver_list);
1046         }
1047
1048         /* If the user has specified device then make sure the driver
1049          * gets prioritized. The driver of the last device specified on
1050          * command line will be put first on the list.
1051          */
1052         n = strlen(epdrv->pdrv->driver.name);
1053         if (buf && !strncmp(buf, epdrv->pdrv->driver.name, n)) {
1054                 list_move(&epdrv->list, &early_platform_driver_list);
1055
1056                 if (!strcmp(buf, epdrv->pdrv->driver.name))
1057                         epdrv->requested_id = -1;
1058                 else if (buf[n] == '.' && strict_strtoul(&buf[n + 1], 10,
1059                                                          &index) == 0)
1060                         epdrv->requested_id = index;
1061                 else
1062                         epdrv->requested_id = EARLY_PLATFORM_ID_ERROR;
1063         }
1064
1065         return 0;
1066 }
1067
1068 /**
1069  * early_platform_add_devices - add a numbers of early platform devices
1070  * @devs: array of early platform devices to add
1071  * @num: number of early platform devices in array
1072  */
1073 void __init early_platform_add_devices(struct platform_device **devs, int num)
1074 {
1075         struct device *dev;
1076         int i;
1077
1078         /* simply add the devices to list */
1079         for (i = 0; i < num; i++) {
1080                 dev = &devs[i]->dev;
1081
1082                 if (!dev->devres_head.next) {
1083                         INIT_LIST_HEAD(&dev->devres_head);
1084                         list_add_tail(&dev->devres_head,
1085                                       &early_platform_device_list);
1086                 }
1087         }
1088 }
1089
1090 /**
1091  * early_platform_driver_register_all
1092  * @class_str: string to identify early platform driver class
1093  */
1094 void __init early_platform_driver_register_all(char *class_str)
1095 {
1096         /* The "class_str" parameter may or may not be present on the kernel
1097          * command line. If it is present then there may be more than one
1098          * matching parameter.
1099          *
1100          * Since we register our early platform drivers using early_param()
1101          * we need to make sure that they also get registered in the case
1102          * when the parameter is missing from the kernel command line.
1103          *
1104          * We use parse_early_options() to make sure the early_param() gets
1105          * called at least once. The early_param() may be called more than
1106          * once since the name of the preferred device may be specified on
1107          * the kernel command line. early_platform_driver_register() handles
1108          * this case for us.
1109          */
1110         parse_early_options(class_str);
1111 }
1112
1113 /**
1114  * early_platform_match
1115  * @edrv: early platform driver structure
1116  * @id: id to match against
1117  */
1118 static  __init struct platform_device *
1119 early_platform_match(struct early_platform_driver *epdrv, int id)
1120 {
1121         struct platform_device *pd;
1122
1123         list_for_each_entry(pd, &early_platform_device_list, dev.devres_head)
1124                 if (platform_match(&pd->dev, &epdrv->pdrv->driver))
1125                         if (pd->id == id)
1126                                 return pd;
1127
1128         return NULL;
1129 }
1130
1131 /**
1132  * early_platform_left
1133  * @edrv: early platform driver structure
1134  * @id: return true if id or above exists
1135  */
1136 static  __init int early_platform_left(struct early_platform_driver *epdrv,
1137                                        int id)
1138 {
1139         struct platform_device *pd;
1140
1141         list_for_each_entry(pd, &early_platform_device_list, dev.devres_head)
1142                 if (platform_match(&pd->dev, &epdrv->pdrv->driver))
1143                         if (pd->id >= id)
1144                                 return 1;
1145
1146         return 0;
1147 }
1148
1149 /**
1150  * early_platform_driver_probe_id
1151  * @class_str: string to identify early platform driver class
1152  * @id: id to match against
1153  * @nr_probe: number of platform devices to successfully probe before exiting
1154  */
1155 static int __init early_platform_driver_probe_id(char *class_str,
1156                                                  int id,
1157                                                  int nr_probe)
1158 {
1159         struct early_platform_driver *epdrv;
1160         struct platform_device *match;
1161         int match_id;
1162         int n = 0;
1163         int left = 0;
1164
1165         list_for_each_entry(epdrv, &early_platform_driver_list, list) {
1166                 /* only use drivers matching our class_str */
1167                 if (strcmp(class_str, epdrv->class_str))
1168                         continue;
1169
1170                 if (id == -2) {
1171                         match_id = epdrv->requested_id;
1172                         left = 1;
1173
1174                 } else {
1175                         match_id = id;
1176                         left += early_platform_left(epdrv, id);
1177
1178                         /* skip requested id */
1179                         switch (epdrv->requested_id) {
1180                         case EARLY_PLATFORM_ID_ERROR:
1181                         case EARLY_PLATFORM_ID_UNSET:
1182                                 break;
1183                         default:
1184                                 if (epdrv->requested_id == id)
1185                                         match_id = EARLY_PLATFORM_ID_UNSET;
1186                         }
1187                 }
1188
1189                 switch (match_id) {
1190                 case EARLY_PLATFORM_ID_ERROR:
1191                         pr_warning("%s: unable to parse %s parameter\n",
1192                                    class_str, epdrv->pdrv->driver.name);
1193                         /* fall-through */
1194                 case EARLY_PLATFORM_ID_UNSET:
1195                         match = NULL;
1196                         break;
1197                 default:
1198                         match = early_platform_match(epdrv, match_id);
1199                 }
1200
1201                 if (match) {
1202                         if (epdrv->pdrv->probe(match))
1203                                 pr_warning("%s: unable to probe %s early.\n",
1204                                            class_str, match->name);
1205                         else
1206                                 n++;
1207                 }
1208
1209                 if (n >= nr_probe)
1210                         break;
1211         }
1212
1213         if (left)
1214                 return n;
1215         else
1216                 return -ENODEV;
1217 }
1218
1219 /**
1220  * early_platform_driver_probe
1221  * @class_str: string to identify early platform driver class
1222  * @nr_probe: number of platform devices to successfully probe before exiting
1223  * @user_only: only probe user specified early platform devices
1224  */
1225 int __init early_platform_driver_probe(char *class_str,
1226                                        int nr_probe,
1227                                        int user_only)
1228 {
1229         int k, n, i;
1230
1231         n = 0;
1232         for (i = -2; n < nr_probe; i++) {
1233                 k = early_platform_driver_probe_id(class_str, i, nr_probe - n);
1234
1235                 if (k < 0)
1236                         break;
1237
1238                 n += k;
1239
1240                 if (user_only)
1241                         break;
1242         }
1243
1244         return n;
1245 }
1246
1247 /**
1248  * early_platform_cleanup - clean up early platform code
1249  */
1250 void __init early_platform_cleanup(void)
1251 {
1252         struct platform_device *pd, *pd2;
1253
1254         /* clean up the devres list used to chain devices */
1255         list_for_each_entry_safe(pd, pd2, &early_platform_device_list,
1256                                  dev.devres_head) {
1257                 list_del(&pd->dev.devres_head);
1258                 memset(&pd->dev.devres_head, 0, sizeof(pd->dev.devres_head));
1259         }
1260 }
1261