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