2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Generic gameport layer
|
|
|
|
*
|
|
|
|
* Copyright (c) 1999-2002 Vojtech Pavlik
|
|
|
|
* Copyright (c) 2005 Dmitry Torokhov
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of the GNU General Public License version 2 as published by
|
|
|
|
* the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
2010-01-06 08:56:03 +07:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/gameport.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/delay.h>
|
2010-11-15 16:39:57 +07:00
|
|
|
#include <linux/workqueue.h>
|
2005-10-31 06:03:48 +07:00
|
|
|
#include <linux/sched.h> /* HZ */
|
2006-02-19 12:22:03 +07:00
|
|
|
#include <linux/mutex.h>
|
2014-09-12 00:28:30 +07:00
|
|
|
#include <linux/timekeeping.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*#include <asm/io.h>*/
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
|
|
|
|
MODULE_DESCRIPTION("Generic gameport layer");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2014-09-12 00:28:30 +07:00
|
|
|
static bool use_ktime = true;
|
|
|
|
module_param(use_ktime, bool, 0400);
|
|
|
|
MODULE_PARM_DESC(use_ktime, "Use ktime for measuring I/O speed");
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2006-02-19 12:22:03 +07:00
|
|
|
* gameport_mutex protects entire gameport subsystem and is taken
|
2005-04-17 05:20:36 +07:00
|
|
|
* every time gameport port or driver registrered or unregistered.
|
|
|
|
*/
|
2006-02-19 12:22:03 +07:00
|
|
|
static DEFINE_MUTEX(gameport_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
static LIST_HEAD(gameport_list);
|
|
|
|
|
2006-01-05 21:38:22 +07:00
|
|
|
static struct bus_type gameport_bus;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
static void gameport_add_port(struct gameport *gameport);
|
2009-04-14 05:27:49 +07:00
|
|
|
static void gameport_attach_driver(struct gameport_driver *drv);
|
2005-04-17 05:20:36 +07:00
|
|
|
static void gameport_reconnect_port(struct gameport *gameport);
|
|
|
|
static void gameport_disconnect_port(struct gameport *gameport);
|
|
|
|
|
|
|
|
#if defined(__i386__)
|
|
|
|
|
2011-06-02 01:04:57 +07:00
|
|
|
#include <linux/i8253.h>
|
2005-06-30 16:58:55 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#define DELTA(x,y) ((y)-(x)+((y)<(x)?1193182/HZ:0))
|
|
|
|
#define GET_TIME(x) do { x = get_time_pit(); } while (0)
|
|
|
|
|
|
|
|
static unsigned int get_time_pit(void)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int count;
|
|
|
|
|
2010-02-17 23:47:10 +07:00
|
|
|
raw_spin_lock_irqsave(&i8253_lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
outb_p(0x00, 0x43);
|
|
|
|
count = inb_p(0x40);
|
|
|
|
count |= inb_p(0x40) << 8;
|
2010-02-17 23:47:10 +07:00
|
|
|
raw_spin_unlock_irqrestore(&i8253_lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* gameport_measure_speed() measures the gameport i/o speed.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gameport_measure_speed(struct gameport *gameport)
|
2014-09-12 00:28:30 +07:00
|
|
|
{
|
|
|
|
unsigned int i, t, tx;
|
|
|
|
u64 t1, t2, t3;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (gameport_open(gameport, NULL, GAMEPORT_MODE_RAW))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
tx = ~0;
|
|
|
|
|
|
|
|
for (i = 0; i < 50; i++) {
|
|
|
|
local_irq_save(flags);
|
|
|
|
t1 = ktime_get_ns();
|
|
|
|
for (t = 0; t < 50; t++)
|
|
|
|
gameport_read(gameport);
|
|
|
|
t2 = ktime_get_ns();
|
|
|
|
t3 = ktime_get_ns();
|
|
|
|
local_irq_restore(flags);
|
|
|
|
udelay(i * 10);
|
|
|
|
t = (t2 - t1) - (t3 - t2);
|
|
|
|
if (t < tx)
|
|
|
|
tx = t;
|
|
|
|
}
|
|
|
|
|
|
|
|
gameport_close(gameport);
|
|
|
|
t = 1000000 * 50;
|
|
|
|
if (tx)
|
|
|
|
t /= tx;
|
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int old_gameport_measure_speed(struct gameport *gameport)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
#if defined(__i386__)
|
|
|
|
|
|
|
|
unsigned int i, t, t1, t2, t3, tx;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (gameport_open(gameport, NULL, GAMEPORT_MODE_RAW))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
tx = 1 << 30;
|
|
|
|
|
|
|
|
for(i = 0; i < 50; i++) {
|
|
|
|
local_irq_save(flags);
|
|
|
|
GET_TIME(t1);
|
|
|
|
for (t = 0; t < 50; t++) gameport_read(gameport);
|
|
|
|
GET_TIME(t2);
|
|
|
|
GET_TIME(t3);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
udelay(i * 10);
|
|
|
|
if ((t = DELTA(t2,t1) - DELTA(t3,t2)) < tx) tx = t;
|
|
|
|
}
|
|
|
|
|
|
|
|
gameport_close(gameport);
|
|
|
|
return 59659 / (tx < 1 ? 1 : tx);
|
|
|
|
|
|
|
|
#elif defined (__x86_64__)
|
|
|
|
|
|
|
|
unsigned int i, t;
|
|
|
|
unsigned long tx, t1, t2, flags;
|
|
|
|
|
|
|
|
if (gameport_open(gameport, NULL, GAMEPORT_MODE_RAW))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
tx = 1 << 30;
|
|
|
|
|
|
|
|
for(i = 0; i < 50; i++) {
|
|
|
|
local_irq_save(flags);
|
2015-06-25 23:44:07 +07:00
|
|
|
t1 = rdtsc();
|
2005-04-17 05:20:36 +07:00
|
|
|
for (t = 0; t < 50; t++) gameport_read(gameport);
|
2015-06-25 23:44:07 +07:00
|
|
|
t2 = rdtsc();
|
2005-04-17 05:20:36 +07:00
|
|
|
local_irq_restore(flags);
|
|
|
|
udelay(i * 10);
|
|
|
|
if (t2 - t1 < tx) tx = t2 - t1;
|
|
|
|
}
|
|
|
|
|
|
|
|
gameport_close(gameport);
|
2010-12-17 01:15:15 +07:00
|
|
|
return (this_cpu_read(cpu_info.loops_per_jiffy) *
|
2007-10-20 01:35:04 +07:00
|
|
|
(unsigned long)HZ / (1000 / 50)) / (tx < 1 ? 1 : tx);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
unsigned int j, t = 0;
|
|
|
|
|
|
|
|
if (gameport_open(gameport, NULL, GAMEPORT_MODE_RAW))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
j = jiffies; while (j == jiffies);
|
|
|
|
j = jiffies; while (j == jiffies) { t++; gameport_read(gameport); }
|
|
|
|
|
|
|
|
gameport_close(gameport);
|
|
|
|
return t * HZ / 1000;
|
|
|
|
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void gameport_start_polling(struct gameport *gameport)
|
|
|
|
{
|
|
|
|
spin_lock(&gameport->timer_lock);
|
|
|
|
|
|
|
|
if (!gameport->poll_cnt++) {
|
|
|
|
BUG_ON(!gameport->poll_handler);
|
|
|
|
BUG_ON(!gameport->poll_interval);
|
|
|
|
mod_timer(&gameport->poll_timer, jiffies + msecs_to_jiffies(gameport->poll_interval));
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&gameport->timer_lock);
|
|
|
|
}
|
2009-04-18 10:12:05 +07:00
|
|
|
EXPORT_SYMBOL(gameport_start_polling);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
void gameport_stop_polling(struct gameport *gameport)
|
|
|
|
{
|
|
|
|
spin_lock(&gameport->timer_lock);
|
|
|
|
|
|
|
|
if (!--gameport->poll_cnt)
|
|
|
|
del_timer(&gameport->poll_timer);
|
|
|
|
|
|
|
|
spin_unlock(&gameport->timer_lock);
|
|
|
|
}
|
2009-04-18 10:12:05 +07:00
|
|
|
EXPORT_SYMBOL(gameport_stop_polling);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-17 04:43:17 +07:00
|
|
|
static void gameport_run_poll_handler(struct timer_list *t)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-17 04:43:17 +07:00
|
|
|
struct gameport *gameport = from_timer(gameport, t, poll_timer);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
gameport->poll_handler(gameport);
|
|
|
|
if (gameport->poll_cnt)
|
|
|
|
mod_timer(&gameport->poll_timer, jiffies + msecs_to_jiffies(gameport->poll_interval));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Basic gameport -> driver core mappings
|
|
|
|
*/
|
|
|
|
|
2007-04-10 11:40:48 +07:00
|
|
|
static int gameport_bind_driver(struct gameport *gameport, struct gameport_driver *drv)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-10-12 12:06:34 +07:00
|
|
|
int error;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
gameport->dev.driver = &drv->driver;
|
|
|
|
if (drv->connect(gameport, drv)) {
|
|
|
|
gameport->dev.driver = NULL;
|
2007-04-10 11:40:48 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-10-12 12:06:34 +07:00
|
|
|
|
|
|
|
error = device_bind_driver(&gameport->dev);
|
|
|
|
if (error) {
|
2010-01-06 08:56:03 +07:00
|
|
|
dev_warn(&gameport->dev,
|
|
|
|
"device_bind_driver() failed for %s (%s) and %s, error: %d\n",
|
2006-10-12 12:06:34 +07:00
|
|
|
gameport->phys, gameport->name,
|
|
|
|
drv->description, error);
|
|
|
|
drv->disconnect(gameport);
|
|
|
|
gameport->dev.driver = NULL;
|
2007-04-10 11:40:48 +07:00
|
|
|
return error;
|
2006-10-12 12:06:34 +07:00
|
|
|
}
|
|
|
|
|
2007-04-10 11:40:48 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void gameport_find_driver(struct gameport *gameport)
|
|
|
|
{
|
2006-07-19 12:14:55 +07:00
|
|
|
int error;
|
|
|
|
|
|
|
|
error = device_attach(&gameport->dev);
|
|
|
|
if (error < 0)
|
2010-01-06 08:56:03 +07:00
|
|
|
dev_warn(&gameport->dev,
|
|
|
|
"device_attach() failed for %s (%s), error: %d\n",
|
|
|
|
gameport->phys, gameport->name, error);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Gameport event processing.
|
|
|
|
*/
|
|
|
|
|
|
|
|
enum gameport_event_type {
|
|
|
|
GAMEPORT_REGISTER_PORT,
|
2008-06-06 12:33:22 +07:00
|
|
|
GAMEPORT_ATTACH_DRIVER,
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct gameport_event {
|
|
|
|
enum gameport_event_type type;
|
|
|
|
void *object;
|
|
|
|
struct module *owner;
|
|
|
|
struct list_head node;
|
|
|
|
};
|
|
|
|
|
|
|
|
static DEFINE_SPINLOCK(gameport_event_lock); /* protects gameport_event_list */
|
|
|
|
static LIST_HEAD(gameport_event_list);
|
|
|
|
|
2010-11-15 16:39:57 +07:00
|
|
|
static struct gameport_event *gameport_get_event(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2010-11-15 16:39:57 +07:00
|
|
|
struct gameport_event *event = NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&gameport_event_lock, flags);
|
|
|
|
|
2010-11-15 16:39:57 +07:00
|
|
|
if (!list_empty(&gameport_event_list)) {
|
|
|
|
event = list_first_entry(&gameport_event_list,
|
|
|
|
struct gameport_event, node);
|
|
|
|
list_del_init(&event->node);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-06-06 12:33:22 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irqrestore(&gameport_event_lock, flags);
|
2010-11-15 16:39:57 +07:00
|
|
|
return event;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void gameport_free_event(struct gameport_event *event)
|
|
|
|
{
|
|
|
|
module_put(event->owner);
|
|
|
|
kfree(event);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gameport_remove_duplicate_events(struct gameport_event *event)
|
|
|
|
{
|
2010-01-06 08:56:03 +07:00
|
|
|
struct gameport_event *e, *next;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&gameport_event_lock, flags);
|
|
|
|
|
2010-01-06 08:56:03 +07:00
|
|
|
list_for_each_entry_safe(e, next, &gameport_event_list, node) {
|
2005-04-17 05:20:36 +07:00
|
|
|
if (event->object == e->object) {
|
|
|
|
/*
|
|
|
|
* If this event is of different type we should not
|
|
|
|
* look further - we only suppress duplicate events
|
|
|
|
* that were sent back-to-back.
|
|
|
|
*/
|
|
|
|
if (event->type != e->type)
|
|
|
|
break;
|
|
|
|
|
2010-01-06 08:56:03 +07:00
|
|
|
list_del_init(&e->node);
|
2005-04-17 05:20:36 +07:00
|
|
|
gameport_free_event(e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&gameport_event_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-11-15 16:39:57 +07:00
|
|
|
static void gameport_handle_events(struct work_struct *work)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct gameport_event *event;
|
|
|
|
|
2006-02-19 12:22:03 +07:00
|
|
|
mutex_lock(&gameport_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-11-20 12:56:43 +07:00
|
|
|
/*
|
|
|
|
* Note that we handle only one event here to give swsusp
|
|
|
|
* a chance to freeze kgameportd thread. Gameport events
|
|
|
|
* should be pretty rare so we are not concerned about
|
|
|
|
* taking performance hit.
|
|
|
|
*/
|
|
|
|
if ((event = gameport_get_event())) {
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
switch (event->type) {
|
|
|
|
|
2010-01-06 08:56:03 +07:00
|
|
|
case GAMEPORT_REGISTER_PORT:
|
|
|
|
gameport_add_port(event->object);
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-01-06 08:56:03 +07:00
|
|
|
case GAMEPORT_ATTACH_DRIVER:
|
|
|
|
gameport_attach_driver(event->object);
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
gameport_remove_duplicate_events(event);
|
|
|
|
gameport_free_event(event);
|
|
|
|
}
|
|
|
|
|
2006-02-19 12:22:03 +07:00
|
|
|
mutex_unlock(&gameport_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2010-11-15 16:39:57 +07:00
|
|
|
static DECLARE_WORK(gameport_event_work, gameport_handle_events);
|
|
|
|
|
|
|
|
static int gameport_queue_event(void *object, struct module *owner,
|
|
|
|
enum gameport_event_type event_type)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct gameport_event *event;
|
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&gameport_event_lock, flags);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scan event list for the other events for the same gameport port,
|
|
|
|
* starting with the most recent one. If event is the same we
|
|
|
|
* do not need add new one. If event is of different type we
|
|
|
|
* need to add this event and should not look further because
|
|
|
|
* we need to preserve sequence of distinct events.
|
|
|
|
*/
|
|
|
|
list_for_each_entry_reverse(event, &gameport_event_list, node) {
|
|
|
|
if (event->object == object) {
|
|
|
|
if (event->type == event_type)
|
|
|
|
goto out;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
event = kmalloc(sizeof(struct gameport_event), GFP_ATOMIC);
|
|
|
|
if (!event) {
|
|
|
|
pr_err("Not enough memory to queue event %d\n", event_type);
|
|
|
|
retval = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!try_module_get(owner)) {
|
2017-03-18 07:15:38 +07:00
|
|
|
pr_warn("Can't get module reference, dropping event %d\n",
|
|
|
|
event_type);
|
2010-11-15 16:39:57 +07:00
|
|
|
kfree(event);
|
|
|
|
retval = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
event->type = event_type;
|
|
|
|
event->object = object;
|
|
|
|
event->owner = owner;
|
|
|
|
|
|
|
|
list_add_tail(&event->node, &gameport_event_list);
|
2011-02-23 23:51:28 +07:00
|
|
|
queue_work(system_long_wq, &gameport_event_work);
|
2010-11-15 16:39:57 +07:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&gameport_event_lock, flags);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2008-06-06 12:33:22 +07:00
|
|
|
* Remove all events that have been submitted for a given object,
|
|
|
|
* be it a gameport port or a driver.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2008-06-06 12:33:22 +07:00
|
|
|
static void gameport_remove_pending_events(void *object)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2010-01-06 08:56:03 +07:00
|
|
|
struct gameport_event *event, *next;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&gameport_event_lock, flags);
|
|
|
|
|
2010-01-06 08:56:03 +07:00
|
|
|
list_for_each_entry_safe(event, next, &gameport_event_list, node) {
|
2008-06-06 12:33:22 +07:00
|
|
|
if (event->object == object) {
|
2010-01-06 08:56:03 +07:00
|
|
|
list_del_init(&event->node);
|
2005-04-17 05:20:36 +07:00
|
|
|
gameport_free_event(event);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&gameport_event_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Destroy child gameport port (if any) that has not been fully registered yet.
|
|
|
|
*
|
|
|
|
* Note that we rely on the fact that port can have only one child and therefore
|
|
|
|
* only one child registration request can be pending. Additionally, children
|
|
|
|
* are registered by driver's connect() handler so there can't be a grandchild
|
|
|
|
* pending registration together with a child.
|
|
|
|
*/
|
|
|
|
static struct gameport *gameport_get_pending_child(struct gameport *parent)
|
|
|
|
{
|
|
|
|
struct gameport_event *event;
|
|
|
|
struct gameport *gameport, *child = NULL;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&gameport_event_lock, flags);
|
|
|
|
|
|
|
|
list_for_each_entry(event, &gameport_event_list, node) {
|
|
|
|
if (event->type == GAMEPORT_REGISTER_PORT) {
|
|
|
|
gameport = event->object;
|
|
|
|
if (gameport->parent == parent) {
|
|
|
|
child = gameport;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&gameport_event_lock, flags);
|
|
|
|
return child;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Gameport port operations
|
|
|
|
*/
|
|
|
|
|
2013-10-08 08:27:37 +07:00
|
|
|
static ssize_t gameport_description_show(struct device *dev, struct device_attribute *attr, char *buf)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct gameport *gameport = to_gameport_port(dev);
|
2010-01-06 08:56:03 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return sprintf(buf, "%s\n", gameport->name);
|
|
|
|
}
|
2013-10-08 08:27:37 +07:00
|
|
|
static DEVICE_ATTR(description, S_IRUGO, gameport_description_show, NULL);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2013-10-08 08:27:37 +07:00
|
|
|
static ssize_t drvctl_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct gameport *gameport = to_gameport_port(dev);
|
|
|
|
struct device_driver *drv;
|
2007-04-10 11:40:48 +07:00
|
|
|
int error;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-04-10 11:40:48 +07:00
|
|
|
error = mutex_lock_interruptible(&gameport_mutex);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (!strncmp(buf, "none", count)) {
|
|
|
|
gameport_disconnect_port(gameport);
|
|
|
|
} else if (!strncmp(buf, "reconnect", count)) {
|
|
|
|
gameport_reconnect_port(gameport);
|
|
|
|
} else if (!strncmp(buf, "rescan", count)) {
|
|
|
|
gameport_disconnect_port(gameport);
|
|
|
|
gameport_find_driver(gameport);
|
|
|
|
} else if ((drv = driver_find(buf, &gameport_bus)) != NULL) {
|
|
|
|
gameport_disconnect_port(gameport);
|
2007-04-10 11:40:48 +07:00
|
|
|
error = gameport_bind_driver(gameport, to_gameport_driver(drv));
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
2007-04-10 11:40:48 +07:00
|
|
|
error = -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-02-19 12:22:03 +07:00
|
|
|
mutex_unlock(&gameport_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-04-10 11:40:48 +07:00
|
|
|
return error ? error : count;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2013-10-08 08:27:37 +07:00
|
|
|
static DEVICE_ATTR_WO(drvctl);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2013-10-08 08:27:37 +07:00
|
|
|
static struct attribute *gameport_device_attrs[] = {
|
|
|
|
&dev_attr_description.attr,
|
|
|
|
&dev_attr_drvctl.attr,
|
|
|
|
NULL,
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
2013-10-08 08:27:37 +07:00
|
|
|
ATTRIBUTE_GROUPS(gameport_device);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
static void gameport_release_port(struct device *dev)
|
|
|
|
{
|
|
|
|
struct gameport *gameport = to_gameport_port(dev);
|
|
|
|
|
|
|
|
kfree(gameport);
|
|
|
|
module_put(THIS_MODULE);
|
|
|
|
}
|
|
|
|
|
|
|
|
void gameport_set_phys(struct gameport *gameport, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
vsnprintf(gameport->phys, sizeof(gameport->phys), fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
}
|
2009-04-18 10:12:05 +07:00
|
|
|
EXPORT_SYMBOL(gameport_set_phys);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Prepare gameport port for registration.
|
|
|
|
*/
|
|
|
|
static void gameport_init_port(struct gameport *gameport)
|
|
|
|
{
|
2014-12-04 05:27:42 +07:00
|
|
|
static atomic_t gameport_no = ATOMIC_INIT(-1);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
__module_get(THIS_MODULE);
|
|
|
|
|
2006-02-19 12:22:03 +07:00
|
|
|
mutex_init(&gameport->drv_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
device_initialize(&gameport->dev);
|
2010-01-06 08:56:03 +07:00
|
|
|
dev_set_name(&gameport->dev, "gameport%lu",
|
2014-12-04 05:27:42 +07:00
|
|
|
(unsigned long)atomic_inc_return(&gameport_no));
|
2005-04-17 05:20:36 +07:00
|
|
|
gameport->dev.bus = &gameport_bus;
|
|
|
|
gameport->dev.release = gameport_release_port;
|
|
|
|
if (gameport->parent)
|
|
|
|
gameport->dev.parent = &gameport->parent->dev;
|
|
|
|
|
2006-07-19 12:14:55 +07:00
|
|
|
INIT_LIST_HEAD(&gameport->node);
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_lock_init(&gameport->timer_lock);
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-17 04:43:17 +07:00
|
|
|
timer_setup(&gameport->poll_timer, gameport_run_poll_handler, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Complete gameport port registration.
|
|
|
|
* Driver core will attempt to find appropriate driver for the port.
|
|
|
|
*/
|
|
|
|
static void gameport_add_port(struct gameport *gameport)
|
|
|
|
{
|
2006-07-19 12:14:55 +07:00
|
|
|
int error;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (gameport->parent)
|
|
|
|
gameport->parent->child = gameport;
|
|
|
|
|
2014-09-12 00:28:30 +07:00
|
|
|
gameport->speed = use_ktime ?
|
|
|
|
gameport_measure_speed(gameport) :
|
|
|
|
old_gameport_measure_speed(gameport);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
list_add_tail(&gameport->node, &gameport_list);
|
|
|
|
|
|
|
|
if (gameport->io)
|
2010-01-06 08:56:03 +07:00
|
|
|
dev_info(&gameport->dev, "%s is %s, io %#x, speed %dkHz\n",
|
|
|
|
gameport->name, gameport->phys, gameport->io, gameport->speed);
|
2005-04-17 05:20:36 +07:00
|
|
|
else
|
2010-01-06 08:56:03 +07:00
|
|
|
dev_info(&gameport->dev, "%s is %s, speed %dkHz\n",
|
2005-04-17 05:20:36 +07:00
|
|
|
gameport->name, gameport->phys, gameport->speed);
|
|
|
|
|
2006-07-19 12:14:55 +07:00
|
|
|
error = device_add(&gameport->dev);
|
|
|
|
if (error)
|
2010-01-06 08:56:03 +07:00
|
|
|
dev_err(&gameport->dev,
|
|
|
|
"device_add() failed for %s (%s), error: %d\n",
|
2006-07-19 12:14:55 +07:00
|
|
|
gameport->phys, gameport->name, error);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* gameport_destroy_port() completes deregistration process and removes
|
|
|
|
* port from the system
|
|
|
|
*/
|
|
|
|
static void gameport_destroy_port(struct gameport *gameport)
|
|
|
|
{
|
|
|
|
struct gameport *child;
|
|
|
|
|
|
|
|
child = gameport_get_pending_child(gameport);
|
|
|
|
if (child) {
|
|
|
|
gameport_remove_pending_events(child);
|
|
|
|
put_device(&child->dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gameport->parent) {
|
|
|
|
gameport->parent->child = NULL;
|
|
|
|
gameport->parent = NULL;
|
|
|
|
}
|
|
|
|
|
2010-01-06 08:56:03 +07:00
|
|
|
if (device_is_registered(&gameport->dev))
|
2005-04-17 05:20:36 +07:00
|
|
|
device_del(&gameport->dev);
|
|
|
|
|
2006-07-19 12:14:55 +07:00
|
|
|
list_del_init(&gameport->node);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
gameport_remove_pending_events(gameport);
|
|
|
|
put_device(&gameport->dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reconnect gameport port and all its children (re-initialize attached devices)
|
|
|
|
*/
|
|
|
|
static void gameport_reconnect_port(struct gameport *gameport)
|
|
|
|
{
|
|
|
|
do {
|
|
|
|
if (!gameport->drv || !gameport->drv->reconnect || gameport->drv->reconnect(gameport)) {
|
|
|
|
gameport_disconnect_port(gameport);
|
|
|
|
gameport_find_driver(gameport);
|
|
|
|
/* Ok, old children are now gone, we are done */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
gameport = gameport->child;
|
|
|
|
} while (gameport);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* gameport_disconnect_port() unbinds a port from its driver. As a side effect
|
|
|
|
* all child ports are unbound and destroyed.
|
|
|
|
*/
|
|
|
|
static void gameport_disconnect_port(struct gameport *gameport)
|
|
|
|
{
|
|
|
|
struct gameport *s, *parent;
|
|
|
|
|
|
|
|
if (gameport->child) {
|
|
|
|
/*
|
|
|
|
* Children ports should be disconnected and destroyed
|
|
|
|
* first, staring with the leaf one, since we don't want
|
|
|
|
* to do recursion
|
|
|
|
*/
|
|
|
|
for (s = gameport; s->child; s = s->child)
|
|
|
|
/* empty */;
|
|
|
|
|
|
|
|
do {
|
|
|
|
parent = s->parent;
|
|
|
|
|
2007-04-10 11:40:48 +07:00
|
|
|
device_release_driver(&s->dev);
|
2005-04-17 05:20:36 +07:00
|
|
|
gameport_destroy_port(s);
|
|
|
|
} while ((s = parent) != gameport);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ok, no children left, now disconnect this port
|
|
|
|
*/
|
2007-04-10 11:40:48 +07:00
|
|
|
device_release_driver(&gameport->dev);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Submits register request to kgameportd for subsequent execution.
|
|
|
|
* Note that port registration is always asynchronous.
|
|
|
|
*/
|
|
|
|
void __gameport_register_port(struct gameport *gameport, struct module *owner)
|
|
|
|
{
|
|
|
|
gameport_init_port(gameport);
|
|
|
|
gameport_queue_event(gameport, owner, GAMEPORT_REGISTER_PORT);
|
|
|
|
}
|
2009-04-18 10:12:05 +07:00
|
|
|
EXPORT_SYMBOL(__gameport_register_port);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Synchronously unregisters gameport port.
|
|
|
|
*/
|
|
|
|
void gameport_unregister_port(struct gameport *gameport)
|
|
|
|
{
|
2006-02-19 12:22:03 +07:00
|
|
|
mutex_lock(&gameport_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
gameport_disconnect_port(gameport);
|
|
|
|
gameport_destroy_port(gameport);
|
2006-02-19 12:22:03 +07:00
|
|
|
mutex_unlock(&gameport_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-04-18 10:12:05 +07:00
|
|
|
EXPORT_SYMBOL(gameport_unregister_port);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Gameport driver operations
|
|
|
|
*/
|
|
|
|
|
2013-08-24 04:24:33 +07:00
|
|
|
static ssize_t description_show(struct device_driver *drv, char *buf)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct gameport_driver *driver = to_gameport_driver(drv);
|
|
|
|
return sprintf(buf, "%s\n", driver->description ? driver->description : "(none)");
|
|
|
|
}
|
2013-08-24 04:24:33 +07:00
|
|
|
static DRIVER_ATTR_RO(description);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2013-08-24 04:24:33 +07:00
|
|
|
static struct attribute *gameport_driver_attrs[] = {
|
|
|
|
&driver_attr_description.attr,
|
|
|
|
NULL
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
2013-08-24 04:24:33 +07:00
|
|
|
ATTRIBUTE_GROUPS(gameport_driver);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
static int gameport_driver_probe(struct device *dev)
|
|
|
|
{
|
|
|
|
struct gameport *gameport = to_gameport_port(dev);
|
|
|
|
struct gameport_driver *drv = to_gameport_driver(dev->driver);
|
|
|
|
|
|
|
|
drv->connect(gameport, drv);
|
|
|
|
return gameport->drv ? 0 : -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gameport_driver_remove(struct device *dev)
|
|
|
|
{
|
|
|
|
struct gameport *gameport = to_gameport_port(dev);
|
|
|
|
struct gameport_driver *drv = to_gameport_driver(dev->driver);
|
|
|
|
|
|
|
|
drv->disconnect(gameport);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-14 05:27:49 +07:00
|
|
|
static void gameport_attach_driver(struct gameport_driver *drv)
|
2006-07-19 12:14:55 +07:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2009-04-14 05:27:49 +07:00
|
|
|
error = driver_attach(&drv->driver);
|
2006-07-19 12:14:55 +07:00
|
|
|
if (error)
|
2010-01-06 08:56:03 +07:00
|
|
|
pr_err("driver_attach() failed for %s, error: %d\n",
|
2006-07-19 12:14:55 +07:00
|
|
|
drv->driver.name, error);
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:33:22 +07:00
|
|
|
int __gameport_register_driver(struct gameport_driver *drv, struct module *owner,
|
|
|
|
const char *mod_name)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-06-06 12:33:22 +07:00
|
|
|
int error;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
drv->driver.bus = &gameport_bus;
|
2008-06-06 12:33:22 +07:00
|
|
|
drv->driver.owner = owner;
|
|
|
|
drv->driver.mod_name = mod_name;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Temporarily disable automatic binding because probing
|
|
|
|
* takes long time and we are better off doing it in kgameportd
|
|
|
|
*/
|
2009-05-10 06:08:05 +07:00
|
|
|
drv->ignore = true;
|
2008-06-06 12:33:22 +07:00
|
|
|
|
|
|
|
error = driver_register(&drv->driver);
|
|
|
|
if (error) {
|
2010-01-06 08:56:03 +07:00
|
|
|
pr_err("driver_register() failed for %s, error: %d\n",
|
2008-06-06 12:33:22 +07:00
|
|
|
drv->driver.name, error);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reset ignore flag and let kgameportd bind the driver to free ports
|
|
|
|
*/
|
2009-05-10 06:08:05 +07:00
|
|
|
drv->ignore = false;
|
2008-06-06 12:33:22 +07:00
|
|
|
error = gameport_queue_event(drv, NULL, GAMEPORT_ATTACH_DRIVER);
|
|
|
|
if (error) {
|
|
|
|
driver_unregister(&drv->driver);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-04-18 10:12:05 +07:00
|
|
|
EXPORT_SYMBOL(__gameport_register_driver);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
void gameport_unregister_driver(struct gameport_driver *drv)
|
|
|
|
{
|
|
|
|
struct gameport *gameport;
|
|
|
|
|
2006-02-19 12:22:03 +07:00
|
|
|
mutex_lock(&gameport_mutex);
|
2008-06-06 12:33:22 +07:00
|
|
|
|
2009-05-10 06:08:05 +07:00
|
|
|
drv->ignore = true; /* so gameport_find_driver ignores it */
|
2008-06-06 12:33:22 +07:00
|
|
|
gameport_remove_pending_events(drv);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
start_over:
|
|
|
|
list_for_each_entry(gameport, &gameport_list, node) {
|
|
|
|
if (gameport->drv == drv) {
|
|
|
|
gameport_disconnect_port(gameport);
|
|
|
|
gameport_find_driver(gameport);
|
|
|
|
/* we could've deleted some ports, restart */
|
|
|
|
goto start_over;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
driver_unregister(&drv->driver);
|
2008-06-06 12:33:22 +07:00
|
|
|
|
2006-02-19 12:22:03 +07:00
|
|
|
mutex_unlock(&gameport_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-04-18 10:12:05 +07:00
|
|
|
EXPORT_SYMBOL(gameport_unregister_driver);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
static int gameport_bus_match(struct device *dev, struct device_driver *drv)
|
|
|
|
{
|
|
|
|
struct gameport_driver *gameport_drv = to_gameport_driver(drv);
|
|
|
|
|
|
|
|
return !gameport_drv->ignore;
|
|
|
|
}
|
|
|
|
|
2006-11-03 11:27:30 +07:00
|
|
|
static struct bus_type gameport_bus = {
|
|
|
|
.name = "gameport",
|
2013-10-08 08:27:37 +07:00
|
|
|
.dev_groups = gameport_device_groups,
|
2013-08-24 04:24:33 +07:00
|
|
|
.drv_groups = gameport_driver_groups,
|
2006-11-03 11:27:30 +07:00
|
|
|
.match = gameport_bus_match,
|
|
|
|
.probe = gameport_driver_probe,
|
|
|
|
.remove = gameport_driver_remove,
|
|
|
|
};
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static void gameport_set_drv(struct gameport *gameport, struct gameport_driver *drv)
|
|
|
|
{
|
2006-02-19 12:22:03 +07:00
|
|
|
mutex_lock(&gameport->drv_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
gameport->drv = drv;
|
2006-02-19 12:22:03 +07:00
|
|
|
mutex_unlock(&gameport->drv_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
int gameport_open(struct gameport *gameport, struct gameport_driver *drv, int mode)
|
|
|
|
{
|
|
|
|
if (gameport->open) {
|
|
|
|
if (gameport->open(gameport, mode)) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (mode != GAMEPORT_MODE_RAW)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
gameport_set_drv(gameport, drv);
|
|
|
|
return 0;
|
|
|
|
}
|
2009-04-18 10:12:05 +07:00
|
|
|
EXPORT_SYMBOL(gameport_open);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
void gameport_close(struct gameport *gameport)
|
|
|
|
{
|
|
|
|
del_timer_sync(&gameport->poll_timer);
|
|
|
|
gameport->poll_handler = NULL;
|
|
|
|
gameport->poll_interval = 0;
|
|
|
|
gameport_set_drv(gameport, NULL);
|
|
|
|
if (gameport->close)
|
|
|
|
gameport->close(gameport);
|
|
|
|
}
|
2009-04-18 10:12:05 +07:00
|
|
|
EXPORT_SYMBOL(gameport_close);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
static int __init gameport_init(void)
|
|
|
|
{
|
2006-07-19 12:14:55 +07:00
|
|
|
int error;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-07-19 12:14:55 +07:00
|
|
|
error = bus_register(&gameport_bus);
|
|
|
|
if (error) {
|
2010-01-06 08:56:03 +07:00
|
|
|
pr_err("failed to register gameport bus, error: %d\n", error);
|
2006-07-19 12:14:55 +07:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit gameport_exit(void)
|
|
|
|
{
|
|
|
|
bus_unregister(&gameport_bus);
|
2010-11-15 16:39:57 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* There should not be any outstanding events but work may
|
|
|
|
* still be scheduled so simply cancel it.
|
|
|
|
*/
|
|
|
|
cancel_work_sync(&gameport_event_work);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-02-19 12:22:51 +07:00
|
|
|
subsys_initcall(gameport_init);
|
2005-04-17 05:20:36 +07:00
|
|
|
module_exit(gameport_exit);
|