← Back to branch summary

~ubuntu-branches/ubuntu/saucy/linux-n900/saucy

« back to all changes in this revision

Viewing changes to drivers/base/platform.c

  • Committer: Bazaar Package Importer
  • Author(s): Mathieu Poirier
  • Date: 2011-02-18 09:43:31 UTC
  • Revision ID: james.westby@ubuntu.com-20110218094331-eyubsja4f9k0yhmq
Tags: 2.6.35-1.1
Initial release.

Show diffs side-by-side

added added

removed removed

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