Commit 3c803e8e authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Commit the manual part of the input layer merge. 

git did actually warn me about the fact that I hadn't actually done an
"update-cache" on these two files, but the warning was at the bottom of
a list of all the files that _did_ change in the merge, so I never
noticed.  My bad.
parent c47abbbf

drivers/input/gameport/gameport.c

+12 −19
Original line number Diff line number Diff line
@@ -17,11 +17,10 @@ 
#include <linux/init.h>

#include <linux/gameport.h>

#include <linux/wait.h>

#include <linux/completion.h>

#include <linux/sched.h>

#include <linux/smp_lock.h>

#include <linux/slab.h>

#include <linux/delay.h>

#include <linux/kthread.h>



/*#include <asm/io.h>*/
@@ -238,8 +237,7 @@ struct gameport_event { 
static DEFINE_SPINLOCK(gameport_event_lock);	/* protects gameport_event_list */

static LIST_HEAD(gameport_event_list);

static DECLARE_WAIT_QUEUE_HEAD(gameport_wait);

static DECLARE_COMPLETION(gameport_exited);

static int gameport_pid;

static struct task_struct *gameport_task;



static void gameport_queue_event(void *object, struct module *owner,

			      enum gameport_event_type event_type)
@@ -432,20 +430,15 @@ static struct gameport *gameport_get_pending_child(struct gameport *parent) 


static int gameport_thread(void *nothing)

{

	lock_kernel();

	daemonize("kgameportd");

	allow_signal(SIGTERM);



	do {

		gameport_handle_events();

		wait_event_interruptible(gameport_wait, !list_empty(&gameport_event_list));

		wait_event_interruptible(gameport_wait,

			kthread_should_stop() || !list_empty(&gameport_event_list));

		try_to_freeze();

	} while (!signal_pending(current));

	} while (!kthread_should_stop());



	printk(KERN_DEBUG "gameport: kgameportd exiting\n");



	unlock_kernel();

	complete_and_exit(&gameport_exited, 0);

	return 0;

}
@@ -773,9 +766,10 @@ void gameport_close(struct gameport *gameport) 


static int __init gameport_init(void)

