From: David Brownell <[email protected]>

This defines a new platform_driver_probe() method allowing the driver's
probe() method, and its support code+data, to safely live in __init
sections for typical system configurations.

Many system-on-chip processors could benefit from this API, to the tune
of recovering hundreds to thousands of bytes per driver. That's memory
which is currently wasted holding code which can never be called after
system startup, yet can not be removed. It can't be removed because of
the linkage requirement that pointers to init section code (like, ideally,
probe support) must not live in other sections (like driver method tables)
after those pointers would be invalid.

Signed-off-by: David Brownell <[email protected]>
Signed-off-by: Greg Kroah-Hartman <[email protected]>
---
drivers/base/platform.c | 48 +++++++++++++++++++++++++++++++++++++++
include/linux/platform_device.h | 6 +++++
2 files changed, 54 insertions(+), 0 deletions(-)

diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 940ce41..d1df4a0 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -388,6 +388,11 @@ static int platform_drv_probe(struct dev
return drv->probe(dev);
}

+static int platform_drv_probe_fail(struct device *_dev)
+{
+ return -ENXIO;
+}
+
static int platform_drv_remove(struct device *_dev)
{
struct platform_driver *drv = to_platform_driver(_dev->driver);
@@ -451,6 +456,49 @@ void platform_driver_unregister(struct p
}
EXPORT_SYMBOL_GPL(platform_driver_unregister);

+/**
+ * platform_driver_probe - register driver for non-hotpluggable device
+ * @drv: platform driver structure
+ * @probe: the driver probe routine, probably from an __init section
+ *
+ * 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.
+ *
+ * Returns zero if the driver registered and bound to a device, else returns
+ * a negative error code and with the driver not registered.
+ */
+int platform_driver_probe(struct platform_driver *drv,
+ int (*probe)(struct platform_device *))
+{
+ int retval, code;
+
+ /* temporary section violation during probe() */
+ drv->probe = probe;
+ retval = code = platform_driver_register(drv);
+
+ /* Fixup that section violation, being paranoid about code scanning
+ * 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.
+ */
+ spin_lock(&platform_bus_type.klist_drivers.k_lock);
+ drv->probe = NULL;
+ if (code == 0 && list_empty(&drv->driver.klist_devices.k_list))
+ retval = -ENODEV;
+ drv->driver.probe = platform_drv_probe_fail;
+ spin_unlock(&platform_bus_type.klist_drivers.k_lock);
+
+ if (code != retval)
+ platform_driver_unregister(drv);
+ return retval;
+}
+EXPORT_SYMBOL_GPL(platform_driver_probe);

/* modalias support enables more hands-off userspace setup:
* (a) environment variable lets new-style hotplug events work once system is
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index 29cd6de..20f47b8 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -58,6 +58,12 @@ struct platform_driver {
extern int platform_driver_register(struct platform_driver *);
extern void platform_driver_unregister(struct platform_driver *);

+/* non-hotpluggable platform devices may use this so that probe() and
+ * its support may live in __init sections, conserving runtime memory.
+ */
+extern int platform_driver_probe(struct platform_driver *driver,
+ int (*probe)(struct platform_device *));
+
#define platform_get_drvdata(_dev) dev_get_drvdata(&(_dev)->dev)
#define platform_set_drvdata(_dev,data) dev_set_drvdata(&(_dev)->dev, (data))

--
1.4.4.1

2006-12-01 23:28:01

by Greg KH

[permalink] [raw]

Subject: [PATCH 17/36] Driver core: convert cpuid code to use struct device

2006-12-01 23:28:00

by Greg KH

[permalink] [raw]

Subject: [PATCH 16/36] Driver core: convert msr code to use struct device

2006-12-01 23:24:10

by Greg KH

[permalink] [raw]

Subject: [PATCH 14/36] Driver core: convert raw device code to use struct device

2006-12-01 23:24:57

by Greg KH

[permalink] [raw]

Subject: [PATCH 33/36] driver core: Use klist_remove() in device_move()

From: Cornelia Huck <[email protected]>

As pointed out by Alan Stern, device_move needs to use klist_remove which waits
until removal is complete.

Signed-off-by: Cornelia Huck <[email protected]>
Cc: Alan Stern <[email protected]>
Signed-off-by: Greg Kroah-Hartman <[email protected]>
---
drivers/base/core.c | 4 ++--
1 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/drivers/base/core.c b/drivers/base/core.c
index e4eaf46..e4b530e 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -1022,7 +1022,7 @@ int device_move(struct device *dev, stru
old_parent = dev->parent;
dev->parent = new_parent;
if (old_parent)
- klist_del(&dev->knode_parent);
+ klist_remove(&dev->knode_parent);
klist_add_tail(&dev->knode_parent, &new_parent->klist_children);
if (!dev->class)
goto out_put;
@@ -1031,7 +1031,7 @@ int device_move(struct device *dev, stru
/* We ignore errors on cleanup since we're hosed anyway... */
device_move_class_links(dev, new_parent, old_parent);
if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
- klist_del(&dev->knode_parent);
+ klist_remove(&dev->knode_parent);
if (old_parent)
klist_add_tail(&dev->knode_parent,
&old_parent->klist_children);
--
1.4.4.1

2006-12-01 23:28:05

by Greg KH

[permalink] [raw]

Subject: [PATCH 19/36] Driver core: convert ppdev code to use struct device

2006-12-01 23:28:03

by Greg KH

[permalink] [raw]

Subject: [PATCH 18/36] Driver core: convert PPP code to use struct device

2006-12-01 23:29:33

by Greg KH

[permalink] [raw]

On Tue, 05 Dec 2006 16:26:11 +0100,
Marcel Holtmann <[email protected]> wrote:

[sorry about the late reply, but I've been on vacation & offline]

> I was checking why device_move() fails and it seems that the check for
> is_registered is the problem here.
>
> if (!device_is_registered(dev)) {
> error = -EINVAL;
> goto out;
> }
>
> The ACL link has been attached to the Bluetooth bus, but for some reason
> it still thinks that it is unregistered. Is this check really needed. I
> think it should be possible to also move devices that are not part of a
> bus, yet. And removing that check makes it work for me.

Hm, device_is_registered() is always false for devices not belonging to
a bus. I'll remove that check.

> > > > > And shouldn't device_move(dev, NULL) re-attach it to the virtual device
> > > > > tree instead of failing?
> > > >
> > > > Yes, that would be good to have.
> > >
> > > Cornelia, please fix this, because otherwise we can't detach a device
> > > from its parent. Storing the current virtual parent looks racy to me.
> >
> > You can always restore the previous "virtual" parent from the
> > information given to you in the device itself. That is what the code
> > does when it first registers the device.
> >
> > And yes, I too think it should be fixed.
>
> My knowledge of the driver model is still limited. Can you fix that
> quickly. This is really needed.

I'm currently working on a patch. Sorry for the delay, I hope I can get
it out today.

--
Cornelia Huck
Linux for zSeries Developer
Tel.: +49-7031-16-4837, Mail: [email protected]