serio_disconnect_port(serio);		serio_bind_driver(serio, to_serio_driver(drv));		put_driver(drv);	} else {		retval = -EINVAL;	}	up(&serio_sem);	return retval;}static ssize_t serio_show_bind_mode(struct device *dev, struct device_attribute *attr, char *buf){	struct serio *serio = to_serio_port(dev);	return sprintf(buf, "%s\n", serio->manual_bind ? "manual" : "auto");}static ssize_t serio_set_bind_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){	struct serio *serio = to_serio_port(dev);	int retval;	retval = count;	if (!strncmp(buf, "manual", count)) {		serio->manual_bind = 1;	} else if (!strncmp(buf, "auto", count)) {		serio->manual_bind = 0;	} else {		retval = -EINVAL;	}	return retval;}static struct device_attribute serio_device_attrs[] = {	__ATTR(description, S_IRUGO, serio_show_description, NULL),	__ATTR(modalias, S_IRUGO, serio_show_modalias, NULL),	__ATTR(drvctl, S_IWUSR, NULL, serio_rebind_driver),	__ATTR(bind_mode, S_IWUSR | S_IRUGO, serio_show_bind_mode, serio_set_bind_mode),	__ATTR_NULL};static void serio_release_port(struct device *dev){	struct serio *serio = to_serio_port(dev);	kfree(serio);	module_put(THIS_MODULE);}/* * Prepare serio port for registration. */static void serio_init_port(struct serio *serio){	static atomic_t serio_no = ATOMIC_INIT(0);	__module_get(THIS_MODULE);	spin_lock_init(&serio->lock);	init_MUTEX(&serio->drv_sem);	device_initialize(&serio->dev);	snprintf(serio->dev.bus_id, sizeof(serio->dev.bus_id),		 "serio%ld", (long)atomic_inc_return(&serio_no) - 1);	serio->dev.bus = &serio_bus;	serio->dev.release = serio_release_port;	if (serio->parent)		serio->dev.parent = &serio->parent->dev;}/* * Complete serio port registration. * Driver core will attempt to find appropriate driver for the port. */static void serio_add_port(struct serio *serio){	if (serio->parent) {		serio_pause_rx(serio->parent);		serio->parent->child = serio;		serio_continue_rx(serio->parent);	}	list_add_tail(&serio->node, &serio_list);	if (serio->start)		serio->start(serio);	device_add(&serio->dev);	sysfs_create_group(&serio->dev.kobj, &serio_id_attr_group);	serio->registered = 1;}/* * serio_destroy_port() completes deregistration process and removes * port from the system */static void serio_destroy_port(struct serio *serio){	struct serio *child;	child = serio_get_pending_child(serio);	if (child) {		serio_remove_pending_events(child);		put_device(&child->dev);	}	if (serio->stop)		serio->stop(serio);	if (serio->parent) {		serio_pause_rx(serio->parent);		serio->parent->child = NULL;		serio_continue_rx(serio->parent);		serio->parent = NULL;	}	if (serio->registered) {		sysfs_remove_group(&serio->dev.kobj, &serio_id_attr_group);		device_del(&serio->dev);		list_del_init(&serio->node);		serio->registered = 0;	}	serio_remove_pending_events(serio);	put_device(&serio->dev);}/* * Reconnect serio port and all its children (re-initialize attached devices) */static void serio_reconnect_port(struct serio *serio){	do {		if (serio_reconnect_driver(serio)) {			serio_disconnect_port(serio);			serio_find_driver(serio);			/* Ok, old children are now gone, we are done */			break;		}		serio = serio->child;	} while (serio);}/* * serio_disconnect_port() unbinds a port from its driver. As a side effect * all child ports are unbound and destroyed. */static void serio_disconnect_port(struct serio *serio){	struct serio *s, *parent;	if (serio->child) {		/*		 * Children ports should be disconnected and destroyed		 * first, staring with the leaf one, since we don't want		 * to do recursion		 */		for (s = serio; s->child; s = s->child)			/* empty */;		do {			parent = s->parent;			serio_release_driver(s);			serio_destroy_port(s);		} while ((s = parent) != serio);	}	/*	 * Ok, no children left, now disconnect this port	 */	serio_release_driver(serio);}void serio_rescan(struct serio *serio){	serio_queue_event(serio, NULL, SERIO_RESCAN);}void serio_reconnect(struct serio *serio){	serio_queue_event(serio, NULL, SERIO_RECONNECT);}/* * Submits register request to kseriod for subsequent execution. * Note that port registration is always asynchronous. */void __serio_register_port(struct serio *serio, struct module *owner){	serio_init_port(serio);	serio_queue_event(serio, owner, SERIO_REGISTER_PORT);}/* * Synchronously unregisters serio port. */void serio_unregister_port(struct serio *serio){	down(&serio_sem);	serio_disconnect_port(serio);	serio_destroy_port(serio);	up(&serio_sem);}/* * Safely unregisters child port if one is present. */void serio_unregister_child_port(struct serio *serio){	down(&serio_sem);	if (serio->child) {		serio_disconnect_port(serio->child);		serio_destroy_port(serio->child);	}	up(&serio_sem);}/* * Submits register request to kseriod for subsequent execution. * Can be used when it is not obvious whether the serio_sem is * taken or not and when delayed execution is feasible. */void __serio_unregister_port_delayed(struct serio *serio, struct module *owner){	serio_queue_event(serio, owner, SERIO_UNREGISTER_PORT);}/* * Serio driver operations */static ssize_t serio_driver_show_description(struct device_driver *drv, char *buf){	struct serio_driver *driver = to_serio_driver(drv);	return sprintf(buf, "%s\n", driver->description ? driver->description : "(none)");}static ssize_t serio_driver_show_bind_mode(struct device_driver *drv, char *buf){	struct serio_driver *serio_drv = to_serio_driver(drv);	return sprintf(buf, "%s\n", serio_drv->manual_bind ? "manual" : "auto");}static ssize_t serio_driver_set_bind_mode(struct device_driver *drv, const char *buf, size_t count){	struct serio_driver *serio_drv = to_serio_driver(drv);	int retval;	retval = count;	if (!strncmp(buf, "manual", count)) {		serio_drv->manual_bind = 1;	} else if (!strncmp(buf, "auto", count)) {		serio_drv->manual_bind = 0;	} else {		retval = -EINVAL;	}	return retval;}static struct driver_attribute serio_driver_attrs[] = {	__ATTR(description, S_IRUGO, serio_driver_show_description, NULL),	__ATTR(bind_mode, S_IWUSR | S_IRUGO,		serio_driver_show_bind_mode, serio_driver_set_bind_mode),	__ATTR_NULL};static int serio_driver_probe(struct device *dev){	struct serio *serio = to_serio_port(dev);	struct serio_driver *drv = to_serio_driver(dev->driver);	return serio_connect_driver(serio, drv);}static int serio_driver_remove(struct device *dev){	struct serio *serio = to_serio_port(dev);	serio_disconnect_driver(serio);	return 0;}void __serio_register_driver(struct serio_driver *drv, struct module *owner){	drv->driver.bus = &serio_bus;	drv->driver.probe = serio_driver_probe;	drv->driver.remove = serio_driver_remove;	serio_queue_event(drv, owner, SERIO_REGISTER_DRIVER);}void serio_unregister_driver(struct serio_driver *drv){	struct serio *serio;	down(&serio_sem);	drv->manual_bind = 1;	/* so serio_find_driver ignores it */start_over:	list_for_each_entry(serio, &serio_list, node) {		if (serio->drv == drv) {			serio_disconnect_port(serio);			serio_find_driver(serio);			/* we could've deleted some ports, restart */			goto start_over;		}	}	driver_unregister(&drv->driver);	up(&serio_sem);}static void serio_set_drv(struct serio *serio, struct serio_driver *drv){	serio_pause_rx(serio);	serio->drv = drv;	serio_continue_rx(serio);}static int serio_bus_match(struct device *dev, struct device_driver *drv){	struct serio *serio = to_serio_port(dev);	struct serio_driver *serio_drv = to_serio_driver(drv);	if (serio->manual_bind || serio_drv->manual_bind)		return 0;	return serio_match_port(serio_drv->id_table, serio);}#ifdef CONFIG_HOTPLUG#define SERIO_ADD_HOTPLUG_VAR(fmt, val...)				\	do {								\		int err = add_hotplug_env_var(envp, num_envp, &i,	\					buffer, buffer_size, &len,	\					fmt, val);			\		if (err)						\			return err;					\	} while (0)static int serio_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size){	struct serio *serio;	int i = 0;	int len = 0;	if (!dev)		return -ENODEV;	serio = to_serio_port(dev);	SERIO_ADD_HOTPLUG_VAR("SERIO_TYPE=%02x", serio->id.type);	SERIO_ADD_HOTPLUG_VAR("SERIO_PROTO=%02x", serio->id.proto);	SERIO_ADD_HOTPLUG_VAR("SERIO_ID=%02x", serio->id.id);	SERIO_ADD_HOTPLUG_VAR("SERIO_EXTRA=%02x", serio->id.extra);	SERIO_ADD_HOTPLUG_VAR("MODALIAS=serio:ty%02Xpr%02Xid%02Xex%02X",				serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);	envp[i] = NULL;	return 0;}#undef SERIO_ADD_HOTPLUG_VAR#elsestatic int serio_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size){	return -ENODEV;}#endif /* CONFIG_HOTPLUG */static int serio_resume(struct device *dev){	struct serio *serio = to_serio_port(dev);	if (serio_reconnect_driver(serio)) {		/*		 * Driver re-probing can take a while, so better let kseriod		 * deal with it.		 */		serio_rescan(serio);	}	return 0;}/* called from serio_driver->connect/disconnect methods under serio_sem */int serio_open(struct serio *serio, struct serio_driver *drv){	serio_set_drv(serio, drv);	if (serio->open && serio->open(serio)) {		serio_set_drv(serio, NULL);		return -1;	}	return 0;}/* called from serio_driver->connect/disconnect methods under serio_sem */void serio_close(struct serio *serio){	if (serio->close)		serio->close(serio);	serio_set_drv(serio, NULL);}irqreturn_t serio_interrupt(struct serio *serio,		unsigned char data, unsigned int dfl, struct pt_regs *regs){	unsigned long flags;	irqreturn_t ret = IRQ_NONE;	spin_lock_irqsave(&serio->lock, flags);        if (likely(serio->drv)) {                ret = serio->drv->interrupt(serio, data, dfl, regs);	} else if (!dfl && serio->registered) {		serio_rescan(serio);		ret = IRQ_HANDLED;	}	spin_unlock_irqrestore(&serio->lock, flags);	return ret;}static int __init serio_init(void){	serio_task = kthread_run(serio_thread, NULL, "kseriod");	if (IS_ERR(serio_task)) {		printk(KERN_ERR "serio: Failed to start kseriod\n");		return PTR_ERR(serio_task);	}	serio_bus.dev_attrs = serio_device_attrs;	serio_bus.drv_attrs = serio_driver_attrs;	serio_bus.match = serio_bus_match;	serio_bus.hotplug = serio_hotplug;	serio_bus.resume = serio_resume;	bus_register(&serio_bus);	return 0;}static void __exit serio_exit(void){	bus_unregister(&serio_bus);	kthread_stop(serio_task);}module_init(serio_init);module_exit(serio_exit);