{

	if (!(gameport_pid = kernel_thread(gameport_thread, NULL, CLONE_KERNEL))) {

	gameport_task = kthread_run(gameport_thread, NULL, "kgameportd");

	if (IS_ERR(gameport_task)) {

		printk(KERN_ERR "gameport: Failed to start kgameportd\n");

		return -1;

		return PTR_ERR(gameport_task);

	}



	gameport_bus.dev_attrs = gameport_device_attrs;
@@ -789,8 +783,7 @@ static int __init gameport_init(void) 
static void __exit gameport_exit(void)

{

	bus_unregister(&gameport_bus);

	kill_proc(gameport_pid, SIGTERM, 1);

	wait_for_completion(&gameport_exited);

	kthread_stop(gameport_task);

}



module_init(gameport_init);

drivers/input/serio/serio.c

+62 −27
Original line number Diff line number Diff line
@@ -31,10 +31,9 @@ 
#include <linux/serio.h>

#include <linux/errno.h>

#include <linux/wait.h>

#include <linux/completion.h>

#include <linux/sched.h>

#include <linux/smp_lock.h>

#include <linux/slab.h>

#include <linux/kthread.h>



MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");

MODULE_DESCRIPTION("Serio abstraction core");
@@ -43,6 +42,7 @@ MODULE_LICENSE("GPL"); 
EXPORT_SYMBOL(serio_interrupt);

EXPORT_SYMBOL(__serio_register_port);

EXPORT_SYMBOL(serio_unregister_port);

EXPORT_SYMBOL(serio_unregister_child_port);

EXPORT_SYMBOL(__serio_unregister_port_delayed);

EXPORT_SYMBOL(__serio_register_driver);

EXPORT_SYMBOL(serio_unregister_driver);
@@ -68,6 +68,37 @@ static void serio_destroy_port(struct serio *serio); 
static void serio_reconnect_port(struct serio *serio);

static void serio_disconnect_port(struct serio *serio);



static int serio_connect_driver(struct serio *serio, struct serio_driver *drv)

{

	int retval;



	down(&serio->drv_sem);

	retval = drv->connect(serio, drv);

	up(&serio->drv_sem);



	return retval;

}



static int serio_reconnect_driver(struct serio *serio)

{

	int retval = -1;



	down(&serio->drv_sem);

	if (serio->drv && serio->drv->reconnect)

		retval = serio->drv->reconnect(serio);

	up(&serio->drv_sem);



	return retval;

}



static void serio_disconnect_driver(struct serio *serio)

{

	down(&serio->drv_sem);

	if (serio->drv)

		serio->drv->disconnect(serio);

	up(&serio->drv_sem);

}



static int serio_match_port(const struct serio_device_id *ids, struct serio *serio)

{

	while (ids->type || ids->proto) {
@@ -91,7 +122,7 @@ static void serio_bind_driver(struct serio *serio, struct serio_driver *drv) 


	if (serio_match_port(drv->id_table, serio)) {

		serio->dev.driver = &drv->driver;

		if (drv->connect(serio, drv)) {

		if (serio_connect_driver(serio, drv)) {

			serio->dev.driver = NULL;

			goto out;

		}
@@ -138,8 +169,7 @@ struct serio_event { 
static DEFINE_SPINLOCK(serio_event_lock);	/* protects serio_event_list */

static LIST_HEAD(serio_event_list);

static DECLARE_WAIT_QUEUE_HEAD(serio_wait);

static DECLARE_COMPLETION(serio_exited);

static int serio_pid;

static struct task_struct *serio_task;



static void serio_queue_event(void *object, struct module *owner,

			      enum serio_event_type event_type)
@@ -337,20 +367,15 @@ static struct serio *serio_get_pending_child(struct serio *parent) 


static int serio_thread(void *nothing)

{

	lock_kernel();

	daemonize("kseriod");

	allow_signal(SIGTERM);



	do {

		serio_handle_events();

		wait_event_interruptible(serio_wait, !list_empty(&serio_event_list));

		wait_event_interruptible(serio_wait,

			kthread_should_stop() || !list_empty(&serio_event_list));

		try_to_freeze();

	} while (!signal_pending(current));

	} while (!kthread_should_stop());



	printk(KERN_DEBUG "serio: kseriod exiting\n");



	unlock_kernel();

	complete_and_exit(&serio_exited, 0);

	return 0;

}
@@ -557,7 +582,7 @@ static void serio_destroy_port(struct serio *serio) 
static void serio_reconnect_port(struct serio *serio)

{

	do {

		if (!serio->drv || !serio->drv->reconnect || serio->drv->reconnect(serio)) {

		if (serio_reconnect_driver(serio)) {

			serio_disconnect_port(serio);

			serio_find_driver(serio);

			/* Ok, old children are now gone, we are done */
@@ -629,6 +654,19 @@ void serio_unregister_port(struct serio *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
@@ -686,15 +724,14 @@ 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 drv->connect(serio, drv);

	return serio_connect_driver(serio, drv);

}



static int serio_driver_remove(struct device *dev)

{

	struct serio *serio = to_serio_port(dev);

	struct serio_driver *drv = to_serio_driver(dev->driver);



	drv->disconnect(serio);

	serio_disconnect_driver(serio);

	return 0;

}
@@ -730,11 +767,9 @@ void serio_unregister_driver(struct serio_driver *drv) 


static void serio_set_drv(struct serio *serio, struct serio_driver *drv)

{

	down(&serio->drv_sem);

	serio_pause_rx(serio);

	serio->drv = drv;

	serio_continue_rx(serio);

	up(&serio->drv_sem);

}



static int serio_bus_match(struct device *dev, struct device_driver *drv)
@@ -794,7 +829,7 @@ static int serio_resume(struct device *dev) 
{

	struct serio *serio = to_serio_port(dev);



	if (!serio->drv || !serio->drv->reconnect || serio->drv->reconnect(serio)) {

	if (serio_reconnect_driver(serio)) {

		/*

		 * Driver re-probing can take a while, so better let kseriod

		 * deal with it.
@@ -848,9 +883,10 @@ irqreturn_t serio_interrupt(struct serio *serio, 


static int __init serio_init(void)

{

	if (!(serio_pid = kernel_thread(serio_thread, NULL, CLONE_KERNEL))) {

	serio_task = kthread_run(serio_thread, NULL, "kseriod");

	if (IS_ERR(serio_task)) {

		printk(KERN_ERR "serio: Failed to start kseriod\n");

		return -1;

		return PTR_ERR(serio_task);

	}



	serio_bus.dev_attrs = serio_device_attrs;
@@ -866,8 +902,7 @@ static int __init serio_init(void) 
static void __exit serio_exit(void)

{

	bus_unregister(&serio_bus);

	kill_proc(serio_pid, SIGTERM, 1);

	wait_for_completion(&serio_exited);

	kthread_stop(serio_task);

}



module_init(serio_init);