obj-$(CONFIG_FB_I810) += video/i810/
obj-$(CONFIG_FB_INTEL) += video/intelfb/
-# we also need input/serio early so serio bus is initialized by the time
-# serial drivers start registering their serio ports
-obj-$(CONFIG_SERIO) += input/serio/
obj-y += serial/
obj-$(CONFIG_PARPORT) += parport/
obj-y += base/ block/ misc/ mfd/ net/ media/
obj-$(CONFIG_USB) += usb/
obj-$(CONFIG_PCI) += usb/
obj-$(CONFIG_USB_GADGET) += usb/gadget/
+obj-$(CONFIG_SERIO) += input/serio/
obj-$(CONFIG_GAMEPORT) += input/gameport/
obj-$(CONFIG_INPUT) += input/
obj-$(CONFIG_I2O) += message/
#include <linux/delay.h>
#include <linux/kthread.h>
#include <linux/sched.h> /* HZ */
+#include <linux/mutex.h>
/*#include <asm/io.h>*/
EXPORT_SYMBOL(gameport_stop_polling);
/*
- * gameport_sem protects entire gameport subsystem and is taken
+ * gameport_mutex protects entire gameport subsystem and is taken
* every time gameport port or driver registrered or unregistered.
*/
-static DECLARE_MUTEX(gameport_sem);
+static DEFINE_MUTEX(gameport_mutex);
static LIST_HEAD(gameport_list);
struct gameport_event *event;
struct gameport_driver *gameport_drv;
- down(&gameport_sem);
+ mutex_lock(&gameport_mutex);
/*
* Note that we handle only one event here to give swsusp
gameport_free_event(event);
}
- up(&gameport_sem);
+ mutex_unlock(&gameport_mutex);
}
/*
struct device_driver *drv;
int retval;
- retval = down_interruptible(&gameport_sem);
+ retval = mutex_lock_interruptible(&gameport_mutex);
if (retval)
return retval;
retval = -EINVAL;
}
- up(&gameport_sem);
+ mutex_unlock(&gameport_mutex);
return retval;
}
__module_get(THIS_MODULE);
- init_MUTEX(&gameport->drv_sem);
+ mutex_init(&gameport->drv_mutex);
device_initialize(&gameport->dev);
snprintf(gameport->dev.bus_id, sizeof(gameport->dev.bus_id),
"gameport%lu", (unsigned long)atomic_inc_return(&gameport_no) - 1);
*/
void gameport_unregister_port(struct gameport *gameport)
{
- down(&gameport_sem);
+ mutex_lock(&gameport_mutex);
gameport_disconnect_port(gameport);
gameport_destroy_port(gameport);
- up(&gameport_sem);
+ mutex_unlock(&gameport_mutex);
}
{
struct gameport *gameport;
- down(&gameport_sem);
+ mutex_lock(&gameport_mutex);
drv->ignore = 1; /* so gameport_find_driver ignores it */
start_over:
}
driver_unregister(&drv->driver);
- up(&gameport_sem);
+ mutex_unlock(&gameport_mutex);
}
static int gameport_bus_match(struct device *dev, struct device_driver *drv)
static void gameport_set_drv(struct gameport *gameport, struct gameport_driver *drv)
{
- down(&gameport->drv_sem);
+ mutex_lock(&gameport->drv_mutex);
gameport->drv = drv;
- up(&gameport->drv_sem);
+ mutex_unlock(&gameport->drv_mutex);
}
int gameport_open(struct gameport *gameport, struct gameport_driver *drv, int mode)
kthread_stop(gameport_task);
}
-module_init(gameport_init);
+subsys_initcall(gameport_init);
module_exit(gameport_exit);
#include <linux/interrupt.h>
#include <linux/poll.h>
#include <linux/device.h>
+#include <linux/mutex.h>
MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
MODULE_DESCRIPTION("Input core");
struct input_dev *dev = handle->dev;
int err;
- err = down_interruptible(&dev->sem);
+ err = mutex_lock_interruptible(&dev->mutex);
if (err)
return err;
if (err)
handle->open--;
- up(&dev->sem);
+ mutex_unlock(&dev->mutex);
return err;
}
input_release_device(handle);
- down(&dev->sem);
+ mutex_lock(&dev->mutex);
if (!--dev->users && dev->close)
dev->close(dev);
handle->open--;
- up(&dev->sem);
+ mutex_unlock(&dev->mutex);
}
static void input_link_handle(struct input_handle *handle)
struct input_dev *input_dev = to_input_dev(dev); \
int retval; \
\
- retval = down_interruptible(&input_dev->sem); \
+ retval = mutex_lock_interruptible(&input_dev->mutex); \
if (retval) \
return retval; \
\
retval = sprintf(buf, "%s\n", input_dev->name ? input_dev->name : ""); \
\
- up(&input_dev->sem); \
+ mutex_unlock(&input_dev->mutex); \
\
return retval; \
} \
return -EINVAL;
}
- init_MUTEX(&dev->sem);
+ mutex_init(&dev->mutex);
set_bit(EV_SYN, dev->evbit);
/*
#include <linux/init.h>
#include <linux/input.h>
#include <linux/interrupt.h>
+#include <linux/mutex.h>
#include <asm/system.h>
#include <asm/amigahw.h>
__obsolete_setup("amijoy=");
static int amijoy_used;
-static DECLARE_MUTEX(amijoy_sem);
+static DEFINE_MUTEX(amijoy_mutex);
static struct input_dev *amijoy_dev[2];
static char *amijoy_phys[2] = { "amijoy/input0", "amijoy/input1" };
{
int err;
- err = down_interruptible(&amijoy_sem);
+ err = mutex_lock_interruptible(&amijoy_mutex);
if (err)
return err;
amijoy_used++;
out:
- up(&amijoy_sem);
+ mutex_unlock(&amijoy_mutex);
return err;
}
static void amijoy_close(struct input_dev *dev)
{
- down(&amijoy_sem);
+ mutex_lock(&amijoy_mutex);
if (!--amijoy_used)
free_irq(IRQ_AMIGA_VERTB, amijoy_interrupt);
- up(&amijoy_sem);
+ mutex_unlock(&amijoy_mutex);
}
static int __init amijoy_init(void)
#include <linux/init.h>
#include <linux/parport.h>
#include <linux/input.h>
+#include <linux/mutex.h>
MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
MODULE_DESCRIPTION("Atari, Amstrad, Commodore, Amiga, Sega, etc. joystick driver");
struct pardevice *pd;
int mode;
int used;
- struct semaphore sem;
+ struct mutex mutex;
char phys[DB9_MAX_DEVICES][32];
};
struct parport *port = db9->pd->port;
int err;
- err = down_interruptible(&db9->sem);
+ err = mutex_lock_interruptible(&db9->mutex);
if (err)
return err;
mod_timer(&db9->timer, jiffies + DB9_REFRESH_TIME);
}
- up(&db9->sem);
+ mutex_unlock(&db9->mutex);
return 0;
}
struct db9 *db9 = dev->private;
struct parport *port = db9->pd->port;
- down(&db9->sem);
+ mutex_lock(&db9->mutex);
if (!--db9->used) {
del_timer_sync(&db9->timer);
parport_write_control(port, 0x00);
parport_data_forward(port);
parport_release(db9->pd);
}
- up(&db9->sem);
+ mutex_unlock(&db9->mutex);
}
static struct db9 __init *db9_probe(int parport, int mode)
goto err_unreg_pardev;
}
- init_MUTEX(&db9->sem);
+ mutex_init(&db9->mutex);
db9->pd = pd;
db9->mode = mode;
init_timer(&db9->timer);
#include <linux/init.h>
#include <linux/parport.h>
#include <linux/input.h>
+#include <linux/mutex.h>
MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
MODULE_DESCRIPTION("NES, SNES, N64, MultiSystem, PSX gamepad driver");
struct timer_list timer;
unsigned char pads[GC_MAX + 1];
int used;
- struct semaphore sem;
+ struct mutex mutex;
char phys[GC_MAX_DEVICES][32];
};
struct gc *gc = dev->private;
int err;
- err = down_interruptible(&gc->sem);
+ err = mutex_lock_interruptible(&gc->mutex);
if (err)
return err;
mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME);
}
- up(&gc->sem);
+ mutex_unlock(&gc->mutex);
return 0;
}
{
struct gc *gc = dev->private;
- down(&gc->sem);
+ mutex_lock(&gc->mutex);
if (!--gc->used) {
del_timer_sync(&gc->timer);
parport_write_control(gc->pd->port, 0x00);
parport_release(gc->pd);
}
- up(&gc->sem);
+ mutex_unlock(&gc->mutex);
}
static int __init gc_setup_pad(struct gc *gc, int idx, int pad_type)
goto err_unreg_pardev;
}
- init_MUTEX(&gc->sem);
+ mutex_init(&gc->mutex);
gc->pd = pd;
init_timer(&gc->timer);
gc->timer.data = (long) gc;
unsigned char data[3];
if (!no_alloc) {
- down(&iforce->mem_mutex);
+ mutex_lock(&iforce->mem_mutex);
if (allocate_resource(&(iforce->device_memory), mod_chunk, 2,
iforce->device_memory.start, iforce->device_memory.end, 2L,
NULL, NULL)) {
- up(&iforce->mem_mutex);
+ mutex_unlock(&iforce->mem_mutex);
return -ENOMEM;
}
- up(&iforce->mem_mutex);
+ mutex_unlock(&iforce->mem_mutex);
}
data[0] = LO(mod_chunk->start);
period = TIME_SCALE(period);
if (!no_alloc) {
- down(&iforce->mem_mutex);
+ mutex_lock(&iforce->mem_mutex);
if (allocate_resource(&(iforce->device_memory), mod_chunk, 0x0c,
iforce->device_memory.start, iforce->device_memory.end, 2L,
NULL, NULL)) {
- up(&iforce->mem_mutex);
+ mutex_unlock(&iforce->mem_mutex);
return -ENOMEM;
}
- up(&iforce->mem_mutex);
+ mutex_unlock(&iforce->mem_mutex);
}
data[0] = LO(mod_chunk->start);
fade_duration = TIME_SCALE(fade_duration);
if (!no_alloc) {
- down(&iforce->mem_mutex);
+ mutex_lock(&iforce->mem_mutex);
if (allocate_resource(&(iforce->device_memory), mod_chunk, 0x0e,
iforce->device_memory.start, iforce->device_memory.end, 2L,
NULL, NULL)) {
- up(&iforce->mem_mutex);
+ mutex_unlock(&iforce->mem_mutex);
return -ENOMEM;
}
- up(&iforce->mem_mutex);
+ mutex_unlock(&iforce->mem_mutex);
}
data[0] = LO(mod_chunk->start);
unsigned char data[10];
if (!no_alloc) {
- down(&iforce->mem_mutex);
+ mutex_lock(&iforce->mem_mutex);
if (allocate_resource(&(iforce->device_memory), mod_chunk, 8,
iforce->device_memory.start, iforce->device_memory.end, 2L,
NULL, NULL)) {
- up(&iforce->mem_mutex);
+ mutex_unlock(&iforce->mem_mutex);
return -ENOMEM;
}
- up(&iforce->mem_mutex);
+ mutex_unlock(&iforce->mem_mutex);
}
data[0] = LO(mod_chunk->start);
init_waitqueue_head(&iforce->wait);
spin_lock_init(&iforce->xmit_lock);
- init_MUTEX(&iforce->mem_mutex);
+ mutex_init(&iforce->mem_mutex);
iforce->xmit.buf = iforce->xmit_data;
iforce->dev = input_dev;
#include <linux/serio.h>
#include <linux/config.h>
#include <linux/circ_buf.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
/* This module provides arbitrary resource management routines.
* I use it to manage the device's memory.
*/
#include <linux/ioport.h>
+
#define IFORCE_MAX_LENGTH 16
/* iforce::bus */
wait_queue_head_t wait;
struct resource device_memory;
struct iforce_core_effect core_effects[FF_EFFECTS_MAX];
- struct semaphore mem_mutex;
+ struct mutex mem_mutex;
};
/* Get hi and low bytes of a 16-bits int */
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
+#include <linux/mutex.h>
MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
MODULE_DESCRIPTION("TurboGraFX parallel port interface driver");
char phys[TGFX_MAX_DEVICES][32];
int sticks;
int used;
- struct semaphore sem;
+ struct mutex sem;
} *tgfx_base[TGFX_MAX_PORTS];
/*
struct tgfx *tgfx = dev->private;
int err;
- err = down_interruptible(&tgfx->sem);
+ err = mutex_lock_interruptible(&tgfx->sem);
if (err)
return err;
mod_timer(&tgfx->timer, jiffies + TGFX_REFRESH_TIME);
}
- up(&tgfx->sem);
+ mutex_unlock(&tgfx->sem);
return 0;
}
{
struct tgfx *tgfx = dev->private;
- down(&tgfx->sem);
+ mutex_lock(&tgfx->sem);
if (!--tgfx->used) {
del_timer_sync(&tgfx->timer);
parport_write_control(tgfx->pd->port, 0x00);
parport_release(tgfx->pd);
}
- up(&tgfx->sem);
+ mutex_unlock(&tgfx->sem);
}
goto err_unreg_pardev;
}
- init_MUTEX(&tgfx->sem);
+ mutex_init(&tgfx->sem);
tgfx->pd = pd;
init_timer(&tgfx->timer);
tgfx->timer.data = (long) tgfx;
#include <linux/serio.h>
#include <linux/workqueue.h>
#include <linux/libps2.h>
+#include <linux/mutex.h>
#define DRIVER_DESC "AT and PS/2 keyboard driver"
unsigned long time;
struct work_struct event_work;
- struct semaphore event_sem;
+ struct mutex event_mutex;
unsigned long event_mask;
};
unsigned char param[2];
int i, j;
- down(&atkbd->event_sem);
+ mutex_lock(&atkbd->event_mutex);
if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask)) {
param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETREP);
}
- up(&atkbd->event_sem);
+ mutex_unlock(&atkbd->event_mutex);
}
/*
atkbd->dev = dev;
ps2_init(&atkbd->ps2dev, serio);
INIT_WORK(&atkbd->event_work, atkbd_event_work, atkbd);
- init_MUTEX(&atkbd->event_sem);
+ mutex_init(&atkbd->event_mutex);
switch (serio->id.type) {
if (!newdev)
return -ENOMEM;
- init_MUTEX(&newdev->sem);
+ mutex_init(&newdev->mutex);
spin_lock_init(&newdev->requests_lock);
init_waitqueue_head(&newdev->requests_waitq);
init_waitqueue_head(&newdev->waitq);
struct uinput_device *udev = file->private_data;
int retval;
- retval = down_interruptible(&udev->sem);
+ retval = mutex_lock_interruptible(&udev->mutex);
if (retval)
return retval;
uinput_inject_event(udev, buffer, count) :
uinput_setup_device(udev, buffer, count);
- up(&udev->sem);
+ mutex_unlock(&udev->mutex);
return retval;
}
if (retval)
return retval;
- retval = down_interruptible(&udev->sem);
+ retval = mutex_lock_interruptible(&udev->mutex);
if (retval)
return retval;
}
out:
- up(&udev->sem);
+ mutex_unlock(&udev->mutex);
return retval;
}
udev = file->private_data;
- retval = down_interruptible(&udev->sem);
+ retval = mutex_lock_interruptible(&udev->mutex);
if (retval)
return retval;
}
out:
- up(&udev->sem);
+ mutex_unlock(&udev->mutex);
return retval;
}
#include <linux/serio.h>
#include <linux/init.h>
#include <linux/libps2.h>
+#include <linux/mutex.h>
+
#include "psmouse.h"
#include "synaptics.h"
#include "logips2pp.h"
__obsolete_setup("psmouse_rate=");
/*
- * psmouse_sem protects all operations changing state of mouse
+ * psmouse_mutex protects all operations changing state of mouse
* (connecting, disconnecting, changing rate or resolution via
* sysfs). We could use a per-device semaphore but since there
* rarely more than one PS/2 mouse connected and since semaphore
* is taken in "slow" paths it is not worth it.
*/
-static DECLARE_MUTEX(psmouse_sem);
+static DEFINE_MUTEX(psmouse_mutex);
static struct workqueue_struct *kpsmoused_wq;
int failed = 0, enabled = 0;
int i;
- down(&psmouse_sem);
+ mutex_lock(&psmouse_mutex);
if (psmouse->state != PSMOUSE_RESYNCING)
goto out;
if (parent)
psmouse_activate(parent);
out:
- up(&psmouse_sem);
+ mutex_unlock(&psmouse_mutex);
}
/*
sysfs_remove_group(&serio->dev.kobj, &psmouse_attribute_group);
- down(&psmouse_sem);
+ mutex_lock(&psmouse_mutex);
psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
/* make sure we don't have a resync in progress */
- up(&psmouse_sem);
+ mutex_unlock(&psmouse_mutex);
flush_workqueue(kpsmoused_wq);
- down(&psmouse_sem);
+ mutex_lock(&psmouse_mutex);
if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
parent = serio_get_drvdata(serio->parent);
if (parent)
psmouse_activate(parent);
- up(&psmouse_sem);
+ mutex_unlock(&psmouse_mutex);
}
static int psmouse_switch_protocol(struct psmouse *psmouse, struct psmouse_protocol *proto)
struct input_dev *input_dev;
int retval = -ENOMEM;
- down(&psmouse_sem);
+ mutex_lock(&psmouse_mutex);
/*
* If this is a pass-through port deactivate parent so the device
if (parent)
psmouse_activate(parent);
- up(&psmouse_sem);
+ mutex_unlock(&psmouse_mutex);
return retval;
}
return -1;
}
- down(&psmouse_sem);
+ mutex_lock(&psmouse_mutex);
if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
parent = serio_get_drvdata(serio->parent);
if (parent)
psmouse_activate(parent);
- up(&psmouse_sem);
+ mutex_unlock(&psmouse_mutex);
return rc;
}
goto out_unpin;
}
- retval = down_interruptible(&psmouse_sem);
+ retval = mutex_lock_interruptible(&psmouse_mutex);
if (retval)
goto out_unpin;
if (psmouse->state == PSMOUSE_IGNORE) {
retval = -ENODEV;
- goto out_up;
+ goto out_unlock;
}
if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
if (parent)
psmouse_activate(parent);
- out_up:
- up(&psmouse_sem);
+ out_unlock:
+ mutex_unlock(&psmouse_mutex);
out_unpin:
serio_unpin_driver(serio);
return retval;
return -EIO;
}
- up(&psmouse_sem);
+ mutex_unlock(&psmouse_mutex);
serio_unpin_driver(serio);
serio_unregister_child_port(serio);
serio_pin_driver_uninterruptible(serio);
- down(&psmouse_sem);
+ mutex_lock(&psmouse_mutex);
if (serio->drv != &psmouse_drv) {
input_free_device(new_dev);
maxbytes = sizeof(ps2dev->cmdbuf);
}
- down(&ps2dev->cmd_sem);
+ mutex_lock(&ps2dev->cmd_mutex);
serio_pause_rx(ps2dev->serio);
ps2dev->flags = PS2_FLAG_CMD;
wait_event_timeout(ps2dev->wait,
!(ps2dev->flags & PS2_FLAG_CMD),
msecs_to_jiffies(timeout));
- up(&ps2dev->cmd_sem);
+ mutex_unlock(&ps2dev->cmd_mutex);
}
/*
return -1;
}
- down(&ps2dev->cmd_sem);
+ mutex_lock(&ps2dev->cmd_mutex);
serio_pause_rx(ps2dev->serio);
ps2dev->flags = command == PS2_CMD_GETID ? PS2_FLAG_WAITID : 0;
ps2dev->flags = 0;
serio_continue_rx(ps2dev->serio);
- up(&ps2dev->cmd_sem);
+ mutex_unlock(&ps2dev->cmd_mutex);
return rc;
}
void ps2_init(struct ps2dev *ps2dev, struct serio *serio)
{
- init_MUTEX(&ps2dev->cmd_sem);
+ mutex_init(&ps2dev->cmd_mutex);
init_waitqueue_head(&ps2dev->wait);
ps2dev->serio = serio;
}
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/kthread.h>
+#include <linux/mutex.h>
MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
MODULE_DESCRIPTION("Serio abstraction core");
EXPORT_SYMBOL(serio_reconnect);
/*
- * serio_sem protects entire serio subsystem and is taken every time
+ * serio_mutex protects entire serio subsystem and is taken every time
* serio port or driver registrered or unregistered.
*/
-static DECLARE_MUTEX(serio_sem);
+static DEFINE_MUTEX(serio_mutex);
static LIST_HEAD(serio_list);
{
int retval;
- down(&serio->drv_sem);
+ mutex_lock(&serio->drv_mutex);
retval = drv->connect(serio, drv);
- up(&serio->drv_sem);
+ mutex_unlock(&serio->drv_mutex);
return retval;
}
{
int retval = -1;
- down(&serio->drv_sem);
+ mutex_lock(&serio->drv_mutex);
if (serio->drv && serio->drv->reconnect)
retval = serio->drv->reconnect(serio);
- up(&serio->drv_sem);
+ mutex_unlock(&serio->drv_mutex);
return retval;
}
static void serio_disconnect_driver(struct serio *serio)
{
- down(&serio->drv_sem);
+ mutex_lock(&serio->drv_mutex);
if (serio->drv)
serio->drv->disconnect(serio);
- up(&serio->drv_sem);
+ mutex_unlock(&serio->drv_mutex);
}
static int serio_match_port(const struct serio_device_id *ids, struct serio *serio)
struct serio_event *event;
struct serio_driver *serio_drv;
- down(&serio_sem);
+ mutex_lock(&serio_mutex);
/*
* Note that we handle only one event here to give swsusp
serio_free_event(event);
}
- up(&serio_sem);
+ mutex_unlock(&serio_mutex);
}
/*
struct device_driver *drv;
int retval;
- retval = down_interruptible(&serio_sem);
+ retval = mutex_lock_interruptible(&serio_mutex);
if (retval)
return retval;
retval = -EINVAL;
}
- up(&serio_sem);
+ mutex_unlock(&serio_mutex);
return retval;
}
__module_get(THIS_MODULE);
spin_lock_init(&serio->lock);
- init_MUTEX(&serio->drv_sem);
+ mutex_init(&serio->drv_mutex);
device_initialize(&serio->dev);
snprintf(serio->dev.bus_id, sizeof(serio->dev.bus_id),
"serio%ld", (long)atomic_inc_return(&serio_no) - 1);
*/
void serio_unregister_port(struct serio *serio)
{
- down(&serio_sem);
+ mutex_lock(&serio_mutex);
serio_disconnect_port(serio);
serio_destroy_port(serio);
- up(&serio_sem);
+ mutex_unlock(&serio_mutex);
}
/*
*/
void serio_unregister_child_port(struct serio *serio)
{
- down(&serio_sem);
+ mutex_lock(&serio_mutex);
if (serio->child) {
serio_disconnect_port(serio->child);
serio_destroy_port(serio->child);
}
- up(&serio_sem);
+ mutex_unlock(&serio_mutex);
}
/*
* Submits register request to kseriod for subsequent execution.
- * Can be used when it is not obvious whether the serio_sem is
+ * Can be used when it is not obvious whether the serio_mutex is
* taken or not and when delayed execution is feasible.
*/
void __serio_unregister_port_delayed(struct serio *serio, struct module *owner)
{
struct serio *serio;
- down(&serio_sem);
+ mutex_lock(&serio_mutex);
drv->manual_bind = 1; /* so serio_find_driver ignores it */
start_over:
}
driver_unregister(&drv->driver);
- up(&serio_sem);
+ mutex_unlock(&serio_mutex);
}
static void serio_set_drv(struct serio *serio, struct serio_driver *drv)
return 0;
}
-/* called from serio_driver->connect/disconnect methods under serio_sem */
+/* called from serio_driver->connect/disconnect methods under serio_mutex */
int serio_open(struct serio *serio, struct serio_driver *drv)
{
serio_set_drv(serio, drv);
return 0;
}
-/* called from serio_driver->connect/disconnect methods under serio_sem */
+/* called from serio_driver->connect/disconnect methods under serio_mutex */
void serio_close(struct serio *serio)
{
if (serio->close)
kthread_stop(serio_task);
}
-module_init(serio_init);
+subsys_initcall(serio_init);
module_exit(serio_exit);
#include <linux/devfs_fs_kernel.h>
#include <linux/miscdevice.h>
#include <linux/wait.h>
+#include <linux/mutex.h>
#define DRIVER_DESC "Raw serio driver"
struct list_head node;
};
-static DECLARE_MUTEX(serio_raw_sem);
+static DEFINE_MUTEX(serio_raw_mutex);
static LIST_HEAD(serio_raw_list);
static unsigned int serio_raw_no;
struct serio_raw_list *list;
int retval = 0;
- retval = down_interruptible(&serio_raw_sem);
+ retval = mutex_lock_interruptible(&serio_raw_mutex);
if (retval)
return retval;
list_add_tail(&list->node, &serio_raw->list);
out:
- up(&serio_raw_sem);
+ mutex_unlock(&serio_raw_mutex);
return retval;
}
struct serio_raw_list *list = file->private_data;
struct serio_raw *serio_raw = list->serio_raw;
- down(&serio_raw_sem);
+ mutex_lock(&serio_raw_mutex);
serio_raw_fasync(-1, file, 0);
serio_raw_cleanup(serio_raw);
- up(&serio_raw_sem);
+ mutex_unlock(&serio_raw_mutex);
return 0;
}
int retval;
unsigned char c;
- retval = down_interruptible(&serio_raw_sem);
+ retval = mutex_lock_interruptible(&serio_raw_mutex);
if (retval)
return retval;
};
out:
- up(&serio_raw_sem);
+ mutex_unlock(&serio_raw_mutex);
return written;
}
return -ENOMEM;
}
- down(&serio_raw_sem);
+ mutex_lock(&serio_raw_mutex);
memset(serio_raw, 0, sizeof(struct serio_raw));
snprintf(serio_raw->name, sizeof(serio_raw->name), "serio_raw%d", serio_raw_no++);
serio_set_drvdata(serio, NULL);
kfree(serio_raw);
out:
- up(&serio_raw_sem);
+ mutex_unlock(&serio_raw_mutex);
return err;
}
{
struct serio_raw *serio_raw;
- down(&serio_raw_sem);
+ mutex_lock(&serio_raw_mutex);
serio_raw = serio_get_drvdata(serio);
if (!serio_raw_cleanup(serio_raw))
wake_up_interruptible(&serio_raw->wait);
- up(&serio_raw_sem);
+ mutex_unlock(&serio_raw_mutex);
}
static struct serio_device_id serio_raw_serio_ids[] = {
#include <asm/io.h>
#include <linux/list.h>
+#include <linux/mutex.h>
#include <linux/device.h>
#include <linux/timer.h>
struct gameport *parent, *child;
struct gameport_driver *drv;
- struct semaphore drv_sem; /* protects serio->drv so attributes can pin driver */
+ struct mutex drv_mutex; /* protects serio->drv so attributes can pin driver */
struct device dev;
unsigned int registered; /* port has been fully registered with driver core */
*/
static inline int gameport_pin_driver(struct gameport *gameport)
{
- return down_interruptible(&gameport->drv_sem);
+ return mutex_lock_interruptible(&gameport->drv_mutex);
}
static inline void gameport_unpin_driver(struct gameport *gameport)
{
- up(&gameport->drv_sem);
+ mutex_unlock(&gameport->drv_mutex);
}
void __gameport_register_driver(struct gameport_driver *drv, struct module *owner);
struct input_handle *grab;
- struct semaphore sem; /* serializes open and close operations */
+ struct mutex mutex; /* serializes open and close operations */
unsigned int users;
struct class_device cdev;
struct serio *serio;
/* Ensures that only one command is executing at a time */
- struct semaphore cmd_sem;
+ struct mutex cmd_mutex;
/* Used to signal completion from interrupt handler */
wait_queue_head_t wait;
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/spinlock.h>
+#include <linux/mutex.h>
#include <linux/device.h>
#include <linux/mod_devicetable.h>
struct serio *parent, *child;
struct serio_driver *drv; /* accessed from interrupt, must be protected by serio->lock and serio->sem */
- struct semaphore drv_sem; /* protects serio->drv so attributes can pin driver */
+ struct mutex drv_mutex; /* protects serio->drv so attributes can pin driver */
struct device dev;
unsigned int registered; /* port has been fully registered with driver core */
*/
static inline int serio_pin_driver(struct serio *serio)
{
- return down_interruptible(&serio->drv_sem);
+ return mutex_lock_interruptible(&serio->drv_mutex);
}
static inline void serio_pin_driver_uninterruptible(struct serio *serio)
{
- down(&serio->drv_sem);
+ mutex_lock(&serio->drv_mutex);
}
static inline void serio_unpin_driver(struct serio *serio)
{
- up(&serio->drv_sem);
+ mutex_unlock(&serio->drv_mutex);
}
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Aristeu Sergio Rozanski Filho <aris@cathedrallabs.org>
- *
+ *
* Changes/Revisions:
* 0.2 16/10/2004 (Micah Dowty <micah@navi.cx>)
* - added force feedback support
struct uinput_device {
struct input_dev *dev;
- struct semaphore sem;
+ struct mutex mutex;
enum uinput_state state;
wait_queue_head_t waitq;
unsigned char ready;
projects / mv-sheeva.git / commitdiff