2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* platform.c - platform 'pseudo' bus for legacy devices
|
|
|
|
*
|
|
|
|
* Copyright (c) 2002-3 Patrick Mochel
|
|
|
|
* Copyright (c) 2002-3 Open Source Development Labs
|
|
|
|
*
|
|
|
|
* This file is released under the GPLv2
|
|
|
|
*
|
|
|
|
* Please see Documentation/driver-model/platform.txt for more
|
|
|
|
* information.
|
|
|
|
*/
|
|
|
|
|
2009-08-06 23:00:44 +00:00
|
|
|
#include <linux/string.h>
|
2005-10-29 18:07:23 +00:00
|
|
|
#include <linux/platform_device.h>
|
2010-06-08 13:48:20 +00:00
|
|
|
#include <linux/of_device.h>
|
2014-04-23 22:57:41 +00:00
|
|
|
#include <linux/of_irq.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/bootmem.h>
|
|
|
|
#include <linux/err.h>
|
2005-10-30 23:03:48 +00:00
|
|
|
#include <linux/slab.h>
|
2009-08-20 18:25:32 +00:00
|
|
|
#include <linux/pm_runtime.h>
|
2014-09-29 11:58:47 +00:00
|
|
|
#include <linux/pm_domain.h>
|
2012-07-27 20:14:59 +00:00
|
|
|
#include <linux/idr.h>
|
2012-10-31 21:45:02 +00:00
|
|
|
#include <linux/acpi.h>
|
2014-06-18 15:29:32 +00:00
|
|
|
#include <linux/clk/clk-conf.h>
|
2014-06-03 00:42:58 +00:00
|
|
|
#include <linux/limits.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-13 16:54:41 +00:00
|
|
|
#include "base.h"
|
2012-08-05 23:45:11 +00:00
|
|
|
#include "power/power.h"
|
2005-10-13 16:54:41 +00:00
|
|
|
|
2012-07-27 20:14:59 +00:00
|
|
|
/* For automatically allocated device IDs */
|
|
|
|
static DEFINE_IDA(platform_devid_ida);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct device platform_bus = {
|
2008-10-30 00:36:48 +00:00
|
|
|
.init_name = "platform",
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
2005-12-10 06:36:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(platform_bus);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-06-10 06:52:57 +00:00
|
|
|
/**
|
|
|
|
* arch_setup_pdev_archdata - Allow manipulation of archdata before its used
|
2011-07-27 19:11:25 +00:00
|
|
|
* @pdev: platform device
|
2011-06-10 06:52:57 +00:00
|
|
|
*
|
|
|
|
* This is called before platform_device_add() such that any pdev_archdata may
|
|
|
|
* be setup before the platform_notifier is called. So if a user needs to
|
|
|
|
* manipulate any relevant information in the pdev_archdata they can do:
|
|
|
|
*
|
2012-10-29 17:04:53 +00:00
|
|
|
* platform_device_alloc()
|
2013-03-26 09:35:16 +00:00
|
|
|
* ... manipulate ...
|
|
|
|
* platform_device_add()
|
2011-06-10 06:52:57 +00:00
|
|
|
*
|
|
|
|
* And if they don't care they can just call platform_device_register() and
|
|
|
|
* everything will just work out.
|
|
|
|
*/
|
|
|
|
void __weak arch_setup_pdev_archdata(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* platform_get_resource - get a resource for a device
|
|
|
|
* @dev: platform device
|
|
|
|
* @type: resource type
|
|
|
|
* @num: resource index
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-01-25 06:50:12 +00:00
|
|
|
struct resource *platform_get_resource(struct platform_device *dev,
|
|
|
|
unsigned int type, unsigned int num)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < dev->num_resources; i++) {
|
|
|
|
struct resource *r = &dev->resource[i];
|
|
|
|
|
2008-10-16 05:05:15 +00:00
|
|
|
if (type == resource_type(r) && num-- == 0)
|
|
|
|
return r;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2005-12-10 06:36:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(platform_get_resource);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* platform_get_irq - get an IRQ for a device
|
|
|
|
* @dev: platform device
|
|
|
|
* @num: IRQ number index
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
int platform_get_irq(struct platform_device *dev, unsigned int num)
|
|
|
|
{
|
2012-10-29 23:26:56 +00:00
|
|
|
#ifdef CONFIG_SPARC
|
|
|
|
/* sparc does not have irqs represented as IORESOURCE_IRQ resources */
|
|
|
|
if (!dev || num >= dev->archdata.num_irqs)
|
|
|
|
return -ENXIO;
|
|
|
|
return dev->archdata.irqs[num];
|
|
|
|
#else
|
2014-04-23 22:57:41 +00:00
|
|
|
struct resource *r;
|
2014-06-17 22:51:02 +00:00
|
|
|
if (IS_ENABLED(CONFIG_OF_IRQ) && dev->dev.of_node) {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = of_irq_get(dev->dev.of_node, num);
|
|
|
|
if (ret >= 0 || ret == -EPROBE_DEFER)
|
|
|
|
return ret;
|
|
|
|
}
|
2014-04-23 22:57:41 +00:00
|
|
|
|
|
|
|
r = platform_get_resource(dev, IORESOURCE_IRQ, num);
|
2015-02-18 16:12:18 +00:00
|
|
|
/*
|
|
|
|
* The resources may pass trigger flags to the irqs that need
|
|
|
|
* to be set up. It so happens that the trigger flags for
|
|
|
|
* IORESOURCE_BITS correspond 1-to-1 to the IRQF_TRIGGER*
|
|
|
|
* settings.
|
|
|
|
*/
|
|
|
|
if (r && r->flags & IORESOURCE_BITS)
|
|
|
|
irqd_set_trigger_type(irq_get_irq_data(r->start),
|
|
|
|
r->flags & IORESOURCE_BITS);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-19 17:52:27 +00:00
|
|
|
return r ? r->start : -ENXIO;
|
2012-10-29 23:26:56 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2005-12-10 06:36:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(platform_get_irq);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* platform_get_resource_byname - get a resource for a device by name
|
|
|
|
* @dev: platform device
|
|
|
|
* @type: resource type
|
|
|
|
* @name: resource name
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-01-25 06:50:12 +00:00
|
|
|
struct resource *platform_get_resource_byname(struct platform_device *dev,
|
2009-04-27 00:38:16 +00:00
|
|
|
unsigned int type,
|
|
|
|
const char *name)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < dev->num_resources; i++) {
|
|
|
|
struct resource *r = &dev->resource[i];
|
|
|
|
|
2012-08-23 14:10:00 +00:00
|
|
|
if (unlikely(!r->name))
|
|
|
|
continue;
|
|
|
|
|
2008-10-16 05:05:15 +00:00
|
|
|
if (type == resource_type(r) && !strcmp(r->name, name))
|
|
|
|
return r;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2005-12-10 06:36:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(platform_get_resource_byname);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/**
|
2012-11-13 16:47:13 +00:00
|
|
|
* platform_get_irq_byname - get an IRQ for a device by name
|
2008-01-25 06:50:12 +00:00
|
|
|
* @dev: platform device
|
|
|
|
* @name: IRQ name
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2009-04-27 00:38:16 +00:00
|
|
|
int platform_get_irq_byname(struct platform_device *dev, const char *name)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-05-20 10:42:02 +00:00
|
|
|
struct resource *r;
|
|
|
|
|
2014-06-17 22:51:02 +00:00
|
|
|
if (IS_ENABLED(CONFIG_OF_IRQ) && dev->dev.of_node) {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = of_irq_get_byname(dev->dev.of_node, name);
|
|
|
|
if (ret >= 0 || ret == -EPROBE_DEFER)
|
|
|
|
return ret;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-05-20 10:42:02 +00:00
|
|
|
r = platform_get_resource_byname(dev, IORESOURCE_IRQ, name);
|
2006-01-19 17:52:27 +00:00
|
|
|
return r ? r->start : -ENXIO;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2005-12-10 06:36:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(platform_get_irq_byname);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* platform_add_devices - add a numbers of platform devices
|
|
|
|
* @devs: array of platform devices to add
|
|
|
|
* @num: number of platform devices in array
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
int platform_add_devices(struct platform_device **devs, int num)
|
|
|
|
{
|
|
|
|
int i, ret = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < num; i++) {
|
|
|
|
ret = platform_device_register(devs[i]);
|
|
|
|
if (ret) {
|
|
|
|
while (--i >= 0)
|
|
|
|
platform_device_unregister(devs[i]);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2005-12-10 06:36:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(platform_add_devices);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-11-05 21:19:33 +00:00
|
|
|
struct platform_object {
|
|
|
|
struct platform_device pdev;
|
driver core/platform: remove unused implicit padding in platform_object
Up to 7 bytes are wasted at the end of struct platform_object
in the form of padding after name field: unfortunately this
padding is not used when allocating the memory to hold the
name.
This patch converts name array from name[1] to C99 flexible
array name[] (equivalent to name[0]) so that no padding is
required by the presence of this field. Memory allocation
is updated to take care of allocating an additional byte for
the NUL terminating character.
Built on Fedora 20, using GCC 4.8, for ARM, i386, SPARC64 and
x86_64 architectures, the data structure layout can be reported
with following command:
$ pahole drivers/base/platform.o \
--recursive \
--class_name device,pdev_archdata,platform_device,platform_object
Please find below some comparisons of structure layout for arm,
i386, sparc64 and x86_64 architecture before and after the patch.
--- obj-arm/drivers/base/platform.o.pahole.v3.15-rc7-79-gfe45736f4134 2014-05-30 10:32:06.290960701 +0200
+++ obj-arm/drivers/base/platform.o.pahole.v3.15-rc7-80-g2cdb06858d71 2014-05-30 11:26:20.851988347 +0200
@@ -81,10 +81,9 @@
/* XXX last struct has 4 bytes of padding */
/* --- cacheline 6 boundary (384 bytes) was 8 bytes ago --- */
- char name[1]; /* 392 1 */
+ char name[0]; /* 392 0 */
- /* size: 400, cachelines: 7, members: 2 */
- /* padding: 7 */
+ /* size: 392, cachelines: 7, members: 2 */
/* paddings: 1, sum paddings: 4 */
- /* last cacheline: 16 bytes */
+ /* last cacheline: 8 bytes */
};
--- obj-i386/drivers/base/platform.o.pahole.v3.15-rc7-79-gfe45736f4134 2014-05-30 10:32:06.305960691 +0200
+++ obj-i386/drivers/base/platform.o.pahole.v3.15-rc7-80-g2cdb06858d71 2014-05-30 11:26:20.875988332 +0200
@@ -73,9 +73,8 @@
struct platform_object {
struct platform_device pdev; /* 0 396 */
/* --- cacheline 6 boundary (384 bytes) was 12 bytes ago --- */
- char name[1]; /* 396 1 */
+ char name[0]; /* 396 0 */
- /* size: 400, cachelines: 7, members: 2 */
- /* padding: 3 */
- /* last cacheline: 16 bytes */
+ /* size: 396, cachelines: 7, members: 2 */
+ /* last cacheline: 12 bytes */
};
--- obj-sparc64/drivers/base/platform.o.pahole.v3.15-rc7-79-gfe45736f4134 2014-05-30 10:32:06.406960625 +0200
+++ obj-sparc64/drivers/base/platform.o.pahole.v3.15-rc7-80-g2cdb06858d71 2014-05-30 11:26:20.971988269 +0200
@@ -94,9 +94,8 @@
struct platform_object {
struct platform_device pdev; /* 0 2208 */
/* --- cacheline 34 boundary (2176 bytes) was 32 bytes ago --- */
- char name[1]; /* 2208 1 */
+ char name[0]; /* 2208 0 */
- /* size: 2216, cachelines: 35, members: 2 */
- /* padding: 7 */
- /* last cacheline: 40 bytes */
+ /* size: 2208, cachelines: 35, members: 2 */
+ /* last cacheline: 32 bytes */
};
--- obj-x86_64/drivers/base/platform.o.pahole.v3.15-rc7-79-gfe45736f4134 2014-05-30 10:32:06.432960608 +0200
+++ obj-x86_64/drivers/base/platform.o.pahole.v3.15-rc7-80-g2cdb06858d71 2014-05-30 11:26:21.000988250 +0200
@@ -84,9 +84,8 @@
struct platform_object {
struct platform_device pdev; /* 0 720 */
/* --- cacheline 11 boundary (704 bytes) was 16 bytes ago --- */
- char name[1]; /* 720 1 */
+ char name[0]; /* 720 0 */
- /* size: 728, cachelines: 12, members: 2 */
- /* padding: 7 */
- /* last cacheline: 24 bytes */
+ /* size: 720, cachelines: 12, members: 2 */
+ /* last cacheline: 16 bytes */
};
Changes from v5 [1]:
- dropped dma_mask allocation changes and only kept padding
removal changes (name array length set to 0).
Changes from v4 [2]:
[by Emil Goode <emilgoode@gmail.com>:]
- Split v4 of the patch into two separate patches.
- Generated new object file size and data structure layout info.
- Updated the changelog message.
Changes from v3 [3]:
- fixed commit message so that git am doesn't fail.
Changes from v2 [4]:
- move 'dma_mask' to platform_object so that it's always
allocated and won't leak on release; remove all previously
added support functions.
- use C99 flexible array member for 'name' to remove padding
at the end of platform_object.
Changes from v1 [5]:
- remove unneeded kfree() from error path
- add reference to author/commit adding allocation of dmamask
Changes from v0 [6]:
- small rewrite to squeeze the patch to a bare minimal
[1] http://lkml.kernel.org/r/1401122483-31603-2-git-send-email-emilgoode@gmail.com
http://lkml.kernel.org/r/1401122483-31603-1-git-send-email-emilgoode@gmail.com
http://lkml.kernel.org/r/1401122483-31603-3-git-send-email-emilgoode@gmail.com
[2] http://lkml.kernel.org/r/1390817152-30898-1-git-send-email-ydroneaud@opteya.com
https://patchwork.kernel.org/patch/3541871/
[3] http://lkml.kernel.org/r/1390771138-28348-1-git-send-email-ydroneaud@opteya.com
https://patchwork.kernel.org/patch/3540081/
[4] http://lkml.kernel.org/r/1389683909-17495-1-git-send-email-ydroneaud@opteya.com
https://patchwork.kernel.org/patch/3484411/
[5] http://lkml.kernel.org/r/1389649085-7365-1-git-send-email-ydroneaud@opteya.com
https://patchwork.kernel.org/patch/3480961/
[6] http://lkml.kernel.org/r/1386886207-2735-1-git-send-email-ydroneaud@opteya.com
Cc: Emil Goode <emilgoode@gmail.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Shawn Guo <shawn.guo@freescale.com>
Cc: Sascha Hauer <kernel@pengutronix.de>
Cc: Russell King <linux@arm.linux.org.uk>
Cc: Olof Johansson <olof@lixom.net>
Cc: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Cc: Dmitry Torokhov <dmitry.torokhov@gmail.com>
Signed-off-by: Yann Droneaud <ydroneaud@opteya.com>
Acked-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-05-30 20:02:47 +00:00
|
|
|
char name[];
|
2005-11-05 21:19:33 +00:00
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2010-02-14 14:18:53 +00:00
|
|
|
* platform_device_put - destroy a platform device
|
2008-01-25 06:50:12 +00:00
|
|
|
* @pdev: platform device to free
|
2005-11-05 21:19:33 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* Free all memory associated with a platform device. This function must
|
|
|
|
* _only_ be externally called in error cases. All other usage is a bug.
|
2005-11-05 21:19:33 +00:00
|
|
|
*/
|
|
|
|
void platform_device_put(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
if (pdev)
|
|
|
|
put_device(&pdev->dev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(platform_device_put);
|
|
|
|
|
|
|
|
static void platform_device_release(struct device *dev)
|
|
|
|
{
|
2008-01-25 06:50:12 +00:00
|
|
|
struct platform_object *pa = container_of(dev, struct platform_object,
|
|
|
|
pdev.dev);
|
2005-11-05 21:19:33 +00:00
|
|
|
|
2010-10-20 17:45:13 +00:00
|
|
|
of_device_node_put(&pa->pdev.dev);
|
2005-11-05 21:19:33 +00:00
|
|
|
kfree(pa->pdev.dev.platform_data);
|
2011-04-07 22:43:01 +00:00
|
|
|
kfree(pa->pdev.mfd_cell);
|
2005-11-05 21:19:33 +00:00
|
|
|
kfree(pa->pdev.resource);
|
2014-06-03 00:42:58 +00:00
|
|
|
kfree(pa->pdev.driver_override);
|
2005-11-05 21:19:33 +00:00
|
|
|
kfree(pa);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-02-14 14:18:53 +00:00
|
|
|
* platform_device_alloc - create a platform device
|
2008-01-25 06:50:12 +00:00
|
|
|
* @name: base name of the device we're adding
|
|
|
|
* @id: instance id
|
2005-11-05 21:19:33 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* Create a platform device object which can have other objects attached
|
|
|
|
* to it, and which will have attached objects freed when it is released.
|
2005-11-05 21:19:33 +00:00
|
|
|
*/
|
2007-09-09 10:54:16 +00:00
|
|
|
struct platform_device *platform_device_alloc(const char *name, int id)
|
2005-11-05 21:19:33 +00:00
|
|
|
{
|
|
|
|
struct platform_object *pa;
|
|
|
|
|
driver core/platform: remove unused implicit padding in platform_object
Up to 7 bytes are wasted at the end of struct platform_object
in the form of padding after name field: unfortunately this
padding is not used when allocating the memory to hold the
name.
This patch converts name array from name[1] to C99 flexible
array name[] (equivalent to name[0]) so that no padding is
required by the presence of this field. Memory allocation
is updated to take care of allocating an additional byte for
the NUL terminating character.
Built on Fedora 20, using GCC 4.8, for ARM, i386, SPARC64 and
x86_64 architectures, the data structure layout can be reported
with following command:
$ pahole drivers/base/platform.o \
--recursive \
--class_name device,pdev_archdata,platform_device,platform_object
Please find below some comparisons of structure layout for arm,
i386, sparc64 and x86_64 architecture before and after the patch.
--- obj-arm/drivers/base/platform.o.pahole.v3.15-rc7-79-gfe45736f4134 2014-05-30 10:32:06.290960701 +0200
+++ obj-arm/drivers/base/platform.o.pahole.v3.15-rc7-80-g2cdb06858d71 2014-05-30 11:26:20.851988347 +0200
@@ -81,10 +81,9 @@
/* XXX last struct has 4 bytes of padding */
/* --- cacheline 6 boundary (384 bytes) was 8 bytes ago --- */
- char name[1]; /* 392 1 */
+ char name[0]; /* 392 0 */
- /* size: 400, cachelines: 7, members: 2 */
- /* padding: 7 */
+ /* size: 392, cachelines: 7, members: 2 */
/* paddings: 1, sum paddings: 4 */
- /* last cacheline: 16 bytes */
+ /* last cacheline: 8 bytes */
};
--- obj-i386/drivers/base/platform.o.pahole.v3.15-rc7-79-gfe45736f4134 2014-05-30 10:32:06.305960691 +0200
+++ obj-i386/drivers/base/platform.o.pahole.v3.15-rc7-80-g2cdb06858d71 2014-05-30 11:26:20.875988332 +0200
@@ -73,9 +73,8 @@
struct platform_object {
struct platform_device pdev; /* 0 396 */
/* --- cacheline 6 boundary (384 bytes) was 12 bytes ago --- */
- char name[1]; /* 396 1 */
+ char name[0]; /* 396 0 */
- /* size: 400, cachelines: 7, members: 2 */
- /* padding: 3 */
- /* last cacheline: 16 bytes */
+ /* size: 396, cachelines: 7, members: 2 */
+ /* last cacheline: 12 bytes */
};
--- obj-sparc64/drivers/base/platform.o.pahole.v3.15-rc7-79-gfe45736f4134 2014-05-30 10:32:06.406960625 +0200
+++ obj-sparc64/drivers/base/platform.o.pahole.v3.15-rc7-80-g2cdb06858d71 2014-05-30 11:26:20.971988269 +0200
@@ -94,9 +94,8 @@
struct platform_object {
struct platform_device pdev; /* 0 2208 */
/* --- cacheline 34 boundary (2176 bytes) was 32 bytes ago --- */
- char name[1]; /* 2208 1 */
+ char name[0]; /* 2208 0 */
- /* size: 2216, cachelines: 35, members: 2 */
- /* padding: 7 */
- /* last cacheline: 40 bytes */
+ /* size: 2208, cachelines: 35, members: 2 */
+ /* last cacheline: 32 bytes */
};
--- obj-x86_64/drivers/base/platform.o.pahole.v3.15-rc7-79-gfe45736f4134 2014-05-30 10:32:06.432960608 +0200
+++ obj-x86_64/drivers/base/platform.o.pahole.v3.15-rc7-80-g2cdb06858d71 2014-05-30 11:26:21.000988250 +0200
@@ -84,9 +84,8 @@
struct platform_object {
struct platform_device pdev; /* 0 720 */
/* --- cacheline 11 boundary (704 bytes) was 16 bytes ago --- */
- char name[1]; /* 720 1 */
+ char name[0]; /* 720 0 */
- /* size: 728, cachelines: 12, members: 2 */
- /* padding: 7 */
- /* last cacheline: 24 bytes */
+ /* size: 720, cachelines: 12, members: 2 */
+ /* last cacheline: 16 bytes */
};
Changes from v5 [1]:
- dropped dma_mask allocation changes and only kept padding
removal changes (name array length set to 0).
Changes from v4 [2]:
[by Emil Goode <emilgoode@gmail.com>:]
- Split v4 of the patch into two separate patches.
- Generated new object file size and data structure layout info.
- Updated the changelog message.
Changes from v3 [3]:
- fixed commit message so that git am doesn't fail.
Changes from v2 [4]:
- move 'dma_mask' to platform_object so that it's always
allocated and won't leak on release; remove all previously
added support functions.
- use C99 flexible array member for 'name' to remove padding
at the end of platform_object.
Changes from v1 [5]:
- remove unneeded kfree() from error path
- add reference to author/commit adding allocation of dmamask
Changes from v0 [6]:
- small rewrite to squeeze the patch to a bare minimal
[1] http://lkml.kernel.org/r/1401122483-31603-2-git-send-email-emilgoode@gmail.com
http://lkml.kernel.org/r/1401122483-31603-1-git-send-email-emilgoode@gmail.com
http://lkml.kernel.org/r/1401122483-31603-3-git-send-email-emilgoode@gmail.com
[2] http://lkml.kernel.org/r/1390817152-30898-1-git-send-email-ydroneaud@opteya.com
https://patchwork.kernel.org/patch/3541871/
[3] http://lkml.kernel.org/r/1390771138-28348-1-git-send-email-ydroneaud@opteya.com
https://patchwork.kernel.org/patch/3540081/
[4] http://lkml.kernel.org/r/1389683909-17495-1-git-send-email-ydroneaud@opteya.com
https://patchwork.kernel.org/patch/3484411/
[5] http://lkml.kernel.org/r/1389649085-7365-1-git-send-email-ydroneaud@opteya.com
https://patchwork.kernel.org/patch/3480961/
[6] http://lkml.kernel.org/r/1386886207-2735-1-git-send-email-ydroneaud@opteya.com
Cc: Emil Goode <emilgoode@gmail.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Shawn Guo <shawn.guo@freescale.com>
Cc: Sascha Hauer <kernel@pengutronix.de>
Cc: Russell King <linux@arm.linux.org.uk>
Cc: Olof Johansson <olof@lixom.net>
Cc: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Cc: Dmitry Torokhov <dmitry.torokhov@gmail.com>
Signed-off-by: Yann Droneaud <ydroneaud@opteya.com>
Acked-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-05-30 20:02:47 +00:00
|
|
|
pa = kzalloc(sizeof(*pa) + strlen(name) + 1, GFP_KERNEL);
|
2005-11-05 21:19:33 +00:00
|
|
|
if (pa) {
|
|
|
|
strcpy(pa->name, name);
|
|
|
|
pa->pdev.name = pa->name;
|
|
|
|
pa->pdev.id = id;
|
|
|
|
device_initialize(&pa->pdev.dev);
|
|
|
|
pa->pdev.dev.release = platform_device_release;
|
2011-06-10 06:52:57 +00:00
|
|
|
arch_setup_pdev_archdata(&pa->pdev);
|
2005-11-05 21:19:33 +00:00
|
|
|
}
|
|
|
|
|
2005-12-10 06:36:27 +00:00
|
|
|
return pa ? &pa->pdev : NULL;
|
2005-11-05 21:19:33 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(platform_device_alloc);
|
|
|
|
|
|
|
|
/**
|
2010-02-14 14:18:53 +00:00
|
|
|
* platform_device_add_resources - add resources to a platform device
|
2008-01-25 06:50:12 +00:00
|
|
|
* @pdev: platform device allocated by platform_device_alloc to add resources to
|
|
|
|
* @res: set of resources that needs to be allocated for the device
|
|
|
|
* @num: number of resources
|
2005-11-05 21:19:33 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* Add a copy of the resources to the platform device. The memory
|
|
|
|
* associated with the resources will be freed when the platform device is
|
|
|
|
* released.
|
2005-11-05 21:19:33 +00:00
|
|
|
*/
|
2008-01-25 06:50:12 +00:00
|
|
|
int platform_device_add_resources(struct platform_device *pdev,
|
2009-01-28 20:01:02 +00:00
|
|
|
const struct resource *res, unsigned int num)
|
2005-11-05 21:19:33 +00:00
|
|
|
{
|
2011-04-20 07:44:44 +00:00
|
|
|
struct resource *r = NULL;
|
2005-11-05 21:19:33 +00:00
|
|
|
|
2011-04-20 07:44:44 +00:00
|
|
|
if (res) {
|
|
|
|
r = kmemdup(res, sizeof(struct resource) * num, GFP_KERNEL);
|
|
|
|
if (!r)
|
|
|
|
return -ENOMEM;
|
2005-11-05 21:19:33 +00:00
|
|
|
}
|
2011-04-20 07:44:44 +00:00
|
|
|
|
2011-04-20 07:44:45 +00:00
|
|
|
kfree(pdev->resource);
|
2011-04-20 07:44:44 +00:00
|
|
|
pdev->resource = r;
|
|
|
|
pdev->num_resources = num;
|
|
|
|
return 0;
|
2005-11-05 21:19:33 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(platform_device_add_resources);
|
|
|
|
|
|
|
|
/**
|
2010-02-14 14:18:53 +00:00
|
|
|
* platform_device_add_data - add platform-specific data to a platform device
|
2008-01-25 06:50:12 +00:00
|
|
|
* @pdev: platform device allocated by platform_device_alloc to add resources to
|
|
|
|
* @data: platform specific data for this platform device
|
|
|
|
* @size: size of platform specific data
|
2005-11-05 21:19:33 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* Add a copy of platform specific data to the platform device's
|
|
|
|
* platform_data pointer. The memory associated with the platform data
|
|
|
|
* will be freed when the platform device is released.
|
2005-11-05 21:19:33 +00:00
|
|
|
*/
|
2008-01-25 06:50:12 +00:00
|
|
|
int platform_device_add_data(struct platform_device *pdev, const void *data,
|
|
|
|
size_t size)
|
2005-11-05 21:19:33 +00:00
|
|
|
{
|
2011-04-20 07:44:42 +00:00
|
|
|
void *d = NULL;
|
2010-09-07 13:31:49 +00:00
|
|
|
|
2011-04-20 07:44:42 +00:00
|
|
|
if (data) {
|
|
|
|
d = kmemdup(data, size, GFP_KERNEL);
|
|
|
|
if (!d)
|
|
|
|
return -ENOMEM;
|
2005-11-05 21:19:33 +00:00
|
|
|
}
|
2011-04-20 07:44:42 +00:00
|
|
|
|
2011-04-20 07:44:43 +00:00
|
|
|
kfree(pdev->dev.platform_data);
|
2011-04-20 07:44:42 +00:00
|
|
|
pdev->dev.platform_data = d;
|
|
|
|
return 0;
|
2005-11-05 21:19:33 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(platform_device_add_data);
|
|
|
|
|
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* platform_device_add - add a platform device to device hierarchy
|
|
|
|
* @pdev: platform device we're adding
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* This is part 2 of platform_device_register(), though may be called
|
|
|
|
* separately _iff_ pdev was allocated by platform_device_alloc().
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2005-11-05 21:19:33 +00:00
|
|
|
int platform_device_add(struct platform_device *pdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2012-07-27 20:14:59 +00:00
|
|
|
int i, ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!pdev)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!pdev->dev.parent)
|
|
|
|
pdev->dev.parent = &platform_bus;
|
|
|
|
|
|
|
|
pdev->dev.bus = &platform_bus_type;
|
|
|
|
|
2012-07-27 20:14:59 +00:00
|
|
|
switch (pdev->id) {
|
|
|
|
default:
|
2008-10-30 00:36:48 +00:00
|
|
|
dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
|
2012-07-27 20:14:59 +00:00
|
|
|
break;
|
|
|
|
case PLATFORM_DEVID_NONE:
|
2009-06-02 22:39:55 +00:00
|
|
|
dev_set_name(&pdev->dev, "%s", pdev->name);
|
2012-07-27 20:14:59 +00:00
|
|
|
break;
|
|
|
|
case PLATFORM_DEVID_AUTO:
|
|
|
|
/*
|
|
|
|
* Automatically allocated device ID. We mark it as such so
|
|
|
|
* that we remember it must be freed, and we append a suffix
|
|
|
|
* to avoid namespace collision with explicit IDs.
|
|
|
|
*/
|
|
|
|
ret = ida_simple_get(&platform_devid_ida, 0, 0, GFP_KERNEL);
|
|
|
|
if (ret < 0)
|
2015-05-26 07:31:24 +00:00
|
|
|
return ret;
|
2012-07-27 20:14:59 +00:00
|
|
|
pdev->id = ret;
|
|
|
|
pdev->id_auto = true;
|
|
|
|
dev_set_name(&pdev->dev, "%s.%d.auto", pdev->name, pdev->id);
|
|
|
|
break;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
for (i = 0; i < pdev->num_resources; i++) {
|
2015-05-26 07:31:24 +00:00
|
|
|
struct resource *conflict, *p, *r = &pdev->resource[i];
|
2015-05-26 07:31:23 +00:00
|
|
|
unsigned long type = resource_type(r);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (r->name == NULL)
|
2008-10-30 00:36:48 +00:00
|
|
|
r->name = dev_name(&pdev->dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-05-26 07:31:23 +00:00
|
|
|
if (!(type == IORESOURCE_MEM || type == IORESOURCE_IO))
|
|
|
|
continue;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
p = r->parent;
|
|
|
|
if (!p) {
|
2015-05-26 07:31:23 +00:00
|
|
|
if (type == IORESOURCE_MEM)
|
2005-04-16 22:20:36 +00:00
|
|
|
p = &iomem_resource;
|
2015-05-26 07:31:23 +00:00
|
|
|
else if (type == IORESOURCE_IO)
|
2005-04-16 22:20:36 +00:00
|
|
|
p = &ioport_resource;
|
|
|
|
}
|
|
|
|
|
2015-05-26 07:31:24 +00:00
|
|
|
conflict = insert_resource_conflict(p, r);
|
|
|
|
if (!conflict)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
dev_err(&pdev->dev,
|
|
|
|
"ignoring resource %pR (conflicts with %s %pR)\n",
|
|
|
|
r, conflict->name, conflict);
|
|
|
|
p->parent = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pr_debug("Registering platform device '%s'. Parent at %s\n",
|
2008-10-30 00:36:48 +00:00
|
|
|
dev_name(&pdev->dev), dev_name(pdev->dev.parent));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-05-06 07:15:26 +00:00
|
|
|
ret = device_add(&pdev->dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ret == 0)
|
|
|
|
return ret;
|
|
|
|
|
2015-05-26 07:31:24 +00:00
|
|
|
/* Failure path */
|
2012-07-27 20:14:59 +00:00
|
|
|
if (pdev->id_auto) {
|
|
|
|
ida_simple_remove(&platform_devid_ida, pdev->id);
|
|
|
|
pdev->id = PLATFORM_DEVID_AUTO;
|
|
|
|
}
|
|
|
|
|
2008-10-16 05:05:15 +00:00
|
|
|
while (--i >= 0) {
|
|
|
|
struct resource *r = &pdev->resource[i];
|
|
|
|
unsigned long type = resource_type(r);
|
|
|
|
|
2015-05-26 07:31:24 +00:00
|
|
|
if ((type == IORESOURCE_MEM || type == IORESOURCE_IO) &&
|
|
|
|
r->parent)
|
2008-10-16 05:05:15 +00:00
|
|
|
release_resource(r);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2005-11-05 21:19:33 +00:00
|
|
|
EXPORT_SYMBOL_GPL(platform_device_add);
|
|
|
|
|
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* platform_device_del - remove a platform-level device
|
|
|
|
* @pdev: platform device we're removing
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* Note that this function will also release all memory- and port-based
|
|
|
|
* resources owned by the device (@dev->resource). This function must
|
|
|
|
* _only_ be externally called in error cases. All other usage is a bug.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2005-12-10 06:36:27 +00:00
|
|
|
void platform_device_del(struct platform_device *pdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (pdev) {
|
2007-05-02 18:55:54 +00:00
|
|
|
device_del(&pdev->dev);
|
|
|
|
|
2012-07-27 20:14:59 +00:00
|
|
|
if (pdev->id_auto) {
|
|
|
|
ida_simple_remove(&platform_devid_ida, pdev->id);
|
|
|
|
pdev->id = PLATFORM_DEVID_AUTO;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
for (i = 0; i < pdev->num_resources; i++) {
|
|
|
|
struct resource *r = &pdev->resource[i];
|
2008-10-16 05:05:15 +00:00
|
|
|
unsigned long type = resource_type(r);
|
|
|
|
|
2015-05-26 07:31:24 +00:00
|
|
|
if ((type == IORESOURCE_MEM || type == IORESOURCE_IO) &&
|
|
|
|
r->parent)
|
2005-04-16 22:20:36 +00:00
|
|
|
release_resource(r);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-12-10 06:36:27 +00:00
|
|
|
EXPORT_SYMBOL_GPL(platform_device_del);
|
|
|
|
|
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* platform_device_register - add a platform-level device
|
|
|
|
* @pdev: platform device we're adding
|
2005-12-10 06:36:27 +00:00
|
|
|
*/
|
2008-01-25 06:50:12 +00:00
|
|
|
int platform_device_register(struct platform_device *pdev)
|
2005-12-10 06:36:27 +00:00
|
|
|
{
|
|
|
|
device_initialize(&pdev->dev);
|
2011-06-10 06:52:57 +00:00
|
|
|
arch_setup_pdev_archdata(pdev);
|
2005-12-10 06:36:27 +00:00
|
|
|
return platform_device_add(pdev);
|
|
|
|
}
|
2005-12-10 06:36:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(platform_device_register);
|
2005-12-10 06:36:27 +00:00
|
|
|
|
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* platform_device_unregister - unregister a platform-level device
|
|
|
|
* @pdev: platform device we're unregistering
|
2005-12-10 06:36:27 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* Unregistration is done in 2 steps. First we release all resources
|
|
|
|
* and remove it from the subsystem, then we drop reference count by
|
|
|
|
* calling platform_device_put().
|
2005-12-10 06:36:27 +00:00
|
|
|
*/
|
2008-01-25 06:50:12 +00:00
|
|
|
void platform_device_unregister(struct platform_device *pdev)
|
2005-12-10 06:36:27 +00:00
|
|
|
{
|
|
|
|
platform_device_del(pdev);
|
|
|
|
platform_device_put(pdev);
|
|
|
|
}
|
2005-12-10 06:36:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(platform_device_unregister);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/**
|
2011-08-25 09:16:00 +00:00
|
|
|
* platform_device_register_full - add a platform-level device with
|
2010-06-21 14:11:44 +00:00
|
|
|
* resources and platform-specific data
|
2007-05-08 07:29:39 +00:00
|
|
|
*
|
2011-08-25 09:16:00 +00:00
|
|
|
* @pdevinfo: data used to create device
|
2008-09-22 21:41:40 +00:00
|
|
|
*
|
2010-03-11 16:11:45 +00:00
|
|
|
* Returns &struct platform_device pointer on success, or ERR_PTR() on error.
|
2008-09-22 21:41:40 +00:00
|
|
|
*/
|
2011-08-25 09:16:00 +00:00
|
|
|
struct platform_device *platform_device_register_full(
|
2011-12-08 21:53:29 +00:00
|
|
|
const struct platform_device_info *pdevinfo)
|
2008-09-22 21:41:40 +00:00
|
|
|
{
|
2010-06-21 14:11:44 +00:00
|
|
|
int ret = -ENOMEM;
|
2008-09-22 21:41:40 +00:00
|
|
|
struct platform_device *pdev;
|
|
|
|
|
2011-08-25 09:16:00 +00:00
|
|
|
pdev = platform_device_alloc(pdevinfo->name, pdevinfo->id);
|
2010-06-21 14:11:44 +00:00
|
|
|
if (!pdev)
|
2011-08-25 09:16:00 +00:00
|
|
|
goto err_alloc;
|
|
|
|
|
|
|
|
pdev->dev.parent = pdevinfo->parent;
|
2015-03-16 22:49:03 +00:00
|
|
|
pdev->dev.fwnode = pdevinfo->fwnode;
|
2011-08-25 09:16:00 +00:00
|
|
|
|
|
|
|
if (pdevinfo->dma_mask) {
|
|
|
|
/*
|
|
|
|
* This memory isn't freed when the device is put,
|
|
|
|
* I don't have a nice idea for that though. Conceptually
|
|
|
|
* dma_mask in struct device should not be a pointer.
|
|
|
|
* See http://thread.gmane.org/gmane.linux.kernel.pci/9081
|
|
|
|
*/
|
|
|
|
pdev->dev.dma_mask =
|
|
|
|
kmalloc(sizeof(*pdev->dev.dma_mask), GFP_KERNEL);
|
|
|
|
if (!pdev->dev.dma_mask)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
*pdev->dev.dma_mask = pdevinfo->dma_mask;
|
|
|
|
pdev->dev.coherent_dma_mask = pdevinfo->dma_mask;
|
|
|
|
}
|
2008-09-22 21:41:40 +00:00
|
|
|
|
2011-08-25 09:16:00 +00:00
|
|
|
ret = platform_device_add_resources(pdev,
|
|
|
|
pdevinfo->res, pdevinfo->num_res);
|
2010-09-07 13:31:54 +00:00
|
|
|
if (ret)
|
|
|
|
goto err;
|
2010-06-21 14:11:44 +00:00
|
|
|
|
2011-08-25 09:16:00 +00:00
|
|
|
ret = platform_device_add_data(pdev,
|
|
|
|
pdevinfo->data, pdevinfo->size_data);
|
2010-09-07 13:31:54 +00:00
|
|
|
if (ret)
|
|
|
|
goto err;
|
2008-09-22 21:41:40 +00:00
|
|
|
|
2010-06-21 14:11:44 +00:00
|
|
|
ret = platform_device_add(pdev);
|
|
|
|
if (ret) {
|
|
|
|
err:
|
ACPI / driver core: Store an ACPI device pointer in struct acpi_dev_node
Modify struct acpi_dev_node to contain a pointer to struct acpi_device
associated with the given device object (that is, its ACPI companion
device) instead of an ACPI handle corresponding to it. Introduce two
new macros for manipulating that pointer in a CONFIG_ACPI-safe way,
ACPI_COMPANION() and ACPI_COMPANION_SET(), and rework the
ACPI_HANDLE() macro to take the above changes into account.
Drop the ACPI_HANDLE_SET() macro entirely and rework its users to
use ACPI_COMPANION_SET() instead. For some of them who used to
pass the result of acpi_get_child() directly to ACPI_HANDLE_SET()
introduce a helper routine acpi_preset_companion() doing an
equivalent thing.
The main motivation for doing this is that there are things
represented by struct acpi_device objects that don't have valid
ACPI handles (so called fixed ACPI hardware features, such as
power and sleep buttons) and we would like to create platform
device objects for them and "glue" them to their ACPI companions
in the usual way (which currently is impossible due to the
lack of valid ACPI handles). However, there are more reasons
why it may be useful.
First, struct acpi_device pointers allow of much better type checking
than void pointers which are ACPI handles, so it should be more
difficult to write buggy code using modified struct acpi_dev_node
and the new macros. Second, the change should help to reduce (over
time) the number of places in which the result of ACPI_HANDLE() is
passed to acpi_bus_get_device() in order to obtain a pointer to the
struct acpi_device associated with the given "physical" device,
because now that pointer is returned by ACPI_COMPANION() directly.
Finally, the change should make it easier to write generic code that
will build both for CONFIG_ACPI set and unset without adding explicit
compiler directives to it.
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Tested-by: Mika Westerberg <mika.westerberg@linux.intel.com> # on Haswell
Reviewed-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Reviewed-by: Aaron Lu <aaron.lu@intel.com> # for ATA and SDIO part
2013-11-11 21:41:56 +00:00
|
|
|
ACPI_COMPANION_SET(&pdev->dev, NULL);
|
2011-08-25 09:16:00 +00:00
|
|
|
kfree(pdev->dev.dma_mask);
|
|
|
|
|
|
|
|
err_alloc:
|
2010-06-21 14:11:44 +00:00
|
|
|
platform_device_put(pdev);
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
}
|
2008-09-22 21:41:40 +00:00
|
|
|
|
|
|
|
return pdev;
|
|
|
|
}
|
2011-08-25 09:16:00 +00:00
|
|
|
EXPORT_SYMBOL_GPL(platform_device_register_full);
|
2008-09-22 21:41:40 +00:00
|
|
|
|
2005-11-09 17:23:39 +00:00
|
|
|
static int platform_drv_probe(struct device *_dev)
|
|
|
|
{
|
|
|
|
struct platform_driver *drv = to_platform_driver(_dev->driver);
|
|
|
|
struct platform_device *dev = to_platform_device(_dev);
|
2012-11-26 09:04:53 +00:00
|
|
|
int ret;
|
2005-11-09 17:23:39 +00:00
|
|
|
|
2014-06-18 15:29:32 +00:00
|
|
|
ret = of_clk_set_defaults(_dev->of_node, false);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2014-09-19 18:27:38 +00:00
|
|
|
ret = dev_pm_domain_attach(_dev, true);
|
|
|
|
if (ret != -EPROBE_DEFER) {
|
|
|
|
ret = drv->probe(dev);
|
|
|
|
if (ret)
|
|
|
|
dev_pm_domain_detach(_dev, true);
|
|
|
|
}
|
2012-11-26 09:04:53 +00:00
|
|
|
|
2013-09-23 14:27:26 +00:00
|
|
|
if (drv->prevent_deferred_probe && ret == -EPROBE_DEFER) {
|
|
|
|
dev_warn(_dev, "probe deferral not supported\n");
|
|
|
|
ret = -ENXIO;
|
|
|
|
}
|
|
|
|
|
2012-11-26 09:04:53 +00:00
|
|
|
return ret;
|
2005-11-09 17:23:39 +00:00
|
|
|
}
|
|
|
|
|
2006-11-17 07:28:47 +00:00
|
|
|
static int platform_drv_probe_fail(struct device *_dev)
|
|
|
|
{
|
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
|
2005-11-09 17:23:39 +00:00
|
|
|
static int platform_drv_remove(struct device *_dev)
|
|
|
|
{
|
|
|
|
struct platform_driver *drv = to_platform_driver(_dev->driver);
|
|
|
|
struct platform_device *dev = to_platform_device(_dev);
|
2012-11-26 09:04:53 +00:00
|
|
|
int ret;
|
2005-11-09 17:23:39 +00:00
|
|
|
|
2012-11-26 09:04:53 +00:00
|
|
|
ret = drv->remove(dev);
|
2014-09-19 18:27:38 +00:00
|
|
|
dev_pm_domain_detach(_dev, true);
|
2012-11-26 09:04:53 +00:00
|
|
|
|
|
|
|
return ret;
|
2005-11-09 17:23:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void platform_drv_shutdown(struct device *_dev)
|
|
|
|
{
|
|
|
|
struct platform_driver *drv = to_platform_driver(_dev->driver);
|
|
|
|
struct platform_device *dev = to_platform_device(_dev);
|
|
|
|
|
|
|
|
drv->shutdown(dev);
|
2014-09-19 18:27:38 +00:00
|
|
|
dev_pm_domain_detach(_dev, true);
|
2005-11-09 17:23:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-05-25 04:40:50 +00:00
|
|
|
* __platform_driver_register - register a driver for platform-level devices
|
2008-01-25 06:50:12 +00:00
|
|
|
* @drv: platform driver structure
|
2013-07-15 00:43:06 +00:00
|
|
|
* @owner: owning module/driver
|
2005-11-09 17:23:39 +00:00
|
|
|
*/
|
2013-05-25 04:40:50 +00:00
|
|
|
int __platform_driver_register(struct platform_driver *drv,
|
|
|
|
struct module *owner)
|
2005-11-09 17:23:39 +00:00
|
|
|
{
|
2013-05-25 04:40:50 +00:00
|
|
|
drv->driver.owner = owner;
|
2005-11-09 17:23:39 +00:00
|
|
|
drv->driver.bus = &platform_bus_type;
|
|
|
|
if (drv->probe)
|
|
|
|
drv->driver.probe = platform_drv_probe;
|
|
|
|
if (drv->remove)
|
|
|
|
drv->driver.remove = platform_drv_remove;
|
|
|
|
if (drv->shutdown)
|
|
|
|
drv->driver.shutdown = platform_drv_shutdown;
|
2009-06-04 20:13:33 +00:00
|
|
|
|
2005-11-09 17:23:39 +00:00
|
|
|
return driver_register(&drv->driver);
|
|
|
|
}
|
2013-05-25 04:40:50 +00:00
|
|
|
EXPORT_SYMBOL_GPL(__platform_driver_register);
|
2005-11-09 17:23:39 +00:00
|
|
|
|
|
|
|
/**
|
2010-02-14 14:18:53 +00:00
|
|
|
* platform_driver_unregister - unregister a driver for platform-level devices
|
2008-01-25 06:50:12 +00:00
|
|
|
* @drv: platform driver structure
|
2005-11-09 17:23:39 +00:00
|
|
|
*/
|
|
|
|
void platform_driver_unregister(struct platform_driver *drv)
|
|
|
|
{
|
|
|
|
driver_unregister(&drv->driver);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(platform_driver_unregister);
|
|
|
|
|
2006-11-17 07:28:47 +00:00
|
|
|
/**
|
2014-10-28 16:40:41 +00:00
|
|
|
* __platform_driver_probe - register driver for non-hotpluggable device
|
2006-11-17 07:28:47 +00:00
|
|
|
* @drv: platform driver structure
|
2013-09-23 14:27:26 +00:00
|
|
|
* @probe: the driver probe routine, probably from an __init section
|
2014-10-28 16:40:41 +00:00
|
|
|
* @module: module which will be the owner of the driver
|
2006-11-17 07:28:47 +00:00
|
|
|
*
|
|
|
|
* Use this instead of platform_driver_register() when you know the device
|
|
|
|
* is not hotpluggable and has already been registered, and you want to
|
|
|
|
* remove its run-once probe() infrastructure from memory after the driver
|
|
|
|
* has bound to the device.
|
|
|
|
*
|
|
|
|
* One typical use for this would be with drivers for controllers integrated
|
|
|
|
* into system-on-chip processors, where the controller devices have been
|
|
|
|
* configured as part of board setup.
|
|
|
|
*
|
2013-09-23 14:27:26 +00:00
|
|
|
* Note that this is incompatible with deferred probing.
|
2013-03-26 09:35:15 +00:00
|
|
|
*
|
2006-11-17 07:28:47 +00:00
|
|
|
* Returns zero if the driver registered and bound to a device, else returns
|
|
|
|
* a negative error code and with the driver not registered.
|
|
|
|
*/
|
2014-10-28 16:40:41 +00:00
|
|
|
int __init_or_module __platform_driver_probe(struct platform_driver *drv,
|
|
|
|
int (*probe)(struct platform_device *), struct module *module)
|
2006-11-17 07:28:47 +00:00
|
|
|
{
|
|
|
|
int retval, code;
|
|
|
|
|
2015-03-30 23:20:07 +00:00
|
|
|
if (drv->driver.probe_type == PROBE_PREFER_ASYNCHRONOUS) {
|
|
|
|
pr_err("%s: drivers registered with %s can not be probed asynchronously\n",
|
|
|
|
drv->driver.name, __func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have to run our probes synchronously because we check if
|
|
|
|
* we find any devices to bind to and exit with error if there
|
|
|
|
* are any.
|
|
|
|
*/
|
|
|
|
drv->driver.probe_type = PROBE_FORCE_SYNCHRONOUS;
|
|
|
|
|
2013-09-23 14:27:26 +00:00
|
|
|
/*
|
|
|
|
* Prevent driver from requesting probe deferral to avoid further
|
|
|
|
* futile probe attempts.
|
|
|
|
*/
|
|
|
|
drv->prevent_deferred_probe = true;
|
|
|
|
|
2009-10-13 03:17:41 +00:00
|
|
|
/* make sure driver won't have bind/unbind attributes */
|
|
|
|
drv->driver.suppress_bind_attrs = true;
|
|
|
|
|
2006-11-17 07:28:47 +00:00
|
|
|
/* temporary section violation during probe() */
|
|
|
|
drv->probe = probe;
|
2014-10-28 16:40:41 +00:00
|
|
|
retval = code = __platform_driver_register(drv, module);
|
2006-11-17 07:28:47 +00:00
|
|
|
|
2009-10-13 03:17:41 +00:00
|
|
|
/*
|
|
|
|
* Fixup that section violation, being paranoid about code scanning
|
2006-11-17 07:28:47 +00:00
|
|
|
* the list of drivers in order to probe new devices. Check to see
|
|
|
|
* if the probe was successful, and make sure any forced probes of
|
|
|
|
* new devices fail.
|
|
|
|
*/
|
2010-08-07 00:12:41 +00:00
|
|
|
spin_lock(&drv->driver.bus->p->klist_drivers.k_lock);
|
2006-11-17 07:28:47 +00:00
|
|
|
drv->probe = NULL;
|
2007-11-28 23:59:15 +00:00
|
|
|
if (code == 0 && list_empty(&drv->driver.p->klist_devices.k_list))
|
2006-11-17 07:28:47 +00:00
|
|
|
retval = -ENODEV;
|
|
|
|
drv->driver.probe = platform_drv_probe_fail;
|
2010-08-07 00:12:41 +00:00
|
|
|
spin_unlock(&drv->driver.bus->p->klist_drivers.k_lock);
|
2006-11-17 07:28:47 +00:00
|
|
|
|
|
|
|
if (code != retval)
|
|
|
|
platform_driver_unregister(drv);
|
|
|
|
return retval;
|
|
|
|
}
|
2014-10-28 16:40:41 +00:00
|
|
|
EXPORT_SYMBOL_GPL(__platform_driver_probe);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-12-30 04:11:20 +00:00
|
|
|
/**
|
2014-10-28 16:40:42 +00:00
|
|
|
* __platform_create_bundle - register driver and create corresponding device
|
2009-12-30 04:11:20 +00:00
|
|
|
* @driver: platform driver structure
|
|
|
|
* @probe: the driver probe routine, probably from an __init section
|
|
|
|
* @res: set of resources that needs to be allocated for the device
|
|
|
|
* @n_res: number of resources
|
|
|
|
* @data: platform specific data for this platform device
|
|
|
|
* @size: size of platform specific data
|
2014-10-28 16:40:42 +00:00
|
|
|
* @module: module which will be the owner of the driver
|
2009-12-30 04:11:20 +00:00
|
|
|
*
|
|
|
|
* Use this in legacy-style modules that probe hardware directly and
|
|
|
|
* register a single platform device and corresponding platform driver.
|
2010-03-11 16:11:45 +00:00
|
|
|
*
|
|
|
|
* Returns &struct platform_device pointer on success, or ERR_PTR() on error.
|
2009-12-30 04:11:20 +00:00
|
|
|
*/
|
2014-10-28 16:40:42 +00:00
|
|
|
struct platform_device * __init_or_module __platform_create_bundle(
|
2009-12-30 04:11:20 +00:00
|
|
|
struct platform_driver *driver,
|
|
|
|
int (*probe)(struct platform_device *),
|
|
|
|
struct resource *res, unsigned int n_res,
|
2014-10-28 16:40:42 +00:00
|
|
|
const void *data, size_t size, struct module *module)
|
2009-12-30 04:11:20 +00:00
|
|
|
{
|
|
|
|
struct platform_device *pdev;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
pdev = platform_device_alloc(driver->driver.name, -1);
|
|
|
|
if (!pdev) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
2010-09-07 13:31:54 +00:00
|
|
|
error = platform_device_add_resources(pdev, res, n_res);
|
|
|
|
if (error)
|
|
|
|
goto err_pdev_put;
|
2009-12-30 04:11:20 +00:00
|
|
|
|
2010-09-07 13:31:54 +00:00
|
|
|
error = platform_device_add_data(pdev, data, size);
|
|
|
|
if (error)
|
|
|
|
goto err_pdev_put;
|
2009-12-30 04:11:20 +00:00
|
|
|
|
|
|
|
error = platform_device_add(pdev);
|
|
|
|
if (error)
|
|
|
|
goto err_pdev_put;
|
|
|
|
|
2014-10-28 16:40:42 +00:00
|
|
|
error = __platform_driver_probe(driver, probe, module);
|
2009-12-30 04:11:20 +00:00
|
|
|
if (error)
|
|
|
|
goto err_pdev_del;
|
|
|
|
|
|
|
|
return pdev;
|
|
|
|
|
|
|
|
err_pdev_del:
|
|
|
|
platform_device_del(pdev);
|
|
|
|
err_pdev_put:
|
|
|
|
platform_device_put(pdev);
|
|
|
|
err_out:
|
|
|
|
return ERR_PTR(error);
|
|
|
|
}
|
2014-10-28 16:40:42 +00:00
|
|
|
EXPORT_SYMBOL_GPL(__platform_create_bundle);
|
2009-12-30 04:11:20 +00:00
|
|
|
|
2006-05-29 17:37:33 +00:00
|
|
|
/* modalias support enables more hands-off userspace setup:
|
|
|
|
* (a) environment variable lets new-style hotplug events work once system is
|
|
|
|
* fully running: "modprobe $MODALIAS"
|
|
|
|
* (b) sysfs attribute lets new-style coldplug recover from hotplug events
|
|
|
|
* mishandled before system is fully running: "modprobe $(cat modalias)"
|
|
|
|
*/
|
2008-01-25 06:50:12 +00:00
|
|
|
static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
|
|
|
|
char *buf)
|
2006-05-29 17:37:33 +00:00
|
|
|
{
|
|
|
|
struct platform_device *pdev = to_platform_device(dev);
|
ACPI: fix module autoloading for ACPI enumerated devices
ACPI enumerated devices has ACPI style _HID and _CID strings,
all of these strings can be used for both driver loading and matching.
Currently, in Platform, I2C and SPI bus, the ACPI style driver matching
is supported by invoking acpi_driver_match_device() in bus .match() callback.
But, the module autoloading is still broken.
For example, there is any ACPI device with _HID "INTABCD" that is
enumerated to platform bus, and we have a driver that can probe it.
The driver exports its module_alias as "acpi:INTABCD" use the following code
static const struct acpi_device_id xxx_acpi_match[] = {
{ "INTABCD", 0 },
{ }
};
MODULE_DEVICE_TABLE(acpi, xxx_acpi_match);
But, unfortunately, the device' modalias is shown as "platform:INTABCD:00",
please refer to modalias_show() and platform_uevent() in
drivers/base/platform.c.
This results in that the driver will not be loaded automatically when the
device node is created, because their modalias do not match.
This also applies to I2C and SPI bus.
With this patch, the device' modalias will be shown as "acpi:INTABCD" as well.
Signed-off-by: Zhang Rui <rui.zhang@intel.com>
Acked-by: Mark Brown <broonie@linaro.org>
Acked-by: Wolfram Sang <wsa@the-dreams.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-01-14 08:46:37 +00:00
|
|
|
int len;
|
|
|
|
|
2014-01-14 08:46:38 +00:00
|
|
|
len = of_device_get_modalias(dev, buf, PAGE_SIZE -1);
|
|
|
|
if (len != -ENODEV)
|
|
|
|
return len;
|
|
|
|
|
ACPI: fix module autoloading for ACPI enumerated devices
ACPI enumerated devices has ACPI style _HID and _CID strings,
all of these strings can be used for both driver loading and matching.
Currently, in Platform, I2C and SPI bus, the ACPI style driver matching
is supported by invoking acpi_driver_match_device() in bus .match() callback.
But, the module autoloading is still broken.
For example, there is any ACPI device with _HID "INTABCD" that is
enumerated to platform bus, and we have a driver that can probe it.
The driver exports its module_alias as "acpi:INTABCD" use the following code
static const struct acpi_device_id xxx_acpi_match[] = {
{ "INTABCD", 0 },
{ }
};
MODULE_DEVICE_TABLE(acpi, xxx_acpi_match);
But, unfortunately, the device' modalias is shown as "platform:INTABCD:00",
please refer to modalias_show() and platform_uevent() in
drivers/base/platform.c.
This results in that the driver will not be loaded automatically when the
device node is created, because their modalias do not match.
This also applies to I2C and SPI bus.
With this patch, the device' modalias will be shown as "acpi:INTABCD" as well.
Signed-off-by: Zhang Rui <rui.zhang@intel.com>
Acked-by: Mark Brown <broonie@linaro.org>
Acked-by: Wolfram Sang <wsa@the-dreams.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-01-14 08:46:37 +00:00
|
|
|
len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
|
|
|
|
if (len != -ENODEV)
|
|
|
|
return len;
|
|
|
|
|
|
|
|
len = snprintf(buf, PAGE_SIZE, "platform:%s\n", pdev->name);
|
2006-05-29 17:37:33 +00:00
|
|
|
|
|
|
|
return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
|
|
|
|
}
|
2013-08-23 21:24:37 +00:00
|
|
|
static DEVICE_ATTR_RO(modalias);
|
2006-05-29 17:37:33 +00:00
|
|
|
|
2014-06-03 00:42:58 +00:00
|
|
|
static ssize_t driver_override_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
char *driver_override, *old = pdev->driver_override, *cp;
|
|
|
|
|
|
|
|
if (count > PATH_MAX)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
driver_override = kstrndup(buf, count, GFP_KERNEL);
|
|
|
|
if (!driver_override)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
cp = strchr(driver_override, '\n');
|
|
|
|
if (cp)
|
|
|
|
*cp = '\0';
|
|
|
|
|
|
|
|
if (strlen(driver_override)) {
|
|
|
|
pdev->driver_override = driver_override;
|
|
|
|
} else {
|
|
|
|
kfree(driver_override);
|
|
|
|
pdev->driver_override = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(old);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t driver_override_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
|
|
|
|
return sprintf(buf, "%s\n", pdev->driver_override);
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR_RW(driver_override);
|
|
|
|
|
|
|
|
|
2013-08-23 21:24:37 +00:00
|
|
|
static struct attribute *platform_dev_attrs[] = {
|
|
|
|
&dev_attr_modalias.attr,
|
2014-06-03 00:42:58 +00:00
|
|
|
&dev_attr_driver_override.attr,
|
2013-08-23 21:24:37 +00:00
|
|
|
NULL,
|
2006-05-29 17:37:33 +00:00
|
|
|
};
|
2013-08-23 21:24:37 +00:00
|
|
|
ATTRIBUTE_GROUPS(platform_dev);
|
2006-05-29 17:37:33 +00:00
|
|
|
|
2007-08-14 13:15:12 +00:00
|
|
|
static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
|
2006-05-29 17:37:33 +00:00
|
|
|
{
|
|
|
|
struct platform_device *pdev = to_platform_device(dev);
|
2010-06-08 13:48:21 +00:00
|
|
|
int rc;
|
|
|
|
|
|
|
|
/* Some devices have extra OF data and an OF-style MODALIAS */
|
2013-03-26 09:35:16 +00:00
|
|
|
rc = of_device_uevent_modalias(dev, env);
|
2010-06-08 13:48:21 +00:00
|
|
|
if (rc != -ENODEV)
|
|
|
|
return rc;
|
2006-05-29 17:37:33 +00:00
|
|
|
|
ACPI: fix module autoloading for ACPI enumerated devices
ACPI enumerated devices has ACPI style _HID and _CID strings,
all of these strings can be used for both driver loading and matching.
Currently, in Platform, I2C and SPI bus, the ACPI style driver matching
is supported by invoking acpi_driver_match_device() in bus .match() callback.
But, the module autoloading is still broken.
For example, there is any ACPI device with _HID "INTABCD" that is
enumerated to platform bus, and we have a driver that can probe it.
The driver exports its module_alias as "acpi:INTABCD" use the following code
static const struct acpi_device_id xxx_acpi_match[] = {
{ "INTABCD", 0 },
{ }
};
MODULE_DEVICE_TABLE(acpi, xxx_acpi_match);
But, unfortunately, the device' modalias is shown as "platform:INTABCD:00",
please refer to modalias_show() and platform_uevent() in
drivers/base/platform.c.
This results in that the driver will not be loaded automatically when the
device node is created, because their modalias do not match.
This also applies to I2C and SPI bus.
With this patch, the device' modalias will be shown as "acpi:INTABCD" as well.
Signed-off-by: Zhang Rui <rui.zhang@intel.com>
Acked-by: Mark Brown <broonie@linaro.org>
Acked-by: Wolfram Sang <wsa@the-dreams.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-01-14 08:46:37 +00:00
|
|
|
rc = acpi_device_uevent_modalias(dev, env);
|
|
|
|
if (rc != -ENODEV)
|
|
|
|
return rc;
|
|
|
|
|
2009-02-04 03:52:40 +00:00
|
|
|
add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX,
|
2011-08-15 14:51:22 +00:00
|
|
|
pdev->name);
|
2006-05-29 17:37:33 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-04 03:52:40 +00:00
|
|
|
static const struct platform_device_id *platform_match_id(
|
2010-01-26 08:35:00 +00:00
|
|
|
const struct platform_device_id *id,
|
2009-02-04 03:52:40 +00:00
|
|
|
struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
while (id->name[0]) {
|
|
|
|
if (strcmp(pdev->name, id->name) == 0) {
|
|
|
|
pdev->id_entry = id;
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
id++;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* platform_match - bind platform device to platform driver.
|
|
|
|
* @dev: device.
|
|
|
|
* @drv: driver.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* Platform device IDs are assumed to be encoded like this:
|
|
|
|
* "<name><instance>", where <name> is a short description of the type of
|
|
|
|
* device, like "pci" or "floppy", and <instance> is the enumerated
|
|
|
|
* instance of the device, like '0' or '42'. Driver IDs are simply
|
|
|
|
* "<name>". So, extract the <name> from the platform_device structure,
|
|
|
|
* and compare it against the name of the driver. Return whether they match
|
|
|
|
* or not.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-01-25 06:50:12 +00:00
|
|
|
static int platform_match(struct device *dev, struct device_driver *drv)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-01-31 14:47:44 +00:00
|
|
|
struct platform_device *pdev = to_platform_device(dev);
|
2009-02-04 03:52:40 +00:00
|
|
|
struct platform_driver *pdrv = to_platform_driver(drv);
|
|
|
|
|
2014-06-03 00:42:58 +00:00
|
|
|
/* When driver_override is set, only bind to the matching driver */
|
|
|
|
if (pdev->driver_override)
|
|
|
|
return !strcmp(pdev->driver_override, drv->name);
|
|
|
|
|
2010-06-08 13:48:20 +00:00
|
|
|
/* Attempt an OF style match first */
|
|
|
|
if (of_driver_match_device(dev, drv))
|
|
|
|
return 1;
|
|
|
|
|
2012-10-31 21:45:02 +00:00
|
|
|
/* Then try ACPI style match */
|
|
|
|
if (acpi_driver_match_device(dev, drv))
|
|
|
|
return 1;
|
|
|
|
|
2010-06-08 13:48:20 +00:00
|
|
|
/* Then try to match against the id table */
|
2009-02-04 03:52:40 +00:00
|
|
|
if (pdrv->id_table)
|
|
|
|
return platform_match_id(pdrv->id_table, pdev) != NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-02-04 03:52:40 +00:00
|
|
|
/* fall-back to driver name match */
|
2008-10-30 00:36:48 +00:00
|
|
|
return (strcmp(pdev->name, drv->name) == 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-05-20 23:40:43 +00:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
|
|
|
|
static int platform_legacy_suspend(struct device *dev, pm_message_t mesg)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-06-04 20:13:33 +00:00
|
|
|
struct platform_driver *pdrv = to_platform_driver(dev->driver);
|
|
|
|
struct platform_device *pdev = to_platform_device(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
2009-06-04 20:13:33 +00:00
|
|
|
if (dev->driver && pdrv->suspend)
|
|
|
|
ret = pdrv->suspend(pdev, mesg);
|
2006-09-03 20:16:45 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-05-20 23:40:43 +00:00
|
|
|
static int platform_legacy_resume(struct device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-06-04 20:13:33 +00:00
|
|
|
struct platform_driver *pdrv = to_platform_driver(dev->driver);
|
|
|
|
struct platform_device *pdev = to_platform_device(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
2009-06-04 20:13:33 +00:00
|
|
|
if (dev->driver && pdrv->resume)
|
|
|
|
ret = pdrv->resume(pdev);
|
2005-10-28 16:52:56 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-04-28 22:36:05 +00:00
|
|
|
#endif /* CONFIG_PM_SLEEP */
|
2009-08-20 18:25:32 +00:00
|
|
|
|
2008-05-20 23:40:43 +00:00
|
|
|
#ifdef CONFIG_SUSPEND
|
|
|
|
|
2011-04-28 22:36:05 +00:00
|
|
|
int platform_pm_suspend(struct device *dev)
|
2008-05-20 23:40:43 +00:00
|
|
|
{
|
|
|
|
struct device_driver *drv = dev->driver;
|
|
|
|
int ret = 0;
|
|
|
|
|
2008-10-06 20:46:05 +00:00
|
|
|
if (!drv)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (drv->pm) {
|
2008-05-20 23:40:43 +00:00
|
|
|
if (drv->pm->suspend)
|
|
|
|
ret = drv->pm->suspend(dev);
|
|
|
|
} else {
|
|
|
|
ret = platform_legacy_suspend(dev, PMSG_SUSPEND);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-04-28 22:36:05 +00:00
|
|
|
int platform_pm_resume(struct device *dev)
|
2008-05-20 23:40:43 +00:00
|
|
|
{
|
|
|
|
struct device_driver *drv = dev->driver;
|
|
|
|
int ret = 0;
|
|
|
|
|
2008-10-06 20:46:05 +00:00
|
|
|
if (!drv)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (drv->pm) {
|
2008-05-20 23:40:43 +00:00
|
|
|
if (drv->pm->resume)
|
|
|
|
ret = drv->pm->resume(dev);
|
|
|
|
} else {
|
|
|
|
ret = platform_legacy_resume(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-04-28 22:36:05 +00:00
|
|
|
#endif /* CONFIG_SUSPEND */
|
2008-05-20 23:40:43 +00:00
|
|
|
|
2011-04-11 20:54:42 +00:00
|
|
|
#ifdef CONFIG_HIBERNATE_CALLBACKS
|
2008-05-20 23:40:43 +00:00
|
|
|
|
2011-04-28 22:36:05 +00:00
|
|
|
int platform_pm_freeze(struct device *dev)
|
2008-05-20 23:40:43 +00:00
|
|
|
{
|
|
|
|
struct device_driver *drv = dev->driver;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!drv)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (drv->pm) {
|
|
|
|
if (drv->pm->freeze)
|
|
|
|
ret = drv->pm->freeze(dev);
|
|
|
|
} else {
|
|
|
|
ret = platform_legacy_suspend(dev, PMSG_FREEZE);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-04-28 22:36:05 +00:00
|
|
|
int platform_pm_thaw(struct device *dev)
|
2008-05-20 23:40:43 +00:00
|
|
|
{
|
|
|
|
struct device_driver *drv = dev->driver;
|
|
|
|
int ret = 0;
|
|
|
|
|
2008-10-06 20:46:05 +00:00
|
|
|
if (!drv)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (drv->pm) {
|
2008-05-20 23:40:43 +00:00
|
|
|
if (drv->pm->thaw)
|
|
|
|
ret = drv->pm->thaw(dev);
|
|
|
|
} else {
|
|
|
|
ret = platform_legacy_resume(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-04-28 22:36:05 +00:00
|
|
|
int platform_pm_poweroff(struct device *dev)
|
2008-05-20 23:40:43 +00:00
|
|
|
{
|
|
|
|
struct device_driver *drv = dev->driver;
|
|
|
|
int ret = 0;
|
|
|
|
|
2008-10-06 20:46:05 +00:00
|
|
|
if (!drv)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (drv->pm) {
|
2008-05-20 23:40:43 +00:00
|
|
|
if (drv->pm->poweroff)
|
|
|
|
ret = drv->pm->poweroff(dev);
|
|
|
|
} else {
|
|
|
|
ret = platform_legacy_suspend(dev, PMSG_HIBERNATE);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-04-28 22:36:05 +00:00
|
|
|
int platform_pm_restore(struct device *dev)
|
2008-05-20 23:40:43 +00:00
|
|
|
{
|
|
|
|
struct device_driver *drv = dev->driver;
|
|
|
|
int ret = 0;
|
|
|
|
|
2008-10-06 20:46:05 +00:00
|
|
|
if (!drv)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (drv->pm) {
|
2008-05-20 23:40:43 +00:00
|
|
|
if (drv->pm->restore)
|
|
|
|
ret = drv->pm->restore(dev);
|
|
|
|
} else {
|
|
|
|
ret = platform_legacy_resume(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-04-28 22:36:05 +00:00
|
|
|
#endif /* CONFIG_HIBERNATE_CALLBACKS */
|
2008-05-20 23:40:43 +00:00
|
|
|
|
2009-07-21 22:37:25 +00:00
|
|
|
static const struct dev_pm_ops platform_dev_pm_ops = {
|
2011-04-28 22:36:32 +00:00
|
|
|
.runtime_suspend = pm_generic_runtime_suspend,
|
|
|
|
.runtime_resume = pm_generic_runtime_resume,
|
2011-04-28 22:36:05 +00:00
|
|
|
USE_PLATFORM_PM_SLEEP_OPS
|
2008-05-20 23:40:43 +00:00
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct bus_type platform_bus_type = {
|
|
|
|
.name = "platform",
|
2013-08-23 21:24:37 +00:00
|
|
|
.dev_groups = platform_dev_groups,
|
2005-04-16 22:20:36 +00:00
|
|
|
.match = platform_match,
|
2006-05-29 17:37:33 +00:00
|
|
|
.uevent = platform_uevent,
|
2009-08-20 18:25:32 +00:00
|
|
|
.pm = &platform_dev_pm_ops,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
2005-12-10 06:36:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(platform_bus_type);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
int __init platform_bus_init(void)
|
|
|
|
{
|
2006-11-27 09:35:08 +00:00
|
|
|
int error;
|
|
|
|
|
2009-03-30 21:37:25 +00:00
|
|
|
early_platform_cleanup();
|
|
|
|
|
2006-11-27 09:35:08 +00:00
|
|
|
error = device_register(&platform_bus);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
error = bus_register(&platform_bus_type);
|
|
|
|
if (error)
|
|
|
|
device_unregister(&platform_bus);
|
2014-10-28 20:36:01 +00:00
|
|
|
of_platform_register_reconfig_notifier();
|
2006-11-27 09:35:08 +00:00
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef ARCH_HAS_DMA_GET_REQUIRED_MASK
|
|
|
|
u64 dma_get_required_mask(struct device *dev)
|
|
|
|
{
|
|
|
|
u32 low_totalram = ((max_pfn - 1) << PAGE_SHIFT);
|
|
|
|
u32 high_totalram = ((max_pfn - 1) >> (32 - PAGE_SHIFT));
|
|
|
|
u64 mask;
|
|
|
|
|
|
|
|
if (!high_totalram) {
|
|
|
|
/* convert to mask just covering totalram */
|
|
|
|
low_totalram = (1 << (fls(low_totalram) - 1));
|
|
|
|
low_totalram += low_totalram - 1;
|
|
|
|
mask = low_totalram;
|
|
|
|
} else {
|
|
|
|
high_totalram = (1 << (fls(high_totalram) - 1));
|
|
|
|
high_totalram += high_totalram - 1;
|
|
|
|
mask = (((u64)high_totalram) << 32) + 0xffffffff;
|
|
|
|
}
|
2008-03-09 16:57:56 +00:00
|
|
|
return mask;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dma_get_required_mask);
|
|
|
|
#endif
|
2009-03-30 21:37:25 +00:00
|
|
|
|
|
|
|
static __initdata LIST_HEAD(early_platform_driver_list);
|
|
|
|
static __initdata LIST_HEAD(early_platform_device_list);
|
|
|
|
|
|
|
|
/**
|
2010-03-10 11:50:38 +00:00
|
|
|
* early_platform_driver_register - register early platform driver
|
2009-04-21 14:22:53 +00:00
|
|
|
* @epdrv: early_platform driver structure
|
2009-03-30 21:37:25 +00:00
|
|
|
* @buf: string passed from early_param()
|
2010-03-10 11:50:38 +00:00
|
|
|
*
|
|
|
|
* Helper function for early_platform_init() / early_platform_init_buffer()
|
2009-03-30 21:37:25 +00:00
|
|
|
*/
|
|
|
|
int __init early_platform_driver_register(struct early_platform_driver *epdrv,
|
|
|
|
char *buf)
|
|
|
|
{
|
2009-11-27 08:38:51 +00:00
|
|
|
char *tmp;
|
2009-03-30 21:37:25 +00:00
|
|
|
int n;
|
|
|
|
|
|
|
|
/* Simply add the driver to the end of the global list.
|
|
|
|
* Drivers will by default be put on the list in compiled-in order.
|
|
|
|
*/
|
|
|
|
if (!epdrv->list.next) {
|
|
|
|
INIT_LIST_HEAD(&epdrv->list);
|
|
|
|
list_add_tail(&epdrv->list, &early_platform_driver_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If the user has specified device then make sure the driver
|
|
|
|
* gets prioritized. The driver of the last device specified on
|
|
|
|
* command line will be put first on the list.
|
|
|
|
*/
|
|
|
|
n = strlen(epdrv->pdrv->driver.name);
|
|
|
|
if (buf && !strncmp(buf, epdrv->pdrv->driver.name, n)) {
|
|
|
|
list_move(&epdrv->list, &early_platform_driver_list);
|
|
|
|
|
2009-11-27 08:38:51 +00:00
|
|
|
/* Allow passing parameters after device name */
|
|
|
|
if (buf[n] == '\0' || buf[n] == ',')
|
2009-03-30 21:37:25 +00:00
|
|
|
epdrv->requested_id = -1;
|
2009-11-27 08:38:51 +00:00
|
|
|
else {
|
|
|
|
epdrv->requested_id = simple_strtoul(&buf[n + 1],
|
|
|
|
&tmp, 10);
|
|
|
|
|
|
|
|
if (buf[n] != '.' || (tmp == &buf[n + 1])) {
|
|
|
|
epdrv->requested_id = EARLY_PLATFORM_ID_ERROR;
|
|
|
|
n = 0;
|
|
|
|
} else
|
|
|
|
n += strcspn(&buf[n + 1], ",") + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (buf[n] == ',')
|
|
|
|
n++;
|
|
|
|
|
|
|
|
if (epdrv->bufsize) {
|
|
|
|
memcpy(epdrv->buffer, &buf[n],
|
|
|
|
min_t(int, epdrv->bufsize, strlen(&buf[n]) + 1));
|
|
|
|
epdrv->buffer[epdrv->bufsize - 1] = '\0';
|
|
|
|
}
|
2009-03-30 21:37:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-03-10 11:50:38 +00:00
|
|
|
* early_platform_add_devices - adds a number of early platform devices
|
2009-03-30 21:37:25 +00:00
|
|
|
* @devs: array of early platform devices to add
|
|
|
|
* @num: number of early platform devices in array
|
2010-03-10 11:50:38 +00:00
|
|
|
*
|
|
|
|
* Used by early architecture code to register early platform devices and
|
|
|
|
* their platform data.
|
2009-03-30 21:37:25 +00:00
|
|
|
*/
|
|
|
|
void __init early_platform_add_devices(struct platform_device **devs, int num)
|
|
|
|
{
|
|
|
|
struct device *dev;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* simply add the devices to list */
|
|
|
|
for (i = 0; i < num; i++) {
|
|
|
|
dev = &devs[i]->dev;
|
|
|
|
|
|
|
|
if (!dev->devres_head.next) {
|
2012-08-05 23:45:11 +00:00
|
|
|
pm_runtime_early_init(dev);
|
2009-03-30 21:37:25 +00:00
|
|
|
INIT_LIST_HEAD(&dev->devres_head);
|
|
|
|
list_add_tail(&dev->devres_head,
|
|
|
|
&early_platform_device_list);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-03-10 11:50:38 +00:00
|
|
|
* early_platform_driver_register_all - register early platform drivers
|
2009-03-30 21:37:25 +00:00
|
|
|
* @class_str: string to identify early platform driver class
|
2010-03-10 11:50:38 +00:00
|
|
|
*
|
|
|
|
* Used by architecture code to register all early platform drivers
|
|
|
|
* for a certain class. If omitted then only early platform drivers
|
|
|
|
* with matching kernel command line class parameters will be registered.
|
2009-03-30 21:37:25 +00:00
|
|
|
*/
|
|
|
|
void __init early_platform_driver_register_all(char *class_str)
|
|
|
|
{
|
|
|
|
/* The "class_str" parameter may or may not be present on the kernel
|
|
|
|
* command line. If it is present then there may be more than one
|
|
|
|
* matching parameter.
|
|
|
|
*
|
|
|
|
* Since we register our early platform drivers using early_param()
|
|
|
|
* we need to make sure that they also get registered in the case
|
|
|
|
* when the parameter is missing from the kernel command line.
|
|
|
|
*
|
|
|
|
* We use parse_early_options() to make sure the early_param() gets
|
|
|
|
* called at least once. The early_param() may be called more than
|
|
|
|
* once since the name of the preferred device may be specified on
|
|
|
|
* the kernel command line. early_platform_driver_register() handles
|
|
|
|
* this case for us.
|
|
|
|
*/
|
|
|
|
parse_early_options(class_str);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-03-10 11:50:38 +00:00
|
|
|
* early_platform_match - find early platform device matching driver
|
2009-04-21 14:22:53 +00:00
|
|
|
* @epdrv: early platform driver structure
|
2009-03-30 21:37:25 +00:00
|
|
|
* @id: id to match against
|
|
|
|
*/
|
2013-08-17 12:42:25 +00:00
|
|
|
static struct platform_device * __init
|
2009-03-30 21:37:25 +00:00
|
|
|
early_platform_match(struct early_platform_driver *epdrv, int id)
|
|
|
|
{
|
|
|
|
struct platform_device *pd;
|
|
|
|
|
|
|
|
list_for_each_entry(pd, &early_platform_device_list, dev.devres_head)
|
|
|
|
if (platform_match(&pd->dev, &epdrv->pdrv->driver))
|
|
|
|
if (pd->id == id)
|
|
|
|
return pd;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-03-10 11:50:38 +00:00
|
|
|
* early_platform_left - check if early platform driver has matching devices
|
2009-04-21 14:22:53 +00:00
|
|
|
* @epdrv: early platform driver structure
|
2009-03-30 21:37:25 +00:00
|
|
|
* @id: return true if id or above exists
|
|
|
|
*/
|
2013-08-17 12:42:25 +00:00
|
|
|
static int __init early_platform_left(struct early_platform_driver *epdrv,
|
2009-03-30 21:37:25 +00:00
|
|
|
int id)
|
|
|
|
{
|
|
|
|
struct platform_device *pd;
|
|
|
|
|
|
|
|
list_for_each_entry(pd, &early_platform_device_list, dev.devres_head)
|
|
|
|
if (platform_match(&pd->dev, &epdrv->pdrv->driver))
|
|
|
|
if (pd->id >= id)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-03-10 11:50:38 +00:00
|
|
|
* early_platform_driver_probe_id - probe drivers matching class_str and id
|
2009-03-30 21:37:25 +00:00
|
|
|
* @class_str: string to identify early platform driver class
|
|
|
|
* @id: id to match against
|
|
|
|
* @nr_probe: number of platform devices to successfully probe before exiting
|
|
|
|
*/
|
|
|
|
static int __init early_platform_driver_probe_id(char *class_str,
|
|
|
|
int id,
|
|
|
|
int nr_probe)
|
|
|
|
{
|
|
|
|
struct early_platform_driver *epdrv;
|
|
|
|
struct platform_device *match;
|
|
|
|
int match_id;
|
|
|
|
int n = 0;
|
|
|
|
int left = 0;
|
|
|
|
|
|
|
|
list_for_each_entry(epdrv, &early_platform_driver_list, list) {
|
|
|
|
/* only use drivers matching our class_str */
|
|
|
|
if (strcmp(class_str, epdrv->class_str))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (id == -2) {
|
|
|
|
match_id = epdrv->requested_id;
|
|
|
|
left = 1;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
match_id = id;
|
|
|
|
left += early_platform_left(epdrv, id);
|
|
|
|
|
|
|
|
/* skip requested id */
|
|
|
|
switch (epdrv->requested_id) {
|
|
|
|
case EARLY_PLATFORM_ID_ERROR:
|
|
|
|
case EARLY_PLATFORM_ID_UNSET:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (epdrv->requested_id == id)
|
|
|
|
match_id = EARLY_PLATFORM_ID_UNSET;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (match_id) {
|
|
|
|
case EARLY_PLATFORM_ID_ERROR:
|
2013-03-26 09:35:16 +00:00
|
|
|
pr_warn("%s: unable to parse %s parameter\n",
|
|
|
|
class_str, epdrv->pdrv->driver.name);
|
2009-03-30 21:37:25 +00:00
|
|
|
/* fall-through */
|
|
|
|
case EARLY_PLATFORM_ID_UNSET:
|
|
|
|
match = NULL;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
match = early_platform_match(epdrv, match_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (match) {
|
2010-03-09 06:57:53 +00:00
|
|
|
/*
|
|
|
|
* Set up a sensible init_name to enable
|
|
|
|
* dev_name() and others to be used before the
|
|
|
|
* rest of the driver core is initialized.
|
|
|
|
*/
|
2010-05-13 08:56:56 +00:00
|
|
|
if (!match->dev.init_name && slab_is_available()) {
|
2010-03-09 06:57:53 +00:00
|
|
|
if (match->id != -1)
|
2010-03-29 06:51:35 +00:00
|
|
|
match->dev.init_name =
|
|
|
|
kasprintf(GFP_KERNEL, "%s.%d",
|
|
|
|
match->name,
|
|
|
|
match->id);
|
2010-03-09 06:57:53 +00:00
|
|
|
else
|
2010-03-29 06:51:35 +00:00
|
|
|
match->dev.init_name =
|
|
|
|
kasprintf(GFP_KERNEL, "%s",
|
|
|
|
match->name);
|
2010-03-09 06:57:53 +00:00
|
|
|
|
|
|
|
if (!match->dev.init_name)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2010-03-29 06:51:35 +00:00
|
|
|
|
2009-03-30 21:37:25 +00:00
|
|
|
if (epdrv->pdrv->probe(match))
|
2013-03-26 09:35:16 +00:00
|
|
|
pr_warn("%s: unable to probe %s early.\n",
|
|
|
|
class_str, match->name);
|
2009-03-30 21:37:25 +00:00
|
|
|
else
|
|
|
|
n++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (n >= nr_probe)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (left)
|
|
|
|
return n;
|
|
|
|
else
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-03-10 11:50:38 +00:00
|
|
|
* early_platform_driver_probe - probe a class of registered drivers
|
2009-03-30 21:37:25 +00:00
|
|
|
* @class_str: string to identify early platform driver class
|
|
|
|
* @nr_probe: number of platform devices to successfully probe before exiting
|
|
|
|
* @user_only: only probe user specified early platform devices
|
2010-03-10 11:50:38 +00:00
|
|
|
*
|
|
|
|
* Used by architecture code to probe registered early platform drivers
|
|
|
|
* within a certain class. For probe to happen a registered early platform
|
|
|
|
* device matching a registered early platform driver is needed.
|
2009-03-30 21:37:25 +00:00
|
|
|
*/
|
|
|
|
int __init early_platform_driver_probe(char *class_str,
|
|
|
|
int nr_probe,
|
|
|
|
int user_only)
|
|
|
|
{
|
|
|
|
int k, n, i;
|
|
|
|
|
|
|
|
n = 0;
|
|
|
|
for (i = -2; n < nr_probe; i++) {
|
|
|
|
k = early_platform_driver_probe_id(class_str, i, nr_probe - n);
|
|
|
|
|
|
|
|
if (k < 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
n += k;
|
|
|
|
|
|
|
|
if (user_only)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* early_platform_cleanup - clean up early platform code
|
|
|
|
*/
|
|
|
|
void __init early_platform_cleanup(void)
|
|
|
|
{
|
|
|
|
struct platform_device *pd, *pd2;
|
|
|
|
|
|
|
|
/* clean up the devres list used to chain devices */
|
|
|
|
list_for_each_entry_safe(pd, pd2, &early_platform_device_list,
|
|
|
|
dev.devres_head) {
|
|
|
|
list_del(&pd->dev.devres_head);
|
|
|
|
memset(&pd->dev.devres_head, 0, sizeof(pd->dev.devres_head));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|