driver-model: manual device attach

Index: linux-export/drivers/base/bus.c
===================================================================
@@ -17,6 +17,12 @@
 #include "base.h"
 #include "power/power.h"
 
+int dev_autoattach = 1, dev_autoattach_min = 0, dev_autoattach_max = 2;
+
+static LIST_HEAD(all_buses);
+static spinlock_t all_buses_lock = SPIN_LOCK_UNLOCKED;
+static DECLARE_MUTEX(all_buses_traverse_mutex);
+
 #define to_dev(node) container_of(node, struct device, bus_list)
 #define to_drv(node) container_of(node, struct device_driver, kobj.entry)
 

@@ -329,7 +335,7 @@ int device_attach(struct device * dev)
 		return 1;
 	}
 
-	if (bus->match) {
+	if (dev_autoattach && bus->match) {
 		list_for_each(entry, &bus->drivers.list) {
 			struct device_driver * drv = to_drv(entry);
 			error = driver_probe_device(drv, dev);

@@ -366,7 +372,7 @@ void driver_attach(struct device_driver 
 	struct list_head * entry;
 	int error;
 
-	if (!bus->match)
+	if (!dev_autoattach || !bus->match)
 		return;
 
 	list_for_each(entry, &bus->devices.list) {

@@ -723,6 +729,10 @@ int bus_register(struct bus_type * bus)
 		goto bus_drivers_fail;
 	bus_add_attrs(bus);
 
+	spin_lock(&all_buses_lock);
+	list_add_tail(&bus->node, &all_buses);
+	spin_unlock(&all_buses_lock);
+
 	pr_debug("bus type '%s' registered\n", bus->name);
 	return 0;
 

@@ -745,12 +755,61 @@ out:
 void bus_unregister(struct bus_type * bus)
 {
 	pr_debug("bus %s: unregistering\n", bus->name);
+
+	spin_lock(&all_buses_lock);
+	list_del(&bus->node);
+	spin_unlock(&all_buses_lock);
+
 	bus_remove_attrs(bus);
 	kset_unregister(&bus->drivers);
 	kset_unregister(&bus->devices);
 	subsystem_unregister(&bus->subsys);
 }
 
+
+/**
+ *	dev_autoattach_handler - proc_handler for sysctl node dev.autoattach
+ */
+int dev_autoattach_handler(ctl_table *table, int write, struct file *filp,
+			   void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+	int ret;
+
+	ret = proc_dointvec_minmax(table, write, filp, buffer, lenp, ppos);
+
+	down(&all_buses_traverse_mutex);
+
+	if (dev_autoattach == 2) {
+		struct list_head marker;
+
+		spin_lock(&all_buses_lock);
+		list_add(&marker, &all_buses);
+		while (marker.next != &all_buses) {
+			struct bus_type *bus;
+			bus = container_of(marker.next, struct bus_type, node);
+			if (!(bus = get_bus(bus)))
+				continue;
+			/* Okay, we have the next bus, move it ahead
+			   of the marker and perform rescan. */
+			list_del(&bus->node);
+			list_add_tail(&bus->node, &marker);
+			spin_unlock(&all_buses_lock);
+
+			bus_rescan_devices(bus);
+
+			put_bus(bus);
+			spin_lock(&all_buses_lock);
+		}
+		list_del(&marker);
+		spin_unlock(&all_buses_lock);
+		dev_autoattach = 1;
+	}
+
+	up(&all_buses_traverse_mutex);
+
+	return ret;
+}
+
 int __init buses_init(void)
 {
 	return subsystem_register(&bus_subsys);

Index: linux-export/include/linux/device.h
===================================================================
@@ -20,6 +20,7 @@
 #include <linux/module.h>
 #include <linux/pm.h>
 #include <linux/deviceparam.h>
+#include <linux/sysctl.h>
 #include <asm/semaphore.h>
 #include <asm/atomic.h>
 

@@ -54,6 +55,7 @@ struct bus_type {
 	struct subsystem	subsys;
 	struct kset		drivers;
 	struct kset		devices;
+	struct list_head	node;
 
 	struct bus_attribute	* bus_attrs;
 	struct device_attribute	* dev_attrs;

@@ -414,6 +416,12 @@ extern void device_shutdown(void);
 extern int firmware_register(struct subsystem *);
 extern void firmware_unregister(struct subsystem *);
 
+/* dev.autoattach sysctl node */
+extern int dev_autoattach, dev_autoattach_min, dev_autoattach_max;
+extern int dev_autoattach_handler(ctl_table *table, int write,
+				  struct file *filp, void __user *buffer,
+				  size_t *lenp, loff_t *ppos);
+
 /* debugging and troubleshooting/diagnostic helpers. */
 #define dev_printk(level, dev, format, arg...)	\
 	printk(level "%s %s: " format , (dev)->driver ? (dev)->driver->name : "" , (dev)->bus_id , ## arg)

Index: linux-export/include/linux/sysctl.h
===================================================================
@@ -691,6 +691,7 @@ enum {
 	DEV_RAID=4,
 	DEV_MAC_HID=5,
 	DEV_SCSI=6,
+	DEV_AUTOATTACH=7,
 };
 
 /* /proc/sys/dev/cdrom */

Index: linux-export/kernel/sysctl.c
===================================================================
@@ -41,6 +41,7 @@
 #include <linux/limits.h>
 #include <linux/dcache.h>
 #include <linux/syscalls.h>
+#include <linux/device.h>
 
 #include <asm/uaccess.h>
 #include <asm/processor.h>

@@ -936,6 +937,16 @@ static ctl_table debug_table[] = {
 };
 
 static ctl_table dev_table[] = {
+	{
+		.ctl_name	= DEV_AUTOATTACH,
+		.procname	= "autoattach",
+		.data		= &dev_autoattach,
+		.maxlen		= sizeof(int),
+		.mode		= 0644,
+		.proc_handler	= &dev_autoattach_handler,
+		.extra1		= &dev_autoattach_min,
+		.extra2		= &dev_autoattach_max,
+	},
 	{ .ctl_name = 0 }
 };  
 

Index: linux-export/drivers/base/interface.c
===================================================================
@@ -27,12 +27,13 @@
  *	driver's suspend method.
  */
 
-static ssize_t detach_show(struct device * dev, char * buf)
+static ssize_t detach_state_show(struct device * dev, char * buf)
 {
 	return sprintf(buf, "%u\n", dev->detach_state);
 }
 
-static ssize_t detach_store(struct device * dev, const char * buf, size_t n)
+static ssize_t detach_state_store(struct device * dev,
+				  const char * buf, size_t n)
 {
 	u32 state;
 	state = simple_strtoul(buf, NULL, 10);

@@ -42,7 +43,7 @@ static ssize_t detach_store(struct devic
 	return n;
 }
 
-static DEVICE_ATTR(detach_state, 0644, detach_show, detach_store);
+static DEVICE_ATTR(detach_state, 0644, detach_state_show, detach_state_store);
 
 
 struct attribute * dev_default_attrs[] = {

Index: linux-export/drivers/base/bus.c
===================================================================
@@ -287,7 +287,8 @@ void device_bind_driver(struct device * 
  *	If we find a match, we call @drv->probe(@dev) if it exists, and
  *	call device_bind_driver() above.
  */
-int driver_probe_device(struct device_driver * drv, struct device * dev)
+int driver_probe_device(struct device_driver * drv, struct device * dev,
+			const char *args)
 {
 	int error;
 

@@ -296,7 +297,7 @@ int driver_probe_device(struct device_dr
 
 	dev->driver = drv;
 
-	if ((error = devparam_set_params(dev)) != 0)
+	if ((error = devparam_set_params(dev, args)) != 0)
 		goto devparam_fail;
 
 	if (drv->probe) {

@@ -338,7 +339,7 @@ int device_attach(struct device * dev)
 	if (dev_autoattach && bus->match) {
 		list_for_each(entry, &bus->drivers.list) {
 			struct device_driver * drv = to_drv(entry);
-			error = driver_probe_device(drv, dev);
+			error = driver_probe_device(drv, dev, NULL);
 			if (!error)
 				/* success, driver matched */
 				return 1;

@@ -378,7 +379,7 @@ void driver_attach(struct device_driver 
 	list_for_each(entry, &bus->devices.list) {
 		struct device * dev = container_of(entry, struct device, bus_list);
 		if (!dev->driver) {
-			error = driver_probe_device(drv, dev);
+			error = driver_probe_device(drv, dev, NULL);
 			if (error && (error != -ENODEV))
 				/* driver matched but the probe failed */
 				printk(KERN_WARNING

138 lines not on this page · raw message

Index: linux-export/include/linux/device.h
===================================================================
@@ -342,7 +342,8 @@ extern int device_for_each_child(struct 
  * Manual binding of a device to driver. See drivers/base/bus.c
  * for information on use.
  */
-extern int  driver_probe_device(struct device_driver * drv, struct device * dev);
+extern int  driver_probe_device(struct device_driver * drv, struct device * dev,
+				const char *args);
 extern void device_bind_driver(struct device * dev);
 extern void device_release_driver(struct device * dev);
 extern int  device_attach(struct device * dev);

Index: linux-export/include/linux/deviceparam.h
===================================================================
@@ -220,7 +220,7 @@ int devparam_module_init(struct module *
 int devparam_unknown_modparam(char *name, char *val, void *arg);
 void devparam_module_done(struct module *module);
 
-int devparam_set_params(struct device *dev);
+int devparam_set_params(struct device *dev, const char *args);
 void devparam_release_params(struct device *dev);
 
 #endif /*__LINUX_DEVICEPARAM_H*/

Index: linux-export/drivers/base/interface.c
===================================================================
@@ -13,6 +13,7 @@
 #include <linux/err.h>
 #include <linux/stat.h>
 #include <linux/string.h>
+#include <linux/ctype.h>
 
 /**
  *	detach_state - control the default power state for the device.

@@ -46,7 +47,113 @@ static ssize_t detach_state_store(struct
 static DEVICE_ATTR(detach_state, 0644, detach_state_show, detach_state_store);
 
 
+/**
+ *	attach - manually attaches the device to the specified driver
+ *
+ *	When read, this node shows the list of the attachable drivers.
+ *	Writing the name of a driver attaches the device to the
+ *	driver.
+ */
+
+struct attach_show_arg {
+	struct device * dev;
+	char * buf;
+	size_t left;
+};
+
+static int attach_show_helper(struct device_driver * drv, void * void_arg)
+{
+	struct attach_show_arg * arg = void_arg;
+	int ret;
+
+	if (drv->bus->match(arg->dev, drv)) {
+		ret = snprintf(arg->buf, arg->left, "%s\n", drv->name);
+		if (ret >= arg->left)
+			return -ENOSPC;
+		arg->buf += ret;
+		arg->left -= ret;
+	}
+
+	return 0;
+}
+
+static ssize_t attach_show(struct device * dev, char * buf)
+{
+	struct attach_show_arg arg = { dev, buf, PAGE_SIZE };
+	int ret = 0;
+
+	if (dev->bus->match)
+		ret = bus_for_each_drv(dev->bus, NULL, &arg, attach_show_helper);
+
+	return ret ?: PAGE_SIZE - arg.left;
+}
+
+static int attach_store_helper(struct device_driver * drv, void * arg)
+{
+	const char * p = *(void **)arg;
+	int len;
+
+	len = strlen(drv->name);
+	if (!strncmp(drv->name, p, len) &&
+	    (p[len] == '\0' || isspace(p[len]))) {
+		*(void **)(arg) = get_driver(drv);
+		return 1;
+	}
+
+	return 0;
+}
+
+static ssize_t attach_store(struct device * dev, const char * buf, size_t n)
+{
+	void * arg = (void *)buf;
+	struct device_driver *drv;
+	int error;
+
+	if (bus_for_each_drv(dev->bus, NULL, &arg, attach_store_helper) == 0)
+		return -ENOENT;
+	drv = arg;
+
+	/* Skip driver name */
+	while (*buf != '\0' && !isspace(*buf))
+		buf++;
+
+	/* Attach */
+	error = -EBUSY;
+	down_write(&dev->bus->subsys.rwsem);
+	if (dev->driver == NULL)
+		error = driver_probe_device(drv, dev, buf);
+	up_write(&dev->bus->subsys.rwsem);
+
+	if (error)
+		printk(KERN_WARNING "%s: probe of %s failed with error %d\n",
+		       drv->name, dev->bus_id, error);
+
+	return error ?: n;
+}
+
+static DEVICE_ATTR(attach, 0644, attach_show, attach_store);
+
+
+/**
+ *	detach - manually detaches the device from its associated driver.
+ *
+ *	This is a write-only node.  When any value is written, it detaches
+ *	the device from its associated driver.
+ */
+static ssize_t detach_store(struct device * dev, const char * buf, size_t n)
+{
+	down_write(&dev->bus->subsys.rwsem);
+	device_release_driver(dev);
+	up_write(&dev->bus->subsys.rwsem);
+	return n;
+}
+
+static DEVICE_ATTR(detach, 0200, NULL, detach_store);
+
+
 struct attribute * dev_default_attrs[] = {
 	&dev_attr_detach_state.attr,
+	&dev_attr_attach.attr,
+	&dev_attr_detach.attr,
 	NULL,
 };

diff -Nru a/drivers/base/interface.c b/drivers/base/interface.c
@@ -13,6 +13,7 @@
 #include <linux/err.h>
 #include <linux/stat.h>
 #include <linux/string.h>
+#include <linux/ctype.h>
 
 /**
  *	detach_state - control the default power state for the device.

@@ -42,10 +43,81 @@
 	return n;
 }
 
-static DEVICE_ATTR(detach_state, 0644, detach_show, detach_store);
+/**
+ *	drvctl - controls device and driver binding.
+ *
+ *	Writing to the attribute causes execution of bus-specific drvctl()
+ *	helper that is used to disconnect device from its driver or rebind
+ *	device to a specific driver.
+ *	Commands are expected in the following format:
+ *	CMD [DRIVER_NAME] [ARG ARG ARG]
+ *	drvctl handler is free to mangle the args string.
+ */
+
+#define GET_WORD(x)					\
+do {							\
+	while (isspace(*args)) args++;			\
+	(x) = args;					\
+	while (*args && !isspace(*args)) args++;	\
+	if (isspace(*args)) {				\
+		save_chr = *args;			\
+		*args++ = '\0';				\
+	}						\
+} while (0)						\
 
+static ssize_t drvctl_store(struct device * dev, const char * buf, size_t count)
+{
+	int retval = -ENOSYS;
+	struct device_driver *drv = NULL;
+	char *str, *action, *drv_name, *args;
+	char save_chr = 0;
+
+	if (!dev->bus->drvctl)
+		return -ENOSYS;
+
+	/* copy buffer so we can mangle it */
+	if (!(args = str = kmalloc(count + 1, GFP_KERNEL)))
+		return -ENOMEM;
+
+	memcpy(str, buf, count);
+	str[count] = '\0';
+
+	GET_WORD(action);
+	GET_WORD(drv_name);
+
+	if (*drv_name) {
+		if (!(drv = driver_find(drv_name, dev->bus))) {
+			/*
+			 * if this is not a name of existing driver
+			 * merge it with thye rest of the string and
+			 * pass to drvctl as 'args'
+			 */
+			if (*args)
+				*--args = save_chr;
+			args = drv_name;
+		}
+	}
+
+	while (*args == ' ') args++;
+
+	pr_debug("drvctl -  action: '%s', driver: '%s', args: '%s'\n",
+		 action, drv ? drv->name : "", args);
+
+	retval = dev->bus->drvctl(dev, action, drv, args);
+
+	if (drv)
+		put_driver(drv);
+	kfree(str);
+
+	return (retval < 0) ? retval : count;
+}
+#undef GET_WORD
+
+static DEVICE_ATTR(detach_state, 0644, detach_show, detach_store);
+static DEVICE_ATTR(drvctl, 0200, NULL, drvctl_store);
 
 struct attribute * dev_default_attrs[] = {
 	&dev_attr_detach_state.attr,
+	&dev_attr_drvctl.attr,
 	NULL,
 };

85 lines not on this page · raw message

diff -Nru a/include/linux/device.h b/include/linux/device.h
@@ -59,7 +59,9 @@
 	struct driver_attribute	* drv_attrs;
 
 	int		(*match)(struct device * dev, struct device_driver * drv);
-	int		(*hotplug) (struct device *dev, char **envp, 
+	int		(*drvctl)(struct device * dev, const char * action,
+				  struct device_driver * drv, char * args);
+	int		(*hotplug) (struct device *dev, char **envp,
 				    int num_envp, char *buffer, int buffer_size);
 	int		(*suspend)(struct device * dev, u32 state);
 	int		(*resume)(struct device * dev);

diff -Nru a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
@@ -186,7 +186,7 @@
  *                    PCI device id structure
  * @ids: array of PCI device id structures to search in
  * @dev: the PCI device structure to match against
- * 
+ *
  * Used by a driver to check whether a PCI device present in the
  * system is in its list of supported devices.Returns the matching
  * pci_device_id structure or %NULL if there is no match.

@@ -204,12 +204,12 @@
 
 /**
  * pci_device_probe_static()
- * 
+ *
  * returns 0 and sets pci_dev->driver when drv claims pci_dev, else error.
  */
 static int
 pci_device_probe_static(struct pci_driver *drv, struct pci_dev *pci_dev)
-{		   
+{
 	int error = -ENODEV;
 	const struct pci_device_id *id;
 

@@ -227,13 +227,13 @@
 
 /**
  * __pci_device_probe()
- * 
+ *
  * returns 0  on success, else error.
  * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
  */
 static int
 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
-{		   
+{
 	int error = 0;
 
 	if (!pci_dev->driver && drv->probe) {

@@ -314,7 +314,7 @@
 }
 
 
-/* 
+/*
  * Default resume method for devices that have no driver provided resume,
  * or not even a driver at all.
  */

@@ -394,10 +394,10 @@
 /**
  * pci_register_driver - register a new pci driver
  * @drv: the driver structure to register
- * 
+ *
  * Adds the driver structure to the list of registered drivers.
- * Returns a negative value on error, otherwise 0. 
- * If no error occured, the driver remains registered even if 
+ * Returns a negative value on error, otherwise 0.
+ * If no error occured, the driver remains registered even if
  * no device was claimed during registration.
  */
 int pci_register_driver(struct pci_driver *drv)

@@ -425,7 +425,7 @@
 /**
  * pci_unregister_driver - unregister a pci driver
  * @drv: the driver structure to unregister
- * 
+ *
  * Deletes the driver structure from the list of registered PCI drivers,
  * gives it a chance to clean up by calling its remove() function for
  * each device it was responsible for, and marks those devices as

@@ -447,7 +447,7 @@
  * pci_dev_driver - get the pci_driver of a device
  * @dev: the device to query
  *
- * Returns the appropriate pci_driver structure or %NULL if there is no 
+ * Returns the appropriate pci_driver structure or %NULL if there is no
  * registered driver for the device.
  */
 struct pci_driver *

@@ -457,7 +457,7 @@
 		return dev->driver;
 	else {
 		int i;
-		for(i=0; i<=PCI_ROM_RESOURCE; i++)
+		for(i = 0; i <= PCI_ROM_RESOURCE; i++)
 			if (dev->resource[i].flags & IORESOURCE_BUSY)
 				return &pci_compat_driver;
 	}

@@ -468,12 +468,12 @@
  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
  * @ids: array of PCI device id structures to search in
  * @dev: the PCI device structure to match against
- * 
+ *
  * Used by a driver to check whether a PCI device present in the
  * system is in its list of supported devices.Returns the matching
  * pci_device_id structure or %NULL if there is no match.
  */
-static int pci_bus_match(struct device * dev, struct device_driver * drv) 
+static int pci_bus_match(struct device * dev, struct device_driver * drv)
 {
 	const struct pci_dev * pci_dev = to_pci_dev(dev);
 	struct pci_driver * pci_drv = to_pci_driver(drv);

@@ -490,6 +490,35 @@
 	return pci_bus_match_dynids(pci_dev, pci_drv);
 }
 
+/*
+ * This is PCI bus's drvctl method that handles manual device binding.
+ */
+static int pci_rebind_driver(struct device *dev, const char *action,
+			     struct device_driver *drv, char *args)
+{
+	int retval = 0;
+
+	if (!strcmp(action, "detach")) {
+		down_write(&dev->bus->subsys.rwsem);
+		device_release_driver(dev);
+		up_write(&dev->bus->subsys.rwsem);
+	} else if (!strcmp(action, "rescan")) {
+		down_write(&dev->bus->subsys.rwsem);
+		device_release_driver(dev);
+		device_attach(dev);
+		up_write(&dev->bus->subsys.rwsem);
+	} else if (!strcmp(action, "attach") && drv) {
+		down_write(&dev->bus->subsys.rwsem);
+		device_release_driver(dev);
+		driver_probe_device(drv, dev);
+		up_write(&dev->bus->subsys.rwsem);
+	} else {
+		retval = -EINVAL;
+	}
+
+	return retval;
+}
+
 /**
  * pci_dev_get - increments the reference count of the pci device structure
  * @dev: the device being referenced

@@ -534,6 +563,7 @@
 	.name		= "pci",
 	.match		= pci_bus_match,
 	.hotplug	= pci_hotplug,
+	.drvctl		= pci_rebind_driver,
 	.suspend	= pci_device_suspend,
 	.resume		= pci_device_resume,
 	.dev_attrs	= pci_dev_attrs,

diff -Nru a/drivers/base/bus.c b/drivers/base/bus.c
@@ -68,9 +68,12 @@
 	up(&drv->unload_sem);
 }
 
+extern struct attribute * drv_default_attrs[];
+
 static struct kobj_type ktype_driver = {
 	.sysfs_ops	= &driver_sysfs_ops,
 	.release	= driver_release,
+	.default_attrs	= drv_default_attrs,
 };
 
 

@@ -319,9 +322,12 @@
 		return 1;
 	}
 
-	if (bus->match) {
-		list_for_each(entry, &bus->drivers.list) {
-			struct device_driver * drv = to_drv(entry);
+	if (dev->manual_bind || !bus->match)
+		return 0;
+
+	list_for_each(entry, &bus->drivers.list) {
+		struct device_driver * drv = to_drv(entry);
+		if (!drv->manual_bind) {
 			error = driver_probe_device(drv, dev);
 			if (!error)
 				/* success, driver matched */

@@ -329,8 +335,8 @@
 			if (error != -ENODEV)
 				/* driver matched but the probe failed */
 				printk(KERN_WARNING
-				    "%s: probe of %s failed with error %d\n",
-				    drv->name, dev->bus_id, error);
+					"%s: probe of %s failed with error %d\n",
+					drv->name, dev->bus_id, error);
 		}
 	}
 

@@ -356,12 +362,12 @@
 	struct list_head * entry;
 	int error;
 
-	if (!bus->match)
+	if (drv->manual_bind || !bus->match)
 		return;
 
 	list_for_each(entry, &bus->devices.list) {
 		struct device * dev = container_of(entry, struct device, bus_list);
-		if (!dev->driver) {
+		if (!dev->driver && !dev->manual_bind) {
 			error = driver_probe_device(drv, dev);
 			if (error && (error != -ENODEV))
 				/* driver matched but the probe failed */

115 lines not on this page · raw message

99 lines not on this page · raw message

diff -Nru a/drivers/input/serio/serio_raw.c b/drivers/input/serio/serio_raw.c
@@ -365,14 +365,14 @@
 
 static struct serio_driver serio_raw_drv = {
 	.driver		= {
-		.name	= "serio_raw",
+		.name		= "serio_raw",
+		.manual_bind	= 1,
 	},
 	.description	= DRIVER_DESC,
 	.interrupt	= serio_raw_interrupt,
 	.connect	= serio_raw_connect,
 	.reconnect	= serio_raw_reconnect,
 	.disconnect	= serio_raw_disconnect,
-	.manual_bind	= 1,
 };
 
 int __init serio_raw_init(void)

diff -Nru a/include/linux/device.h b/include/linux/device.h
@@ -104,6 +104,8 @@
 	char			* name;
 	struct bus_type		* bus;
 
+	unsigned int		manual_bind;
+
 	struct semaphore	unload_sem;
 	struct kobject		kobj;
 	struct list_head	devices;

@@ -266,6 +268,9 @@
 	struct bus_type	* bus;		/* type of bus device is on */
 	struct device_driver *driver;	/* which driver has allocated this
 					   device */
+	unsigned int manual_bind;	/* indicates whether the core will
+					   try to find a driver for the
+					   device automatically */
 	void		*driver_data;	/* data private to the driver */
 	void		*platform_data;	/* Platform specific data (e.g. ACPI,
 					   BIOS data relevant to device) */

diff -Nru a/include/linux/serio.h b/include/linux/serio.h
@@ -27,8 +27,6 @@
 	char name[32];
 	char phys[32];
 
-	unsigned int manual_bind;
-
 	unsigned short idbus;
 	unsigned short idvendor;
 	unsigned short idproduct;

@@ -59,8 +57,6 @@
 struct serio_driver {
 	void *private;
 	char *description;
-
-	unsigned int manual_bind;
 
 	void (*write_wakeup)(struct serio *);
 	irqreturn_t (*interrupt)(struct serio *, unsigned char,